From Frontend to Full-Stack: My 11-Year Journey

8 min read
careerfull-stackfrontendjourneyadvice

I started writing JavaScript professionally in 2015. jQuery was still everywhere. React had just hit 0.14. "Full-stack developer" meant something very different than it does today.

Eleven years later, I lead frontend teams at Planetary Digital Agency, ship indie products through Helsky Labs, and work daily with AI tools that would have seemed like science fiction to 2015-me.

Here's what I learned along the way.

The Timeline

2015: Entry Point

I got my first frontend job in Brazil writing jQuery plugins and wrestling with Internet Explorer compatibility. The job title was "Web Developer," but the work was almost entirely frontend.

The stack: HTML, CSS, JavaScript (ES5), jQuery, Bootstrap.

The deployment process: FTP files to a server. Pray.

Full-stack was a different job entirely, usually involving PHP or .NET developers who lived in a different part of the office.

2016-2017: The React Transformation

React changed everything. The component model, the virtual DOM, the idea that UI could be declarative—it was a paradigm shift.

I remember the resistance from senior developers. "It's just JavaScript in HTML." "What about separation of concerns?" "This will never catch on."

I bet on React anyway. Spent nights learning while delivering jQuery at work. Slowly started introducing React into projects. By 2017, it was obvious: this was the future.

Lesson: When a new technology feels fundamentally different (not just different syntax), pay attention. The skeptics are often right about specific criticisms but wrong about the trajectory.

2018-2019: The First Full-Stack Steps

I hit a wall. I could build beautiful frontends, but I kept waiting on backend developers to:

  • Create the API endpoints I needed
  • Fix data shape issues
  • Handle authentication
  • Deploy changes

The dependency was frustrating. So I started learning Node.js.

This wasn't a formal decision to "become full-stack." It was pragmatic: I needed to unblock myself.

// My first Express API, circa 2018
// Looking at this now is painful, but it worked
app.get('/api/users', function(req, res) {
  db.query('SELECT * FROM users', function(err, results) {
    res.json(results);
  });
});

The quality was terrible by modern standards. No TypeScript. Callbacks everywhere. SQL injection vulnerabilities I didn't even know about.

But I could ship end-to-end. That capability changed my career.

2020-2021: Remote Work Explosion

COVID hit. Suddenly everyone was remote.

This was transformative for a developer in Brazil. Previously, my career options were local companies or the rare remote-first startup. Suddenly, US and European companies were hiring globally.

The time zone math worked: Brazil to US East Coast is 1-4 hours depending on daylight saving. I could overlap with both European mornings and US afternoons.

Lesson: Geography used to be destiny for developers. That's mostly over. The LATAM time zone advantage for US clients is real.

2022-2024: Full-Stack Transition Completes

At Planetary, I moved into technical leadership. The role demanded understanding the full picture—frontend architecture, API design, database modeling, deployment pipelines.

I wasn't the best at any single piece. The backend specialists knew more about database optimization. The DevOps engineers understood infrastructure better. But I could see how everything connected.

That systems thinking—understanding how frontend decisions affect backend load, how database schema choices impact UI possibilities—became my differentiator.

Lesson: Full-stack doesn't mean expert at everything. It means fluent enough in each layer to make good architectural decisions.

2025-2026: AI Changes Everything

Then AI tools arrived. Not the hype. The actual, useful tools.

I now use Claude Code daily for architectural discussions and complex implementations. Cursor handles inline coding with context awareness. GitHub Copilot autocompletes the mundane.

But here's what surprised me: these tools made my 11 years of experience more valuable, not less.

When Claude suggests an implementation, I can evaluate it. I know the edge cases that might bite. I understand why certain patterns exist. I can ask better follow-up questions because I know what I don't know.

Junior developers using AI tools are coding faster. But they're not necessarily making better decisions. The AI is only as good as the human directing it.

Lesson: AI accelerates execution. Experience improves direction. You need both.

Skills That Stayed Relevant

Problem Decomposition

The ability to take a vague requirement and break it into concrete technical tasks hasn't changed. AI can help with implementation, but someone still needs to define what "implement user authentication" actually means.

Reading Code

I spend more time reading than writing. Understanding existing codebases, reviewing PRs, debugging production issues—this never became obsolete.

Communication

Explaining technical decisions to non-technical stakeholders. Writing clear documentation. Articulating tradeoffs. These skills transfer across every technology shift.

Learning How to Learn

I've learned jQuery, Angular 1, React, Vue, Node.js, Next.js, and countless other tools. The specific knowledge becomes outdated. The ability to pick up new technology quickly doesn't.

Skills That Became Obsolete

jQuery Mastery

I was genuinely good at jQuery. Complex animations, plugin development, cross-browser compatibility hacks. All irrelevant now.

Webpack Configuration

I used to spend days optimizing Webpack configs. Now frameworks abstract this away, and I'm grateful.

Manual Browser Compatibility

We used to test in IE8. We used to write vendor prefixes by hand. We used to care about which CSS properties worked where. Modern tooling handles most of this.

CSS Specificity Tricks

Pre-Tailwind, I had elaborate CSS architecture knowledge. SMACSS, BEM, OOCSS. Most of it unnecessary now.

What I'd Tell 2015-Me

Learn TypeScript immediately. I resisted for too long. TypeScript isn't optional anymore—it's the baseline expectation for professional JavaScript development.

Don't treat frameworks as identity. Early in my career, I thought of myself as a "React developer." That's limiting. React is a tool. Knowing it well is good. Being unable to work without it is a handicap.

Backend knowledge compounds. Every hour spent understanding databases, APIs, and infrastructure pays dividends for years. Frontend-only developers hit a ceiling faster than they expect.

Remote work skills matter. Async communication, written documentation, proactive status updates—these are learnable skills that differentiate remote developers.

Side projects are career accelerators. Not for the portfolio. For the learning. Building something end-to-end, making every decision, seeing consequences—there's no substitute.

Advice for Developers Starting Today

The entry path is harder now. Demand for entry-level engineers has fallen. The "just learn to code" advice from 2015 needs updating.

What's Different

AI tools are expected. You should be comfortable with Copilot, Claude, or similar. Not as a crutch—as a force multiplier.

The bar is higher. "I can write React components" isn't differentiated anymore. You need to show systems thinking, project ownership, or deep specialization.

Full-stack from the start. The strict frontend/backend split is blurring. Employers expect some fluency across the stack, even for nominally specialized roles.

What They Can Skip

The old browser wars. Don't spend time learning IE compatibility or obscure CSS hacks. The battle is won.

Framework churn anxiety. React isn't going anywhere soon. Learn it well. The fundamentals transfer if it ever does decline.

Premature portfolio polishing. Employers care less about pretty portfolio sites than real projects with real code to review.

What They Must Not Skip

Fundamentals. How the browser works. How HTTP works. How databases work. AI tools can help you code faster, but they can't help you understand why something is broken if you don't have mental models.

Reading code. Contribute to open source. Read framework source code. Most developers can't read code they didn't write—this is a superpower.

Communication skills. Code reviews, documentation, explaining decisions—these never automate away.

The Longer Arc

Looking back at 11 years, the specific technologies were the least important part. The patterns recur:

  1. New technology emerges
  2. Skeptics dismiss it
  3. Early adopters struggle with immaturity
  4. It either succeeds and becomes mainstream, or fails and is forgotten
  5. The cycle repeats

The developers who thrive aren't the ones who pick the right technology every time. They're the ones who learn fast, ship consistently, and don't attach their identity to any particular tool.

I don't know what the industry will look like in another 11 years. AI might genuinely transform everything. Or it might become a normal tool, like the IDE did before it.

What I do know: the ability to learn, to ship, to communicate, and to solve problems will remain valuable. Everything else is implementation detail.

If you're navigating your own career transition—frontend to full-stack, IC to lead, or anything else—I'm always happy to chat. Find me on GitHub or LinkedIn.