--- title: "ShipReal: From Vibe Coder to Real Engineer" description: "Your AI wrote the app. Nobody wrote the part that keeps it up. This 20 hour course closes that gap." canonical: "https://shipreal.dev/" last-updated: "2026-08-30" --- # From Vibe Coder to Real Engineer > Your AI wrote the app. Nobody wrote the part that keeps it up. This 20 hour course closes that gap. **11 parts · 38 modules · 481 chapters**: start with Free on [YouTube](https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo), or take Complete on [Teachable](https://shipreal.teachable.com/courses/course/lectures/66619411). ## Course Contents ### 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** (13 chapters, ~25 min): The map on the table: all 38 modules, what every deep dive delivers, and which module to jump to when something breaks. ### Part 1: The Mental Shift Rewire how you think about working software - systems, state, and trade-offs. The judgment layer AI can't supply. - **The Illusion of 'It Works'** (12 chapters, ~28 min): The request lifecycle, environments, and the production iceberg - why 'it runs on my laptop' means almost nothing. - **Thinking in Systems & State** (12 chapters, ~29 min): State, side effects, and idempotency - why 'just run it again' sometimes makes things worse. - **Decisions, Complexity & Abstraction** (14 chapters, ~36 min): Trade-offs, YAGNI, and when an abstraction pays rent - the judgment calls AI can't make for you. ### 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. - **Version Control as a Thinking Tool** (13 chapters, ~33 min): Git beyond commit and push: branching strategy, bisect, and blame as archaeology. - **The AI-Native Engineering Workflow** (13 chapters, ~31 min): Prompting as spec-writing, reviewing code you didn't write, and the guardrails that keep AI speed safe. - **How Code Runs: The Runtime Layer** (13 chapters, ~33 min): Processes, memory, and the event loop - why Node blocks and why Python's GIL matters. - **Algorithmic Thinking: Complexity & Data Structures** (13 chapters, ~27 min): Big-O intuition and arrays vs maps vs trees - when N-squared quietly kills you at 10,000 users. - **Frontend Architecture: What AI Builds for You (And What It Gets Wrong)** (13 chapters, ~35 min): Rendering models, state management, and the parts of your frontend AI scaffolds wrong. - **Dependency Management: The Hidden Minefield** (12 chapters, ~31 min): Lockfiles, semver lies, and supply-chain attacks - the left-pad story and how not to star in the sequel. ### 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. - **Database Fundamentals: Thinking in Data** (13 chapters, ~33 min): Thinking in tables, indexes, and constraints before you write a single query. - **SQL & Query Thinking** (13 chapters, ~33 min): Joins without fear, query plans you can actually read, and the queries that melt at scale. - **Data at Scale: Mutations, Migrations & Beyond** (13 chapters, ~34 min): Mutations, migrations, and backfills that don't take production down with them. ### 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. - **API Design as Contracts** (13 chapters, ~35 min): REST vs RPC thinking, versioning, and evolving APIs without breaking the people who depend on them. - **Networking Fundamentals** (12 chapters, ~33 min): DNS, TCP, TLS, HTTP - the chain every request lives or dies on. - **Real-Time & Event-Driven Patterns** (12 chapters, ~33 min): WebSockets, server-sent events, and event-driven flows - for when polling stops being enough. ### 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'. - **Security by Default** (12 chapters, ~35 min): OWASP's top risks, injection, and auth failures - the attacks that find you, not the other way around. - **Error Handling & Resilience** (12 chapters, ~32 min): Timeouts, retries with backoff, and circuit breakers - failing gracefully instead of loudly. - **Testing: Confidence, Not Coverage** (12 chapters, ~33 min): Tests that buy confidence instead of coverage numbers - what to test, what to skip, and why. - **Observability: Logs, Metrics & Traces** (15 chapters, ~33 min): Logs, metrics, and traces that answer 'what broke at 3 AM' before your users do. ### 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. - **Containers: Why, Not How** (12 chapters, ~35 min): What Docker actually solves: images vs containers, and why 'works in the container' finally means something. - **Cloud Infrastructure: Concepts Over Console Clicks** (12 chapters, ~38 min): The managed-services decision tree - cloud concepts that outlive any console redesign. - **CI/CD: The Pipeline That Protects You** (12 chapters, ~33 min): The pipeline that blocks bad deploys before your users find them. ### Part 7: Architecture & Scale Designing for growth: monolith-first architecture, queues, caching, profiling before optimizing, and distributed-systems intuition. - **Architecture Patterns: Monoliths, Services & the Middle Ground** (13 chapters, ~34 min): Monolith-first thinking, when services earn their complexity, and the middle ground nobody markets. - **Asynchronous Processing & Queues** (14 chapters, ~34 min): Message queues - why every real system has one, and what happens when consumers fall behind. - **Caching Strategies** (12 chapters, ~30 min): Redis, TTLs, and cache invalidation - famously one of the two hard problems in computer science. - **Performance, Profiling & Scaling** (14 chapters, ~33 min): Profile before you optimize: finding the real bottleneck instead of the one you guessed. - **Distributed Systems Intuition** (12 chapters, ~34 min): The fallacies of distributed computing - and the intuition to spot them in your own design. ### 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. - **Payments, Subscriptions & Compliance** (12 chapters, ~34 min): Payment webhooks that survive retries, subscription state machines, and the compliance basics you can't skip. - **Business Metrics & Product Analytics** (13 chapters, ~35 min): The metrics that actually predict revenue - and the vanity ones that don't. - **User Acquisition, Ads & Attribution** (13 chapters, ~36 min): UTMs, attribution windows, and ad math without lying to yourself. ### Part 9: AI-Powered Products Shipping intelligence responsibly: how models learn, embeddings and RAG, and production AI features with evals and cost budgets. - **Machine Learning Fundamentals: How Models Learn** (12 chapters, ~33 min): How models actually learn - enough to not be fooled by demos or vendors. - **Adding Intelligence to Your App** (13 chapters, ~33 min): Embeddings, RAG, and picking the right model for the job instead of the loudest one. - **Building Production AI Features** (12 chapters, ~33 min): Evals, cost and latency budgets, and LLM features that survive real users. ### Part 10: Craft & Production Mastery The senior habits: hypothesis-driven debugging and the go-live checklist that separates launches from gambles. - **Debugging as a Discipline** (12 chapters, ~35 min): Hypothesis-driven debugging: reproduce, isolate, prove - not print statements and prayer. - **Production Readiness & Ongoing Operations** (14 chapters, ~37 min): The go-live checklist, incident response, and the operations rhythm that starts after launch. ### Part 11: Mobile Expansion Everything changes on a phone: offline-first data, networks that vanish mid-request, and app-store release trains. - **Mobile-Specific Mental Models** (13 chapters, ~33 min): Why mobile isn't a small website: lifecycles, permissions, and the OS as a strict landlord. - **Mobile Data & Networking** (12 chapters, ~37 min): Offline-first data, sync conflicts, and networks that vanish mid-request. - **Mobile Release & Distribution** (12 chapters, ~30 min): App-store review, release trains, and why you can't hotfix a binary. ### Part 12: 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** (7 chapters, ~12 min): What changed in how you think, the one thing to do this week, and how to keep the judgment you just built. ## Formats - Free (1-minute module overviews, on YouTube): https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo - Complete (25-40 minute deep dives, postmortems, hands-on assignments, self-graded quizzes, open-ended questions, subtitles, instructor Q&A, earned certificate of graduation, on Teachable; one-time purchase): https://shipreal.teachable.com/courses/course/lectures/66619411 - Teams & corporate (SSO, progress reporting, SCORM/xAPI/LTI delivery): michael@shipreal.dev ## FAQ ### 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 are the postmortems and assignments? Every module in Complete 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? Complete is 38 teaching modules of 25-40 minutes each, plus assignments, and it closes with a short send-off. Figure about 20 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? Yes! And it's earned rather than handed out for watching: the ShipReal certificate of graduation, from Teachable. Every module closes with a 10-question self-graded quiz and an open-ended question, and the certificate comes once you have worked through all of them. ### Can my company get this for the whole team? Yes. Seats are sold directly, at the per-seat price in team plans above, on one invoice, and they move with the team as people join and leave. Every engineer gets the Complete course, worked against their own project rather than a shared sandbox. Past 20 seats, or when you need a PO, single sign-on over SAML or OIDC, or the modules delivered into your own LMS as SCORM or xAPI packages or over LTI, inside Cornerstone, Workday, Moodle, or whatever your org runs, write to me and we will scope it together. ### 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. Past that, the guarantee in the pricing table is the whole answer, and the mechanics of claiming it are in the refund policy. ### What languages is it available in? Narration is English only for now. Complete on Teachable includes English, French, German, Italian, Spanish & Hebrew subtitles. More languages are coming soon. ## Legal [Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)