Use this provider-neutral cloud security checklist to review identity, secrets, network exposure, encryption, logging, dependencies, backups, and incident response before releasing an application. It is designed to be reused for every production deployment, architecture change, new cloud account, and access review.
Overview
A secure cloud deployment is not created by one setting or one scan. It is the result of controls working together: the right people and services have the right access, sensitive values are protected, public exposure is intentional, application and infrastructure changes are traceable, and the team can recover when something goes wrong.
Developers are often closest to the application and its deployment pipeline, so they are well placed to catch practical risks before production. This does not mean every developer must become a security specialist. It does mean that security checks should be part of the release path rather than an informal review performed after deployment.
Use the checklist below as a pre-production gate. Mark each item as verified, needs remediation, or accepted risk. For accepted risks, record the reason, owner, compensating control, and review date. A checklist without ownership and follow-up quickly becomes documentation rather than protection.
What to track
1. Identity and permissions
Start with a clear inventory of human users, service accounts, workload identities, automation tokens, and administrative roles. For each identity, ask:
- Is access required for the person or workload to perform its current function?
- Are permissions scoped to specific resources and actions instead of broad administrative roles?
- Are production and non-production environments separated?
- Are privileged actions protected by stronger authentication and recorded in audit logs?
- Are inactive users, former team members, temporary accounts, and unused credentials removed?
Prefer short-lived credentials, workload identity, and role-based access where your cloud platform supports them. Avoid placing long-lived provider keys in source code, container images, local configuration files, or CI logs. Review both direct permissions and permissions inherited through groups, roles, projects, subscriptions, or organization-level policies; excessive access can hide in any of these layers.
2. Secrets and configuration
List every sensitive value the application uses, including database credentials, signing keys, API tokens, encryption keys, webhook secrets, and private certificates. Confirm where each value is stored, who can read it, how it reaches the application, and how it will be rotated.
Use a dedicated secrets-management facility or an equivalent protected mechanism rather than ordinary environment files committed to a repository. Treat build logs, error messages, crash reports, and support exports as possible disclosure paths. Test that a secret cannot be retrieved by an unrelated workload or exposed through a diagnostic endpoint. Document the rotation procedure before launch; a secret that cannot be rotated safely creates operational pressure during an incident.
3. Network exposure
Draw the intended traffic path from users to the application, application services to data stores, and administrative users to management interfaces. Then compare that design with the actual firewall rules, security groups, load balancer listeners, ingress routes, DNS records, and exposed ports.
- Keep databases, queues, internal dashboards, and administrative interfaces private unless public access is explicitly required.
- Allow inbound traffic only on required ports and from defined sources.
- Restrict outbound access where practical, especially for sensitive workloads.
- Use separate network boundaries for production, staging, and development when the risk or architecture justifies it.
- Verify that temporary troubleshooting rules have an owner and an expiry date.
Do not treat a private subnet as a complete security control. Application authorization, identity checks, patching, and monitoring are still required inside the network.
4. Encryption and data handling
Identify what data the application collects, where it is stored, where it travels, and how long it is retained. Confirm encryption in transit for external and internal connections where sensitive data is involved, and confirm encryption at rest for databases, object storage, backups, and logs when appropriate.
Review key ownership and access separately from the data itself. A service may support encryption while still allowing too many identities to decrypt the data. Also check whether sensitive values appear in application logs, analytics events, traces, test fixtures, or exported backups. Minimize collection and retention when the data is not needed for the product or operational purpose.
5. Application, dependency, and image risk
Run checks against application dependencies, container images, infrastructure code, and build tools before release. Pin or otherwise control dependency versions according to your maintenance process, review unexpected package changes, and remove unused components. Scan images for known issues and keep base images and runtimes on a defined update path.
A scan is a signal, not a complete decision. Triage findings based on exploitability, exposure, affected component, available fix, and whether the vulnerable code path is reachable. Record exceptions rather than silently ignoring recurring findings. Build artifacts should be produced by a controlled pipeline and promoted between environments where possible, instead of being rebuilt differently for production.
6. Logging, alerting, and auditability
Decide which security-relevant events must be visible: authentication failures, privilege changes, secret access, administrative actions, configuration changes, data-export events, deployment activity, and unusual service behavior. Confirm that logs include enough context to investigate without recording passwords, tokens, or unnecessary personal data.
Check that logs are delivered to a location protected from alteration by the application’s normal runtime identity. Define retention according to operational, contractual, and compliance needs rather than choosing a period by habit. Alerts should have an owner and a response path; an alert that no one can interpret or act on creates noise rather than detection.
7. Backups, recovery, and incident response
Verify that important data and configuration can be restored, not merely that a backup job reports success. Check backup scope, isolation, access controls, retention, and restore time expectations. Perform a restore test for critical systems and record what was learned.
Maintain a short incident response plan covering who can declare an incident, who owns technical containment, how credentials are revoked, how evidence is preserved, how customers or stakeholders are informed, and how recovery is approved. Include provider support and escalation details where relevant. A plan that exists only in a compromised production account may not be available when needed.
Example ownership matrix
| Control area | Primary owner | Release evidence |
|---|---|---|
| IAM and privileged access | Platform or infrastructure owner | Role review and audit record |
| Secrets and key rotation | Application owner | Secret inventory and rotation procedure |
| Network exposure | Platform owner with application input | Traffic diagram and rule review |
| Dependencies and images | Development team | Scan results and exception decisions |
| Logging and alerts | Operations owner | Event coverage and alert test |
| Backups and response | Service owner | Restore evidence and response plan |
Cadence and checkpoints
Use different review depths for different events. A lightweight review can run on every release, while a broader review should happen on a recurring schedule.
- Every release: Check changed permissions, secrets, network rules, dependencies, images, exposed endpoints, and logging for the affected components.
- Monthly: Review privileged users, service accounts, failed authentication patterns, open security findings, public storage or services, and temporary access grants.
- Quarterly: Reconcile the asset inventory, review data flows and retention, test a backup restore, exercise an incident scenario, and reassess accepted risks.
- After an architecture change: Repeat the review when adding a provider, region, cluster, managed service, external integration, AI workload, data store, or new deployment path.
- After an incident or major advisory: Recheck related controls immediately and update detection, prevention, or recovery steps based on the findings.
Infrastructure defined through Terraform or another infrastructure-as-code system can make recurring reviews easier because changes are visible and repeatable. Pair code review with a check of the deployed state: configuration can drift after manual changes, emergency access, provider defaults, or one-off fixes.
How to interpret changes
Prioritize findings by combining impact and exposure. A practical first pass is:
| Priority | Typical condition | Expected action |
|---|---|---|
| Immediate | Publicly exposed sensitive data, compromised credentials, or unrestricted privileged access | Contain, revoke or restrict access, preserve evidence, and assign incident ownership |
| High | Production weakness with a plausible path to sensitive systems or data | Remediate before release or document an explicit, time-limited exception |
| Medium | Control gap with limited exposure, compensating controls, or lower-impact data | Schedule a fix and track it through the next review |
| Low | Hardening or documentation improvement without an immediate exposure | Include it in routine maintenance and avoid allowing the backlog to grow unchecked |
Look for trends rather than isolated results. Repeated secret exposure in logs may indicate an application design problem. Recurring broad permissions may indicate that roles are too difficult to manage. Repeated emergency firewall changes may indicate that the network design does not match operational needs. The useful question is not only “Did this release pass?” but also “What keeps returning, and why?”
When to revisit
Revisit this article before every production release and schedule a broader cloud security review at least monthly or quarterly, depending on the application’s change rate and risk. Return immediately when you add a new cloud account, region, cluster, database, external integration, identity provider, AI service, or public endpoint. Also repeat the review after an incident, a significant dependency change, a change in data handled by the application, or a change in team responsibilities.
To make the next review efficient, keep a small security register with the application’s owners, environments, data stores, public entry points, privileged roles, secrets, backup locations, open findings, accepted risks, and next review date. At the end of each review, record three things: what changed, what remains exposed, and who will act next.
Before approving a release, confirm that critical findings are closed or formally accepted, evidence is linked to the relevant change, and someone has tested the recovery path. Then set the next checkpoint. Cloud security is a recurring operating practice, not a one-time launch task, and a dependable review rhythm is one of the simplest ways to keep a scalable application secure as its architecture evolves.