For most of 2023 I described myself as a “frontend developer.” That framing limited the work I could take, so I stopped using it.
Here’s what actually changed once I owned both sides.
The integration bugs vanish
The class of bug where the UI says one thing and the server records another — almost every project has these. When the same person owns both sides, they get caught in the same pull request instead of becoming tickets that bounce between two developers.
The brief becomes simpler
“Here’s a Figma, build it” and “here’s an idea, ship a product” are wildly different jobs. The second pays better and lasts longer — but only if you can do the second.
You stop pretending data models are someone else’s problem
A bad schema is a worse UX than bad CSS. You can refactor CSS in an afternoon. Refactoring a schema that has data in it is a weekend. Once you’ve had to do the second, you stop treating the database as “the backend person’s concern.”
You argue with yourself in the right direction
The best version of the back-and-forth between frontend and backend is when one person has it inside their own head. No politics, no Slack threads — just “this API is awkward, let me change it” and “this UI needs a field I didn’t expose, let me expose it.”
What you give up
Depth. A full-stack developer at any given moment is less deep on either side than a specialist. For most small and mid-size projects, the trade is worth it. For projects at scale, it isn’t — that’s where specialists come in and earn their keep.
The stack I use
- Node.js or Golang on the backend depending on the job
- React on the frontend, with either Next.js or Astro as the framework
- PostgreSQL as the default database
- Django when a project wants the boring parts done for it
The stack doesn’t matter. What matters is picking one you can reach for without thinking, so the interesting decisions happen at the product level, not the “which framework” level.