DEVREPS

Core language mechanics — the fundamentals worth actually understanding, not memorizing.

The language mechanics underneath both TypeScript and React — the event loop, closures, prototypes, and promises — explained from how the engine actually executes them, not just the syntax for using them.

A type system bolted onto JavaScript — what it actually checks, what it can't, and the handful of ideas (structural typing, narrowing, generics) everything else builds on.

This curriculum's first compiled, statically-typed systems language — explicit error handling instead of exceptions, goroutines and channels for concurrency, and a deliberately small language where composition replaces inheritance entirely.

The patterns that show up over and over — arrays, hash maps, trees, and how to recognize which one fits.

SOLID, composition over inheritance, and the patterns worth recognizing in real code.

The paradigm OOP's own domain doesn't cover — pure functions, immutability, and composition as the alternative to classes and inheritance, plus the ideas (Option/Result types, monads, map/filter/reduce) that already show up constantly in ordinary Python and JavaScript code, explained as what they actually are.

What's actually happening underneath every program you run — processes and threads, how the CPU is shared, virtual memory and paging, concurrency primitives and deadlock, and how a file on disk really works. The theory Linux & the Command Line's practical commands sit on top of.

The meta-skills no single language or framework teaches — reading unfamiliar code, debugging as a discipline instead of guessing, technical debt, refactoring safely, code review, and writing down engineering decisions so the next person (often you) understands why.

How machines actually talk to each other — IP addresses, DNS, TCP vs UDP, HTTP/HTTPS internals, and the load balancers, NAT, and CDNs every other domain in this app quietly assumes you already understand.

Shell fluency every other domain quietly assumes — navigating and searching the filesystem, permissions, processes, environment variables, SSH, and enough shell scripting to automate the things you do by hand more than twice.

The component model, the render cycle, and the App Router patterns underneath a real production app — not just JSX syntax, but why re-renders happen and where server and client actually split.

Layout, the cascade, and the modern tools (Grid, custom properties, container queries) that replaced two decades of float and z-index hacks — why each property actually behaves the way it does, not just which one to reach for.

Design thinking for engineers, not a design-tool curriculum — visual hierarchy, typography, contrast, form design, loading/empty/error states, accessibility, and the usability heuristics that turn 'it works' into 'people can actually use it.'

Where React's own component model — props, state, hooks, the render cycle — stops being enough on its own: no DOM, no CSS cascade, a native UI thread, platform-specific APIs, and an app-store review process standing between a build and a real user's device.

ORM internals, request lifecycle, and the parts of the framework worth understanding, not just using.

The server-side half of the JavaScript story — the runtime's non-blocking I/O model, streams, building a real HTTP API with Express, and the process-level mechanics (child processes, clustering, graceful shutdown) a browser never needs.

The actual language of relational data — queries, joins, and the practical skills behind working with SQL day to day, not just the system-design trade-offs.

The tool every other domain in this app assumes you already know — commits, branches, and the actual mental model behind them, not just a list of commands to memorize.

What actually makes a test worth having — the AAA pattern, test doubles used correctly instead of over-mocked, the pyramid's real shape, and the CI habits that keep a suite fast and trusted instead of ignored.

What makes an API pleasant (or painful) to build against, beyond the HTTP/REST basics System Design already covers — pagination and filtering conventions, GraphQL and gRPC as real alternatives to REST, consistent error responses, contract-first design with OpenAPI, webhooks, API gateways, and designing for operations that don't finish instantly.

The primitives underneath Auth, Web Security, and Payments' practical use of crypto — what actually makes a hash function secure, block cipher modes, digital signatures, HMAC, key exchange, TLS's certificate chain, key derivation, and the mistakes that keep breaking otherwise-correct cryptographic code.

Who is this user, what can they do, and whose data should they see? Authentication (proving identity), authorization (granting permissions), and multi-tenancy (safe isolation between customers). Hashing passwords, managing sessions, issuing tokens, and the gotchas that leak data across tenants.

How real applications actually get compromised — SQL injection, XSS, CSRF, SSRF, and the rest of the OWASP Top 10 vulnerability classes, explained by the exact mechanism an attacker exploits, not just a checklist of things to avoid.

Security categories Web Security's browser-focused domain doesn't reach — OS command injection, business-logic abuse, memory-safety bug classes, SAST/DAST/fuzzing, CI/CD pipeline supply-chain risk, privacy by design, and the compliance frameworks engineers actually have to satisfy.

How real infrastructure scales: infrastructure as code, serverless compute, load balancing, queues, networking, auto-scaling, observability, and the cost gotchas that appear once you're managing real cloud resources.

Amazon Web Services in practice — IAM, EC2, S3, RDS, DynamoDB, Route 53, CloudFront, the CLI/SDK, CloudFormation, multi-account strategy, and the Well-Architected Framework. The hands-on, one-provider layer on top of Cloud Computing & Infrastructure's provider-agnostic concepts.

Packaging, running, securing, and orchestrating containers — Dockerfiles and image layers, local dev with Compose, health checks, Kubernetes fundamentals, and the gotchas that show up once containers run in a real cluster.

Everything Docker & Containers' Pods/Deployments/Services lesson explicitly left for later — cluster architecture, namespaces, ConfigMaps and Secrets, Ingress, autoscaling, StatefulSets, DaemonSets, Jobs and CronJobs, persistent storage, RBAC, and Helm.

How code actually gets from a commit to production safely — pipeline stages and gates, OIDC-based deploy credentials, artifact versioning, feature flags, and the rollout strategies (rolling, blue-green, canary) that make shipping routine instead of risky.

The theory Cloud Computing's single observability lesson only introduced — metric types, the RED and USE methods, SLIs/SLOs and error budgets, OpenTelemetry and trace sampling, designing alerts that don't cause fatigue, dashboards, and synthetic vs. real-user monitoring.

The platform built around Next.js, and the one most of this curriculum's own frontend deploys actually run on — preview deployments per commit, the Edge Network, the rendering-model spectrum (Static/ISR/SSR/Edge), and the exact usage limits (ISR writes, Fast Origin Transfer, function duration) that actually matter once a real app is live.

A platform for deploying anything, not just frontend frameworks — Nixpacks builds without a Dockerfile, private networking between services in one project, usage-based pricing, and one-click databases with persistent volumes, contrasted directly against Vercel's frontend-first model and Render's fuller service taxonomy.

The Docker-native middle ground between Vercel's frontend focus and a full cloud provider — static sites, web services, background workers, and cron jobs as first-class service types, render.yaml blueprints for infrastructure-as-code, and the free tier's spin-down behavior every first-time user eventually hits.

Real, unrestricted Postgres with an entire backend already built around it — Row Level Security policies enforced by the database itself, an auto-generated REST API, built-in auth that RLS policies reference directly, realtime subscriptions over logical replication, and the open-source alternative to a fully proprietary BaaS.

Past how DNS resolution actually works (Networking Fundamentals) and the record types themselves (System Design, AWS's Route 53) — the practical layer of actually owning and operating a domain: registrars, the apex-domain CNAME problem every platform solves differently, connecting a domain to a deployment platform, email deliverability (SPF/DKIM/DMARC), and a real multi-platform domain architecture.

Trade-offs at scale — caching, queues, consistency, and how real systems actually fail.

The theory underneath System Design's practical trade-offs — why you can't trust a clock across machines, how nodes actually agree on anything (Paxos, Raft), replication strategies, failure detection, and what happens when a transaction spans more than one machine.

The specific mechanics System Design's queue lesson only introduced — Kafka partitions and consumer groups, RabbitMQ exchanges and routing, ordering guarantees, the transactional outbox pattern, schema evolution, and the pitfalls that turn 'event-driven' into a distributed monolith nobody can debug.

Past cache-aside and CDN headers — Redis data structures and eviction policies, the thundering-herd problem, cache-cluster sharding, fleet-wide invalidation, and measuring whether a cache is actually earning its complexity.

The concepts underneath every LLM feature you'll ever build — what a neural network actually computes, how tokens and embeddings turn meaning into numbers, why models hallucinate, and when fine-tuning, prompting, or RAG is actually the right tool.

Building a real, production LLM-powered feature: tool-calling architecture, the propose-then-confirm pattern for anything that writes data, authorization that never trusts the model, and the genuine bugs this kind of system produces.

How to wire a real product into a third-party messaging platform, using Meta's WhatsApp Business Platform as the concrete, working example — Business Manager, Meta for Developers, access tokens, templates, webhooks, and the trade-offs behind each design decision.

How real products safely move money: gateway integration, why the webhook is the source of truth (not the browser redirect), idempotency, and the double-entry ledger patterns behind every serious billing system.

How software actually gets planned, estimated, and delivered on a team — Scrum and Kanban in practice, writing stories and acceptance criteria that hold up, estimation that doesn't pretend to be precise, and the anti-patterns that turn "agile" into a buzzword instead of a working process.

The skills that decide whether all the technical work in this app actually turns into a job and a career — coding and system-design interview technique, behavioral prep, resumes and portfolios that survive a skim, negotiating an offer, and growing once you're in the seat.