In this chapter
We'll turn a chosen path and a list of gaps into a realistic 12-month learning roadmap — fundamentals deeply, tools just in time, one project per stage — and see how BizTechLab's courses fit in, explained as a marathon training plan.
The Problem in Real Life
Anna's first attempt at a plan is a list of 23 technologies, all due by March. John reads it and smiles. "That's not a plan. That's a way to feel bad every Sunday."
He draws three boxes: 3 months · 6 months · 12 months. "Each box gets one main goal, one project to prove it, and nothing else. Fundamentals deeply. Tools when you need them."
Learning is a marathon. Train for it like one.
John
A List of 23 Technologies vs. A Plan You Can Actually Follow
Trying to learn everything
A long list leads to shallow knowledge of everything and confidence in nothing.
Limited time
With a full-time job, there are a few hours a week for deliberate learning.
Proving it
Learning only counts when you can show it — in work, projects or explanations.
Building a Learning Roadmap and Building Projects
The marathon analogy: nobody trains for a marathon by running 42 km on the first day. A training plan builds up in stages, each with one main goal (run 5 km, then 10, then 21), a test run at the end of each stage, rest weeks, and steady, regular effort. A learning roadmap works the same way: stages, one goal each, a project as the test run, and a pace you can keep.
- Start from your path and your gaps: the path from chapter two (backend with DevOps) and the gaps from chapter three (deeper databases, Linux, Docker in practice, Kubernetes, one cloud provider, messaging) — in that order of importance for the work.
- Fundamentals deeply, tools just in time: fundamentals — data structures, SQL and data modelling, HTTP, operating systems, networking, testing, security — change slowly and pay off for decades. Specific tools change every few years; learn them when a task or job needs them. This course was the fundamentals' map; the specialist courses go deep.
- T-shaped skills: broad, basic understanding of everything (the top of the T — this course) and deep skill in one or two areas (the stem — your path). Teams love T-shaped people: they go deep but can talk to everyone.
- Stages with one goal and one project each: each stage ends with a project that proves the goal (Act 27's ladder): small and finished beats big and abandoned. Increase difficulty a little each time.
- A realistic pace: a few focused hours a week, every week, beats occasional weekend marathons. Use your daily work as a learning source too — volunteer for tasks slightly beyond your level (Act 24).
- Review and adjust every stage: at the end of each stage, look back: what did I learn, what took longer, what does my work need now? Change the plan; plans are allowed to change.
| Fundamental (learn deeply) | Example tools (learn just in time) |
|---|---|
| Data modelling and SQL | PostgreSQL, MySQL, an ORM |
| HTTP and API design | Express, FastAPI, Spring |
| Operating systems and Linux | systemd, specific distributions |
| Networking | Specific load balancers, CDNs |
| Containers and orchestration ideas | Docker, Kubernetes, ECS |
| Testing | Vitest, Jest, pytest |
| Security | Specific scanners and providers |
| Level | Project idea | Proves |
|---|---|---|
| 1 | CLI tool (Act 27) | Input, logic, errors |
| 2 | REST API + database (Act 27) | Backend basics |
| 3 | Deployed app with auth, tests, CI, monitoring (Act 27) | End-to-end ownership |
| 4 | Multi-service app with a queue and worker | Async systems |
| 5 | Same app on Kubernetes or a cloud provider with IaC | Operations at scale |
Anna's 12-month roadmap
Months 1–3: databases in depth
project: reports + indexes on the waitlist
Months 4–6: Linux + Docker in practice
project: multi-container app with a worker
Months 7–12: cloud + Kubernetes + messaging
project: waitlist on Kubernetes with queued emails
Anna's roadmap: Months 1–3 — databases in depth: the Relational Databases course; project: add reports with indexes and query plans to the Event Waitlist. Months 4–6 — Linux and Docker in practice: Linux and Docker courses as they arrive on BizTechLab, plus moving the organiser dashboard into the pipeline at work (the job she promised after Sale Day); project: a multi-container setup with a queue worker. Months 7–12 — cloud and orchestration: one cloud provider's fundamentals, Kubernetes basics, and messaging; project: the waitlist on Kubernetes with email notifications through a queue. Every week: three hours, Friday notes (Act 24), one TIL post a month.
Key Takeaway
Turn your path and gaps into a marathon-style plan: stages of three to six months, each with one main goal and one project that proves it. Learn fundamentals deeply and tools just in time; aim for T-shaped skills (broad understanding, one or two deep areas); keep a steady weekly pace, use daily work as practice, and review and adjust the plan at the end of every stage.
Why This Matters
Without a plan, learning becomes a pile of half-finished tutorials. A staged roadmap with one goal and one project per stage turns limited time into visible progress — and gives you concrete stories and projects for every future interview and performance review.
The plan is on the wall. Samantha has one more practical question: "If you ever did go looking for a job — not that I want you to — could anyone outside BlueTicket see what you can do?"