A reliable CI/CD pipeline for a cloud web application should do more than run a build. It should provide a controlled path from pull request to production, verify the change at several points, protect secrets and data, and give the team a clear recovery option when something fails. This reusable checklist covers the core workflow, provider choices, release scenarios, and review questions to use before a significant deployment.
Overview
Continuous integration and continuous delivery (CI/CD) turn a code change into a repeatable cloud deployment workflow. In a typical setup, a developer opens a pull request, automated checks validate the change, an approved commit is built into a deployable artifact, and a controlled process promotes that artifact through staging and production.
The exact implementation depends on the application and its cloud app development platform. A React frontend, Node.js API, serverless app, and containerized service may use different build commands and deployment targets. The quality goals, however, are consistent:
- Fast feedback: Developers should learn about formatting, type, dependency, and test failures before a change is merged.
- Reproducible builds: The same source revision and declared dependencies should produce an identifiable artifact.
- Controlled promotion: Production deployment should require the appropriate review, approval, or automated condition.
- Safe changes: Database migrations, configuration changes, and infrastructure updates need explicit consideration.
- Verifiable releases: Smoke tests and monitoring should confirm that the new version works after deployment.
- Recoverable failures: The team should know how to stop, roll back, or roll forward without improvising under pressure.
A pipeline is not automatically reliable because it is automated. Reliability comes from making each decision visible, limiting production access, and regularly testing the recovery path. For background on deployment preparation, see the production checklist for deploying a Node.js app to the cloud.
A practical pipeline sequence
- Pull request opens or updates.
- Static checks, dependency checks, unit tests, and build validation run.
- Reviewers assess the code, configuration, migration plan, and risk.
- The merged revision produces a versioned artifact.
- The artifact deploys to a preview or staging environment.
- Integration tests and smoke tests run against the deployed version.
- A migration and production approval step is completed when needed.
- Production deployment proceeds using a defined rollout method.
- Post-deployment checks verify application health, key user flows, logs, and alerts.
- The team records the result and retains enough information to investigate or recover.
Checklist by scenario
For every pull request
- Confirm that the pipeline runs for the intended branches and pull request events.
- Install dependencies from a lockfile or another controlled resolution method.
- Run formatting, linting, type checks, and unit tests where applicable.
- Build the application using the same runtime family and required environment assumptions as the target platform.
- Check for vulnerable or disallowed dependencies using the scanning capability selected by the team.
- Prevent secrets, private keys, local configuration files, and generated credentials from entering the repository.
- Publish clear failure output so a developer can identify the failing command without opening the pipeline definition.
Keep pull request checks focused enough to provide useful feedback. Long-running end-to-end suites can run in a separate stage or against a preview environment if they would otherwise slow every small change.
For a new application or deployment target
- Document the build command, start command, supported runtime, package manager, and required environment variables.
- Separate build-time values from runtime secrets. A frontend may embed some configuration during its build, while an API usually reads secrets at runtime.
- Define the target environment, region or location assumptions, service dependencies, and required permissions.
- Decide whether the deployment target is a managed app hosting service, container platform, serverless app platform, or another platform as a service.
- Create a staging or preview path before enabling production promotion. The staging environment guide explains how preview and promotion decisions can be organized.
- Record the rollback method before the first release. This may mean selecting a previous artifact, reverting a platform revision, or deploying a known-good commit.
For database or schema changes
- Make the migration part of the release plan rather than an incidental shell command.
- Review whether the migration is backward compatible with the version currently in production.
- Back up or otherwise protect recoverable data according to the application's requirements.
- Decide who can approve production migrations and whether the migration runs before, during, or after application deployment.
- Test the migration and, where practical, its recovery implications in a representative environment.
- Check connection limits, startup behavior, and timeout assumptions for serverless or autoscaled services. Connection pooling deserves special attention; see the guide to serverless database connection pooling.
For a production deployment
- Confirm that the revision being deployed matches the approved source revision and build artifact.
- Verify production secrets, domains, certificates, feature flags, queues, storage, and third-party integrations.
- Use an approval or protected-environment control appropriate to the application's risk.
- Deploy in a way that limits exposure when the platform supports staged, rolling, preview, or traffic-based promotion.
- Run smoke tests for startup, authentication, a critical read path, a critical write path, and any essential background process.
- Watch logs, error rates, latency, resource use, and business-critical alerts after release.
- Notify the people responsible for the application, including the outcome and the revision deployed.
Provider and pipeline model comparison
GitHub Actions, GitLab CI/CD, and managed platform pipelines can all support CI/CD for web apps, but they place responsibility in different parts of the workflow. Names, runner options, integrations, limits, and pricing can change, so verify current details in the provider documentation before selecting an implementation.
| Pipeline model | Useful when | Review carefully |
|---|---|---|
| GitHub Actions | The repository is hosted on GitHub and the team wants workflow definitions, checks, and deployment automation close to the code. | Runner permissions, action provenance, secret handling, concurrency, approval controls, and usage limits. |
| GitLab CI/CD | The team wants repository, pipeline, environment, and release controls within a GitLab-centered workflow. | Runner ownership, protected variables, environment permissions, pipeline reuse, and artifact retention. |
| Managed platform pipeline | The application is deployed to a platform that can connect a repository and handle common build and deployment steps. | Build customization, preview environments, rollback behavior, logs, environment variables, provider lock-in, and the boundaries of platform control. |
Choose the model that makes the application's risks easiest to manage, not simply the one with the shortest initial setup. A small static site may benefit from a managed app hosting workflow, while a multi-service system may need the explicit controls of a repository-based pipeline.
What to double-check
Security and permissions
Use least-privilege credentials for build and deployment jobs. Separate pull request permissions from production deployment permissions, especially when external contributions or untrusted code may run in the pipeline. Review whether a job can read production secrets, modify infrastructure, or approve its own release. Rotate credentials through the selected secret-management process, and avoid printing environment variables in logs.
Build consistency
Pin or constrain action versions and important tool versions according to the team's maintenance policy. Use a declared runtime version, a lockfile, and a repeatable build command. Cache dependencies only when the cache cannot silently replace a clean install or hide a broken dependency resolution. Retain the commit identifier, artifact identifier, and relevant build metadata with each release.
Environment parity
Staging does not need to be identical to production in every dimension, but differences that affect behavior should be documented. Compare runtime versions, database engines, queue behavior, authentication configuration, networking, feature flags, and resource limits. For a React application, validate the build-time configuration separately from the hosting configuration; the React cloud hosting guide provides a useful deployment context.
Capacity, cost, and observability
CI/CD can fail because the application is unhealthy, but it can also fail because a quota, timeout, concurrency limit, or storage limit was reached. Review the limits that affect builds, deployments, logs, artifacts, and runtime services. The cloud quotas and rate limits reference can help organize this review. Also confirm that deployment alerts reach a monitored channel and that logs contain enough context to identify the release involved. See the cloud observability stack guide for a broader review of logs, metrics, traces, and alerts.
Rollback and data compatibility
Application rollback is not always database rollback. A previous application version may not work with a destructive schema change, changed queue format, or incompatible cached data. Prefer additive, backward-compatible changes where possible, and document the forward recovery plan when a simple rollback cannot restore service safely.
Common mistakes
- Deploying directly from a developer workstation: This bypasses review, provenance, and repeatability.
- Testing only the build: A successful build does not prove that routes, credentials, migrations, integrations, or critical user flows work.
- Using production secrets in pull request jobs: Separate untrusted validation from privileged deployment stages.
- Allowing every branch to deploy production: Define protected branches, environments, or equivalent controls.
- Running migrations without an owner: Make migration approval and failure handling explicit.
- Ignoring failed notifications: A pipeline that fails silently is not a dependable control.
- Skipping rollback practice: Write the procedure and rehearse it in a safe environment before an incident.
- Overloading one pipeline: Keep fast checks, deployment tasks, infrastructure changes, and long-running tests logically separated so failures are easier to diagnose.
When to revisit
Review the pipeline before a major release, a seasonal planning cycle, a change in deployment target, a new application service, or a runtime upgrade. Also revisit it after a failed deployment, security finding, quota incident, database migration problem, or change to the team's branching and approval model.
At minimum, perform a scheduled review twice a year or whenever the underlying workflow and tools change. Check provider documentation for action and runner capabilities, deployment integrations, security recommendations, supported runtimes, usage limits, and pricing before relying on older assumptions. The cloud app platform pricing guide can support the cost portion of that review.
Reusable release review
- Open the pipeline definition and identify every production-capable job.
- Confirm triggers, branch protections, approvals, permissions, secrets, and environment boundaries.
- Run or inspect pull request checks for formatting, dependencies, tests, build output, and security scanning.
- Verify that the artifact, revision, runtime, and configuration are traceable.
- Review migrations, compatibility, backups, quotas, and expected capacity.
- Deploy to staging or a preview environment and run critical-path smoke tests.
- Confirm the production rollout, monitoring, notification, and rollback procedures.
- Record any gap as an owner-assigned task with a due date before the next significant release.
A good cloud deployment pipeline is a maintained developer tool, not a one-time configuration file. Keep this checklist with the application documentation, update it when the workflow changes, and use it as a release gate when the cost of an avoidable failure is higher than the time required to verify the basics.