From Vibe Coder to Real Engineer

The engineering knowledge layer for AI-native developers. Bridge the gap between shipping code and engineering production systems.

11parts 38modules 481chapters
Start free on YouTube Enroll full course

The Curriculum

An introduction, eleven parts and a send-off, built around decisions instead of theory: real postmortems, real defaults, and work on your own project.

Intro

Introduction

Your map of the whole course: what every deep-dive module delivers and how the eleven parts build on each other.

  • Introduction: The Road Ahead
    The map on the table: all 38 modules, what every deep dive delivers, and which module to jump to when something breaks.
    13 chapters~25 minutes
    1. You Ship. Now Let's Make It Real.
    2. Part 1: The Mental Shift (Modules 1 through 3)
    3. Part 2: The Developer's Foundation (Modules 4 through 9)
    4. Part 3: Data (Modules 10 through 12)
    5. Part 4: Networks and APIs (Modules 13 through 15)
    6. Part 5: Fortification (Modules 16 through 19)
    7. Part 6: Infrastructure (Modules 20 through 22)
    8. Part 7: Architecture and Performance (Modules 23 through 27)
    9. Part 8: The Business Layer (Modules 28 through 30)
    10. Part 9: AI and ML Products (Modules 31 through 33)
    11. Parts 10-11: Debugging, Production Readiness, and Mobile (Modules 34 through 38)
    12. The Anatomy of Every Module
    13. Your Project Is the Patient
Part 1

The Mental Shift

Rewire how you think about working software - systems, state, and trade-offs. The judgment layer AI can't supply.

  • 1The Illusion of 'It Works'
    The request lifecycle, environments, and the production iceberg - why 'it runs on my laptop' means almost nothing.
    12 chapters~28 minutes
    1. The Line You Can't See
    2. The Life of a Request
    3. The Iceberg Beneath Your Features
    4. Why Your Laptop Lies to You
    5. The Environment Ladder
    6. How Production Fails: Performance and Data
    7. How Production Fails: Security and Cost
    8. The Gap Has a Price Tag
    9. What Engineers Actually Do
    10. Software Is a Restaurant, Not a Document
    11. Your Production Degradation Timeline
    12. The Checklist Before You Close This Module
  • 2Thinking in Systems & State
    State, side effects, and idempotency - why 'just run it again' sometimes makes things worse.
    12 chapters~29 minutes
    1. You Build Features. Systems Build Bugs.
    2. The Cast of Characters: What Systems Are Made Of
    3. Following a Request Through the System
    4. State: The Root of All Your Bugs
    5. Where State Lives: The Decision That Makes or Breaks You
    6. How State Moves: Data Flow Patterns
    7. Rendering Models: Where Your UI Gets Built Changes Everything
    8. Hydration: The Bug Factory You Didn't Know Existed
    9. Stateless vs. Stateful: The Distinction That Governs Scaling
    10. The Statelessness Checklist
    11. Reading Architecture Diagrams
    12. Putting It Together: A System Thinking Walkthrough
  • 3Decisions, Complexity & Abstraction
    Trade-offs, YAGNI, and when an abstraction pays rent - the judgment calls AI can't make for you.
    14 chapters~36 minutes
    1. Why "It Depends" Isn't a Dodge
    2. Satisficing: The Art of Good Enough
    3. Build vs Buy vs Glue
    4. The 30-Minute Technology Litmus Test
    5. Complexity: The Thing That Actually Kills Software
    6. The Complexity Budget
    7. Abstraction: Your Most Dangerous Weapon
    8. Over-Engineering: Friendly Fire
    9. Technical Debt Is a Strategy, Not an Insult
    10. The Twelve-Factor App: Principles That Survived 15 Years
    11. Reading Systems You Didn't Build
    12. Reading Documentation Like an Engineer
    13. Code Smells: Diagnostic Signals in Unfamiliar Code
    14. Pulling It Together: Your Engineering Decision Instinct
Part 2

Developer's Foundation

The daily craft: Git as a thinking tool, an AI-native workflow, runtimes, algorithms, frontend architecture, and the dependency minefield.

  • 4Version Control as a Thinking Tool
    Git beyond commit and push: branching strategy, bisect, and blame as archaeology.
    13 chapters~33 minutes
    1. The Most Misunderstood Tool You Use Every Day
    2. Snapshots, Hashes, and the Graph You Never Knew You Were Building
    3. The Three Trees: Your Surgical Precision Toolkit
    4. Atomic Commits: Write History Like a Story
    5. What Goes In, What Stays Out, and What Can Never Be Deleted
    6. Branching Strategies: Picking the Right Model for Your Team
    7. Merges, Rebases, and the Golden Rule
    8. Conflict Resolution: The Skill Nobody Teaches
    9. Pull Requests Are Design Documents, Not Merge Buttons
    10. Time Travel: Revert, Reset, Cherry-Pick, and Bisect
    11. The Reflog: Your Hidden Safety Net
    12. Monorepo vs. Polyrepo: The Repository Architecture Decision
    13. Putting It All Together: Your Version Control Habits
  • 5The AI-Native Engineering Workflow
    Prompting as spec-writing, reviewing code you didn't write, and the guardrails that keep AI speed safe.
    13 chapters~31 minutes
    1. The Slot Machine Problem
    2. The Division of Labor
    3. Specification-Driven Development
    4. Effective Prompting (Without the Magic)
    5. Context Management: What the AI Can See
    6. Reviewing AI-Generated Code
    7. Calibrating Your Trust
    8. Naming as a Design Act
    9. Code Organization and the DRY Trap
    10. Type Systems: Your Best AI Guardrail
    11. Automated Quality Enforcement
    12. Documentation That Actually Gets Read
    13. Putting It All Together
  • 6How Code Runs: The Runtime Layer
    Processes, memory, and the event loop - why Node blocks and why Python's GIL matters.
    13 chapters~33 minutes
    1. The Gap You Don't Know You Have
    2. From Text File to Running Instructions
    3. Processes and the OS Contract
    4. Memory: Stack and Heap
    5. Memory Leaks in Garbage-Collected Languages
    6. Garbage Collection: How It Actually Works
    7. Execution Models: Threads, Event Loops, Coroutines
    8. Blocking vs Non-Blocking I/O
    9. Concurrency vs Parallelism
    10. Async/Await: What It Actually Does
    11. Cold Starts and Connection Costs
    12. Resource Limits and Production Failure Modes
    13. Putting It All Together: The Runtime Mental Model
  • 7Algorithmic Thinking: Complexity & Data Structures
    Big-O intuition and arrays vs maps vs trees - when N-squared quietly kills you at 10,000 users.
    13 chapters~27 minutes
    1. "It Works Fine" Is Not an Engineering Statement
    2. Big-O as a Feeling, Not a Formula
    3. Pricing Your Everyday Operations
    4. Arrays: What They're Good At, What They're Terrible At
    5. Hash Maps: The Single Most Useful Performance Upgrade
    6. Sets: Membership and Deduplication in One Line
    7. Stacks and Queues: Order as a Constraint
    8. Trees and Heaps: Why Your Database Is Fast
    9. Graphs: Your Data Is Already a Graph
    10. Choosing the Right Structure: A Decision Checklist
    11. Reading AI-Generated Code Like an Engineer
    12. Talking to the AI Better: Complexity as a Prompt Tool
    13. Installing the Smoke Detector
  • 8Frontend Architecture: What AI Builds for You (And What It Gets Wrong)
    Rendering models, state management, and the parts of your frontend AI scaffolds wrong.
    13 chapters~35 minutes
    1. The Screenshot Lies
    2. Components That Have One Reason to Change
    3. The Tree, Props Down, Events Up
    4. Five Kinds of State and Where Each One Lives
    5. Derived State and the Server Cache You Keep Rebuilding
    6. Re-renders, Keys, and Why Memo Isn't the Fix
    7. The URL Is Your Most Important State Container
    8. Forms: Every Unhappy Path AI Skipped
    9. Accessibility Is Load-Bearing
    10. CSS Architecture and the Fifty Shades of Gray Problem
    11. Design Systems: Buy the Behavior, Own the Paint
    12. Mobile-First for Real, Not as a Slogan
    13. Every Byte You Ship Is a Choice
  • 9Dependency Management: The Hidden Minefield
    Lockfiles, semver lies, and supply-chain attacks - the left-pad story and how not to star in the sequel.
    12 chapters~31 minutes
    1. You're Shipping 300 Megabytes of Strangers' Code
    2. What Install Actually Does
    3. Semver Is a Promise, Not a Guarantee
    4. Lock Files: What You Actually Got
    5. Diamonds, Duplicates and Peer Dependencies
    6. The Attack Surface of Install
    7. Should This Package Exist In Your Project
    8. Tree Shaking and What Actually Ships
    9. Staying Current Without Losing a Week
    10. Your Own Code as a Dependency
    11. Triaging Audit Noise
    12. Write the Policy Down
Part 3

The Data Layer

Databases as mental models: tables and indexes before queries, SQL without fear, and migrations that don't take production down.

  • 10Database Fundamentals: Thinking in Data
    Thinking in tables, indexes, and constraints before you write a single query.
    13 chapters~33 minutes
    1. Your App Is a Data Model Wearing a UI
    2. Entities and Attributes: Which Nouns Earn a Table
    3. Relationships, Cardinality, and the Junction Table Nobody Respects
    4. Modeling a Real Domain: What Is vs What Happened
    5. The Relational Model and the Keys That Hold It Together
    6. Constraints: Business Rules the Database Actually Enforces
    7. Normalization Without the Textbook
    8. Denormalization as a Calculated Bet
    9. Beyond Relational: Picking the Right Shape
    10. Schemas Are Contracts With Your Future Self
    11. ORMs and Query Builders: The Leaky Layer You Use Daily
    12. Where the Database Runs: Managed, Self-Hosted, Embedded
    13. Choosing a Database Without Lying to Yourself
  • 11SQL & Query Thinking
    Joins without fear, query plans you can actually read, and the queries that melt at scale.
    13 chapters~33 minutes
    1. Declarative Is the Whole Trick
    2. Sets, Not Loops
    3. The Query Runs in a Different Order Than You Wrote It
    4. JOINs and the Rows That Multiply
    5. Counting Things Correctly
    6. Indexes: The One Performance Concept That Pays for Itself
    7. Stop Guessing. Ask the Planner.
    8. Transactions: What You're Actually Promised
    9. Isolation Levels and the Double Booking
    10. N+1: The Silent Epidemic
    11. CTEs, Subqueries, and the NOT IN Landmine
    12. Window Functions: Analytics Without Leaving the Database
    13. Views, Materialized Views, and What to Do Monday
  • 12Data at Scale: Mutations, Migrations & Beyond
    Mutations, migrations, and backfills that don't take production down with them.
    13 chapters~34 minutes
    1. Success Is the Problem
    2. Why Your Database Says No
    3. Transaction Mode, Session Mode, and Serverless
    4. Expand and Contract: Changing the Plane While Flying
    5. The DDL That Locks Your Table
    6. Deletes, Bloat and Retention
    7. Two Writers, One Row
    8. Replication and the Read You Can't Trust
    9. Failover Is a Loaded Weapon
    10. Partitioning, Sharding, and the Ladder You Climb First
    11. When LIKE Takes Nine Seconds
    12. The Backup You Never Restored
    13. CAP: The Questions, Not the Triangle
Part 4

Networks & Contracts

How systems talk to each other: APIs as contracts, the DNS-to-HTTP chain every request lives on, and real-time patterns.

  • 13API Design as Contracts
    REST vs RPC thinking, versioning, and evolving APIs without breaking the people who depend on them.
    13 chapters~35 minutes
    1. The Eight-Second API and the Ten-Year Promise
    2. Contract-First and Consumer-Driven Design
    3. REST: The Constraints That Actually Pay Rent
    4. HTTP Methods and the Idempotency Contract
    5. Status Codes as a Communication System
    6. URLs, Resources, and Actions That Don't Fit CRUD
    7. Payloads, Nulls, and the PATCH Everyone Botches
    8. Pagination: The Decision You Can't Take Back
    9. Error Design as a First-Class Contract
    10. GraphQL: What It Buys and What It Costs
    11. gRPC and tRPC: Contracts Between Services
    12. OpenAPI, Docs, and Specs That Don't Drift
    13. Versioning, Deprecation, and the Enum Trap
  • 14Networking Fundamentals
    DNS, TCP, TLS, HTTP - the chain every request lives or dies on.
    12 chapters~33 minutes
    1. The Pipe Is Not Magic
    2. Addresses, Ports and the Socket Nobody Explained
    3. TCP, UDP and the Cost of Being Reliable
    4. DNS: Caches Expiring, Not Propagating
    5. HTTP, Four Generations Deep
    6. TLS Without the Hand-Waving
    7. CORS Is Not a Feature You Enable
    8. Everything Between the User and Your Server
    9. Drawing the Blast Radius
    10. Physics Doesn't Negotiate
    11. Timeouts, Retries and the Stampede You Caused
    12. The Triage Playbook
  • 15Real-Time & Event-Driven Patterns
    WebSockets, server-sent events, and event-driven flows - for when polling stops being enough.
    12 chapters~33 minutes
    1. The Pull Ceiling
    2. Four Transports, One Decision
    3. WebSockets: The Upgrade And The Hole In It
    4. Staying Connected: Heartbeats, Backoff, And Gaps
    5. Server-Sent Events: The One You're Skipping
    6. Long Polling: Ugly, Useful, Everywhere
    7. Webhooks: Someone Else's Push, Your Problem
    8. Commands And Facts
    9. Event Sourcing: Keep The Ledger, Derive The Balance
    10. CQRS Without The Religion
    11. Pub/Sub: The Wiring Behind Events
    12. Scaling, Serialization, And When To Buy Instead
Part 5

Fortification

Making it survive contact with reality: security by default, resilient error handling, tests that buy confidence, and observability that answers 'what broke at 3 AM'.

  • 16Security by Default
    OWASP's top risks, injection, and auth failures - the attacks that find you, not the other way around.
    12 chapters~35 minutes
    1. The Code Works. That's Not the Same as Safe.
    2. Threat Modeling in Thirty Minutes
    3. The OWASP Top Ten as a Map, Not a Quiz
    4. Injection: Data That Becomes Instructions
    5. XSS and the Browser's Only Real Rule
    6. CSRF, SameSite, and the CORS Misunderstanding
    7. Authentication: Buy It, Don't Build It
    8. Authorization: The Check AI Always Skips
    9. Passwords and the Crypto You're Allowed to Touch
    10. Sessions, Cookies, and the JWT You Can't Log Out Of
    11. Secrets, Rotation, and Least Privilege
    12. Defense in Depth: The Outer Rings
  • 17Error Handling & Resilience
    Timeouts, retries with backoff, and circuit breakers - failing gracefully instead of loudly.
    12 chapters~32 minutes
    1. The Unhappy Path Is the Job
    2. Why Generated Code Is Optimistic
    3. Classify Before You Handle
    4. Partial Failure: The Charge With No Order
    5. Handle, Propagate, or Swallow
    6. Three Audiences, One Failure
    7. Timeouts: The One Pattern to Take
    8. Retries Without the Storm
    9. Circuit Breakers and Bulkheads
    10. Degrade on Purpose
    11. How One Slow Thing Kills Everything
    12. Finding Out, and Closing the Loop
  • 18Testing: Confidence, Not Coverage
    Tests that buy confidence instead of coverage numbers - what to test, what to skip, and why.
    12 chapters~33 minutes
    1. Tests Are a Change Detector, Not a Proof
    2. The Pyramid Is an Economics Argument
    3. Unit Tests: Test the Behavior, Not the Function
    4. Integration Tests: The Seams Are Where Bugs Live
    5. End-to-End: Five Flows, Ten Minutes, No Sleeps
    6. Test Doubles: Fake the Boundary, Nothing Else
    7. Property-Based Testing: Let the Machine Find It
    8. Contract Testing: Stop Finding Out From Customers
    9. TDD as a Design Tool, Used Selectively
    10. Reviewing AI-Generated Tests
    11. Determinism, Data, and the Flaky Test Policy
    12. Coverage Lies. Mutation Testing Doesn't.
  • 19Observability: Logs, Metrics & Traces
    Logs, metrics, and traces that answer 'what broke at 3 AM' before your users do.
    15 chapters~33 minutes
    1. Flying Blind: What Observability Actually Means
    2. Cardinality: The Number That Decides Your Bill
    3. Structured Logs: Events, Not Sentences
    4. Levels Are a Contract, and Secrets Are Forever
    5. Correlation IDs: Stitching One Request Together
    6. Aggregation and Retention: Where the Money Goes
    7. Metrics: Counters, Gauges, and Why Averages Lie
    8. The Four Golden Signals and Their Sharp Edges
    9. Distributed Tracing and the Sampling Decision
    10. OpenTelemetry: Instrument Once, Export Anywhere
    11. Dashboards That Answer Questions
    12. Alerting Without Burning Your On-Call
    13. SLIs, SLOs and the Error Budget
    14. Real Users and Robots: RUM and Synthetics
    15. The Economics of Watching Your Own System
Part 6

Infrastructure & Deployment

What your code stands on: what containers actually solve, cloud concepts that outlive any console redesign, and pipelines that block bad deploys.

  • 20Containers: Why, Not How
    What Docker actually solves: images vs containers, and why 'works in the container' finally means something.
    12 chapters~35 minutes
    1. The Dockerfile You Copy-Pasted
    2. It's a Process, Not a Machine
    3. Layers and Why Your Build Takes Eleven Minutes
    4. Images That Belong in Production
    5. Networking: localhost Is Lying to You
    6. Ephemeral by Design, and Where Your Data Goes
    7. Compose: The Whole Stack as One File
    8. Registries, Tags, and Why latest Is a Loaded Gun
    9. Limits, Throttles, and the OOM Killer
    10. The Thin Wall: Container Security
    11. When Not to Containerize
    12. Outgrowing One Host
  • 21Cloud Infrastructure: Concepts Over Console Clicks
    The managed-services decision tree - cloud concepts that outlive any console redesign.
    12 chapters~38 minutes
    1. The Cloud Is a Landlord, Not Magic
    2. The Compute Spectrum: VMs, Containers, Functions
    3. Storage: Block, Object, and the One You Should Default To
    4. VPCs and Cloud Networking: Why Your Deploy Times Out
    5. IAM: The Blast Radius You Choose in Advance
    6. Regions and Availability Zones: Geography Is Latency
    7. Managed Services: Renting Someone Else's On-Call
    8. Serverless, Honestly: Limits, Cold Starts, and the Memory Dial
    9. Edge Computing: The Thin Layer at the Perimeter
    10. Cloud Cost: Where the Bill Actually Comes From
    11. Infrastructure as Code: Clicking Is Debt With Interest
    12. The Defaults, and What Every Abstraction Costs You
  • 22CI/CD: The Pipeline That Protects You
    The pipeline that blocks bad deploys before your users find them.
    12 chapters~33 minutes
    1. Integration Hell and the Tax You're Already Paying
    2. Delivery vs Deployment: Where Your Team Actually Belongs
    3. Anatomy of a Pipeline: Build Once, Promote Everywhere
    4. Runners: The Machines Your Pipeline Actually Runs On
    5. Environments, Promotion Gates, and Why Staging Lies
    6. Preview Environments: Every Pull Request Gets a World
    7. Deployment Strategies: Rolling, Blue Green, Canary
    8. Feature Flags: Deploy Is Not Release
    9. Zero Downtime: The Four Mechanics
    10. Rollbacks: Your Most Important Deployment
    11. Pipeline Security: Secrets, Scanning, Supply Chain
    12. Speed Is a Feature
Part 7

Architecture & Scale

Designing for growth: monolith-first architecture, queues, caching, profiling before optimizing, and distributed-systems intuition.

  • 23Architecture Patterns: Monoliths, Services & the Middle Ground
    Monolith-first thinking, when services earn their complexity, and the middle ground nobody markets.
    13 chapters~34 minutes
    1. Your Architecture Is Your Org Chart
    2. Four Forces and the Door You Can't Walk Back Through
    3. The Monolith Deserves More Respect Than You Give It
    4. What a Good Monolith Looks Like Inside
    5. When the Monolith Actually Cracks
    6. Microservices Buy Autonomy, Not Speed
    7. The Distributed Systems Tax
    8. The Middle Ground Where Most Teams Actually Live
    9. Domain-Driven Design: Where To Actually Cut
    10. Who Owns the Data
    11. Multi-Tenancy: One System, Many Customers
    12. The Front Door: API Gateway and Backend-for-Frontend
    13. The Strangler Fig: Migrating Without Betting the Company
  • 24Asynchronous Processing & Queues
    Message queues - why every real system has one, and what happens when consumers fall behind.
    14 chapters~34 minutes
    1. Four Seconds of Spinner: Why Sync Breaks
    2. What Async Actually Costs You
    3. Queues and Streams Are Not the Same Thing
    4. Producers, Brokers, Consumers: The Moving Parts
    5. Delivery Guarantees and the Exactly-Once Lie
    6. Idempotency: The Concept That Makes Retries Safe
    7. Background Jobs and Worker Design
    8. Email Is a Pipeline, Not an API Call
    9. File Pipelines and Notification Fanout
    10. Scheduled Jobs Versus Event-Driven Work
    11. Sagas: Transactions Across Services
    12. The Transactional Outbox and the Dual Write Problem
    13. Poison Messages and Dead Letter Queues
    14. Backpressure, Consumer Lag, and Shedding Load
  • 25Caching Strategies
    Redis, TTLs, and cache invalidation - famously one of the two hard problems in computer science.
    12 chapters~30 minutes
    1. The Bargain: You're Trading Truth for Speed
    2. Where Caches Actually Live
    3. HTTP Caching, Part One: The Free Infrastructure
    4. HTTP Caching, Part Two: ETags, Vary, and Cache Busting
    5. Application Patterns: Cache-Aside and Its Cousins
    6. Eviction: What to Forget, and How Big to Get
    7. Invalidation: Make the Lie Expire
    8. Redis Does More Than get and set
    9. The Four Ways Your Cache Kills Your Database
    10. Cold Starts and Multi-Tier Caching
    11. What You Must Never Cache
    12. The Decision Framework You'll Actually Use
  • 26Performance, Profiling & Scaling
    Profile before you optimize: finding the real bottleneck instead of the one you guessed.
    14 chapters~33 minutes
    1. You're Guessing, And Guessing Is Expensive
    2. The Four Kinds Of Slow
    3. Percentiles, Budgets, And The Loop
    4. Reading A Flame Graph Without Pretending
    5. Memory Leaks, GC Pressure, And The Sawtooth
    6. Where The Milliseconds Actually Go
    7. The Database Is The Bottleneck (It Usually Is)
    8. Frontend: Measuring What Users Feel
    9. Load Testing: Breaking It On Purpose
    10. Bigger Machine Or More Machines
    11. Auto-scaling That Actually Arrives In Time
    12. Rate Limiting, Throttling, And Load Shedding
    13. Global Distribution And The Speed Of Light
    14. Code, Hardware, Or Architecture: Pick The Lever
  • 27Distributed Systems Intuition
    The fallacies of distributed computing - and the intuition to spot them in your own design.
    12 chapters~34 minutes
    1. One Machine Was Lying To You
    2. The Eight Fallacies, Used As A Checklist
    3. Partial Failure: Nobody Crashed, Everything Is Wrong
    4. Clocks Lie, And Nobody Logs It
    5. Causality: Ordering Without Trusting Time
    6. FLP, CAP, And The Version Of CAP You Should Actually Use
    7. Consensus, Quorums, And Fencing Tokens
    8. The Consistency Spectrum And What Users Actually Notice
    9. Replication: Three Architectures, One Default
    10. Partitions And Split Brain
    11. Telling Slow From Dead
    12. The Reflex: Reading Any Architecture Diagram
Part 8

The Business Layer

The code that pays the bills: payments and compliance, metrics that actually predict revenue, and attribution without lying to yourself.

  • 28Payments, Subscriptions & Compliance
    Payment webhooks that survive retries, subscription state machines, and the compliance basics you can't skip.
    12 chapters~34 minutes
    1. Money Doesn't Retry
    2. Authorize, Capture, Settle
    3. Card Data Is Radioactive
    4. Picking a Provider Without Marrying One
    5. The Subscription State Machine
    6. Dunning, Proration and Usage
    7. Marketplaces and Other People's Money
    8. Fraud Is a Dial, Not a Switch
    9. Chargebacks Cost More Than the Sale
    10. Currency, Local Methods and Tax
    11. Webhooks Without Duplicate Charges
    12. Reconciliation, or How You Find Out You're Wrong
  • 29Business Metrics & Product Analytics
    The metrics that actually predict revenue - and the vanity ones that don't.
    13 chapters~35 minutes
    1. Your Code Is the Measuring Instrument
    2. The Metrics, Rewritten as Questions Your System Must Answer
    3. Designing the Event Schema Before You Write a Single track() Call
    4. Client or Server: Where the Event Is Born
    5. Identity Resolution: One Human, Five User IDs
    6. The Stack: Hosted, Product Analytics, or Your Own Warehouse
    7. Pipelines: Getting Events There Without Losing or Cloning Them
    8. Sessions and the Shape of a Retention Curve
    9. Activation, Behavioral Segments, and Feature Adoption
    10. Experiment Infrastructure: Assignment, Exposure, Sample Size
    11. How Your Experiment Lies to You
    12. Data Quality: Tests, Contracts, and One Definition of MAU
    13. Privacy-Compliant Analytics: Consent as a System
  • 30User Acquisition, Ads & Attribution
    UTMs, attribution windows, and ad math without lying to yourself.
    13 chapters~36 minutes
    1. The Funnel Is a Data Pipeline, Not a Slide
    2. Ad Auctions: You're Training Someone Else's Model
    3. Attribution Models Are Queries, and Last Touch Lies
    4. Incrementality: The Only Number That Survives an Audit
    5. Click IDs, UTMs, and Capturing Them Before They Vanish
    6. Server-Side Conversions, Hashing, and Deduplication
    7. Signal Loss: Build for What You Own
    8. Deep Links and Identity Resolution
    9. SEO Is a Rendering Problem
    10. Owned Channels: Deliverability Is Engineering
    11. Landing Pages and the State Machine Behind Signup
    12. Referrals, K-Factor, and Cycle Time
    13. Ad Fraud and the Reconciliation Job
Part 9

AI-Powered Products

Shipping intelligence responsibly: how models learn, embeddings and RAG, and production AI features with evals and cost budgets.

  • 31Machine Learning Fundamentals: How Models Learn
    How models actually learn - enough to not be fooled by demos or vendors.
    12 chapters~33 minutes
    1. Rules In, Answers Out - and the Inversion
    2. Three Kinds of Examples: Supervised, Unsupervised, Reinforcement
    3. Features, Labels, and Why the Data Is the Project
    4. Leakage: The Mistake That Looks Like Success
    5. Train, Validation, Test - the Split That Keeps You Honest
    6. Overfitting and Underfitting in Thirty Seconds
    7. Bias, Variance, and Why Bigger Isn't Better
    8. The Model Families and Your Default Stack
    9. Accuracy Is Lying to You
    10. The Rest of the Report Card - and What Each Number Hides
    11. When Not to Use Machine Learning
    12. Five Questions That Make You the Adult in the Room
  • 32Adding Intelligence to Your App
    Embeddings, RAG, and picking the right model for the job instead of the loudest one.
    13 chapters~33 minutes
    1. You're Renting a Model, Not Hiring One
    2. The Cheapest AI Feature Is the One You Don't Build
    3. Five Rungs: API Call to Your Own GPUs
    4. Choosing a Model Without Reading a Leaderboard
    5. A Prompt Is an Interface Contract
    6. Prompt Injection: Permissions, Not Persuasion
    7. Structured Outputs and the Trust Boundary
    8. Embeddings: Meaning as Coordinates
    9. Chunking Decides Your Answer Quality
    10. The RAG Pipeline, Stage by Stage
    11. Vision, Audio, and Documents That Have Layout
    12. Tokens Are Money and Users Control the Spend
    13. Evaluation: The File That Outlives Your Prompt
  • 33Building Production AI Features
    Evals, cost and latency budgets, and LLM features that survive real users.
    12 chapters~33 minutes
    1. It Worked in the Demo
    2. Pick the Pattern Before You Pick the Model
    3. Streaming: Buying Patience by the Token
    4. Prompts Are Code, Treat Them That Way
    5. Context Budgets and the Memory That Isn't
    6. Prompt Injection: The Unsolved One
    7. Output Validation: Nothing Ships Unchecked
    8. Grounding, Citations, and Earning the Right to Say I Don't Know
    9. Agents: Bounding the Loop
    10. Humans in the Loop Without Burning Them Out
    11. Observability: Watching Quality Move
    12. Latency, Cache, Cascade, Fallback
Part 10

Craft & Production Mastery

The senior habits: hypothesis-driven debugging and the go-live checklist that separates launches from gambles.

  • 34Debugging as a Discipline
    Hypothesis-driven debugging: reproduce, isolate, prove - not print statements and prayer.
    12 chapters~35 minutes
    1. Slot Machine Engineering (And Why It Fails)
    2. The Debugging Journal and the Forty-Five Minute Rule
    3. The Loop: Reproduce, Isolate, Identify, Fix, Verify, Prevent
    4. Reading the Announcement: Traces, Errors, Logs
    5. Cut It In Half: Bisect, Wolf Fence, Delta Debugging
    6. Client and Network: The Tab You Never Opened
    7. The Data Layer: Pools, Plans, Locks, Corruption
    8. Containers: The Four Things It Can't Package
    9. Production: Debugging Without a Debugger
    10. Leaks, Descriptors, and Flame Graphs
    11. Concurrency: Widen the Window, Then Design It Away
    12. Ducks, Fresh Eyes, and Saying I Don't Know
  • 35Production Readiness & Ongoing Operations
    The go-live checklist, incident response, and the operations rhythm that starts after launch.
    14 chapters~37 minutes
    1. Deployed Is Not Ready
    2. Probes That Lie, Shutdowns That Drop Requests
    3. Migrations With No Undo Button
    4. Rollback Is A Feature You Ship
    5. Alerts People Actually Answer
    6. Stop The Bleeding First
    7. Postmortems That Change Something
    8. Runbooks And ADRs: Memory Outside Your Head
    9. Break It On Purpose
    10. Compliance As Engineering Work
    11. The World Is Not Your Locale
    12. Rot: Dependencies, Vacuum, Certs, Dead Features
    13. The Bill And The Ceiling
    14. Backups You Have Actually Restored
Part 11

Mobile Expansion

Everything changes on a phone: offline-first data, networks that vanish mid-request, and app-store release trains.

  • 36Mobile-Specific Mental Models
    Why mobile isn't a small website: lifecycles, permissions, and the OS as a strict landlord.
    13 chapters~33 minutes
    1. A Phone Is Not a Small Laptop
    2. Native, Cross-Platform, or WebView
    3. The Lifecycle: Your Code Runs on Borrowed Time
    4. Design for Death: State Restoration
    5. The Sandbox and the Permission Model
    6. Talking to the Outside World
    7. Offline-First Is a Product Decision
    8. Touch, Conventions, and Accessibility
    9. Push Notifications: Plumbing and Restraint
    10. Deep Links: Giving Screens an Address
    11. PWAs: When Native Isn't Worth It
    12. The Five Numbers of Mobile Performance
    13. You Cannot Hotfix a Phone
  • 37Mobile Data & Networking
    Offline-first data, sync conflicts, and networks that vanish mid-request.
    12 chapters~37 minutes
    1. The Radio Is Asleep: Mobile Networking as a Physical Problem
    2. Four Storage Tiers, and Putting Data in the Wrong One
    3. Local-First: The Network Is Not in the Read Path
    4. The Operation Queue: Where Money Gets Lost
    5. Delta Sync: Only Ask for What Changed
    6. Conflict Resolution: Deciding Whose Edit Dies
    7. API Shapes That Survive a Cold Radio
    8. Serialization: When JSON Stops Being Free
    9. Images: The 200KB File That Costs You 12MB of RAM
    10. Background Work: You Don't Get to Decide When
    11. Adapting in Real Time: Reachability Lies
    12. Security on a Device You Don't Own
  • 38Mobile Release & Distribution
    App-store review, release trains, and why you can't hotfix a binary.
    12 chapters~30 minutes
    1. The Distribution Wall
    2. Code Signing and the Trust Chain
    3. Variants, Versioning and the Update Policy
    4. Beta Testing That Isn't Theater
    5. The Review Gauntlet
    6. The Pipeline: CI/CD With a Human at the End
    7. Staged Rollouts and the Statistics Trap
    8. Over the Air: A Scalpel, Not a Sword
    9. Crash Reporting and Release Health
    10. Remote Config, Experiments and the Kill Switch
    11. ASO: The Four Seconds Before Install
    12. The Runbook You Write Before You Need It
Send-Off

The Send-Off

The closing bookend: what changed in how you think, and the one thing to go do while it is still fresh.

  • The Send-Off: Now Go Ship Something That Holds
    What changed in how you think, the one thing to do this week, and how to keep the judgment you just built.
    7 chapters~12 minutes
    1. You Finished
    2. The Expensive Way
    3. Think About What Changed
    4. The Questions That Fire Automatically Now
    5. The Modules That Felt Abstract
    6. Do One Thing This Week
    7. Now Go Ship Something That Holds

Choose Your Course

Same 38 modules, three depths. Everything between "it runs" and production.

Free CourseFreeOn YouTube Quick CourseQuickOn Udemy Full CourseFullOn Teachable
Each video length1 minute5-6 minutes25-40 minutes
PricingFreeMonthlyOne-time
Ongoing updatesNot includedIncludedIncluded
Direct instructor Q&AInstructor Q&ANot includedIncludedIncluded
Real-world postmortemsNot includedNot includedIncluded
Hands-on assignmentsNot includedNot includedIncluded
Audits & knowledge checksSelf auditsNot includedNot includedIncluded
Multilingual subtitlesNot includedNot includedIncluded
Start freeStart Enroll full courseEnroll

Assignments run on your own shipped project, not a toy repo. Rolling it out to a team? See Teams & Corporate.

Teams & Corporate

Roll the course out to your team, served and tracked in your LMS. Every plan is scoped together before anything is signed.

Progress visibility

Completion and quiz results flow back as SCORM or xAPI statements: who started, who finished, and where people get stuck.

SSO & seat management

Single sign-on over SAML or OIDC through your identity provider, and seats move with the team as people join and leave.

LMS-ready delivery

Ships as SCORM or xAPI packages, or connects over LTI, so modules are served, assigned, and tracked inside Cornerstone, Workday, Moodle, or whatever LMS your org runs.

Contact me

Frequently Asked Questions

Who is this course for?

Developers who learned by building, not by studying. You ship apps with AI tools daily (Copilot, Claude, ChatGPT) and you're faster than ever. But there's a gap between "it runs" and "it's engineered", and you feel it when something breaks at 3 AM or when a senior dev asks "why did you do it this way?"

You're not a beginner. You can write code but can't always explain what happens after you hit Enter. That's exactly the gap this course closes.

What does it teach that I can't just prompt for?

Judgment. AI writes 80% of your code now; the 20% that matters is architecture, error handling, the security model, and system design. That 20% requires understanding trade-offs, context, and consequences, which is precisely what AI can't do for you.

Every module takes something you already "know" (databases, APIs, deploys) and shows you what you're missing: the request lifecycle, query plans, retry storms, cache invalidation, the go-live checklist.

Do I need a CS degree or a specific tech stack?

No degree needed. The course was built for people who skipped it, or got one and forgot most of it. It's concept-first: examples use mainstream tools like PostgreSQL, Redis, Docker, and Stripe, but every module teaches the mental model, not vendor button-clicking, so it transfers to whatever stack you ship with.

What's the difference between the free, quick, and full courses?

Same curriculum, three depths. The free course on YouTube is a 1-minute overview of every module: enough to know what you don't know. The quick course on Udemy (coming soon) compresses each module into a 5-6 minute lesson, without the postmortems or assignments, and is billed monthly through Udemy's subscription. The full course on Teachable is the real thing, bought once: 25-40 minute deep dives per module, plus the real-world postmortem, the hands-on assignment, multilingual subtitles, and direct instructor Q&A.

What are the postmortems and assignments?

Every full-course module dissects a real, documented engineering disaster: real company, real date, real root cause, and what would have prevented it. Then the assignment applies the module to your own shipped project, not a toy repo, so every module ends with your real system a little more production-grade than before.

How long will it take?

The full course is 38 teaching modules of 25-40 minutes each, plus assignments, and it closes with a short send-off. Figure 25-30 hours of video, and roughly double that with the hands-on work. It's structured in eleven independent parts, so you can also jump straight to the part that's currently on fire: deploys broken? Part 6. Query slow? Part 3.

Do I get a certificate?

The quick course on Udemy (coming soon) issues Udemy's certificate of completion when you finish it. The full course does not: it is built around the postmortems, the assignments on your own project, and direct instructor Q&A, which is what a reviewer will actually ask you about. Corporate plans get completion reporting for managers instead.

Can my company get this for the whole team?

Yes. Corporate plans add SSO, progress reporting, and delivery into your LMS as SCORM or xAPI packages, or over LTI. Every plan is scoped with you first, so you only pay for what your org will actually use. Contact me.

What if it's not for me?

Start with the free overviews on YouTube: they'll tell you fast whether the course speaks your language. The full course is a one-time purchase with a 14-day money-back window. The quick course is a monthly subscription on Udemy (coming soon), so you cancel instead of asking for a refund and keep access until the cycle ends. Both are spelled out in the refund policy.

What languages is it available in?

Narration is English only for now. The full course on Teachable includes translations for Spanish, German, Italian, French, and Hebrew. More languages are coming soon.

Ready to bridge the gap?

Start free on YouTube Enroll full course