Deployment
Deployment is the process of making software, models, or other computational systems available to operate in a target environment.
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 an AI web application publicly available while configuring its databases and external services for production.
- How deep it goes
- Provides traffic-based checks and a Vercel CLI walkthrough, while treating Docker and Kubernetes as alternatives rather than worked deployments.
- Examples
- Uses a chat application with Google AI, Upstash Redis, Clerk, environment variables, and Vercel preview and production deployments.
- What you can do after
- Operate/configure a Vercel deployment with production credentials, a preview release, and a traffic-appropriate readiness checklist.
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 a trained model where users or applications can run inference.
- How deep it goes
- Surveys deployment routes and performance tools, without giving a step-by-step procedure in the supplied passages.
- Examples
- Uses a Gradio demo, a FastAPI service, ONNX export, C++ applications, and mobile deployment as concrete options.
- What you can do after
- Evaluate/understand which PyTorch deployment route fits a demo, web service, portable runtime, C++ application, or mobile device.
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 →
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.
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.
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.
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.
Related concepts
- releasecontrasts with · A software release is a version or set of changes made available to intended recipients for deployment or use.
- cloud provideruses · A cloud provider is an organization that delivers computing resources, platforms, or managed services over a network, typically on demand.
- language modeluses · A language model is a computational model that represents patterns in linguistic tokens to estimate sequence probabilities and predict or generate language from context.
- deployment pipelineuses · A sequence of automated or manual stages that builds, tests or validates, packages, and delivers software or models toward 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.
- hostinguses · Hosting is the provision of computing infrastructure and services for running applications or websites and making them accessible over a network.
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.