liveBook · Manning

Deployment

Also called deploy, deploying, redeploy

Deployment is the process of placing or releasing software, models, or configuration into a target environment so they can operate there.

How 29 Manning books explain it

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.

Read how Build AI-Enhanced Web Apps explains deployment →

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.

Read how Lead Developer Career Guide explains deployment →

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.

Read how Road to Kubernetes explains deployment →

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.

Read how Kafka for Architects explains deployment →

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.

Read how Grokking AI Applications explains deployment →

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.

Read how Data Without Labels explains deployment →

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.

Read how Microsoft Azure in Action explains deployment →

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.

Read how Enterprise RAG explains deployment →

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.

Read how Vibe Engineering 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.

Read how ASP.NET Core in Action, 3e explains deployment →

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.

Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains deployment →

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.

Read how Contract Testing in Action explains deployment →

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.

Read how Generative AI in Action explains deployment →

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.

Read how gRPC Microservices in Go explains deployment →

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.

Read how Machines that Think explains deployment →

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.

Read how Modern Angular explains deployment →

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.

Read how Context Engineering explains deployment →

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.

Read how Building Reliable AI Systems explains deployment →

Also covered in

What to know first

Related concepts

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.