Skip to content
All tech roadmaps

Software Development

Full Stack Development

Full stack engineers ship whole features alone. The value is not knowing everything equally; it is being able to carry an idea across every layer without waiting for someone else, which is exactly what small teams and startups need.

4 stages2 projectsIntermediate9 to 12 months, part time

Start here

Do not start here if you have never programmed. Full stack is a second step, not a first one. Learn Frontend or Backend to a working standard first, then come back and add the other half.

Before you begin

  • Comfortable in one language
  • Can build and style a working web page
  • Understands what an HTTP request is
01

Get genuinely good at one side first

The commonest failure on this path is being mediocre at both halves. Be solid at one, then extend.

Which half do you already have?

Complete that roadmap to at least its production stage before continuing here. This stage is a gate, not a suggestion.

Pick one

Coming from the frontend

You already have the language and the user's perspective. What you lack is data modelling and the security mindset.

What to learn

  • You should already have: HTML, CSS, JavaScript, a framework
  • Next: SQL, API design, authentication

Next: The shared middle.

Pick one

Coming from the backend

You already have data and correctness. What you lack is layout, state and accessibility.

What to learn

  • You should already have: a language, SQL, API design
  • Next: CSS layout, component state, accessibility

Next: The shared middle.

02

The shared middle

The layer both halves meet in, which neither roadmap alone covers well.

Required

Data flow across the boundary

Most full stack bugs live exactly here: the shape the server sends is not the shape the client expected.

What to learn

  • Serialisation
  • Validating on both sides
  • Shared types
  • Optimistic updates
  • Loading and error states as first-class

Tools

  • TypeScript
  • Zod or an equivalent validator

Practice

Define one schema and use it to validate on the server and type the client. Break it deliberately and watch where it fails.

Next: Authentication across the whole stack.

Required

End-to-end authentication

Auth is the feature that touches every layer at once, which is why it is the one that most exposes a shaky understanding.

What to learn

  • Sessions and cookies
  • Protecting routes on the server
  • Hiding UI is not security
  • Roles and permissions
  • Session lifetime

Practice

Hide an admin button in the interface, then call the same endpoint directly with curl. If it works, you have learned the lesson.

Next: A meta-framework that owns both halves.

03

A framework that spans both

Modern full stack work happens mostly in frameworks that render on both sides.

Required

A full stack framework

Server rendering, routing, data loading and deployment in one model. This is what most full stack jobs actually use.

What to learn

  • Server versus client rendering
  • Routing and layouts
  • Server-side data loading
  • Mutations and revalidation
  • Caching and its invalidation

Tools

  • Next.js
  • or SvelteKit
  • or Nuxt
  • or Rails / Laravel / Django for the classic model

First understand

  • A frontend framework
  • API design

Project

intermediate

A complete small product

A multi-user application with sign-up, a database, permissions, one list-and-detail flow, and one form that writes data. Deployed and reachable.

  • A full stack framework
  • PostgreSQL
  • A hosting platform

You can take a product idea to a working, deployed application by yourself.

Next: The parts that only appear once real people use it.

04

Production concerns

The things that only surface once the application is not just yours.

Required

The unglamorous essentials

Every real product needs these, and every tutorial skips them.

What to learn

  • File upload and storage
  • Transactional email
  • Background jobs
  • Scheduled tasks
  • Payments in outline

Tools

  • Object storage
  • An email API
  • A queue

Next: Testing what matters.

Recommended

Testing across layers

Full stack surface area is large. A few well-chosen tests are worth more than exhaustive unit coverage of one layer.

What to learn

  • Unit tests for logic
  • Integration tests for API and database
  • One end-to-end path per critical flow

Tools

  • Vitest or Jest
  • Playwright

Next: Operating it.

Required

Deploy, monitor, iterate

Owning a feature end to end includes owning it after release. That ownership is the actual job description.

What to learn

  • CI/CD
  • Database migrations in a pipeline
  • Error tracking
  • Analytics
  • Rolling back safely

Tools

  • GitHub Actions
  • An error tracker
  • A hosting platform

Project

advanced

A product with real users

Put your application in front of at least ten people who are not you. Add error tracking, watch what actually breaks, and fix it based on evidence rather than guesses.

  • An error tracker
  • Analytics
  • Your deployment platform

You have changed a system in response to how strangers used it, which is the whole job.

Where this leads

You do not have to pick one now. These are the directions this path opens up once you are working.

You do not have to do this alone

Our programs are free, taught live, and built around the same progression. Join one and work through it alongside other people.