Deployment pipeline
A sequence of automated or manual stages that builds, tests or validates, packages, and delivers software or models toward deployment.
Platform Engineering on Kubernetes
An automated sequence of activities that moves software changes toward release and deployment.
- How it is used
- Moves service changes toward releasable artifacts and connects them to validation and promotion across environments.
- How deep it goes
- Details triggers, build checks, artifact publication, infrastructure requirements, and the handoff to environment pipelines without prescribing one pipeline boundary.
- Examples
- Uses Conference application services, main-branch and pull-request runs, published container images, and environment-repository change requests.
- What you can do after
- Build it from scratch by separating artifact production from environment promotion and choosing checks, triggers, and publication points.
Read how Platform Engineering on Kubernetes explains deployment pipeline →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A CI/CD pipeline is an automated workflow that validates and delivers software changes through continuous integration and continuous delivery or deployment stages.
- How it is used
- Automates testing and deployment of microservices when repository changes are pushed.
- How deep it goes
- Builds from manual deployment through locally tested scripts and GitHub Actions workflows to per-service and branch-targeted deployments.
- Examples
- Uses a Node.js microservice test command and a path-filtered gateway workflow in a multi-microservice repository.
- What you can do after
- Build it from scratch to test, publish, and deploy a changed microservice automatically with GitHub Actions.
Effective Platform Engineering
An automated deployment pipeline is a tool-driven sequence that builds, validates, and deploys software with minimal manual intervention.
- How it is used
- Moves platform changes through repeatable validation and release paths while reducing manual deployment work.
- How deep it goes
- Specifies environment progression, code identity, test stages, and release observation, with exercises for infrastructure pipelines.
- Examples
- Uses cross-account DNS delegation, VPC provisioning, and separate platform-service and extension pipelines.
- What you can do after
- Build it from scratch by piloting a validated release path, then measure deployment frequency, lead time, and failures.
Read how Effective Platform Engineering explains deployment pipeline →
Learn Docker in a Month of Lunches, Second Edition
A CI/CD pipeline is an automated sequence that builds, tests, packages, and delivers software through continuous integration and continuous delivery or deployment.
- How it is used
- Turns code changes into tested container images and, when configured, deploys the application.
- How deep it goes
- Works through Docker-based build steps, test failures, job configuration, and portability; leaves private-package authentication as additional configuration.
- Examples
- Uses a Jenkinsfile calling a Compose build script and a GitHub Actions workflow that runs a PowerShell build script.
- What you can do after
- Build it from scratch using Docker build scripts and a Jenkins or GitHub Actions job, then diagnose failures in build output.
Read how Learn Docker in a Month of Lunches, Second Edition explains deployment pipeline →
Automating API Delivery
Continuous integration and continuous delivery is a software delivery practice that automates frequent integration, testing, packaging, and deployment.
- How it is used
- Coordinates API governance, artifact production, and deployment in a repeatable Git-based delivery workflow.
- How deep it goes
- Works through PR checks and a GitHub Actions build, including packaging and API-definition transformations; leaves design approval to reviewers.
- Examples
- Uses a PR build with Spectral and Tufin/oasdiff, plus a GitHub Actions workflow that builds an image and bundles OpenAPI.
- What you can do after
- Build it from scratch with GitHub Actions to check API changes and produce service and API-definition artifacts.
Read how Automating API Delivery explains deployment pipeline →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A CI/CD pipeline is an automated workflow that builds, tests, and delivers software through continuous integration and continuous delivery or deployment.
- How it is used
- Coordinates pull-request quality checks, change review, and deployment of Terraform infrastructure from the main branch.
- How deep it goes
- Works through job triggers, steps, test matrices, and a GitOps deployment sequence; leaves CD platform implementation to platform choice.
- Examples
- Uses a GitHub Actions TFLint workflow and test matrices spanning test cases, Terraform or OpenTofu engines, and versions.
- What you can do after
- Build it from scratch using GitHub Actions quality checks and a reviewed GitOps path to automated infrastructure deployment.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A delivery pipeline is an automated sequence of activities that validates, packages, and delivers software or infrastructure changes.
- How it is used
- Organizes infrastructure changes into automated validation, review, deployment, and release stages.
- How deep it goes
- Explains pipeline stages, CI/CD variants, module releases, security controls, and idempotent migrations, but defers extensive migration practice.
- Examples
- Uses CI workflows, GitHub Actions with Google Cloud Run, module version releases, and blue-green database migration.
- What you can do after
- Apply via GitHub Actions a repeatable pipeline that tests infrastructure, gates releases, deploys environments, and migrates state safely.
Web Components in Action
A build step is an automated processing stage that transforms or prepares source code and assets for development or production.
- How it is used
- Transforms or prepares frontend code and assets between editing and browser use, including transpiling, bundling, and processing HTML or CSS.
- How deep it goes
- Explains npm scripts and Rollup component bundling, including output paths and chained builds, while leaving tool choice open.
- Examples
- Uses Sass and LESS compilation, HTML assembly, TypeScript transpilation, and Rollup bundles for component files.
- What you can do after
- Operate/configure npm scripts to run Rollup builds for individual components or chain several component builds.
Read how Web Components in Action explains deployment pipeline →
Shipping Go: Develop, deliver, discuss, design, and go again
A deployment pipeline is an automated sequence of steps that builds, verifies, and delivers software to a deployment environment.
- How it is used
- Automates the path from committed code through verification and build toward a product customers can use.
- How deep it goes
- Works through a trigger, job, steps, and artifact upload, but stops short of configuring a deployment to a running server.
- Examples
- Uses a GitHub Actions YAML workflow that builds a Go binary on pushes to main and uploads it as an artifact.
- What you can do after
- Build it from scratch with GitHub Actions as a small, automated build-and-artifact pipeline that can later gain more checks and deployments.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains deployment pipeline →
Google Anthos in Action
A CI/CD pipeline is an automated workflow that moves software changes through integration, validation, and delivery stages from source to production.
- How it is used
- Automates validation and delivery from source changes toward production.
- How deep it goes
- Defines CI and CD, then details Cloud Deploy manifests, targets, releases, rollouts, and approvals.
- Examples
- Uses a Hello World application and a test-to-staging-to-production deployment sequence.
- What you can do after
- Configure and operate Cloud Deploy releases across ordered target environments.
Read how Google Anthos in Action explains deployment pipeline →
Kubernetes for Developers
A deployment pipeline is an automated sequence of validation and delivery steps that promotes software or configuration changes to a deployment environment.
- How it is used
- Automates Kubernetes configuration rollouts from repository pushes so deployed changes follow committed configuration.
- How deep it goes
- Defines the repository trigger and sketches a Cloud Build setup, while deferring a complete end-to-end CI/CD flow.
- Examples
- Uses namespace-checking rollout scripts and a Cloud Build configuration that runs kubectl apply against a GKE cluster.
- What you can do after
- Apply it via Cloud Build by granting cluster access, creating a repository-push trigger, and configuring a kubectl deployment step.
Read how Kubernetes for Developers explains deployment pipeline →
100 SQL Server Mistakes and How to Avoid Them
A CI/CD pipeline is an automated workflow that integrates, tests, and delivers software changes through continuous integration and continuous delivery or deployment.
- How it is used
- Replaces manual database releases with a repeatable workflow for packaging, validating, and deploying incremental changes.
- How deep it goes
- Explains deployment rationale and DAC packaging, but defers granular configuration because tooling and enterprise requirements vary.
- Examples
- Uses MagicChoc’s manual deployment, DAC packages, Visual Studio publishing, SSMS registration, and SSDT Schema Compare.
- What you can do after
- Operate/configure a safer release process using DAC packaging, schema comparison, source control, and unit tests.
Read how 100 SQL Server Mistakes and How to Avoid Them explains deployment pipeline →
Secure APIs
Continuous integration and delivery is an automated practice for frequently integrating code changes and validating or releasing them through a delivery pipeline.
- How it is used
- Protects API delivery by testing implementations thoroughly and preventing insecure releases.
- How deep it goes
- Describes testing and operational responsibilities without specifying pipeline configuration or implementation steps.
- Examples
- Uses fuzz testers, API security testing tools, integration tests, simulated user flows, and production monitoring.
- What you can do after
- Evaluate API delivery readiness and detect or block malicious behavior after deployment.
Build AI-Enhanced Web Apps
An automated software delivery workflow that integrates code changes and continuously builds, tests, and deploys them.
- How it is used
- Automates Git-connected application builds and deployments as part of production delivery.
- How deep it goes
- Provides a Vercel setup and troubleshooting path, but does not specify a test stage or pipeline configuration file.
- Examples
- Uses a Vercel project, provider credentials, Node.js build settings, CLI deployment, preview output, and failed-deployment logs.
- What you can do after
- Operate/configure it with Vercel’s Git integration, environment settings, build tools, and deployment logs.
Read how Build AI-Enhanced Web Apps explains deployment pipeline →
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A deployment pipeline is an automated sequence of stages that builds, tests, validates, and deploys software.
- How it is used
- Enables teams to reach production quickly while applying quality and compliance requirements.
- How deep it goes
- Defines a robust, secure production path with quality and compliance built in, but gives no implementation steps.
- Examples
- Cites new applications reaching production in hours or minutes and a government service deploying multiple times daily.
- What you can do after
- Evaluate how a paved production path can speed delivery while retaining quality and compliance requirements.
Think Like a Software Engineering Manager
Continuous delivery is a software delivery practice in which changes are kept in a releasable state and delivered frequently through an automated, repeatable process.
- How it is used
- Keeps valuable changes moving to customers through frequent delivery and iterative feedback.
- How deep it goes
- Describes the delivery cycle and operational responsibilities but does not detail pipeline implementation.
- Examples
- Uses a first production deployment with a teammate shadowing, plus iterative delivery and customer feedback.
- What you can do after
- Understand how iterative delivery and production support contribute to a continuing flow of customer value.
Read how Think Like a Software Engineering Manager explains deployment pipeline →
Road to Kubernetes
CI/CD is the practice of continuously integrating code changes and continuously delivering or deploying software through automated pipelines.
- How it is used
- Automates testing, configuration tasks, and delivery or deployment so code changes can move toward production repeatably.
- How deep it goes
- Defines CI, continuous delivery, and continuous deployment, but leaves automated-test authoring beyond scope.
- Examples
- Uses GitHub Actions workflows for tests and configuration automation, and compares automated container builds through GitHub Actions or Docker Hub.
- What you can do after
- Configure GitHub Actions pipelines to run tests and configuration automation, deploy code, and centralize runtime secrets.
Think Like a CTO
An automated sequence of software integration, compilation, testing, packaging, and deployment steps.
- How it is used
- Uses automated code building, testing, and deployment to support reliable releases as teams and codebases become more complex.
- How deep it goes
- Explains the merge-triggered build, test, and deployment flow, then gives security safeguards without implementation-level detail.
- Examples
- Uses a .NET build failure caused by machine updates and the SolarWinds attack to illustrate reliability and security risks.
- What you can do after
- Operate/configure pipelines by automating builds and deployments, separating build environments, locking dependency versions, and monitoring unexpected changes.
Building Distributed Applications that Work
A software delivery pipeline is an automated sequence of steps for building, testing, or deploying software.
- How it is used
- Automates building, testing, and deploying Aspire applications instead of running deployment scripts manually.
- How deep it goes
- Works through AZD setup, generated provider YAML, test gates, environment variables, and Kubernetes adaptations; defers further provider configuration to documentation.
- Examples
- Uses GitHub Actions and Azure DevOps YAML workflows with added tests, plus provider-specific Kubernetes pipeline examples.
- What you can do after
- Operate/configure an AZD-generated Aspire pipeline, add a test gate, and adapt its deployment steps for Kubernetes.
Read how Building Distributed Applications that Work explains deployment pipeline →
gRPC Microservices in Go
A CI/CD pipeline is an automated software-delivery workflow that integrates, tests, and prepares or deploys changes continuously.
- How it is used
- Automates generation, verification, and preparation of Go gRPC microservices for deployment to Kubernetes.
- How deep it goes
- Details a tagged, matrix-based stub-generation workflow and recommends release checks and rollout methods, without specifying a complete deployment job.
- Examples
- Uses a GitHub Actions workflow and Bash script to generate tagged Go stubs for order, payment, and shipping services.
- What you can do after
- Operate/configure it to generate versioned service stubs, verify changes, and plan artifact promotion with rollback readiness.
Read how gRPC Microservices in Go explains deployment pipeline →
Authorization in Action
A CI/CD pipeline is an automated workflow that builds, tests, and delivers software or configuration changes through continuous integration and continuous delivery.
- How it is used
- Automates authorization-policy validation, approval, packaging, and deployment within a governed policy management life cycle.
- How deep it goes
- Traces changes from pull request through validation, review, signed publication, and runtime distribution, stopping short of implementation internals.
- Examples
- Uses Bob’s pull request, Cedar policy bundles, schema checks, automated tests, signed publication, and authorizer evaluation.
- What you can do after
- Operate repeatable policy delivery that catches errors before production and preserves review, version, testing, and rollback visibility.
Read how Authorization in Action explains deployment pipeline →
Kafka for Architects
A continuous integration/continuous deployment pipeline is an automated workflow that validates, builds, tests, and delivers software or infrastructure changes.
- How it is used
- Automates Kafka infrastructure changes by reconciling cluster configuration with declarative state stored in Git.
- How deep it goes
- Explains Git-triggered reconciliation and drift checks, but does not detail pipeline implementation.
- Examples
- Uses Kafka cluster configuration changes and an AsyncAPI-to-Kafka resource workflow for a Customer 360 ODS.
- What you can do after
- Operate/configure Kafka infrastructure by generating resources from AsyncAPI definitions and synchronizing the cluster with Git.
Read how Kafka for Architects explains deployment pipeline →
Machine Learning Platform Engineering
Continuous integration is a software-development practice that automatically builds and verifies changes as they are integrated into a shared codebase.
- How it is used
- Automates application testing and deployment, or supports continuous delivery of retrained ML models to prediction services.
- How deep it goes
- Explains three GitLab CI stages and their jobs, and identifies modular components, validation, monitoring, and triggers for ML pipelines.
- Examples
- Uses a FastAPI application pipeline that tests Python code, builds and pushes a Docker image, and updates a Helm chart.
- What you can do after
- Build a GitLab CI configuration that tests code, publishes a Docker image, and updates a Helm chart.
Read how Machine Learning Platform Engineering explains deployment pipeline →
Delivering Machine Learning Projects: From design to deployment
CI/CD is the practice of automating continuous integration, testing, and delivery or deployment of software changes.
- How it is used
- Automates production promotion and verifies the release with post-release tests.
- How deep it goes
- Details artifact transfer, test planning and execution, and contingency readiness, but not pipeline configuration.
- Examples
- Uses Jenkins, button- or command-triggered releases, and automated post-release tests as examples.
- What you can do after
- Operate/configure it by automating artifact promotion, planning release tests, and preparing responders for deployment failures.
Learn Go with Pocket-Sized Projects
Continuous integration is a software development practice in which changes are automatically built and tested when integrated into a shared codebase.
- How it is used
- Separates lightweight pull-request checks from slower tests that may run during tagging and image building.
- How deep it goes
- Shows how `go test -short` sets `testing.Short()` and skips integration tests, but does not detail CI-system configuration.
- Examples
- Uses a gRPC habits service to test creation, listing, invalid input, and generated IDs.
- What you can do after
- Configure Go integration tests to skip in lightweight runs with `-short`, reserving heavier checks for later runs.
Read how Learn Go with Pocket-Sized Projects explains deployment pipeline →
Microsoft Azure in Action
CI/CD is the practice of automatically integrating, testing, and delivering software changes through a repeatable pipeline.
- How it is used
- Moves validated AI models from staging toward production through repeatable promotion workflows.
- How deep it goes
- Details approval gates, smoke tests, rollout strategies, and monitoring, but leaves pipeline implementation out of scope.
- Examples
- Uses Banning Books recommendation and cover-classifier models, with staging tests and canary or blue/green rollouts.
- What you can do after
- Configure AI Foundry model promotions with staging checks, approval gates, rollout strategies, and monitoring.
Read how Microsoft Azure in Action explains deployment pipeline →
Machine Learning System Design
A set of continuous integration and continuous delivery or deployment practices that automate software integration, testing, and release.
- How it is used
- Connects integration checks and artifact packaging with the practical work of releasing software and machine-learning systems.
- How deep it goes
- Describes CI checks, model packaging, and operational safeguards, without detailing deployment orchestration.
- Examples
- Names unit and integration tests, test deployments, ONNX and CoreML models, JSON configuration, and validation reports.
- What you can do after
- Evaluate release checks and package formats that reduce coupling between training and deployment.
Read how Machine Learning System Design explains deployment pipeline →
Build a Frontend Web Framework (From Scratch)
The process of transforming application source code and assets into files prepared for delivery to users.
- How it is used
- Prepares frontend application files for delivery before deployment to production.
- How deep it goes
- Outlines template compilation, bundling, minification, and HTML output, while treating the process as a simplified set of common practices.
- Examples
- Uses app.bundle.js, vendors.bundle.js, bundle.css, and index.html as example build outputs.
- What you can do after
- Apply it via a framework CLI, commonly invoked with an npm run build script, to prepare files for delivery.
Read how Build a Frontend Web Framework (From Scratch) explains deployment pipeline →
Introduction to Generative AI, Second Edition
CI/CD is the practice of automating continuous integration, testing, delivery, and deployment of software changes.
- How it is used
- Positions CI/CD as a DevOps workflow where AI agents can support operational tasks.
- How deep it goes
- Describes agent-assisted monitoring, test-failure fixes, deployment rollback, and performance triage without implementation details.
- Examples
- Illustrates agents suggesting fixes for failing tests, rolling back deployments, and triaging performance issues.
Read how Introduction to Generative AI, Second Edition explains deployment pipeline →
Build Python Web Apps with Streamlit
Continuous integration is the practice of automatically validating code changes as they are integrated into a shared codebase.
- How it is used
- Automates test runs as code changes are committed or pushed, helping catch problems early.
- How deep it goes
- Shows a pre-commit hook and mentions pre-push hooks and GitHub Actions, but gives no CI-service configuration.
- Examples
- Uses a Git pre-commit hook for non-API tests and names pre-push hooks and push-triggered GitHub Actions.
- What you can do after
- Operate automated checks with Git hooks or CI runs on pushes, blocking failing commits or notifying teams of failures.
Read how Build Python Web Apps with Streamlit explains deployment pipeline →
Related concepts
- software artifactproduces · A software artifact is a persistent work product or object produced or maintained during software development or a related workflow.
- evaluation suiteuses · An evaluation suite is an organized collection of tests, cases, or tasks used to assess a system against specified behaviors or criteria.
- testuses · A test is a procedure or check that evaluates behavior using specified inputs or evidence against expected results or criteria.
- GitHub Actionsused by · GitHub Actions is GitHub’s workflow automation platform for defining and running jobs in response to repository events, schedules, and other triggers.
- integration testuses · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
- container imageproduces · A container image is a packaged filesystem and configuration artifact from which a container can be created and run.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.