02.01 · Short-concept · Free
What Deployment Means
Say what deploying actually moves and where it moves it, and why code in a repository is not code that anyone can reach.
Curated for this lesson
What Deployment Is
03 L What Is Deployment-
States plainly what deploying moves and where, which is the sentence that kills the belief that pushing to a repository is shipping.
Deployment moves a built, configured, runnable version of software from a private development location into an environment that can execute it. A repository holds source; a runtime serves traffic, handles invocations, or runs jobs. Until an artifact and its configuration reach that target, users and clients cannot reach the change.
What this lesson answers
- what does deployment actually move
- why is GitHub not production
- where does deployed code run
Notes
Deployment — Deployment exists to move a built, configured version of software from a private development location into a reachable runtime environment; without it, code may exist in GitHub but no user, browser, API client, or scheduled job can execute it.
Key Concepts: - A repository stores source code such as `app.py` or `index.ts`, while a deployment moves a runnable artifact such as a Docker image `registry.example.com/api:v42` or a Vercel build output. - Deployment usually moves code from a developer-controlled place like GitHub to a runtime target such as Kubernetes, AWS Lambda, Cloud Run, Vercel, or a virtual machine. - A deployed service needs an entry point users can reach, such as `https://api.example.com`, a Kubernetes `Service`, an AWS Lambda function URL, or a Cloud Run HTTPS endpoint. - The deployed version is usually identified by a concrete revision, commit, or image tag, for example Git commit `a1b2c3d` deployed as container image `api:2026-08-22`. - Deployment often includes configuration that is not stored directly in source code, such as environment variable `DATABASE_URL=postgres://...` or Kubernetes Secret `stripe-api-key`. - Code is not reachable just because it is merged; `main` in GitHub becomes reachable only after a build and release process places it into a running environment. - A common deployment path is: Git commit CI build artifact, such as Docker image runtime update, such as Kubernetes `Deployment` rolling out new Pods.
Watch For: - Merging code to GitHub `main` and assuming users have it, when the production Kubernetes `Deployment` is still running image `api:v41`. - Building a Docker image locally with `docker build` but never pushing it to Amazon ECR, Google Artifact Registry, or Docker Hub, so Cloud Run or Kubernetes cannot pull it. - Deploying code without required runtime configuration, such as launching a Lambda function without `DATABASE_URL`, causing startup or request failures. - Updating frontend source in a repository but forgetting to redeploy Vercel or Netlify, so `https://www.example.com` still serves the previous build.
Production Connection: - Kubernetes deploys by updating a `Deployment` object so the cluster replaces old Pods with new Pods running a specified container image such as `ghcr.io/org/api:1.8.0`. - Vercel deploys each GitHub commit into an immutable build with a generated URL like `project-git-feature-user.vercel.app`, then promotes one deployment to the production domain. - AWS Lambda deployment publishes function code and configuration into AWS so an invocation source such as API Gateway or EventBridge can execute that version. - Google Cloud Run deploys a container image from Artifact Registry to a managed HTTPS service, creating a new revision such as `api-00042-x9s` that can receive traffic.
References
Common questions
- Is merging to main the same as deploying?
- No. Merging changes the source stored in the repository. Deployment happens when a built artifact, plus the configuration it needs, is placed into a runtime such as Kubernetes, Lambda, Cloud Run, Vercel, or a virtual machine. Production can still be running an older artifact after main has changed.
- What is the difference between source code and a deployment artifact?
- Source code is what developers edit and review, such as application files in a repository. A deployment artifact is the runnable output a platform can execute, such as a container image or hosted frontend build. Deployment connects that artifact to a runtime target and an entry point clients can use.
- Why can deployed code fail even when the build passed?
- A successful build only proves an artifact was produced. The runtime may still be missing required configuration, secrets, network access, or the correct endpoint wiring. For example, a service can start without the database URL it expects, or a platform can keep serving the previous frontend build.
