Deployment
Deployment is the process of placing or releasing software, models, or configuration into a target environment so they can operate there.
Shipping Go: Develop, deliver, discuss, design, and go again
Software deployment is the process of making a product available for use on a server or other execution environment.
- How it is used
- Makes a delivered artifact run for users so a small product increment can produce feedback.
- How deep it goes
- Defines deployment, walks through automated hosted-container deployment and verification, and outlines Kubernetes resources without detailing Kubernetes internals.
- Examples
- Uses a Cloud Run pipeline that checks /hello and Kubernetes YAML defining a Deployment and Service.
- What you can do after
- Apply it via a Cloud Run pipeline to deploy a container and check its running API endpoint.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains deployment →
Machine Learning Platform Engineering
The process of releasing software into an environment where it can execute and serve its intended users or workloads.
- How it is used
- Makes trained models available for inference in production or staging environments.
- How deep it goes
- Develops staged promotion, automated packaging, serving commands, testing, and monitoring; leaves some CI/CD implementation detail to project deployments.
- Examples
- Uses income classification, object detection, and movie recommendation services, including an MLflow serving command and Docker build.
- What you can do after
- Apply it via BentoML or MLflow to package and serve a model, then validate and monitor the deployment.
Read how Machine Learning Platform Engineering explains deployment →
Build AI-Enhanced Web Apps
Deployment is the process of making an application or service available to run in an operational environment.
- How it is used
- Makes AI web apps publicly available while preparing their dependencies for secure, scalable operation.
- How deep it goes
- Provides traffic-based checklist guidance and a Vercel deployment example, with less procedural detail on container-based deployment.
- Examples
- Uses a chat app with Google AI, Upstash Redis, and Clerk credentials to illustrate Vercel deployment.
- What you can do after
- Apply deployment via Vercel using production configuration, a traffic-based checklist, and deployment logs.
Lead Developer Career Guide
Deployment is the process of installing and releasing software into an environment where it can run.
- How it is used
- Positions deployment as part of testing, releasing, and keeping a development team informed.
- How deep it goes
- Explains environments, documentation, and tracking practices, but does not provide a step-by-step deployment procedure.
- Examples
- Uses a Jira deployment ticket containing an environment, package, and instructions, plus an account of automating Jira and Azure DevOps release tracking.
- What you can do after
- Operate/configure it by identifying target environments, documenting the process, and tracking release status through project-management integration.
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A production deployment is the operational release of a software system or machine-learning solution for live application use.
- How it is used
- Moves a trained model from real-world validation into a local web application and then a callable cloud endpoint.
- How deep it goes
- Explains components, local testing, endpoint configuration, and prediction validation, but defers broader production characteristics and resource scaling.
- Examples
- Uses Kuala Lumpur property-price prediction, a local Flask server, browser testing, and Vertex AI JSON endpoint requests.
- What you can do after
- Operate a local Flask deployment, invoke a Vertex AI endpoint, and interpret its model output as a probability.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains deployment →
Road to Kubernetes
Deployment is the process of releasing software so that it can run in a target environment.
- How it is used
- Frames deployment as a progressive practice for releasing applications, beginning with manual servers and advancing to automated containers and Kubernetes.
- How deep it goes
- Progresses from deployment fundamentals through manual servers, declarative files, containers, automation, and selected Kubernetes operations.
- Examples
- Uses Python and JavaScript applications, NGINX, Docker commands, Git workflows, and Kubernetes Deployments and Services.
- What you can do after
- Build applications from scratch through manual servers, automated workflows, containers, and Kubernetes-managed deployments.
Building Web APIs with ASP.NET Core
Deployment is the process of installing and configuring software in an environment where it can run and be accessed.
- How it is used
- Makes the board-game web API accessible to product owners and testers after a release decision.
- How deep it goes
- Walks through publishing choices and a Windows publishing profile, then checks deployed endpoints and a security-policy issue.
- Examples
- Uses a Visual Studio Windows profile, two test endpoints, and a browser console message about a blocked script.
- What you can do after
- Operate/configure a Windows deployment and diagnose whether an unexpected endpoint result comes from production configuration.
Read how Building Web APIs with ASP.NET Core explains deployment →
Build Python Web Apps with Streamlit
Deployment is the process of making an application available to its intended users by hosting and configuring it.
- How it is used
- Makes Streamlit applications reachable by intended users beyond the developer’s local machine.
- How deep it goes
- Explains URLs, hosting choices, repositories, secrets, dependencies, and production platforms without detailing server administration.
- Examples
- Uses a local network URL, a phone-accessible to-do list app, and a GitHub-hosted deployment.
- What you can do after
- Operate/configure a Streamlit deployment through local networking, Community Cloud, GitHub, dependency files, and production secrets.
Read how Build Python Web Apps with Streamlit explains deployment →
Kafka for Architects
Deployment is the process of installing and making software available to run in a target environment.
- How it is used
- Frames the move from a Kafka prototype to an accessible, operable production system.
- How deep it goes
- Compares deployment models and operational responsibilities without providing a step-by-step cluster installation procedure.
- Examples
- Uses an on-premises prototype needing controllers and a deployed model server serving predictions from streaming events.
- What you can do after
- Evaluate/understand Kafka placement choices by balancing operational burden, control, cost, latency, and compliance.
Deep Learning with PyTorch, Second Edition
The process of putting a trained model into a real runtime environment where it serves users or applications.
- How it is used
- Places trained models in environments where users or applications can use them.
- How deep it goes
- Surveys deployment targets and tools without detailing implementation steps.
- Examples
- Uses a Gradio demo, a FastAPI service, ONNX export, C++ integration, and mobile deployment as options.
- What you can do after
- Evaluate deployment options for web services, C++ applications, mobile devices, and specialized hardware.
Read how Deep Learning with PyTorch, Second Edition explains deployment →
Grokking AI Applications
Deployment is the process of making an AI application available to users or operational systems.
- How it is used
- Makes GenAI applications continuously accessible to users, websites, APIs, and operational systems.
- How deep it goes
- Explains always-on hosting, access points, interoperability, and deployment choices without descending into changing cloud-platform details.
- Examples
- Uses Langflow flows, Hugging Face Spaces, public servers, virtual machines, managed hosting, and embedded website chat widgets.
- What you can do after
- Operate/configure an always-on AI application and expose it through a website, API, or interoperable agent setup.
Data Without Labels
Model deployment is the process of making a trained machine-learning model available to process inputs and produce predictions in an operational environment.
- How it is used
- Bridges development and production so models support operational predictions, recommendations, optimization, and automation.
- How deep it goes
- Explains the end-to-end stages, deployment strategies, and operational safeguards, then stops short of detailed infrastructure implementation.
- Examples
- Uses retail customer clustering, credit-card fraud detection, edge devices, canary releases, and A/B testing.
- What you can do after
- Operate a deployed model through Flask while monitoring performance, drift, security, reproducibility, versioning, and rollback.
Microsoft Azure in Action
Deployment is the process of making a trained model or application available for operational use.
- How it is used
- Makes an Azure OpenAI model available to applications for tasks such as book recommendations.
- How deep it goes
- Walks through model version and capacity settings and a sample request, then sketches production promotion with approval gates.
- Examples
- Uses a named GPT-4o deployment and a customer review requesting dystopian book recommendations.
- What you can do after
- Operate/configure it with Azure CLI by creating a model deployment and sending a request to its endpoint.
Deep Learning with R, Third Edition
Deployment is the process of making a trained machine-learning model available in an operational environment for use.
- How it is used
- Moves a tested model into an operational environment and keeps its production use under observation.
- How deep it goes
- Explains export, inference optimization, serving options, environment choices, and monitoring without detailing infrastructure implementation.
- Examples
- Uses TensorFlow SavedModel and ONNX exports, REST serving, Posit Connect, and deployment to web, mobile, browser, or embedded environments.
- What you can do after
- Operate/configure an exported model for inference through TensorFlow Serving, ONNX, Posit Connect, or another chosen environment.
Read how Deep Learning with R, Third Edition explains deployment →
Enterprise RAG
Deployment is the process of releasing a software system or change into an environment where it can operate for users.
- How it is used
- Guides the transition from a local RAG chatbot to a publicly reachable, automated, monitored, and scalable service.
- How deep it goes
- Explains packaging, secrets, CI testing, endpoint validation, logging, and load testing, stopping short of detailed scaling implementation.
- Examples
- Uses Docker images, Azure Web App domains, GitHub workflow tests, WebSocket smoke tests, Log stream output, and Locust traffic.
- What you can do after
- Operate/configure an Azure-hosted container deployment with automated releases, endpoint checks, logs, and synthetic load tests.
Vibe Engineering
Deployment is the process of installing and configuring software so that it runs in a target environment.
- How it is used
- Uses deployment to move applications into target environments while making supported models, compatibility, and operational assumptions explicit.
- How deep it goes
- Explains models, prerequisites, generated container artifacts, cloud commands, and success output, while deferring Kubernetes and Helm support.
- Examples
- Uses JBoss deployment, a containerized Java application, and a Google Cloud Run service with secret-backed API keys.
- What you can do after
- Operate/configure deployments by selecting a supported model, following prerequisites, building an image, and deploying with guarded credentials.
ASP.NET Core in Action, 3e
Deployment is the process of installing and configuring an application and its required artifacts in an environment where users can access it.
- How it is used
- Moves ASP.NET Core applications from development into production environments where users can access them.
- How deep it goes
- Explains publishing, hosting choices, reverse proxies, CI/CD, and basic IIS setup, while deferring detailed IIS configuration.
- Examples
- Uses Visual Studio Publish destinations, CI/CD systems, and a Windows IIS application pool, website, and hosting folder.
- What you can do after
- Operate/configure an ASP.NET Core deployment through Visual Studio, CI/CD, or basic IIS hosting steps.
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A deployment is a distinct instance of infrastructure managed from a Terraform configuration and associated state.
- How it is used
- Distinguishes independent Terraform environments and the act of applying infrastructure changes to them.
- How deep it goes
- Defines workspace, backend, and state relationships, then explains centralization, automation, access, timing, and consistency without specifying a CD platform.
- Examples
- Contrasts production, staging, and ephemeral feature deployments with conflicting laptop-based applies and a shared Git deployment path.
- What you can do after
- Operate/configure it by centralizing applies, providing runner access, queuing changes, and keeping automated deployments small.
Machine Learning System Design
Deployment is the process of making a software system or model available to operate in a target production environment.
- How it is used
- Connects trained ML systems to production requests, scheduled jobs, monitoring, fallback behavior, and business delivery deadlines.
- How deep it goes
- Explains APIs, monitoring, fallbacks, and separate wrapper-model release cycles, but does not detail model-release procedures beyond their governing factors.
- Examples
- Uses retail demand prediction, weekly sales reports, HTTP prediction requests, JSON responses, drift alarms, and fallback forecasts.
- What you can do after
- Operate/configure production prediction services with APIs, monitoring, fallbacks, release distinctions, and deadline-aware serving choices.
Read how Machine Learning System Design explains deployment →
Contract Testing in Action
A deployment is the act or resulting state of installing a particular software version into a runtime environment.
- How it is used
- Tracks which consumer and provider versions occupy an environment so CI/CD contract checks can evaluate deployed integrations.
- How deep it goes
- Explains deployment state, contrasts it with release state, and demonstrates Pact commands and workflow placement without detailing runtime installation mechanics.
- Examples
- Uses WebConsumer, MoviesAPI, production recording scripts, GitHub Actions steps, and GraphQL deployment exercises.
- What you can do after
- Operate/configure Pact deployment recording and use recorded versions in automated contract verification and can-i-deploy checks.
Think Like a Software Engineering Manager
A software deployment is the process of releasing a software change into an environment where it can run, especially production.
- How it is used
- Uses deployment management to move code into production while balancing release efficiency with safety, stability, and security.
- How deep it goes
- Explains phased releases, bake time, canaries, feature flags, and test coverage, but stops short of implementation details.
- Examples
- Uses staged environments, 24-hour pre-production bake time, canary users, feature toggles, and A/B testing as deployment examples.
- What you can do after
- Operate/configure safer releases through staged environments, canaries, feature flags, testing, and feedback.
Read how Think Like a Software Engineering Manager explains deployment →
Generative AI in Action
A model deployment is a configured, addressable instance of a machine-learning model made available for serving requests.
- How it is used
- Positions models for reliable, scalable, secure, and cost-aware inference in enterprise production systems.
- How deep it goes
- Explains environments, infrastructure, operational criteria, and a production checklist, but stops short of model-serving internals.
- Examples
- Uses Azure and OpenAI fine-tuned models, cloud, on-premise, and hybrid environments, containers, serverless functions, and API gateways.
- What you can do after
- Operate/configure a model deployment by selecting infrastructure, measuring inference, managing capacity, and applying reliability and security controls.
Grokking Software Architecture
Deployment is the act of placing software files or components into an environment where they can run.
- How it is used
- Places compiled binaries on production infrastructure as the engineering step distinct from exposing features to users.
- How deep it goes
- Defines deployment versus release, explains feature flags and dark launches, and compares rollout strategies and their tradeoffs.
- Examples
- Uses a flagged enterprise discount feature and contrasts rolling, blue-green, and canary rollout approaches.
- What you can do after
- Evaluate rolling, blue-green, and canary deployments by cost, fleet complexity, rollback safety, and blast-radius containment.
Read how Grokking Software Architecture explains deployment →
gRPC Microservices in Go
Deployment is the process of releasing software artifacts into an environment where they can run.
- How it is used
- Moves tested service artifacts through UAT and production into Kubernetes workloads within a continuous delivery lifecycle.
- How deep it goes
- Explains validation, promotion, rollback, workload updates, and rollout choices, but stops short of detailed strategy mechanics.
- Examples
- Uses Docker images, UAT and production promotion, kubectl, Kubernetes workloads, ArgoCD, and FluxCD as deployment artifacts or mechanisms.
- What you can do after
- Operate/configure deployments by promoting tested artifacts, updating Kubernetes workloads, selecting rollout strategies, and preparing rollback decisions.
Domain-Specific Small Language Models
- How it is used
- Frames deployment as selecting hardware and serving environments for language-model inference.
- How deep it goes
- Estimates inference memory from parameter count and precision, then outlines MLC build-to-install steps without detailing every serving option.
- Examples
- Uses GPT-Neo and Mistral 7B memory estimates and an MLC LLM workflow for Android phones.
- What you can do after
- Build and install an Android SLM app with MLC LLM by compiling runtime and model libraries, bundling weights, and installing the APK.
Read how Domain-Specific Small Language Models explains deployment →
Machines that Think
Deployment is the process of making a computational model available for operation in a target environment.
- How it is used
- Makes large language models available for practical use while reconciling model scale with operating constraints.
- How deep it goes
- Explains inference costs, serving demands, and infrastructure trade-offs without detailing implementation procedures.
- Examples
- Cites hosted model APIs, managed cloud models, regional replicas, and deployments using GPUs or TPUs.
- What you can do after
- Evaluate deployment choices by weighing operating cost, latency, throughput, capacity, and portability.
Modern Angular
Deployment is the process of releasing software to an environment where it can be executed or accessed by users.
- How it is used
- Prepares Angular applications for hosting through client-side rendering and route-aware server configuration.
- How deep it goes
- Explains build output, file delivery, and SPA fallback configuration, but defers platform-specific deployment procedures.
- Examples
- Uses the HRMS application, an Angular dist folder, and direct navigation to /products as concrete deployment examples.
- What you can do after
- Apply via Angular CLI by building the application, publishing its output, and configuring route fallbacks.
Context Engineering
Deployment is the process of releasing an AI system or a part of it into an environment serving users or production workloads.
- How it is used
- Releases AI systems and context changes into environments serving users or production workloads.
- How deep it goes
- Distinguishes release scope and responsibilities, then outlines blue-green and canary strategies.
- Examples
- Uses blue-green environment switching and gradual canary exposure as rollout examples.
- What you can do after
- Operate releases by validating changes, monitoring production metrics, and retaining rollback options.
Building Reliable AI Systems
The release of software or a software change into an environment where it can operate.
- How it is used
- Uses recent deployments as operational context for investigating alerts and system behavior.
- How deep it goes
- Links deployment history to alerts and correlated metrics, but does not describe release procedures.
- Examples
- Shows a production customer-support dashboard with recent deployments, live metrics, cost, and business effects.
- What you can do after
- Diagnose incidents by correlating alerts with recent deployments, system metrics, and historical behavior.
Also covered in
- Software Engineering for Data ScientistsIn early access (MEAP)
- Designing Deep Learning Systems: A guide for software engineers
- Refactoring to Rust
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- MongoDB 8.0 in Action, Third Edition
- GitHub Actions in Action: Continuous integration and delivery for DevOps
- Build a Website with ChatGPT
- Rust Servers, Services, and Apps
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- Pro Angular 16
- Inside AI
- LLMs in Production
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- productionProduction is the live operational setting in which a deployed software system serves its intended users or processes real workloads.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
Related concepts
- releasecontrasts with · A software release is a version of software made available for use or deployment, or the act of making that version available.
- cloud provideruses · A cloud provider is an organization or service operator that supplies remotely accessible computing resources or services over a network, often on demand.
- manual deploymentincludes · Manual deployment is the release, installation, or configuration of software through steps performed directly by a person rather than an automated workflow.
- language modeluses · A language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- deployment pipelineused by · A deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- canary deploymentincludes · A canary deployment is a release strategy that exposes a change to a limited portion of users, traffic, or infrastructure before expanding it more broadly.
Questions about deployment
What is deployment?
Deployment is the process of placing or releasing software, models, or configuration into a target environment so they can operate there.
Which Manning books explain deployment?
Shipping Go: Develop, deliver, discuss, design, and go again, Machine Learning Platform Engineering, Build AI-Enhanced Web Apps, Lead Developer Career Guide, Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI, Road to Kubernetes, Building Web APIs with ASP.NET Core, Build Python Web Apps with Streamlit and 21 more.
What should I know before learning deployment?
Manning books that teach deployment usually introduce language model, deployment pipeline, production and contract first.
What is the difference between deployment and release?
Deployment is the process of placing or releasing software, models, or configuration into a target environment so they can operate there. A software release is a version of software made available for use or deployment, or the act of making that version available.
What kinds of deployment are there?
Kinds of deployment include manual deployment and canary deployment.
What is deployment also called?
Deployment is also called deploy, deploying or redeploy.
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.




























