Introduction — The Road Ahead

@type: LearningResource

description: The map on the table: all 38 modules, what every deep dive delivers, and which module to jump to when something breaks.

learningResourceType: Course module

educationalLevel: Intermediate

inLanguage: en

From Vibe Coder to Real Engineer

@type: Course

ShipReal

@type: Organization


The Illusion of 'It Works'

description: The request lifecycle, environments, and the production iceberg - why 'it runs on my laptop' means almost nothing.


Thinking in Systems & State

description: State, side effects, and idempotency - why 'just run it again' sometimes makes things worse.


Decisions, Complexity & Abstraction

description: Trade-offs, YAGNI, and when an abstraction pays rent - the judgment calls AI can't make for you.


Version Control as a Thinking Tool

description: Git beyond commit and push: branching strategy, bisect, and blame as archaeology.


The AI-Native Engineering Workflow

description: Prompting as spec-writing, reviewing code you didn't write, and the guardrails that keep AI speed safe.


How Code Runs — The Runtime Layer

description: Processes, memory, and the event loop - why Node blocks and why Python's GIL matters.


name: Algorithmic Thinking — Complexity & Data Structures

description: Big-O intuition and arrays vs maps vs trees - when N-squared quietly kills you at 10,000 users.


name: Frontend Architecture — What AI Builds for You (And What It Gets Wrong)

description: Rendering models, state management, and the parts of your frontend AI scaffolds wrong.


name: Dependency Management — The Hidden Minefield

description: Lockfiles, semver lies, and supply-chain attacks - the left-pad story and how not to star in the sequel.


name: Database Fundamentals — Thinking in Data

description: Thinking in tables, indexes, and constraints before you write a single query.


SQL & Query Thinking

description: Joins without fear, query plans you can actually read, and the queries that melt at scale.


name: Data at Scale — Mutations, Migrations & Beyond

description: Mutations, migrations, and backfills that don't take production down with them.


API Design as Contracts

description: REST vs RPC thinking, versioning, and evolving APIs without breaking the people who depend on them.


Networking Fundamentals

description: DNS, TCP, TLS, HTTP - the chain every request lives or dies on.


Real-Time & Event-Driven Patterns

description: WebSockets, server-sent events, and event-driven flows - for when polling stops being enough.


Security by Default

description: OWASP's top risks, injection, and auth failures - the attacks that find you, not the other way around.


Error Handling & Resilience

description: Timeouts, retries with backoff, and circuit breakers - failing gracefully instead of loudly.


Testing — Confidence, Not Coverage

description: Tests that buy confidence instead of coverage numbers - what to test, what to skip, and why.


Observability — Logs, Metrics & Traces

description: Logs, metrics, and traces that answer 'what broke at 3 AM' before your users do.


Containers — Why, Not How

description: What Docker actually solves: images vs containers, and why 'works in the container' finally means something.


name: Cloud Infrastructure — Concepts Over Console Clicks

description: The managed-services decision tree - cloud concepts that outlive any console redesign.


CI/CD — The Pipeline That Protects You

description: The pipeline that blocks bad deploys before your users find them.


name: Architecture Patterns — Monoliths, Services & the Middle Ground

description: Monolith-first thinking, when services earn their complexity, and the middle ground nobody markets.


Asynchronous Processing & Queues

description: Message queues - why every real system has one, and what happens when consumers fall behind.


Caching Strategies

description: Redis, TTLs, and cache invalidation - famously one of the two hard problems in computer science.


Performance, Profiling & Scaling

description: Profile before you optimize: finding the real bottleneck instead of the one you guessed.


Distributed Systems Intuition

description: The fallacies of distributed computing - and the intuition to spot them in your own design.


Payments, Subscriptions & Compliance

description: Payment webhooks that survive retries, subscription state machines, and the compliance basics you can't skip.


Business Metrics & Product Analytics

description: The metrics that actually predict revenue - and the vanity ones that don't.


User Acquisition, Ads & Attribution

description: UTMs, attribution windows, and ad math without lying to yourself.


name: Machine Learning Fundamentals — How Models Learn

description: How models actually learn - enough to not be fooled by demos or vendors.


Adding Intelligence to Your App

description: Embeddings, RAG, and picking the right model for the job instead of the loudest one.


Building Production AI Features

description: Evals, cost and latency budgets, and LLM features that survive real users.


Debugging as a Discipline

description: Hypothesis-driven debugging: reproduce, isolate, prove - not print statements and prayer.


name: Production Readiness & Ongoing Operations

description: The go-live checklist, incident response, and the operations rhythm that starts after launch.


Mobile-Specific Mental Models

description: Why mobile isn't a small website: lifecycles, permissions, and the OS as a strict landlord.


Mobile Data & Networking

description: Offline-first data, sync conflicts, and networks that vanish mid-request.


Mobile Release & Distribution

description: App-store review, release trains, and why you can't hotfix a binary.


name: The Send-Off — Now Go Ship Something That Holds

description: What changed in how you think, the one thing to do this week, and how to keep the judgment you just built.