Skip to content
Tutorials Center
My learning

Topics

Lesson 37 of 37 ยท Projects and Practice

Practice: Production Readiness Checklist

Review a Heroku app before launch: dynos, database, config, security, logging, backups, deploys and runbooks, then work through practice exercises with runnable calculators.

You have now covered the data, scaling, pipeline and operations chapters. This closing lesson collects everything into a checklist you can run before a launch, and then gives you practice exercises. Heroku cannot be run on this site, so the checklist items are statements you verify against a real app with the commands shown, and the exercises are runnable Python stand-ins.

The checklist

Go through each group. Write down evidence (a command output, a screenshot, a link) for each item.

Process and capacity

  • Two or more web dynos of a Standard or Performance type (not Eco), so one restart does not take the site down (dyno types).
  • Preboot enabled, or deploys scheduled when a short gap is acceptable.
  • Worker dynos for slow tasks, scaled separately (scaling).
  • Server binds to $PORT, handles SIGTERM, and sets worker counts from the dyno's memory.
  • Connection budget calculated: dynos x processes x pool is below the database cap (connections).

Data

  • Production-grade Postgres plan with the features you need (followers, rollback, high availability).
  • Daily scheduled backups plus a rehearsed restore, with measured recovery time (backups).
  • Maintenance window chosen; app reconnects after a database restart.
  • Cache (if any) treated as disposable, with the right eviction policy (cache).

Delivery

  • Pipeline with staging and production; production promoted from the staging slug (pipelines).
  • CI runs tests on every pull request; deploys wait for CI (CI).
  • Migrations are backward compatible and run in the release phase.
  • Rollback practiced: everyone knows heroku releases and releases:rollback.

Security and domains

  • Team ownership, least-privilege roles and two-factor authentication for everyone (security).
  • Secrets only in config vars, different per environment, none in Git.
  • Custom domain with automated certificates; HTTPS redirect and canonical host (domains).
  • Dependencies scanned and updated; DEBUG off.

Observability

  • Log drain with retention and search; structured logs with request ids (logging).
  • Alerts for 5xx rate, slow requests, crashes and memory errors.
  • External uptime check and an error tracker.
  • A runbook: who is on call, where the dashboards are, how to roll back and restore.
flowchart TD
    A["Capacity"] --> Z["Ready to launch"]
    B["Data safety"] --> Z
    C["Delivery"] --> Z
    D["Security"] --> Z
    E["Observability"] --> Z

Launch only when all five areas have evidence, not just promises.

Exercise 1: score a checklist

Automate the review: a dictionary of items with a weight, and a score that shows what to fix first. Run it, then change values to match your own app.

Python Readiness score

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

You should see 15 of 22 (68%) and a list of three missing items with the backup rehearsal at the top. Weights are a judgment; the point is to rank work by risk.

Exercise 2: size an app

Given a traffic profile, compute dynos, connections and a memory limit, then check the budget. Change the inputs and see which limit is hit first.

Python Capacity plan

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

With these inputs 7.2 busy workers at 60% utilization with 4 workers per dyno gives 3 dynos, using 36 of 110 usable connections and 800 MB of 1024 MB per dyno, so the plan fits. Raise traffic_rps to 200 to see the connection cap become the first problem, which is the lesson of the scaling chapter: the database limits you before the dynos do.

Exercise 3: a launch-day timeline

Plan the day of the launch as data, then check that backups, scaling and rollback happen in a safe order.

Python Launch plan sanity check

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

The first plan is safe; the swapped one reports that promotion happened before the backup and the scaling step. Writing dependencies down is a cheap way to avoid ordering mistakes under stress.

Written exercises

  1. Draw your own app's architecture: processes, add-ons, domains, pipeline, drains. Mark every place where a failure would hurt and note the protection.
  2. Write a one-page runbook for "the site is returning 503": steps, commands, owners and when to roll back (troubleshooting).
  3. Estimate the monthly bill of your app: dynos, database, key-value store, logging, review apps. Compare it with one alternative platform from the alternatives lesson.
  4. Rehearse a database restore into a throwaway database and record the time.
  5. Run through this checklist with a colleague who did not build the app; fresh eyes find gaps.

Where to go next

Return to the Heroku track page to revisit earlier chapters, or deepen the topics around it: containers and Docker, Postgres performance, CI/CD, and observability.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Why run at least two web dynos in production?

    Dynos restart daily and on deploys; a second dyno keeps serving while one restarts.
  2. 2. What makes a backup trustworthy?

    Only a successful, timed restore proves the backup works and tells you the real recovery time.
  3. 3. Which limit often decides capacity before dyno count does?

    Connections multiply across dynos and processes and can exceed the plan cap.
  4. 4. What should every checklist item have?

    Evidence turns a promise into a verified fact.

Summary

  • Review capacity, data, delivery, security and observability before launch, with evidence.
  • Automate checks where you can; weights show what to fix first.
  • Size by traffic, connections and memory, and plan launch-day steps with explicit dependencies.
  • Rehearse backups, rollbacks and incidents before you need them.

Next: Heroku track overview