Roadmaps
Learning paths for engineers
Pick your role, see exactly what to learn in order with the best free resources, then let Atlas map the path to your resume.
New Grad SWE
A 2026 path from absolute beginner to a hireable new-grad/junior software engineer, organized around what hiring teams actually screen for: genuine coding ability in one language, computer-science fundamentals (data structures, algorithms, Big-O), confident Git, and the working habits of a professional team (the SDLC, testing, code review, and using AI assistants without surrendering your own judgment). The ordering is intentional: become productive in one language first, then layer on CS fundamentals and the daily professional toolchain (terminal, Git, SQL), then learn to ship and verify code the way teams do. AI coding assistants are now part of the standard workflow, but the same 2026 surveys that put adoption near 84% also show trust in that output collapsing (only ~3% "highly trust" it), so interviewers reward people who can read, debug, and reason about AI-written code, fundamentals matter more, not less. Signal of readiness: 3-5 portfolio projects on GitHub (with tests and a clean commit history), roughly 100-150 solved DSA problems, and the ability to talk through trade-offs out loud. Treat any language or framework beyond your first as depth to add later, not a prerequisite.
Frontend
Frontend hiring in 2026 rewards three things: a genuine command of the web platform (semantic HTML, modern CSS, and JavaScript you understand rather than copy), fluency in a typed component framework (React with TypeScript remains the highest-demand pairing), and the engineering discipline wrapped around the code, accessibility, performance, testing, and the ability to ship to a real URL. The order here is deliberate: learn the platform before any framework, pick up TypeScript in parallel with React rather than bolting it on afterward, and treat accessibility, testing, and Core Web Vitals as the job itself, not extra credit. The common modern setup is Vite + React + TypeScript + Tailwind, with TanStack Query handling server data and Next.js (App Router and React Server Components) as the high-value advanced layer. Tools that used to headline these lists, jQuery, class components, Redux for every piece of state, Create React App, Enzyme, are left out on purpose; they matter only when you inherit older code. Plan on roughly six to nine months of focused effort, and prove it with three or four deployed, tested, accessible projects rather than a stack of certificates.
Backend
A backend engineer builds the server-side systems behind every application: APIs, data stores, business logic, authentication, and the infrastructure that keeps it all fast, secure, and reliable as traffic grows. This path is sequenced to match how the skills genuinely depend on one another and what hiring teams screen for in 2026. Begin with internet/OS/Git fundamentals and ONE language you commit to deeply, then make HTTP APIs real, then databases (relational first, non-negotiable), then auth and security, then caching/queues/async work, then containers and CI/CD, then a cloud provider plus observability, and finally distributed-system design and testing discipline. The biggest 2026 shifts versus older roadmaps: (1) containers and a cloud provider are now baseline expectations, not advanced extras; (2) broken authorization is the dominant real-world API vulnerability, so security is woven in early rather than bolted on; (3) wiring an LLM API to a vector store shows up in a fast-growing slice of backend postings and is now a strong differentiator (recommended, not yet universal). Choose the language by target market: Go or Java for high-scale, infra, and enterprise; Python with FastAPI for AI-adjacent and data-heavy services; Node with TypeScript for product and startup full-stack speed. Real depth in one stack on top of solid fundamentals beats shallow exposure to many.
Full-Stack
A 2026 full-stack engineer ships features end to end: a typed JavaScript/React frontend, a Node-based API, a relational database, and a real deployment, increasingly with AI features wired in. The fastest route to job-ready is depth over breadth. Lock down the three web fundamentals (HTML, CSS, JavaScript), then go deep on ONE frontend framework, React is the safest market bet, used by roughly 45% of professional developers (Stack Overflow 2025) and the most-requested framework in frontend listings. Pick up TypeScript early: it is now the default for serious JS/React work, used by about 78% of professional developers (State of JS 2025) and the most-contributed language on GitHub as of late 2025. Build a real backend with Node and Express against a PostgreSQL database through a type-safe ORM (Prisma or Drizzle), unify the stack with Next.js (the dominant production React framework), and learn to ship it (Git, a managed host like Vercel or Railway, basic CI). Round out with testing, a web-security baseline, and LLM API integration, the capability that moved from nice-to-have to commonly expected. Deliberately skip the dated "essentials" that most 2026 roles do not require: jQuery, defaulting to Angular, reaching for Redux on every project, and Kubernetes (managed hosts abstract orchestration for typical full-stack work). The real proof of competence is two to three deployed full-stack projects with authentication, a database, and tests, not a certificate.
DevOps / SRE
DevOps, Platform Engineering, and SRE are three views of one job: shipping and operating software reliably, safely, and fast. The 2026 path is a dependency chain you cannot shortcut. Begin with how machines and networks actually work (Linux, shell, TCP/IP/DNS/TLS), then version control and one cloud you can reason about end-to-end, then packaging and automated delivery (Docker, CI/CD), then orchestration and declarative infrastructure (Kubernetes, Terraform/OpenTofu), then make systems observable and secure (OpenTelemetry + Prometheus/Grafana, DevSecOps and supply-chain hardening), and finally the operating discipline that defines senior roles: SRE practice (SLIs/SLOs, error budgets, incident response) and Platform Engineering (self-service internal developer platforms). The biggest shifts versus older roadmaps: GitOps (Argo CD/Flux) is now the default Kubernetes delivery model, OpenTelemetry is the vendor-neutral instrumentation standard everyone converges on, and Platform Engineering with internal developer portals such as Backstage is the dominant senior trajectory (Gartner projects 80% of large engineering orgs will run platform teams by 2026, up from 45% in 2022). Learn one tool per concept, build a portfolio of real running systems rather than collecting certs, and treat AI assistants as accelerators for understanding and toil reduction, never as a replacement for knowing what your infrastructure does.
Cloud
A Cloud Engineer designs, provisions, automates, and operates the infrastructure that runs applications on AWS, Azure, or GCP, defining networks, compute, storage, identity, and security as code rather than clicking through a console. The most reliable 2026 path is foundations-first: get genuinely fluent in Linux, networking, Git, and scripting (Python + Bash), then go deep on ONE provider (AWS is the largest entry-level hiring surface) instead of skimming all three. From there the modern non-negotiable stack is Infrastructure as Code (Terraform, and an awareness of its OpenTofu fork after the 2023 license change), containers (Docker) with orchestration (Kubernetes), CI/CD pipelines, cloud IAM and secrets/security, and observability (provider-native metrics plus Prometheus/Grafana). What converts a learner into a hire is not certifications but 3-5 portfolio projects that stand up real infrastructure with Terraform and ship it through an actual pipeline. Certifications (AWS Solutions Architect Associate, then Terraform Associate and CKA) corroborate the work but never substitute for it; AWS Cloud Practitioner is a gentle on-ramp, not a hiring signal. Budget roughly 4-7 months of consistent study to reach a junior cloud or cloud-support entry point. Multi-cloud breadth, GitOps, and FinOps are the levers that raise seniority and pay later, not day-one requirements.
Mobile
A 2026-current, opinionated path to a job-ready Mobile Engineer. The fastest route to hireable is to go NATIVE-FIRST and deep on ONE platform end-to-end, Swift + SwiftUI for iOS, or Kotlin + Jetpack Compose for Android, because real depth on one stack out-hires shallow coverage of three. Modern native in 2026 means declarative UI (SwiftUI / Compose, not UIKit/XML-first), structured concurrency as a core skill (Swift async/await + actors under Swift 6's compiler-enforced data-race safety; Kotlin coroutines + Flow), and the current persistence defaults (SwiftData for new iOS apps, Room for Android). On top of that you need architecture (MVVM/MVI + a clean domain/data/presentation split + dependency injection), real networking (REST via URLSession/Retrofit, GraphQL when the backend uses it), automated testing, accessibility, and CI/CD with an actual store release, these are what separate a tutorial-finisher from someone a team will pay. Only AFTER you have shipped one native app should you add cross-platform: Flutter (largest market share, its own rendering engine), React Native (the natural pick if you already write JS/TS/React), or Kotlin Multiplatform (fast-growing; shares business logic while keeping native SwiftUI/Compose UI, Compose Multiplatform's iOS UI went Stable in 1.8.0, May 2025). Every resource below was checked during review to be free and live.
Data Engineering
A data engineer builds and operates the pipelines and storage that turn raw, messy data into reliable, query-ready datasets for analysts, data scientists, and ML/AI systems. The fastest path in 2026 is depth-first, not tool-collecting: get genuinely fluent in SQL and Python, learn to model data correctly (declare the grain before you draw tables), go deep on ONE cloud data warehouse, then add the transformation layer (dbt), orchestration (Airflow), and distributed processing (Spark). Streaming (Kafka/Flink), AI-data plumbing (vector DBs, RAG ingestion), governance, and infrastructure-as-code are differentiators you layer on after the core is solid. Hiring is decided mostly by demonstrable SQL/Python and "why is your schema shaped this way" reasoning, not by how many logos sit on your resume, so 3-5 end-to-end portfolio projects matter more than certificates. Realistic timeline: roughly 3-4 months for software engineers pivoting in, 6-9 months for analysts and CS grads, and 8-12 months from scratch at a steady pace.
ML / AI
A 2026 ML/AI Engineer designs, ships, and operates intelligent systems end-to-end, not just notebooks. The role rests on a software-engineering-first foundation and then spans two overlapping tracks: classical/deep ML (you train and deploy your own models) and AI/LLM engineering (you build products on foundation models with RAG, agents, tool/protocol integration, and rigorous evaluation). This path is ordered beginner -> job-ready and is deliberately opinionated: get fluent in Python + software engineering + SQL first, pick up just enough math to reason about and debug models (intuition, not a year of proofs), then classical ML, then deep learning with PyTorch (the framework most new postings ask for), then the LLM application layer (RAG, agents, evals, now mainstream, not niche), and finally MLOps/deployment, which is what most separates hireable engineers from notebook tinkerers. Throughout, ship a public portfolio: employers weight demonstrated end-to-end delivery (data -> model/system -> deployed service -> monitoring) far above certificates. Currency notes vs older guides: prefer PyTorch over TensorFlow, treat vector DBs + RAG + agents (and the Model Context Protocol for tool/data wiring) as core, use vLLM/quantization for serving, and treat MLOps (Docker, one cloud, CI/CD, monitoring) as non-negotiable.
Data Science
A 2026 data scientist turns messy data into trustworthy decisions and, increasingly, shipped models. The job-ready path runs in six dependency-ordered stages: (1) Python and the daily toolchain, (2) SQL plus data wrangling, (3) statistics and probability for sound inference, (4) exploratory analysis and visual storytelling, (5) classical machine learning end-to-end, and (6) shipping, lightweight deployment, a portfolio of real projects, and a working layer of modern AI (GenAI/LLM/RAG) with MLOps basics. Order is the point: beginners routinely over-invest in deep learning and Kaggle leaderboards while under-building SQL, statistics, and communication, the durable skills that actually decide interviews. Machine learning is the most-cited technical requirement (about 69% of data-scientist postings in recent large-sample analyses), and classical ML on tabular data still outperforms deep learning for a generalist; deep learning shows up in only roughly 12% of postings, so it is role-specific (computer vision / NLP), not a universal must. Python is the near-universal working language (cited in over half of postings and the medium every later stage is taught in), and SQL is effectively table stakes for reaching the data at all, even though the keyword itself appears in a smaller share of ads. GenAI/LLM/RAG fluency (around 31% of postings and the fastest-growing category) plus lightweight deployment (Docker, Streamlit, MLflow) have moved from nice-to-have toward baseline. The highest-leverage habit throughout is shipping two to three well-documented projects and being able to explain findings to non-technical stakeholders. Budget six to twelve months of steady work. AI assistants speed this up but do not remove the need to understand the statistics, the data, and the business question.
Security
A Security Engineer builds and runs the defenses that protect an organization's systems, networks, applications, and cloud, distinct from a SOC analyst (who mostly monitors) by owning architecture, tooling, and automation. The 2026 path is opinionated about order: you can't secure what you don't understand, so it front-loads strong IT fundamentals (Linux, networking, scripting, Git) before any security tooling. From there you layer the security core that interviews test, the CIA triad, cryptography, identity, risk, and the MITRE/NIST frameworks employers expect you to reference fluently, then go deep on the two areas real postings hammer: defensive operations (SIEM/SOAR, detection engineering, vulnerability management, incident response) and application plus cloud security. The defining 2026 shifts are cloud-native security (AWS/Azure IAM, containers, Kubernetes) and DevSecOps automation (SAST/DAST/SCA shifted left into CI/CD as code); these now separate hireable candidates from the pack, and container/Kubernetes security has crossed from nice-to-have into baseline. The role is increasingly T-shaped: broad literacy across every domain plus one deep specialization (cloud, AppSec, or detection). Certifications (Security+ first, then a cloud or specialist cert) act as resume filters, but demonstrable hands-on work, a home lab, detection rules, a hardened pipeline, write-ups, is what converts interviews. Treat AI/LLM security as a fast-rising area worth real literacy in 2026, just short of a day-one essential.
QA / SDET
A current (2026) path to a job-ready SDET. The role has moved away from manually walking through test cases toward writing production-grade test code, owning the quality gates in CI, and exercising judgment over AI-generated tests. The efficient route is: learn testing fundamentals so you understand WHAT to test, get genuinely comfortable in one programming language (TypeScript/JavaScript is the default for web automation; Python is the strong second for API, data, and AI work), then go deep on Playwright, which overtook Selenium in 2026 as the most-used framework (~45% adoption per TestGuild's survey, with sharply rising demand in job postings). The skills that show up in the majority of SDET listings are API testing, Git, CI/CD pipelines, and SQL; Docker, performance/load testing, and AI-assisted testing then make you competitive. The single strongest interview signal is a public portfolio of real automation frameworks running in CI, that beats certificates. Budget roughly 9-12 months at 10-15 hrs/week. The durable, hard-to-automate skill is judgment about quality and risk: knowing what to test, why a test is flaky, and whether an AI-written test is actually correct.
Embedded
Embedded and systems engineering in 2026 is the craft of making software behave correctly on resource-constrained hardware: microcontrollers (and, at the higher end, embedded-Linux SoCs) inside cars, medical devices, IoT products, robotics, and industrial equipment. The job-ready path is strictly bottom-up and unforgiving of skipped foundations. Start by genuinely owning C, pointers, the memory model, and bit manipulation, then add the embedded-specific layer (volatile, memory-mapped registers, interrupts). Next comes real hardware: pick a real ARM Cortex-M board (an STM32 or Nordic nRF, with an ESP32 alongside for cheap Wi-Fi/BLE) and learn the on-chip peripherals (GPIO, timers, ADC, interrupts) plus the serial buses that tie systems together (UART, then I2C and SPI, then CAN if you target automotive/industrial). The real line between a hobbyist and a hireable engineer is the toolchain-and-debug layer: building from the command line with GCC and CMake, single-stepping on real silicon through an SWD/JTAG probe with GDB/OpenOCD, and reaching for a logic analyzer or oscilloscope when a bus misbehaves. Only once you can confidently build and debug bare-metal firmware should you add an RTOS (FreeRTOS is the gentle on-ramp; Zephyr is the fast-rising employer ask) for tasks, queues, and synchronization. From there the path forks by role: embedded Linux plus device drivers (Yocto/Buildroot, kernel modules) for gateways and infotainment, or production-firmware depth (bootloaders and OTA, low-power design, watchdogs, testing/CI, and the safety/quality standards MISRA C, ISO 26262, IEC 62304). Throughout, a public GitHub of real driver and RTOS projects outweighs any certificate. C and C++ remain non-negotiable; Rust is the clear rising language for new and safety-critical firmware, a qualified compiler subset reached IEC 61508 SIL 2 in late 2025 with ISO 26262 ASIL B following in early 2026, so treat it as a strong "recommended now," not yet a hard requirement. Realistic timeline to junior-ready: roughly 9–18 months of consistent, hands-on work.
Game Dev
A game developer builds the interactive systems behind games, gameplay mechanics, physics, AI, rendering, and tools, almost always inside an engine such as Unity, Unreal, or Godot. In 2026 the route in is engine-and-portfolio first: hiring managers weigh shipped, playable projects and demonstrable engine fluency far above degrees, and the two dominant commercial engines are Unity and Unreal (on Steam, Unity powered roughly half of 2024 releases and Unreal a bit over a quarter, with Unreal leading revenue at the AAA end). Programming roles overwhelmingly want C++ and/or C# plus real hands-on time in a major engine. The sensible order is: get genuinely fluent in ONE language, commit to ONE engine, learn the narrow slice of math that actually shows up daily (vectors, a little trig, transforms), then learn to architect gameplay code (the game loop, state, components) instead of merely following script tutorials. After that you choose a specialization, gameplay, graphics/rendering, AI, or networking/multiplayer, and the whole journey is paced by repeatedly finishing and publishing small games (itch.io, game jams); a portfolio of three to five polished, completed projects is the real job ticket. AI tooling speeds up boilerplate and asset chores, but the durable, hireable skills are scoping, debugging, and shipping working systems.
Personalized
Already have a resume? Atlas reads it and maps any path to where you actually are, then coaches the gaps.