System Design line, station 6 of 8Engineering Roles line, station 3 of 8
Running Software in Production
Learn to see what your software is doing in production, keep it secure, and ship changes safely with a rollback that takes one command.
- 3lessons
- 2 hto read and do
- Intermediatelevel
- 3podcast episodes
- 6checked exercises
Tools you'll use in this course
The lessons open these with a template ready. They work for your own job too, no course needed.
About this course
Writing the code is half the job. The other half starts when real users arrive: a store manager says the app is slow, someone changes a number in a URL and sees another customer's order, or a Friday release breaks checkout. This course teaches the three habits that keep software healthy in production: observability, so you know what is happening and why; security, so each user sees only what they should; and safe shipping, so every change can reach a few users first and be undone in seconds.
You can start here without the earlier courses. Each lesson begins with an everyday picture, explains the mechanism with diagrams and real outputs, and ends with a Build-it for a NestJS and Postgres API: JSON logs, Prometheus metrics, OpenTelemetry traces and alerts; login with rotating refresh tokens and queries scoped to each user; a Docker image, a GitHub Actions pipeline, a blue-green switch and feature flags. You practise the core logic in auto-checked JavaScript and SQL exercises in your browser.
Every example happens at Mangrove Market, a fictional grocery chain with 320 stores and a Store app on handheld scanners. The capstone is a production-readiness review of that app's API.
What you will be able to do
- Instrument an API with structured logs, RED and USE metrics and distributed traces, and use them to find where time goes
- Write alert rules tied to an SLO that page only when users are hurting, with a traffic guard and a runbook
- Design login with short access tokens and rotating refresh tokens, and store tokens and passwords safely
- Find and fix IDOR bugs by scoping every query to what the user may see, with row-level security as a safety net
- Build a small container image and a gated CI/CD pipeline, and release with blue-green, canaries, feature flags and a minimum app version
Syllabus
3 stops, about 2 h in total. Each stop fills in when you complete the lesson.
Observability: logs, metrics and traces
When a store manager says "the app is slow today", you need to answer three questions fast: is it really slow, for whom, and where does the time go. Logs, metrics and traces each answer one of them. This lesson wires all three into a NestJS API and adds an alert that wakes someone only when users are hurting.
ObservabilitySLOs and alertingDistributed tracing
Security essentials
Most real breaches are not clever. Someone changes a number in a URL and sees another store's orders, or finds a database password in a git repository. This lesson covers the few controls that stop most of them: how users log in, how the API decides what each user may see, how passwords and secrets are stored, and the headers and limits around it all.
Application securityAuthentication and authorizationAccess control
Shipping safely: containers, CI/CD and releases
Most outages start with a change: a new release, a migration, a config edit. Teams that ship often and safely have a pipeline that tests every change the same way, a release that reaches a few users first, and a rollback that takes one command. This lesson builds that pipeline for a NestJS and Prisma API and covers mobile releases too.
CI/CDContainersSafe releasesFeature flags
Capstone: Production-readiness review for the Store app API
A realistic project with a rubric and a model answer.
Final exam and certificate
10 questions drawn at random, 70% to pass.
Capstone project
Production-readiness review for the Store app API
Mangrove Market's Store app runs on handheld scanners in 320 stores: staff receive deliveries (goods received notes, GRN), count stock and check prices. Its NestJS API is about to get a new GRN scan flow before the festival season. Today the API writes plain-text logs, has no metrics or tracing, and pages the on-call engineer whenever CPU passes 80%. A security review found that GET /v1/grns/:id loads by id only, refresh tokens never expire, and the database password sits in a committed .env file. Deploys are done by hand over SSH, images are tagged latest, and the last release renamed a column and could not be rolled back. Ken, the engineering manager, asks you for a production-readiness review with concrete fixes: how the team will see problems, how each user is limited to their own stores, and how the new GRN flow will reach stores safely.
You will hand in
- An observability plan: the SLO for GRN submit, the log fields, the RED and USE metrics with their labels, and what is traced
- An alert rules file with one page-level and one ticket-level rule, each with its threshold, hold time, traffic guard and runbook link
- A security findings table (finding, risk, fix, owner), plus working code and a test that shows the GRN IDOR is fixed
- A release plan: the pipeline stages and gates, the image tag scheme, the migration order for the new flow, and the flag rollout by store
- A one-page rollback runbook: the exact commands or switches, and how long each takes
Check what you know
Already know some of this? Answer 3 quick questions, one from each lesson, and we will mark the lessons you can skim. It takes about 2 minutes and nothing is graded.
Questions
How long does this course take?
About 2 to 2.5 hours for the three lessons, including the checkpoints and practice exercises, plus 2 to 6 hours for the capstone if you do it. Each lesson also has a podcast episode of about 13 minutes.
Can I start here, and what should I know first?
Yes, the first lesson is written for people who start here. You should know what an API and a database are and be able to read a little JavaScript or TypeScript. How the Web Works helps with HTTP basics, and the Distributed Systems course before this one is useful but not required.
Do I need to install anything?
No. Every practice exercise runs in your browser and checks itself. To follow the Build-it sections on your own machine you need Node.js, Docker, a code editor and a GitHub account; the lessons run Postgres, Prometheus, Grafana, Jaeger and Nginx in Docker containers.
Is the certificate free?
Yes. The lessons, podcasts, exercises, final exam and certificate are all free.
How does the final exam work?
Each attempt draws 15 random questions from this course's question bank, and you need 70% to pass. If you do not pass, you can try again after 24 hours. The questions are new scenarios at Mangrove Market, so understanding the ideas matters more than remembering the lesson text.
Is it really free?
Yes. Every lesson, podcast episode, exercise, quiz, final exam and certificate is free. The labs and their templates for real work are free too. Plus and Premium add every lab challenge, weekly extras and a mentor on top, and they never lock the tools or the courses.