production
The live environment where real users use the service, as opposed to development or testing.
In more detail
Production gets the strictest settings, the most monitoring and the most careful changes, because failures affect real users. Other environments, such as development and staging, exist so problems can be found before they reach it.
Examples
An Ansible project usually keeps production as an inventory group with its own group_vars and its own vault ID.Production Kafka needs at least three brokers, dedicated disks and acks=all rather than one dev-container broker.Production JavaScript bundles omit development-only warnings, so deprecation messages never reach users' consoles.The live environment where real users are served. In DORA metrics, a change counts as delivered only when it is serving production traffic, and a failure counts only when it reached production.Changes on a production host can interrupt real users, so they deserve more care: identify the distribution, preview package transactions and read the plan before applying it. An upgrade there can replace configuration or restart a running service.next build then next start, or node server.js from the standalone output, runs Next.js in production mode.In Terraform: Changes to production deserve saved plans, required approval and credentials nobody holds on a laptop. prevent_destroy and branch protection are common guards.In this course: Production code should not know it is being tested: seams with sensible defaults let production use the real clock, generator or directory while tests pass in their own. A test must never reach production systems, real money or real customers.Related terms
- staging — A pre-production environment set up like production, where changes are tried out before they reach real users.
- environment overlay — Keeping one shared playbook and putting the values that differ between environments in separate variable files, one per environment.
- host key checking — SSH's check that a server's identity key matches the one recorded the first time you connected, protecting you from impostor servers.
- load testing — Measuring how a system behaves while a chosen amount of traffic is sent to it, to find its latency, throughput and limits.
- deployment environment — A named target such as staging or production that a job declares, so GitHub can attach its own variables, secrets and protection rules.
- environment protection rule — A rule on a deployment environment, such as required reviewers, a wait timer or allowed branches, checked before a job may deploy there.
- resource tag — A key and value label, such as Role=web or Environment=production, attached to a cloud resource to describe it.
- rollback — Returning a system to a previous known-good version after a bad change.
- infrastructure as code — Describing servers, networks and other infrastructure in text files that a tool reads to create and change the real thing.
- dev-container mode — A Redpanda start mode that trades production safety checks for a fast, lightweight single-container broker.
- fault tolerance — The ability of a system to keep working correctly when some of its parts fail.
- NODE_ENV — An environment variable, usually set to production or development, that libraries, frameworks and build tools read to switch behaviour.
- environment variable — A named setting such as PORT=8000 that a program reads from its surroundings when it starts.
- environment — One place where a copy of the application runs with its own config, such as development, staging or production.
- image promotion — Moving the exact same, already-tested image through environments, such as staging to production, without rebuilding it.
- resource limit — A cap on how much memory, processor time or number of processes a container may use.
- non-root user — An ordinary user account with limited rights, which a container should run its service as.
- zero-downtime deployment — Releasing a new version while users keep being served, with no period where the service is unavailable.
- Spring profile — A named set of configuration, such as local, test or production, that Spring activates to change properties and beans for one environment.
- package transaction — One install, upgrade or removal operation, planned as a whole and applied together by the package manager.
- support window — The period during which a distribution release keeps receiving security fixes and bug fixes.
- next build — The Next.js command that compiles the app for production and pre-renders every route it can.
- secure by default — Designing software so the setting you get by typing nothing is the safe one, and anything riskier must be asked for by name.
- security gate — An automated check in a pipeline that stops a change going further when it fails, usually by exiting with a non-zero code.
- release gate — An automatic check that must pass before a change may be deployed.
- prevent_destroy — A lifecycle setting that makes any plan fail if it would destroy that resource, including as part of a replacement.
- seam — A place in the code where you can swap in different behaviour without editing the code itself, such as a parameter.
- default argument — A value a function uses for a parameter when the caller leaves that parameter out.
Taught in
- Ansible Architecture And The Control Node — Ansible Configuration Management at Scale
- The Static Inventory File — Ansible Configuration Management at Scale
- Host Groups And Host Variables — Ansible Configuration Management at Scale
- Dynamic Inventory — Ansible Configuration Management at Scale
- Gathering Facts — Ansible Configuration Management at Scale
- Error Handling With Block, Rescue And Always — Ansible Configuration Management at Scale
- Ansible Galaxy — Ansible Configuration Management at Scale
- Testing With Molecule — Ansible Configuration Management at Scale
- Securing Data With Ansible Vault — Ansible Configuration Management at Scale
- Vault IDs And Multiple Passwords — Ansible Configuration Management at Scale
- Environment Specific Configuration — Ansible Configuration Management at Scale
- Idempotency Keys — Modern API Architecture: REST, GraphQL & gRPC
- Load Testing — Modern API Architecture: REST, GraphQL & gRPC
- Performance Optimization — Modern API Architecture: REST, GraphQL & gRPC
- What Is a Pipeline? — Continuous Integration & Continuous Delivery Pipelines
- Defining Environments in GitHub Actions — Continuous Integration & Continuous Delivery Pipelines
- Environment Protection and Manual Approvals — Continuous Integration & Continuous Delivery Pipelines
- Artifact Promotion: Staging to Production — Continuous Integration & Continuous Delivery Pipelines
- Container Images The Exam Way — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Helm: Install, Upgrade And Roll Back — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Kustomize Bases, Overlays And Patches — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Debugging Applications In Kubernetes — Certified Kubernetes Application Developer (CKAD) Exam Prep
- ConfigMaps And Secrets — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Policies and Least Privilege — Cloud Infrastructure & Hyperscaler Architecture
- Metrics, Logs, and Alarms — Cloud Infrastructure & Hyperscaler Architecture
- Cost, Budgets, and Tagging — Cloud Infrastructure & Hyperscaler Architecture
- How Bills Actually Get Large — Cloud Infrastructure & Hyperscaler Architecture
- The Console versus the CLI — Cloud Infrastructure & Hyperscaler Architecture
- Acknowledged Is Not Always Safe — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Works On A Laptop, Fails In Production — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Green Tests, Red Production — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Twelve Lines Instead Of Four Hundred — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Full Disks On Black Friday — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Design Tokens: W3C Specs, Global, Semantic & Component Tokens — Design Systems & Component Engineering
- System Governance: Changesets, Semantic Versioning & Deprecation — Design Systems & Component Engineering
- Throughput: Change Lead Time And Deployment Frequency — DevOps & Site Reliability Engineering
- Instability: Change Fail Rate And Deployment Rework Rate — DevOps & Site Reliability Engineering
- Restoration: Failed Deployment Recovery Time — DevOps & Site Reliability Engineering
- Codebase And Dependencies — DevOps & Site Reliability Engineering
- Config And Backing Services — DevOps & Site Reliability Engineering
- Building And Versioning The Artifact — DevOps & Site Reliability Engineering
- Continuous Delivery Versus Continuous Deployment — DevOps & Site Reliability Engineering
- Namespaces And Cgroups: Isolation And Limits — Docker Architecture & Production Containers
- Docker, OCI, The Engine And The CLI — Docker Architecture & Production Containers
- Install Docker And Verify Your Environment — Docker Architecture & Production Containers
- Pull And Inspect A Third Party Image — Docker Architecture & Production Containers
- Build Context, Dockerignore And Your First Dockerfile — Docker Architecture & Production Containers
- ARG, ENV, LABEL, EXPOSE And VOLUME — Docker Architecture & Production Containers
- CMD, ENTRYPOINT, USER And Process Signals — Docker Architecture & Production Containers
- Multi Stage Builds, Targets And Build Secrets — Docker Architecture & Production Containers
- Tags, Digests And Reproducible Image References — Docker Architecture & Production Containers
- Authenticate, Tag, Push And Pull From A Registry — Docker Architecture & Production Containers
- Minimal Bases, Non Root Users And Smaller Images — Docker Architecture & Production Containers
- Scan, Patch And Inspect The Software Supply Chain — Docker Architecture & Production Containers
- Ephemeral Filesystems And Named Volumes — Docker Architecture & Production Containers
- Bind Mounts, Permissions And Backups — Docker Architecture & Production Containers
- Bridge Networks, DNS And Container Communication — Docker Architecture & Production Containers
- Port Publishing, Localhost And Network Troubleshooting — Docker Architecture & Production Containers
- Environment, Secret Files And Runtime Restrictions — Docker Architecture & Production Containers
- Development Overrides, Hot Reloading And Debuggers — Docker Architecture & Production Containers
- Diagnose Crashes, Resource Limits And Unhealthy Containers — Docker Architecture & Production Containers
- Build, Test And Promote The Same Image In CI — Docker Architecture & Production Containers
- Harden And Deliver The Complete Service Stack — Docker Architecture & Production Containers
- From Local Containers To Kubernetes — Docker Architecture & Production Containers
- The Options Pattern: Strongly Typed Configuration — Modern .NET Core, C# & Enterprise Microservices
- Environment Layering and User Secrets — Modern .NET Core, C# & Enterprise Microservices
- Unified Build Pipelines: Caching & Dependency Graphs — Production Full-Stack Engineering
- Environment Configuration: Secrets & Multi-Stage — Production Full-Stack Engineering
- Database Access & Migrations: ORM & Data Layers — Production Full-Stack Engineering
- Containerization Architecture: Multi-Stage Dockerfiles — Production Full-Stack Engineering
- Continuous Delivery: Blue-Green & Canary Pipelines — Production Full-Stack Engineering
- Interfaces and Why They Are Implicit — Concurrent Systems Programming with Go
- Channels and Synchronization — Concurrent Systems Programming with Go
- The time Package — Concurrent Systems Programming with Go
- Calling APIs with net/http Client — Concurrent Systems Programming with Go
- Building Static Binaries — Concurrent Systems Programming with Go
- Shipping in Scratch and Distroless Images — Concurrent Systems Programming with Go
- Executing Concurrent Checks — Concurrent Systems Programming with Go
- Release Trains And Long Term Support — Modern Java: Virtual Threads & High-Throughput Services
- Configuration And Profiles — Modern Java: Virtual Threads & High-Throughput Services
- Packaging Into A Container — Modern Java: Virtual Threads & High-Throughput Services
- When Kafka Is The Wrong Tool — Apache Kafka & Event Streaming
- DaemonSets And Node Services — Kubernetes: Production-Grade Container Orchestration
- kubeadm, High Availability And Cluster Lifecycle — Kubernetes: Production-Grade Container Orchestration
- etcd Snapshots And A Tested Restore — Kubernetes: Production-Grade Container Orchestration
- Kustomize Base And Dev And Prod Overlays — Kubernetes: Production-Grade Container Orchestration
- Argo CD Applications And Flux Reconciliation — Kubernetes: Production-Grade Container Orchestration
- Troubleshooting: GitOps Drift And Controller Failures — Kubernetes: Production-Grade Container Orchestration
- What A Distribution Actually Is — Linux Fundamentals & Systems Administration
- What A Package Manager Guarantees — Linux Fundamentals & Systems Administration
- Session Management: Secure Cookies & Token Validation — Next.js 15 & Modern App Router Architecture
- Runtime Environments: Node.js vs Edge Runtime Choice — Next.js 15 & Modern App Router Architecture
- Metadata API: Dynamic OpenGraph & Head Management — Next.js 15 & Modern App Router Architecture
- Instrumentation: OpenTelemetry & Performance Spans — Next.js 15 & Modern App Router Architecture
- Containerized Deployment: Multi-Stage Docker Builds — Next.js 15 & Modern App Router Architecture
- Runtime Configuration: CLI Flags & Native --env-file — Node.js Internals & Backend Services
- Close Phase & Signal Dispatch: Sockets & Teardown — Node.js Internals & Backend Services
- Global Error Trapping: uncaughtException & Exits — Node.js Internals & Backend Services
- Production Hardening: Graceful Shutdown & Docker — Node.js Internals & Backend Services
- Secure Defaults — Application Security & Threat Modeling for Engineers
- Provenance And Signing — Application Security & Threat Modeling for Engineers
- How To Stop Drowning In Findings — Application Security & Threat Modeling for Engineers
- Tearing It Down With Destroy — Infrastructure as Code with Terraform
- Parameterising With Input Variables — Infrastructure as Code with Terraform
- The Cost And Value Of A Test — Automated Testing, TDD & Quality Engineering
- Why Over-Mocking Breeds False Positives — Automated Testing, TDD & Quality Engineering
- Testing Time And Randomness — Automated Testing, TDD & Quality Engineering
- Flaky Tests And How To Kill Them — Automated Testing, TDD & Quality Engineering
- The Plan That Wanted To Destroy Production — HashiCorp Terraform Associate (004) Exam Prep
- Infrastructure As Code, And One Workflow For Every Platform — HashiCorp Terraform Associate (004) Exam Prep
- Providers: How Terraform Reaches Every API — HashiCorp Terraform Associate (004) Exam Prep
- Write, Plan, Apply, And What Init Prepares — HashiCorp Terraform Associate (004) Exam Prep
- Input Variables, Outputs, And Which Value Wins — HashiCorp Terraform Associate (004) Exam Prep
- Expressions And Functions: Making Configuration Compute — HashiCorp Terraform Associate (004) Exam Prep
- Module Versions: Pin, Upgrade, Re-Initialise — HashiCorp Terraform Associate (004) Exam Prep
- The Local Backend, And Workspaces On One Machine — HashiCorp Terraform Associate (004) Exam Prep
- Static Inventories: Hosts, Groups And Groups Of Groups — RHCE in Ansible (EX294): Automate Red Hat Systems
- Anatomy Of A Playbook: Plays, Tasks And Modules — RHCE in Ansible (EX294): Automate Red Hat Systems
- Variables And Where They Win: group_vars, host_vars And Play Vars — RHCE in Ansible (EX294): Automate Red Hat Systems
- Jinja Templates: One File, A Different Text Per Host — RHCE in Ansible (EX294): Automate Red Hat Systems
- Ansible Vault: Secrets Encrypted, Runs Without A Prompt — RHCE in Ansible (EX294): Automate Red Hat Systems
- Mock Exam, Part 1: Seven Tasks Across Three Sections — RHCE in Ansible (EX294): Automate Red Hat Systems
References
- Sample Ansible setup: separating production and staging
- Google SRE book: Monitoring distributed systems
- GitHub Docs: Deployments and environments
- AWS Well-Architected: separate workloads using accounts
- The Twelve-Factor App: dev/prod parity
- webpack: mode
- Docker Engine security
- Use multiple environments in ASP.NET Core
- The Twelve-Factor App: Config
- Google SRE book: Introduction
- Next.js 15 docs: Deploying
- NIST SP 800-218: Secure Software Development Framework
- Running Terraform in automation
Certification courses
- CKAD course and practice exam: Certified Kubernetes Application Developer
- CCDAK and CCAAK course and practice exams: Confluent Apache Kafka certifications
- Terraform Associate course and practice exam: HashiCorp Terraform Associate (004)
- RHCE course and practice exam: Red Hat Certified Engineer in Ansible (EX294)