Context
For five years alongside my full-time roles, I took freelance projects for a steady stream of small clients across a wide range of industries — mom-and-pop restaurants, musicians with international audiences, news publications, early-stage startups, e-commerce stores, and internal tooling for small operators. The engagements were typically short, the scope was always end-to-end, and the technology stack changed every time depending on what fit the client.
This chapter wasn’t glamorous, but it was formative. It was the period where I stopped being someone who could follow a spec and became someone who could own a problem from conversation through deployment.
What I Did
End-to-end delivery for every engagement. Every project started the same way: a conversation with a client who didn’t know exactly what they needed, in a domain I’d never worked in before. The job was to figure out what they actually required, pick a technology that fit the problem, design the solution, build it, deploy it, and hand it off in a state the client could maintain or evolve without me.
Wide range of domains and stacks. Angular, Vue.js, React, Node.js, Laravel, PHP — whichever tool fit the project. Small business marketing sites, online stores, custom dashboards and internal tools, content-heavy publishing platforms, audience-facing sites for musicians, booking and inventory tooling for local operators. No two projects looked the same, and that was the point.
Full ownership, every time. On client work this small, there’s no specialization to hide behind. I handled requirements gathering, technical architecture, frontend, backend, database design, deployment, server administration, and client handoff. If it broke on a Saturday, I fixed it on a Saturday. This is where I built a durable instinct for what it actually takes to ship and maintain something real.
Technical Details
Stacks varied by project. When a client needed a polished single-page application with significant interactivity, Angular or Vue made sense. For content-heavy sites where time-to-ship mattered more than frontend complexity, Laravel or a lighter PHP stack got the job done faster. For APIs and custom backends, Node.js was the default. TypeScript became a constant once the toolchain matured.
The common thread wasn’t the stack — it was the discipline of fitting the tool to the problem rather than the reverse. Short engagements don’t forgive over-engineering. The projects that went well were the ones where I resisted the temptation to make every decision future-proof and shipped what the client actually needed.
Outcome
Freelancing is where I compressed five years of diverse experience into the foundation for everything that came after. It’s where I learned how to read a codebase quickly, pick a stack pragmatically, own a deployment pipeline, and have direct conversations with non-technical stakeholders about tradeoffs. It’s also the chapter that taught me most of what I needed to land my first senior role — not because any single project was remarkable, but because the volume and variety forced me to get good at all of it.
Most of those sites and applications are gone now, as small-client work tends to go. What remains is the engineer the work shaped.