The Zero to Elite roadmap: 21 phases from beginner to job-ready engineer

Zero to Elite is a phase-based software engineering curriculum of about 3,034 estimated hours, roughly 17.5 months at 40 hours a week. Each phase explains why it comes where it does, what it depends on, and what you should be able to show before moving on. Follow it with the ZTE Tracker app to track every topic, DSA problem and project.

Foundation phases

Tools, language fundamentals, React and interface systems. 4 phases, about 613 hours.

Phase 01: Developer Environment & Foundations
About 185 hours
Everything later runs in a terminal, an editor and a Git repository, and the web runs on HTML, CSS and JavaScript. Time lost to a broken environment or to not understanding the language underneath is paid back many times over.
What you should be able to show
- A repository with several meaningful commits you can explain
- A static multi-page site built without a framework, deployed publicly
- A short JavaScript program you can debug with devtools and a failing test
Phase 01b: TypeScript Mastery
About 80 hours
TypeScript turns many runtime bugs into editor errors and is the working language of most modern web codebases. It comes right after JavaScript so frameworks are learned with types from the start, not retrofitted.
What you should be able to show
- A small module with generics and a discriminated union, with tests
- A tsconfig you can explain option by option
- A runtime validation schema paired with the inferred static type
Phase 02: React + Next.js Core
About 213 hours
Components, state and routing are how interfaces are built today. This phase comes after JavaScript and TypeScript so learners understand what the framework does for them.
What you should be able to show
- A multi-route app with server and client components used deliberately
- Forms with validation and visible loading and error states
- A deployed app with a README explaining the data flow
Phase 03: UI System & Styling
About 135 hours
Consistent, accessible, responsive interfaces need a system of tokens and components rather than one-off CSS. It follows core React so components exist to be styled.
What you should be able to show
- A themed component set with a documented API
- An automated accessibility check passing on the main journey
- A layout that holds up from a phone to a wide desktop screen

Core phases

State, backend, databases, testing, deployment and DSA. 6 phases, about 1,135 hours.

Phase 04: State, Data Fetching & Advanced React
About 153 hours
Real applications spend most of their complexity in server state, caching and asynchronous behaviour. This comes after the React basics so the cost of each pattern is understood.
What you should be able to show
- An app with cached, invalidated server state and optimistic updates handled safely
- A reproduced and fixed race condition in an asynchronous flow
- A written note on where state lives and why
Phase 05: Backend + Database + Auth
About 314 hours
A product needs durable data, authenticated users and an API. Backend, database and authentication are grouped because they only make sense together, and they follow the frontend so learners have something real to connect.
What you should be able to show
- An authenticated API with a relational schema, migrations and a tested authorisation rule
- Stable pagination and an idempotent create endpoint with tests
- A query plan before and after an index change
Phase 06: Testing + CI/CD + Deployment
About 155 hours
Code that is not tested and deployed through a pipeline is a demo. This phase turns earlier projects into software a team could maintain, so it sits right after the first full-stack system exists.
What you should be able to show
- CI that runs type checks, tests and linting on every change
- Tests at unit, integration and end-to-end level for one feature, with the reasoning for each level
- A deployment with a documented rollback
Phase 06b: React Native (Mobile)
About 111 hours
Mobile reuses React knowledge but adds lifecycle, offline behaviour and store release. It is optional and placed after web fundamentals and testing so it builds on them.
What you should be able to show
- An app that keeps state across a force-quit
- Offline writes that sync without duplicates
- A build on a beta track with crash reporting
Phase 07: API Documentation & Developer Tooling
About 71 hours
An API other people can use needs a contract, documentation and tooling. It follows the backend phase because there must be an API to describe.
What you should be able to show
- An OpenAPI description that matches the implementation and is checked in CI
- A documented error format used consistently
- A client or collection that exercises the documented examples
Phase 08: DSA & Interview Preparation
About 331 hours
Algorithmic problem solving is tested in many interviews and sharpens reasoning about performance. It runs alongside project work from early on, since skill grows from steady practice, and sits here as a deliberate block once the language is solid.
What you should be able to show
- A log of solved problems with the pattern, the complexity and a mistake you made on each
- Timed solutions to unfamiliar problems explained aloud
- A note of the patterns you still miss, with a plan

Advanced phases

Caching, monitoring, real-time, AI and production hardening. 7 phases, about 842 hours.

Phase 09: Caching + Email + Payments
About 98 hours
Caching, email and payments are the first dependencies on external systems that fail in new ways. They follow the backend and testing phases so failure handling can be tested.
What you should be able to show
- Cached responses with a stated invalidation rule
- Webhook handling that is safe when the same event arrives twice
- Email sending that is retried without duplicates
Phase 10: Monitoring & Analytics
About 103 hours
You cannot operate or improve what you cannot see. Logs, metrics and traces turn production behaviour into evidence, and the phase follows deployment because there must be something running to observe.
What you should be able to show
- Structured logs with a request identifier across services
- A dashboard and one alert tied to user impact
- A real or simulated incident investigated from the data
Phase 11: Real-Time + Search + PostgreSQL Internals
About 164 hours
Real-time features, search and database internals are where simple designs strain. They follow the first backend and observability work so learners can measure the strain.
What you should be able to show
- A real-time feature that survives reconnects
- Search with measured relevance on a small labelled set
- A slow query diagnosed and fixed from its plan
Phase 12: AI/RAG + Production AI Patterns
About 207 hours
AI features are now common in products, and building them safely needs retrieval, evaluation and defences against misuse. They sit after backend, testing and observability, since an AI feature is a service that needs all three.
What you should be able to show
- A retrieval feature with recall measured on labelled questions
- A golden evaluation set run as a regression test
- A documented set of defences against prompt injection and the tools the model may call
Phase 13: Advanced Browser APIs + Collaboration
About 137 hours
Advanced browser capabilities and collaboration patterns extend frontend skill once the basics, state and testing are strong.
What you should be able to show
- A feature using an advanced browser API with graceful fallback
- A collaboration pattern with a stated conflict rule
- A measured performance comparison before and after
Phase 14: Load Testing + Security Deep Dive
About 89 hours
Load behaviour and security flaws appear only when an application is real. This phase comes after a deployed, observable system exists to test and harden.
What you should be able to show
- A load test with a stated budget and the bottleneck found
- Injection, XSS and access-control flaws reproduced on a practice app and fixed with tests
- A threat model for one of your own projects
Phase 15: Build Tooling + CSS-in-JS
About 44 hours
Build tooling and CSS-in-JS explain what happens between source and browser. Studying them later means learners already have a project whose build they want to understand.
What you should be able to show
- A bundle analysis with one change that reduced size, measured
- A build configuration you can explain
- A trade-off note on a styling approach

Expert phases

Infrastructure, architecture, craft and career. 4 phases, about 444 hours.

Phase 16: Infrastructure
About 175 hours
Infrastructure turns code into a running, repeatable environment. It follows deployment and observability because those show why repeatability and safe change matter.
What you should be able to show
- An environment created and changed only through code with reviewed plans
- A small, non-root container image
- A rollout with a rollback you exercised
Phase 17: Architectural Patterns
About 178 hours
Architectural patterns are trade-offs between simplicity and the ability to change. They are best studied after a few systems have been built, so the problems the patterns solve have been felt.
What you should be able to show
- A written design with alternatives and the reason each was rejected
- A refactor that applies one pattern, with tests proving behaviour did not change
- A failure analysis of your own design
Phase 18: Engineering Craft + Package Publishing
About 62 hours
Engineering craft, such as code review, documentation, refactoring and publishing a package, is what makes work maintainable by others. It is practised against the codebases built in earlier phases.
What you should be able to show
- A published package or an accepted contribution to someone else's project
- A pull request with a description a reviewer can act on
- A refactor with a before and after explanation
Phase 19: Career & Community
About 29 hours
Evidence only helps if it reaches an employer. This phase turns the work of earlier phases into a resume, a portfolio, interview practice and an honest job-search routine.
What you should be able to show
- A resume where every bullet links to evidence you can show
- Two projects with READMEs a stranger can run
- Recorded mock interviews with notes on what you will change

Ship the roadmap, one topic at a time

Create an account to track progress, lock topics until their prerequisites are done, and schedule revision.

The Zero to Elite roadmap: 21 phases from beginner to job-ready engineer

Foundation phases

Phase 01: Developer Environment & Foundations

Phase 01b: TypeScript Mastery

Phase 02: React + Next.js Core

Phase 03: UI System & Styling

Core phases

Phase 04: State, Data Fetching & Advanced React

Phase 05: Backend + Database + Auth

Phase 06: Testing + CI/CD + Deployment

Phase 06b: React Native (Mobile)

Phase 07: API Documentation & Developer Tooling

Phase 08: DSA & Interview Preparation

Advanced phases

Phase 09: Caching + Email + Payments

Phase 10: Monitoring & Analytics

Phase 11: Real-Time + Search + PostgreSQL Internals

Phase 12: AI/RAG + Production AI Patterns

Phase 13: Advanced Browser APIs + Collaboration

Phase 14: Load Testing + Security Deep Dive

Phase 15: Build Tooling + CSS-in-JS

Expert phases

Phase 16: Infrastructure

Phase 17: Architectural Patterns

Phase 18: Engineering Craft + Package Publishing

Phase 19: Career & Community

Ship the roadmap, one topic at a time