morebyt

Free, updated 20 Nov 2026

C++ Roadmap 2027What to learn, in order. What to skip. Where the jobs actually are.

Get the 1-page checklist

All 42 steps on one printable page — tick them off as you go.

Learn C++ the way companies use it. Spend your time on object lifetime, tools and how the machine works — not syntax. Build a few finished projects a stranger can clone and build. Pick one industry. Let AI agents type, but you own the design and the review — an agent can't tell you who owns the memory. That's what the interview is about.

Your progress
0 / 42

Sheet 0: how to work in 2027

You design. The agent types. The tests judge.

AI agents now write much of the code. They're good inside a box and weak at deciding where the boxes go — and their C++ compiles even when it uses freed memory. So the junior skill of 2027 is design and review. Stages 1–3: write everything by hand. From Stage 4 on, work like this:

  1. 1. You

    Design

    A one-page DESIGN.md: the types, who owns what, the interfaces, how errors and threads work.

  2. 2. Agent

    Build

    The agent writes code inside your design, following your AGENTS.md.

  3. 3. Tools

    Gate

    Tests, warnings, sanitizers and CI must pass. No exceptions.

  4. 4. You

    Review

    Read every line. Find where it left the design. Explain it with the laptop closed.

Sheet 1: the map

8 stages, about 10–14 months

At about 10 hours a week, if you can already program (6–9 months if you code for a living). Start data-structures-and-algorithms practice at Stage 3 and keep it going. Tick items as you go — your progress stays in this browser.

  1. Stage 1, 4–6 weeks

    Tools and core language

    Compile, run, debug and commit a small program from the terminal.

    Learn

    • A current GCC, Clang or Visual Studio
    • Warnings on: -std=c++20 -Wall -Wextra
    • Types, const, references
    • string, vector, struct, enum class
    • What the preprocessor, compiler and linker do
    • A debugger: breakpoints and call stacks
    • Git from day one

    Skip for now

    • Turbo C++ and old college IDEs
    • bits/stdc++.h
    • “Predict the output” UB puzzles
    • C-style char* strings
  2. Stage 2, 6–8 weeks

    Memory, lifetime and RAII

    Know when every object is created, copied, moved and destroyed, and who owns it.

    Learn

    • Stack vs heap, pointers vs references
    • RAII and the Rule of Zero/Five
    • Copy vs move (std::move is only a cast)
    • unique_ptr by default; what shared_ptr costs
    • Dangling: string_view, span, iterators
    • Virtual functions and destructors
    • Undefined behaviour you can name
    • -fsanitize=address,undefined on every debug build

    Skip for now

    • Custom allocators and placement new
    • Design-pattern catalogues
    • shared_ptr instead of deciding who owns it
  3. Stage 3, 6–8 weeks + DSA 2–3/wk

    Standard library and modern C++

    Solve problems with the standard library and read template code without fear.

    Learn

    • Containers and their real costs
    • Iterator invalidation rules
    • Algorithms and lambdas
    • optional, variant, string_view, span
    • Templates constrained with concepts
    • C++17 → C++20 → C++23 where your compiler has it
    • One error policy: exceptions or std::expected

    Skip for now

    • SFINAE and metaprogramming tricks
    • Coroutine internals
    • Modules and C++26 features
  4. Stage 4, 3–4 weeks + DSA 2–3/wk

    A project a stranger can build

    Anyone can clone your repo, build it with one command and see the tests pass.

    Learn

    • Target-based CMake with presets
    • One package manager: vcpkg or Conan 2
    • GoogleTest or Catch2 through CTest
    • clang-format and clang-tidy
    • Standard-library hardening in debug builds
    • GitHub Actions: build, test, sanitize

    Skip for now

    • Bazel and Meson
    • Learning both package managers
    • Cross-compiling (unless embedded)
  5. Stage 5, 6–8 weeks + DSA 2–3/wk

    How the machine works

    Explain why code is fast or slow — and prove it with numbers.

    Learn

    • Caches, cache lines, locality
    • Alignment, padding, structs of arrays
    • Reading assembly on Compiler Explorer
    • Processes, threads, virtual memory, system calls
    • TCP, sockets, epoll/kqueue
    • Google Benchmark, perf, flame graphs

    Skip for now

    • Writing assembly by hand
    • Lock-free anything
    • Optimising what you haven't profiled
  6. Stage 6, 5–6 weeks + DSA 2–3/wk

    Concurrency

    Multithreaded code that's correct first and fast second.

    Learn

    • jthread, mutex, scoped_lock, condition_variable, atomic
    • Data race (UB) vs race condition (logic bug)
    • Deadlock and lock order
    • ThreadSanitizer in its own build
    • False sharing
    • Acquire/release basics

    Skip for now

    • General lock-free structures
    • memory_order_relaxed tricks
    • Async frameworks and GPU code
  7. Stage 7, 4–6 weeks + DSA 2–3/wk

    Reading other people's code

    Find your way around code you didn't write, and get a change merged.

    Learn

    • Build fmt, spdlog, Catch2, DuckDB or llama.cpp from source
    • clangd “go to definition”
    • git log -p, blame, bisect
    • Read the tests first
    • Follow CONTRIBUTING; keep PRs small

    Skip for now

    • Chromium, LLVM or Unreal as a first patch
    • Typo-only pull requests
  8. Stage 8, 8–12 weeks + DSA 2–3/wk

    Specialise and get hired

    Look like a junior in one industry — not a tourist in five.

    Learn

    • The extra skills for one industry
    • Enough Python for scripts and tests
    • Interview DSA from a known list
    • Explaining your projects out loud
    • The interview questions below

    Skip for now

    • Rust at the same time
    • Certificates
    • A second industry
    • An unfinished engine, OS or compiler as your only project

Sheet 2: where the jobs are

The seats aren't where the hype is

Trading and game engines get the attention. The job ads say the seats are in embedded, robotics, chips, infrastructure and AI runtimes. Pick one of these and learn its extra skills.

  • Embedded, automotive, chips

    Firmware, drivers, car computers, chip software

    Extra: C too, RTOS, CAN/SPI/I2C, datasheets, heap-free C++

    Junior doorLarge, steady
  • Robotics and autonomy

    Sensor drivers, perception, planning, control

    Extra: ROS 2, Linux, linear algebra, Python

    Junior doorGrowing
  • Databases and infrastructure

    Storage engines, query execution, networking

    Extra: Linux I/O, concurrency, B-trees/LSM, SQL

    Junior doorBiggest C++ role group
  • AI runtimes and inference

    llama.cpp, ONNX Runtime, TensorRT, GPU kernels

    Extra: Python bindings, SIMD, CUDA, profiling

    Junior doorFastest-growing
  • Simulation, HPC, CAD, EDA

    Solvers, CAD kernels, chip-design tools

    Extra: Numerical methods, MPI/OpenMP/CUDA

    Junior doorGrowing (India semis)
  • Defence and aerospace

    Vehicles, sensors, simulation, control

    Extra: Systems + embedded skills

    Junior doorBig in the US · citizens only
  • Networking and telecom

    Routers, 5G, packet processing

    Extra: TCP/IP in depth, Linux networking, DPDK

    Junior doorBig in India
  • Security

    Fuzzing, hardening, endpoint agents

    Extra: OS internals, sanitizers, fuzzers, assembly

    Junior doorRising with regulation
  • Audio and video

    Plugins, codecs, players, WebRTC

    Extra: DSP, real-time rules, FFmpeg, JUCE

    Junior doorSmall, steady
  • Games

    Unreal C++, engines, tools, rendering

    Extra: 3D maths, Unreal or a graphics API

    Junior doorShaky · layoffs
  • Browsers

    Chromium, WebKit, Gecko, V8

    Extra: Huge codebases, security, some Rust

    Junior doorFlat
  • Low-latency trading

    Market data, order gateways, risk

    Extra: Linux tuning, networking, maths

    Junior doorFew seats · top pay

Junior door = how realistic it is to get in as a junior (my judgment). Signals from job-ad snapshots, Nov 2026: 37,046 live postings required C++ vs about 6,000 for Rust (Alion); C++ is #4 on TIOBE (8.35%). Python is also required in 60% of C++ postings — learn enough of it.

Sheet 4: projects that get you hired

Five finished beats eight abandoned

Every project: builds in one command, has tests, runs sanitizers in CI, and has one measured number in the README. Skip to-do apps and tutorial clones.

  • BeginnerWord counter / log analyserYou finish and ship
  • Beginner+Your own Vector<T>Ownership, copy, move
  • Beginner+CHIP-8 emulatorHow a CPU really runs codeMorebyt series
  • IntermediateMemory allocatorAlignment, fragmentation, measuringMorebyt series
  • IntermediateHTTP or Redis-style serverSockets, non-blocking I/O, safe parsingMorebyt series
  • IntermediateThread pool + bounded queueConcurrency that's actually correct
  • StrongCrash-safe storage engineDurability and binary formats
  • StrongTiny language / compilerHolding a whole program in your headMorebyt series
  • StrongOne industry flagshipYou fit the job you want
  • Any levelA merged pull requestYou can read code and survive review

Sheet 5: the interview

10 questions and one design problem

  1. What does std::move actually do, and what state is a moved-from object in?
  2. Explain RAII. When do you write a destructor and copy/move operations — and when none of them?
  3. Value vs unique_ptr vs shared_ptr vs weak_ptr: when do you use each, and what does shared_ptr cost?
  4. How do virtual functions work underneath? Why does a base class need a virtual destructor?
  5. What happens when vector::push_back runs out of capacity? What becomes invalid?
  6. map vs unordered_map: complexity, ordering, and when is the hash map slower?
  7. What is undefined behaviour? Give three examples and how you'd catch them.
  8. Two threads increment one counter. What's wrong, and what's the smallest fix?
  9. Why is looping over a vector much faster than over a std::list?
  10. Here are 30 lines that crash. Find the bug.
  11. Design it: an LRU cache, a logger, a rate limiter or a thread-safe queue — the types, who owns what, the interface.

Search job titles, not “C++ developer”: embedded or firmware engineer, systems software engineer, graduate software engineer, robotics software engineer. Internships beat certificates. Never write “C/C++” on your CV.

Sheet 6: resources

The short list

Take the checklist with you

One printable page, all 42 steps. You'll also get an email when the roadmap changes — for example when C++26 is finally settled.