Skip to main content
Contact us
Telegram
Learning Path

From zero to Senior — the honest learning path

Built around 4 tracks and 5 levels, with realistic timelines, specific projects, and the mistakes everyone makes. Every step links to courses and blog posts you can act on this week.

Don't know which path yet?

Pick one of two starting points before committing to a track.

Read the explainer first

30 minutes, plain language, no buzzwords. We'll map out what "IT" actually means.

See what the market wants

Real demand, real job titles, sourced data. Then come back here and pick a track.

Pick your track

Four very different jobs. Pick the one that fits how you want to spend your day. You can switch later — most engineers do once or twice.

Frontend Development

~2.5–4 years (Beginner → Senior)

What it's not: Not graphic design — you'll write code, not draw mockups.

Backend Development

~3–5 years (Beginner → Senior)

What it's not: Not DevOps — you'll write the logic, not run the servers.

Data Science / ML

~3–5 years (Junior → Senior — Data rarely starts at Beginner)

What it's not: Not just dashboards — modern data is engineering with a lot of Python.

DevOps / SRE

~4–6 years total (DevOps usually follows 1–2 years of backend or sysadmin)

What it's not: Not entry-level — DevOps usually comes after a year or two as a backend or sysadmin.

Frontend Development

~2.5–4 years (Beginner → Senior)

Beginner

Typical: 4–8 weeks Source: Stack Overflow Developer Survey →

Skills you'll learn

  • HTML & CSS fundamentals
  • JavaScript basics
  • DOM manipulation
  • Responsive design

You're ready for the next level when

  • Built a 1–2 page personal portfolio from scratch and deployed it (Vercel / Netlify is fine)
  • Comfortable reading and modifying HTML/CSS in browser DevTools
  • Can write a button click handler in vanilla JS without copy-pasting
  • Site looks fine on a phone — you understand the box model and flexbox
  • Pushed your code to GitHub and the repo doesn't make you wince

Build this

Specific projects with what they actually teach you.

  • Personal portfolio website (teaches: deploy, responsive, basic JS)
  • A small landing page that fetches and displays one piece of API data (teaches: fetch, async, DOM rendering)

Take these courses

Introduction to HTML & CSS
Beginner

Introduction to HTML & CSS

Learn the fundamentals of HTML and CSS to build modern, responsive web pages from scratch.

WebFrontendHTML
⏱ 4 weeks
Introduction to HTML5 & CSS3
Beginner

Introduction to HTML5 & CSS3

Learn modern HTML5 and CSS3: semantic markup, Canvas, multimedia, WebSockets, WebStorage, animations, transformations, and responsive design.

HTML5CSS3Web
⏱ 6 weeks
Introduction to JavaScript
Beginner

Introduction to JavaScript

Learn core JavaScript from scratch: syntax, logic, arrays, functions, objects, events, DOM, AJAX and client-side data storage. A solid foundation for front-end development.

JavaScriptFrontendWeb
⏱ 7 weeks

Read these

We haven't published a deep-dive for this level yet. Browse the full blog →

Common mistakes at this stage

  • Spending 6 months on tutorials before building a real thing — tutorial hell is the #1 killer at this level
  • Skipping CSS basics because "Tailwind handles it" — you'll regret this at the first non-trivial layout
  • Watching React tutorials before you can write a button click in vanilla JS
  • Treating the portfolio site as throwaway — it's the artifact that gets you hired

What companies expect at this level

  • A 2–3 project portfolio they can clone and run from your GitHub
  • HTML/CSS produced without StackOverflow on a screen-share interview
  • Comfort with browser DevTools — inspect element, console, network tab
  • Basic Git: clone, branch, commit, push. The advanced stuff you'll pick up on the job.

Junior

Typical: 3–6 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • React fundamentals
  • Component lifecycle
  • State management basics
  • API integration

You're ready for the next level when

  • Shipped a React app with 3+ components, real API integration, and a live deployed URL
  • Can explain useState vs useEffect to someone in your own words — without buzzwords
  • Comfortable reading library source on GitHub, even when you don't fully grasp it
  • Used Git in a team flow at least once: branch, PR, addressing review comments
  • Read at least one "When NOT to use AI tools" / opinion piece and have a defensible take

Build this

Specific projects with what they actually teach you.

  • Small React app that talks to a real public API (teaches: components, state, fetch, error handling)
  • A weekend rewrite of your beginner portfolio in React + TypeScript (teaches: refactoring, types, why JSX matters)

Take these courses

React.js Essentials
Intermediate

React.js Essentials

Build modern, interactive UIs with React. Learn components, hooks, state management, routing, API integration, and deploy real projects. The natural next step after JavaScript.

ReactJavaScriptFrontend
⏱ 8 weeks
TypeScript Mastery
Intermediate

TypeScript Mastery

Go from JavaScript to production-grade TypeScript. Covers type system fundamentals, generics, decorators, strict mode, advanced utility types, and integrating TypeScript in real-world projects.

TypeScriptJavaScriptFrontend
⏱ 6 weeks

Read these

Common mistakes at this stage

  • Switching framework every 2 weeks (Vue → React → Svelte → Solid → ...) — pick one and ship something
  • Treating TypeScript as "just JS with types" — the real value is the design discipline
  • Not learning the platform basics (event loop, event delegation, browser rendering)
  • Building only TODO apps. Build something that needs server data and someone else's API.

What companies expect at this level

  • 1+ deployed React app that you understand top to bottom — and can explain in an interview
  • Comfortable with at least one CSS approach (Tailwind / CSS modules / styled-components)
  • Reading the docs is your default move when stuck — not asking the team
  • You can explain WHY you chose a library, not just THAT you used it

Mid-level

Typical: 6–12 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • Advanced React patterns
  • Performance optimization
  • Testing (Jest, React Testing Library)
  • Build tools (Webpack, Vite)

You're ready for the next level when

  • Owned a feature end-to-end at work or in a real project: requirements → design → ship → bugfix
  • Refactored someone else's React component without breaking it (and the team thanked you)
  • Can debug a performance issue using Chrome DevTools — Profiler, Network, Coverage
  • Reviewed PRs on a real team and your reviews aren't just nitpicks
  • Have an opinion on state management you can defend with code, not vibes

Build this

Specific projects with what they actually teach you.

  • Full-featured SPA with auth, routing, optimistic UI, and a real testing pyramid (teaches: shipping at production quality)
  • A small reusable component library + Storybook (teaches: API design, accessibility, documentation)

Take these courses

Introduction to AI: UI Generation with Copilot
Beginner

Introduction to AI: UI Generation with Copilot

Learn how to use AI tools—especially GitHub Copilot—to generate modern UI layouts, components, styles and complete website structures. A practical course for developers who want to speed up front-end development using AI.

AICopilotFrontend
⏱ 5 weeks

Read these

Common mistakes at this stage

  • Over-engineering: building a Redux store and a saga middleware for a 3-page app
  • Reaching for a new lib instead of writing 30 lines of plain code
  • Not writing tests because "it's just frontend" — frontend bugs are the most user-visible bugs you ship
  • Becoming a React-only person — modern stacks rotate, learn the platform, learn HTTP, learn the browser

What companies expect at this level

  • Strong React + TypeScript, but you don't put React on a pedestal — you can switch frameworks if the team needs it
  • Solid testing instinct: unit + integration, ideally a few e2e for critical flows
  • Architect a small feature without a senior holding your hand
  • Reasonable code-review skills — push back on bad PRs constructively

Senior

Typical: 1–2 years

Skills you'll learn

  • Frontend architecture design
  • Performance scaling
  • Team leadership
  • System design decisions

You're ready for the next level when

  • Designed the frontend architecture for a non-trivial product (3+ engineers depending on it)
  • Made a technology choice the team is still using a year later — and you can articulate why
  • Mentored a junior or mid-level engineer past a real plateau
  • Stopped writing tickets because "I want to" — write them because they're the right next move
  • Comfortable saying "this idea is wrong" to a PM or designer, with reasoning

Build this

Specific projects with what they actually teach you.

  • Design scalable frontend architecture for a multi-team product (teaches: module boundaries, build pipelines, design system ownership)
  • Lead a frontend team through a critical migration (teaches: planning, tradeoffs, mentoring under pressure)

Read these

Common mistakes at this stage

  • Believing your title means your opinion is right — it doesn't. Your reasoning does.
  • Over-investing in the tech you started with — Senior is when stacks broaden, not narrow
  • Avoiding people-shaped problems — they're 80% of the senior job
  • Not coaching juniors. Your team's quality plateau is your plateau.

What companies expect at this level

  • Can design and own a frontend architecture across multiple repos / teams
  • Solid technical communication: docs, RFCs, async writing — not just speaking
  • Multiplies the team — juniors get noticeably better when you join
  • Comfortable with ambiguity — products change, requirements change, you adapt without panic

Expert

Typical: 2+ years

Skills you'll learn

  • Framework innovation
  • Technical strategy
  • Deep domain expertise
  • Influencing industry standards

You're ready for the next level when

  • Set technical direction across 2+ teams (or your own scaled team) for a quarter or more
  • Can hold a credible 1-hour technical conversation with another senior at a peer company
  • Have a public artifact others reference — open-source contribution, conference talk, technical writing
  • Mentored multiple Seniors through their senior promotion
  • Comfortable being the "least technical" person in the room when warranted

Build this

Specific projects with what they actually teach you.

  • Contribute to a major frontend framework or its ecosystem (teaches: open-source code-review at world-class scale)
  • Design and write the public spec for a next-generation pattern at your company (teaches: industry-level technical communication)

Read these

Common mistakes at this stage

  • Avoiding ICs entirely — technical credibility erodes fast at this level
  • Refusing to write code "because I'm an Expert" — you should still write some, well
  • Treating your way as the only way — the field has moved past you twice already
  • Optimising for visible work over high-leverage work

What companies expect at this level

  • Sets and defends technical strategy for the function
  • Trusted to make calls that affect 6+ months of roadmap
  • External presence (writing, talks, OSS) OR equivalent internal influence
  • Recognised industry expertise in at least one narrow area

Backend Development

~3–5 years (Beginner → Senior)

Beginner

Typical: 4–8 weeks Source: Stack Overflow Developer Survey →

Skills you'll learn

  • HTTP & REST basics
  • C# and .NET fundamentals
  • OOP basics
  • Database basics (SQL)
  • Version control (Git)

You're ready for the next level when

  • Built and deployed a small CRUD app from scratch — book list, task tracker, anything that touches a database
  • Comfortable with basic SQL: SELECT, JOIN, WHERE, GROUP BY without copy-pasting
  • Can explain what an HTTP request is — method, headers, body, status code
  • Used Git in a real workflow: branch, commit, push to a public repo
  • Know the difference between value and reference types in C# (and why it matters)

Build this

Specific projects with what they actually teach you.

  • Simple C# console app that does something useful (teaches: types, control flow, error handling)
  • Small CRUD app with a SQL database — books / contacts / tasks (teaches: ORM basics, schema design, basic queries)

Take these courses

Introduction to Programming in C#
Beginner

Introduction to Programming in C#

Start from scratch and learn C# step by step: from the very basics of the language to core types, OOP, collections, generics, delegates, events, and error handling. A solid foundation for further .NET backend development.

C#.NETBackend
⏱ 9 weeks
Introduction to SQL
Beginner

Introduction to SQL

Learn SQL from the ground up: queries, database design, indexing, joins, subqueries, and stored procedures. Perfect for beginners entering backend or data engineering.

SQLDatabaseBackend
⏱ 4 weeks
Git & Version Control
Beginner

Git & Version Control

Master Git from the ground up: commits, branching, merging, rebasing, resolving conflicts, GitHub workflows, and CI/CD basics. Every developer needs this — learn it properly.

GitVersion ControlAutomation
⏱ 4 weeks

Read these

Common mistakes at this stage

  • Trying to build a microservices architecture before you can write a single working endpoint
  • Skipping SQL because "ORM handles everything" — when ORM hides a slow query, you need to read SQL to fix it
  • Treating Git as a save button — learn branching and reading diffs early, your future PRs depend on it
  • Memorising syntax instead of understanding flow — code reads bottom-up, not top-to-bottom

What companies expect at this level

  • A 2–3 project portfolio they can clone and run — at least one with a real database
  • Comfort writing basic SQL on a screen-share interview, without StackOverflow open
  • Basic Git workflow — clone, branch, commit, push, address PR comments
  • You can read a stack trace and find the line that broke — not panic when you see one

Junior

Typical: 3–6 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • ASP.NET Core Web API basics
  • Routing, controllers, DTOs
  • Entity Framework Core basics
  • Authentication & authorization (JWT)
  • Async/await and task-based programming

You're ready for the next level when

  • Shipped a REST API with auth, real DB persistence, and at least one integration test
  • Comfortable writing async/await without confusing yourself about the order of execution
  • Can debug a Web API request: from controller through service through repository, with breakpoints
  • Reviewed someone else's PR and gave at least one useful comment that wasn't cosmetic
  • Understand DI well enough to add a new service without copy-pasting from another file

Build this

Specific projects with what they actually teach you.

  • REST API with ASP.NET Core + EF Core, JWT auth, deployed somewhere real (teaches: full stack-of-one, real auth, real DB, real deploy)
  • A user-management or task-tracking service with at least one foreign-key relationship and three protected endpoints (teaches: schema design, route protection, error responses)

Take these courses

Introduction to Entity Framework
Beginner

Introduction to Entity Framework

Learn the fundamentals of Entity Framework, data modeling, querying, and practical examples for modern .NET applications.

C#.NETEntity Framework
⏱ 1 weeks
Introduction to ASP.NET Core
Beginner

Introduction to ASP.NET Core

Learn the fundamentals of ASP.NET Core, modern backend development, dependency injection, routing, controllers, REST APIs and deployment.

ASP.NET CoreC#Backend
⏱ 6 weeks
Introduction to MongoDB
Beginner

Introduction to MongoDB

Learn MongoDB from scratch: NoSQL concepts, documents and collections, queries, indexes, aggregation, and transactions. A practical start for backend and data engineering.

MongoDBNoSQLDatabase
⏱ 4 weeks
Node.js & REST APIs
Intermediate

Node.js & REST APIs

Build production-ready REST APIs with Node.js and Express. Learn async patterns, middleware, authentication with JWT, database integration, error handling, and API deployment.

Node.jsJavaScriptBackend
⏱ 8 weeks

Read these

Common mistakes at this stage

  • Putting business logic in controllers — controllers route, services do work, repositories talk to data
  • Catching every exception with a generic try/catch — let exceptions propagate to a place that knows how to handle them
  • Not writing any tests because "the team will write them later" — they won't. Add at least one integration test per endpoint.
  • Treating EF Core as magic — when a query is slow, you need to read the SQL it generates

What companies expect at this level

  • 1+ deployed REST API on ASP.NET Core that you can walk through in an interview
  • Solid OOP and async fundamentals — explain the difference between Task and Task<T>, value types vs reference types
  • Reading the docs is your default move when stuck — not pinging the team
  • Basic understanding of the request pipeline: middleware, filters, model binding

Mid-level

Typical: 6–12 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • Clean Architecture & layered design
  • Entity Framework Core performance & migrations
  • Caching (Redis / Valkey)
  • Message queues (RabbitMQ, Kafka basics)
  • Unit & integration testing (xUnit, NUnit)
  • CI/CD pipelines for .NET

You're ready for the next level when

  • Owned a feature end-to-end at work or in a real OSS project: requirements → design → ship → on-call when it broke
  • Refactored a non-trivial chunk of someone else's code without making it worse — the team noticed
  • Can debug a slow EF Core query by reading the generated SQL and adding the right index
  • Reviewed PRs on a real team and your reviews are valued — not skipped
  • Have an opinion on Clean Architecture / DDD you can defend with code, not blog posts

Build this

Specific projects with what they actually teach you.

  • A microservice in .NET with database, cache, message queue, observability, and CI/CD (teaches: production-shape thinking — what changes when there are 3+ services, not 1)
  • Refactor an existing monolith feature into a clean modular slice with tests (teaches: incremental refactoring under pressure, the only kind that matters in real teams)

Take these courses

C# Pro: Advanced Programming & System Design
Advanced

C# Pro: Advanced Programming & System Design

Master the advanced capabilities of C# and .NET. Learn collections, reflection, async programming, threading, GC, serialization, TPL, functional programming, Windows kernel synchronization and more.

C#.NETAdvanced
⏱ 9 weeks
Design Patterns in C#: From Theory to Practice
Advanced

Design Patterns in C#: From Theory to Practice

Master classic GoF design patterns in C#. Learn how to apply creational, structural and behavioral patterns to build clean, flexible and maintainable systems.

C#Design PatternsArchitecture
⏱ 6 weeks
Backend Architecture Foundations
Intermediate

Backend Architecture Foundations

A practical backend course focused on architecture thinking. Learn how to design scalable systems, choose between monoliths and microservices, build clean APIs, implement authentication correctly, and think in production-ready systems.

BackendArchitectureMicroservices
⏱ 6 weeks
AI-Powered .NET Development
Intermediate

AI-Powered .NET Development

Integrate AI into your .NET applications using OpenAI and Azure OpenAI APIs. Build intelligent features: chat, summarization, embeddings, semantic search, and RAG pipelines — all in C# and ASP.NET Core.

AIC#.NET
⏱ 8 weeks

Read these

Common mistakes at this stage

  • Cargo-culting Clean Architecture into a 3-endpoint service — layers exist to manage complexity, not to add it
  • Over-microservicing — most teams ship better on a clean modular monolith than a poorly-bounded micro-zoo
  • Caching everything everywhere — caches are invalidation problems waiting to happen
  • Skipping observability "until we need it" — by then you're debugging in the dark with logs.txt and hope

What companies expect at this level

  • Strong .NET + EF Core, with a real grasp of clean architecture and design patterns — not just textbook
  • Solid testing instinct: unit + integration, basic contract testing for inter-service calls
  • Architect a small feature without a senior holding your hand, including DB schema and rollback plan
  • Reasonable code-review skills — push back on bad PRs constructively, mentor juniors during review

Senior

Typical: 1–2 years

Skills you'll learn

  • .NET system architecture design
  • High-load optimization & profiling
  • Observability (logging, tracing, metrics)
  • Domain-Driven Design (DDD), CQRS, event-driven systems
  • Leading backend team & code quality

You're ready for the next level when

  • Designed the backend architecture for a non-trivial product (3+ services or 5+ engineers depending on it)
  • Made a technology choice the team is still using a year later — and you can articulate the trade-offs
  • Mentored a junior or mid-level engineer past a real plateau — they shipped something they couldn't before
  • Stopped writing tickets because "I want to" — write them because they're the right next move for the system
  • Comfortable saying "this idea is wrong" to a PM, designer, or another senior — with reasoning, not status

Build this

Specific projects with what they actually teach you.

  • Design the backend architecture for a multi-service product, including DB strategy, observability, deploy plan (teaches: thinking in terms of failure modes, not happy paths)
  • Lead a critical migration — DB engine swap, framework upgrade, monolith carve-out — with a measurable rollback path (teaches: planning, communication, mentoring under pressure)

Take these courses

1:1 Backend & Architecture Review
Advanced

1:1 Backend & Architecture Review

A private 1:1 architecture-focused session to identify risks, clarify trade-offs, and define concrete next steps. We review your backend architecture and code, assess production readiness, and deliver a clear action plan tailored to your goals.

BackendArchitectureCode Review
⏱ 1 weeks
Building LLM-Powered Apps: RAG & Agents
Advanced

Building LLM-Powered Apps: RAG & Agents

Build production-grade AI applications using large language models. Cover vector databases, retrieval-augmented generation (RAG), autonomous agents, tool use, evaluation, and deployment patterns.

AILLMRAG
⏱ 8 weeks
Building with Claude API: Production AI Apps with the Anthropic SDK
Intermediate

Building with Claude API: Production AI Apps with the Anthropic SDK

Master Anthropic's Claude API end-to-end: messages API, prompt caching, tool use, extended thinking, streaming, batch processing, files, citations, and vision. Build cost-efficient, production-grade AI features in any backend.

AILLMAPI
⏱ 6 weeks
Building Agents with the Claude Agent SDK
Advanced

Building Agents with the Claude Agent SDK

Design and ship custom AI agents with the Claude Agent SDK. Build agent loops, define tools, manage memory and sub-agents, evaluate behavior, and deploy multi-agent systems that solve real engineering tasks autonomously.

AILLMAgents
⏱ 7 weeks

Read these

Common mistakes at this stage

  • Treating system design as a trophy — the architecture exists to serve the team's actual problems, not your résumé
  • Over-investing in the stack you started with — Senior is when stacks broaden (other languages, other paradigms), not narrow
  • Avoiding people-shaped problems — they're 70% of the senior job and the part that determines if you become a Staff
  • Not coaching juniors on real PRs. The team's quality plateau is your plateau.

What companies expect at this level

  • Can design and own backend architecture across multiple services, with a credible failure-mode story
  • Solid technical communication: docs, RFCs, async writing — the team can act on what you write without you in the room
  • Multiplies the team — juniors get noticeably better when you join, mid-levels promote faster
  • Comfortable with ambiguity: products change, requirements change, you adapt without dropping quality

Expert

Typical: 2+ years

Skills you'll learn

  • Platform & architecture strategy for .NET ecosystems
  • Large-scale distributed systems in .NET
  • Cross-team technical leadership
  • Defining engineering standards & best practices
  • Community impact: open-source, talks, mentoring

You're ready for the next level when

  • Set the technical direction across 2+ teams (or your own scaled team) for a quarter or more
  • Can hold a credible 1-hour technical conversation with another senior at a peer company — and walk away having learned something
  • Have a public artifact others reference: OSS contribution, conference talk, or widely-cited internal RFC
  • Mentored multiple Seniors through their senior promotion — they cite you as a reason it happened
  • Comfortable being the "least technical" person in the room when warranted — and the most technical 30 minutes later

Build this

Specific projects with what they actually teach you.

  • Define the .NET platform vision for the company — what services use which patterns, why, and how teams onboard (teaches: standards as a multiplier, not a constraint)
  • Drive a key OSS or internal framework adopted across multiple teams — the kind of artefact that outlives your role at the company (teaches: API design at scale, deprecation discipline)

Take these courses

Building MCP Servers & AI Tool Integrations
Advanced

Building MCP Servers & AI Tool Integrations

Master the Model Context Protocol (MCP) — Anthropic's open standard for connecting AI models to external tools and data. Build custom MCP servers, expose APIs to Claude, and architect next-gen AI integrations.

MCPAIBackend
⏱ 6 weeks
Spec-Driven Development Foundations: From Philosophy to Operating Model
Intermediate

Spec-Driven Development Foundations: From Philosophy to Operating Model

Learn to write specs that agents actually obey, ship code as a cache of a durable spec, and operate the spec→context→evals trinity on real codebases. Vendor-agnostic, tool-agnostic, brownfield-ready — the methodology course that pairs with any agentic stack.

AILLMAgents
⏱ 6 weeks
OpenSpec Mastery: Production Spec-Driven Workflows for AI Coding Agents
Advanced

OpenSpec Mastery: Production Spec-Driven Workflows for AI Coding Agents

Operationalize SDD with OpenSpec — the open-source spec framework that treats specs the way Git treats code. Master /opsx:propose, /opsx:apply, and /opsx:archive on a real brownfield codebase. CI gates, multi-engineer collaboration, retrofitting legacy specs, and the workflow rituals that make it stick.

AIAgentsOpenSpec
⏱ 6 weeks

Read these

Common mistakes at this stage

  • Avoiding ICs entirely — technical credibility erodes fast at this level. Write some code, well, monthly.
  • Refusing to write code "because I'm an Expert" — the moment you can't prototype, your design feedback gets vague
  • Treating your stack as the universal answer — the field has moved past your favourite paradigm at least once already
  • Optimising for visible work over high-leverage work — the work that doesn't ship a release note often matters more

What companies expect at this level

  • Sets and defends technical strategy for the backend function
  • Trusted to make calls that affect 6+ months of roadmap and survive scrutiny from VPs and other Experts
  • External presence (writing, talks, OSS) OR equivalent internal influence (architecture council, hiring bar, mentor pool)
  • Recognised industry expertise in at least one narrow area — distributed systems, performance, security, etc.

Data Science / ML

~3–5 years (Junior → Senior — Data rarely starts at Beginner)

Junior

Typical: 3–6 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • Python for data analysis
  • Pandas & NumPy
  • Data visualization
  • SQL queries
  • Statistics basics

You're ready for the next level when

  • Cleaned and analysed a real public dataset end-to-end — from CSV to a chart someone else understands
  • Comfortable with SQL beyond SELECT — joins, window functions, basic optimisation
  • Wrote a Python script that reads, transforms, and writes data without copy-pasting from StackOverflow
  • Can explain the difference between mean, median, and mode without reaching for Wikipedia
  • Pushed your analysis to GitHub with a README that someone else can follow

Build this

Specific projects with what they actually teach you.

  • A data-analysis project on a public dataset (Kaggle, government data) — clean, analyse, visualise, write up findings (teaches: pandas, matplotlib, the actual analysis loop)
  • A small dashboard that pulls live data from an API and refreshes (teaches: ETL basics, scheduling, presenting data without a notebook)

Take these courses

Python Fundamentals
Beginner

Python Fundamentals

Learn Python from scratch: variables, data types, functions, OOP, file handling, modules, and practical scripting. The ideal first step for backend, data, and AI careers.

PythonBackendAutomation
⏱ 8 weeks
Introduction to SQL
Beginner

Introduction to SQL

Learn SQL from the ground up: queries, database design, indexing, joins, subqueries, and stored procedures. Perfect for beginners entering backend or data engineering.

SQLDatabaseBackend
⏱ 4 weeks

Read these

Common mistakes at this stage

  • Skipping SQL because "I'll just use pandas" — when the dataset is 50GB, pandas falls over and SQL is the only option
  • Building a Streamlit dashboard before understanding what insight you're actually delivering
  • Treating Jupyter notebooks as production code — they're sandboxes, not deliverables
  • Skipping statistics because "the model handles it" — every modelling mistake is a statistics mistake in disguise

What companies expect at this level

  • A 1–2 project portfolio on GitHub showing real data work — Kaggle is a starting point, not a finish line
  • Comfortable with SQL on a screen-share interview, not just notebook one-liners
  • You can explain WHY you cleaned data the way you did — not just THAT you cleaned it
  • Basic git workflow, can read someone else's notebook and turn it into a script

Mid-level

Typical: 6–12 months Source: Stack Overflow Developer Survey →

Skills you'll learn

  • Machine learning basics
  • Scikit-learn
  • Model evaluation
  • Feature engineering
  • Data pipelines

You're ready for the next level when

  • Owned an ML feature end-to-end at work or in a real project: data → model → deploy → monitoring
  • Can debug a model that "got worse in production" by reading data, not by retraining blindly
  • Built at least one ETL/ELT pipeline that runs on a schedule and recovers from failures
  • Reviewed someone else's data work and your feedback wasn't cosmetic
  • Have an opinion on classical ML vs LLM-for-this-task that you can defend with code

Build this

Specific projects with what they actually teach you.

  • Train, evaluate, and deploy a small ML model behind an HTTP API — including a /predict endpoint with retry / timeout (teaches: that "deploying ML" is mostly normal backend work)
  • A retrieval-augmented (RAG) prototype: load a corpus, embed, store, retrieve, answer (teaches: vector DBs, prompt construction, evaluation)

Take these courses

Prompt Engineering & AI Workflow Automation
Beginner

Prompt Engineering & AI Workflow Automation

Learn to work effectively with AI models: write high-quality prompts, build automated workflows using Cursor, Copilot, and API tools, and boost your daily development productivity 10x.

AIPrompt EngineeringCopilot
⏱ 4 weeks
AI-Powered .NET Development
Intermediate

AI-Powered .NET Development

Integrate AI into your .NET applications using OpenAI and Azure OpenAI APIs. Build intelligent features: chat, summarization, embeddings, semantic search, and RAG pipelines — all in C# and ASP.NET Core.

AIC#.NET
⏱ 8 weeks

Read these

Common mistakes at this stage

  • Reaching for an LLM where a 50-line scikit-learn script would solve it cheaper, faster, and more reliably
  • Treating accuracy as the only metric — production ML lives or dies on latency, cost, and failure modes
  • Skipping the eval set discipline — every "the model is amazing" claim without an eval set is marketing
  • Not versioning data — when the model breaks, you need to know what data it was trained on

What companies expect at this level

  • Strong Python + SQL, with real grasp of the ML lifecycle (not just notebooks-to-PowerPoint)
  • Solid grounding in evaluation: train/val/test, leakage, baseline comparisons
  • Architect a small ML feature without a senior holding your hand — including data, model, and serving
  • Reasonable code-review skills — push back on bad data work as well as bad code

Senior

Typical: 1–2 years

Skills you'll learn

  • Advanced ML algorithms
  • Deep learning
  • Model optimization
  • Big data technologies
  • Research

Build this

Specific projects with what they actually teach you.

  • Complex ML system
  • Lead a data science team

Expert

Typical: 2+ years

Skills you'll learn

  • AI innovation
  • Research leadership
  • Algorithm design
  • Industry research
  • Technical strategy

You're ready for the next level when

  • Set the data / ML technical direction across 2+ teams for a quarter or more
  • Can hold a credible 1-hour technical conversation with another senior data person at a peer company
  • Public artefact: paper, OSS, conference talk, or widely-cited internal RFC
  • Mentored multiple Seniors through their senior promotion in the data org
  • Comfortable saying "we should not build this" when the data doesn't support the product idea

Build this

Specific projects with what they actually teach you.

  • Publish a research paper, technical post, or OSS contribution that other practitioners cite (teaches: clarity at the level where industry actually moves)
  • Define the AI/data platform strategy for the company — what stack, what controls, what eval discipline (teaches: standards as a multiplier; making 30 engineers 10% better beats making 1 engineer 50% better)

Take these courses

Building MCP Servers & AI Tool Integrations
Advanced

Building MCP Servers & AI Tool Integrations

Master the Model Context Protocol (MCP) — Anthropic's open standard for connecting AI models to external tools and data. Build custom MCP servers, expose APIs to Claude, and architect next-gen AI integrations.

MCPAIBackend
⏱ 6 weeks
Building Agents with the Claude Agent SDK
Advanced

Building Agents with the Claude Agent SDK

Design and ship custom AI agents with the Claude Agent SDK. Build agent loops, define tools, manage memory and sub-agents, evaluate behavior, and deploy multi-agent systems that solve real engineering tasks autonomously.

AILLMAgents
⏱ 7 weeks

Read these

Common mistakes at this stage

  • Choosing tools by hype rather than what the team needs and can maintain
  • Avoiding business conversations — at this level, "the model is great" is worthless without business impact
  • Treating your way as the only way — the field has moved past your favourite paradigm at least once
  • Optimising for visible work over high-leverage work (eval pipelines that prevent disasters > flashy new model)

What companies expect at this level

  • Sets and defends data / ML technical strategy for the function
  • Trusted to make calls that affect 6+ months of roadmap and survive scrutiny from VPs
  • External presence (papers, talks, OSS) OR equivalent internal influence
  • Recognised industry expertise in at least one narrow area — recsys, LLM agents, time series, etc.

DevOps / SRE

~4–6 years total (DevOps usually follows 1–2 years of backend or sysadmin)

Mid-level

Typical: 6–12 months Source: CNCF Annual Survey →

Skills you'll learn

  • Docker containerization
  • Kubernetes basics
  • CI/CD pipelines
  • Linux administration
  • Networking basics

You're ready for the next level when

  • Took a real service from local dev to production: Dockerfile, CI, deploy, monitoring — without copy-pasting from a tutorial
  • Comfortable reading container logs and a kubectl describe output to diagnose a CrashLoopBackOff
  • Wrote at least one CI pipeline yourself, not just modified an existing one
  • Understand the difference between liveness and readiness probes, and when each matters
  • Have an opinion on Helm vs Kustomize that you can defend with a real config you wrote

Build this

Specific projects with what they actually teach you.

  • Take a real backend service and ship it through a complete pipeline: Dockerfile → CI build → push → deploy → health check (teaches: the actual production loop, not pieces in isolation)
  • Set up monitoring and alerting on a small cluster — get one real alert to fire, then tune it (teaches: alert fatigue is real; quality over quantity)

Take these courses

AWS Bedrock & AI Services for Developers
Intermediate

AWS Bedrock & AI Services for Developers

Deploy and use AI models on AWS: Bedrock (Claude, Llama, Titan), Lambda, API Gateway, S3, and DynamoDB. Build enterprise AI solutions integrated with your existing backend stack.

AWSAIBackend
⏱ 7 weeks

Read these

Common mistakes at this stage

  • Reaching for Kubernetes when a single VM with systemd would solve the problem at 1/10 the operational cost
  • Treating CI/CD as "set and forget" — pipelines need maintenance like any other code
  • Storing secrets in environment variables in CI logs — the failure mode is "your AWS keys on Pastebin"
  • Skipping the on-call experience — DevOps without on-call is theory; on-call is where you learn what actually breaks

What companies expect at this level

  • You've actually shipped to production — not "I learned Kubernetes on my home cluster"
  • Comfortable with at least one cloud provider deeply (AWS, GCP, or Azure) — not all three superficially
  • Solid Linux fundamentals: ssh, file permissions, systemd, basic networking
  • Read the docs first, ping the team second — you don't live in #help-devops chat

Senior

Typical: 1–2 years

Skills you'll learn

  • Advanced Kubernetes
  • Infrastructure as Code (Terraform, Ansible)
  • Monitoring & logging
  • Security & compliance
  • Scaling strategies

You're ready for the next level when

  • Designed and operated infra that 3+ engineers depend on, with a credible failure-mode story
  • Made an infrastructure choice the team is still using a year later — Terraform layout, K8s topology, deploy strategy
  • Mentored a junior or mid-level DevOps engineer past a real plateau — they own a piece of infra now
  • Wrote at least one runbook that someone else followed at 3 a.m. and got the system back without paging you
  • Comfortable saying "this needs a rewrite, not a band-aid" with the cost-benefit analysis ready

Build this

Specific projects with what they actually teach you.

  • Design and run a multi-cluster setup with proper IaC, secrets rotation, and incident playbooks (teaches: thinking in 3-AM-pager terms; design for the failure case)
  • Lead a critical infra migration — cloud move, K8s upgrade, monitoring revamp — with a measurable rollback plan (teaches: planning, mentoring, communication when systems are at risk)

Read these

Common mistakes at this stage

  • Cargo-culting "best practices" without understanding why the team's previous choice was made
  • Over-investing in observability tooling while ignoring the question of what alerts the team should actually wake up for
  • Avoiding the developer-experience side — DevOps that frustrates developers gets routed around, not adopted
  • Treating cost as someone else's problem — Senior DevOps who can't talk in dollars gets stuck at Senior

What companies expect at this level

  • Can design and own infrastructure across multiple services and clusters, with a credible disaster-recovery plan
  • Solid technical communication: docs, RFCs, runbooks — the team can act on what you write at 3 a.m.
  • Multiplies the team — junior DevOps engineers get noticeably better when you join
  • Comfortable talking dollars and reliability with leadership, not just YAML with engineers

Expert

Typical: 2+ years

Skills you'll learn

  • Cloud architecture
  • Infrastructure innovation
  • Team leadership
  • Cost optimization
  • Disaster recovery

You're ready for the next level when

  • Set the infrastructure strategy across 2+ teams (or your own scaled team) for a quarter or more
  • Can hold a credible 1-hour technical conversation with another senior platform person at a peer company
  • Public artefact others reference: OSS, talk, or widely-cited internal RFC about platform/infra design
  • Mentored multiple Seniors through their senior promotion in the platform org
  • Comfortable being the "least technical" person in the room when warranted, and the most when needed

Build this

Specific projects with what they actually teach you.

  • Define the cloud / platform strategy for the company — what services, what controls, what cost ceiling, what failure budget (teaches: standards as a multiplier across multiple teams)
  • Lead the infrastructure team through a major shift — multi-cloud, FinOps overhaul, security overhaul — that survives leadership changes (teaches: durable design; what holds up when stakeholders rotate)

Read these

Common mistakes at this stage

  • Avoiding hands-on work entirely — Expert platform engineers who can't prototype lose credibility within a year
  • Refusing to write IaC "because I'm an Expert" — your design feedback gets vague the moment you stop
  • Treating your stack as the universal answer — what worked at 50 engineers won't work at 5 or 500
  • Optimising for visible work over invisible-but-leveraged work (the deprecation cleanup that prevents 3 incidents)

What companies expect at this level

  • Sets and defends platform / infra technical strategy for the function
  • Trusted to make calls that affect 6+ months of platform roadmap and survive scrutiny from VPs
  • External presence (talks, OSS, writing) OR equivalent internal influence (architecture council, SRE bar, platform RFCs)
  • Recognised industry expertise in at least one narrow area — networking, observability, FinOps, security, etc.

Realistic total timelines

How long does it actually take? Honest answer: it varies. Here's the typical range based on public surveys and our own observation of self-taught learners.

Frontend Development

~2.5–4 years (Beginner → Senior)

Backend Development

~3–5 years (Beginner → Senior)

Data Science / ML

~3–5 years (Junior → Senior — Data rarely starts at Beginner)

DevOps / SRE

~4–6 years total (DevOps usually follows 1–2 years of backend or sysadmin)

Common mistakes everyone makes

Track-agnostic pitfalls. If you avoid these five, you'll learn faster than 80% of the people you'll meet at meetups.

  • Tutorial hell

    Watching 100 hours of tutorials before building anything yourself. The output of every tutorial should be a project you can show. If you finish a course and have no artifact, the course didn't happen — you watched a movie.

  • Framework chasing

    Switching from React to Vue to Svelte to Solid every two weeks "to find the right one". The right one is the one you ship something with. Pick a popular default, build for 6 months, then have an opinion. Not before.

  • Building everything in private

    Your portfolio in 2026 is your GitHub, not your CV. Recruiters and hiring managers click "View on GitHub" before they read your bullets. If your projects aren't public — even rough ones — they don't count. Public > polished.

  • Skipping fundamentals to chase trendy topics

    Jumping into LLM agents before you can write a clean function. Building a microservice mesh before you understand a single HTTP request. The boring fundamentals (HTTP, SQL, the event loop, basic data structures) compound for 30 years. The trendy stuff has a 2-year half-life.

  • Learning alone

    The fastest learners pair-program, post their progress publicly, ask "stupid" questions in Discord, and get code reviews from people slightly ahead of them. Solo learning is roughly half as fast as the same hours spent with one person you can ask.

Still deciding?

Book a free 30-minute call Explore Learning Paths
Start Learning