CI/CD

The output of a build step — a JAR, binary, container image, or bundle — that is promoted through pipeline stages and ultimately deployed.

Running two identical production environments, one live (blue) and one idle (green). Deploy to green, smoke-test, then switch traffic. Rollback is instant — flip the switch back.

The process of compiling source code and packaging it into a runnable artifact. Also refers to the resulting artifact and a numbered identifier for that specific output.

Routing a small slice of traffic (1%, 5%) to a new version while the rest stays on the old one. Metrics from the canary decide whether to progress or roll back. Limits blast radius and surfaces issues that staging missed.

The practice of merging every developer's working copy into a shared branch multiple times a day, with automated builds and tests running on each merge. The goal is to detect integration failures when they're small and cheap to fix, rather than at the end of a release cycle. CI is the foundation of modern delivery pipelines — tests that don't run in CI effectively don't exist.

The process of cryptographically signing a mobile application bundle (IPA for iOS, APK/AAB for Android) with a certificate and provisioning profile before it can be installed on a device or distributed through an app store. On iOS, code signing is enforced strictly by Apple: apps must be signed with a developer or distribution certificate issued from an Apple Developer account, paired with a provisioning profile that lists permitted device UUIDs (for development) or targets the App Store or Enterprise distribution. On Android, signing uses a keystore file and is enforced at install time — unsigned APKs are rejected. Code signing is one of the most common pain points in mobile CI/CD pipelines: certificates expire, provisioning profiles drift out of sync with registered devices, and private keys must be stored securely without being committed to source control. Best practices include using a secrets manager for the keystore or P12 file, and automating certificate rotation.

Packaging an application together with its dependencies into a portable image (typically Docker) that runs identically on a developer laptop, CI, and production. Eliminates 'works on my machine' and underpins modern test environments.

Automating the path from commit to a production-ready artifact. Every change is potentially deployable; the actual deploy may require a manual approval gate.

The practice of merging code changes to a shared branch frequently, with automated builds and tests running on every change. Catches integration issues early and keeps the main branch always shippable.

The act of releasing a built artifact to a target environment (staging, production). Modern teams aim to deploy as often and as automatically as possible.

A runtime toggle that turns code paths on or off without redeploying. Enables progressive rollouts, A/B tests, and instant kill switches. Decouples deploy from release — code ships dark and is enabled later.

Defining servers, networks, and cloud resources in version-controlled configuration files (Terraform, Pulumi, CloudFormation) instead of clicking through dashboards. Brings code review, repeatability, and rollback to infrastructure changes.

An automated, ordered sequence of stages — typically build, test, scan, deploy — that code passes through from commit to release. Enforces quality gates between stages.

Reverting a deployment to the previous known-good version when a release introduces a regression. Modern pipelines aim for one-command rollback; database migrations are the usual complication.