Oct 24, 2026 · 9 min read
Cloud Security Basics That Most Teams Still Get Wrong
Most cloud security incidents don't come from sophisticated attacks. They come from the basics being misconfigured. Here are the ones we see most often and how to fix them.
After auditing cloud infrastructure for several companies, we've noticed a pattern: the serious incidents almost never come from zero-day exploits or sophisticated attacks. They come from the basics being wrong. An S3 bucket left public. A database with no RLS. A CI pipeline with a token that hasn't been rotated in two years.
Here are the fundamentals we see teams get wrong most often, and what to do about each one.
1. Secrets in code or CI
This is the most common finding, and it shouldn't be. But it keeps showing up because the pressure to ship makes the easy path (paste the key in, fix it later) feel reasonable in the moment.
The problem: API keys, database passwords, and service account credentials stored in source code, in CI environment variables that are visible in build logs, or in container images that get pushed to a registry.
The fix:
- Use a secrets manager (AWS Secrets Manager, GCP Secret Manager, Doppler, or HashiCorp Vault). Secrets live there, not in code or CI.
- In CI, use OIDC to authenticate to cloud providers instead of long-lived keys. No token to rotate, no token to leak.
- Scan for secrets in your repository. Tools like GitGuardian, TruffleHog, or GitHub's secret scanning catch the obvious cases.
- Rotate credentials regularly. If a credential has been sitting in CI for more than 90 days, rotate it.
2. Overly permissive IAM
The second most common finding. Most cloud accounts have IAM roles or users with permissions they don't need, often granted during development and never revoked.
The problem: A service that only needs to read from one S3 bucket has a policy that grants s3:* on all resources. A developer who needed temporary access to production data still has it six months later. An EC2 instance role with administrator access because someone couldn't figure out the minimum permissions.
The fix:
- Start with the principle of least privilege. Grant only the permissions a service needs, and only on the resources it needs.
- Use IAM Access Analyzer (AWS) or IAM Recommender (GCP) to identify unused permissions and over-privileged roles.
- For service-to-service communication, use workload identity (GCP) or IAM roles for service accounts (AWS) instead of long-lived credentials.
- Audit who has production access quarterly. Remove access that's no longer needed.
3. Public storage without access controls
S3 buckets, GCS buckets, and Azure Blob containers that are publicly readable (or worse, publicly writable) are still one of the most common causes of data leaks.
The problem: A bucket that was made public for a specific reason (static website hosting, a public download) stays public after the use case changes. Or a bucket is public because someone set BlockPublicAccess to false during development and forgot to turn it back on.
The fix:
- Enable "Block all public access" on every bucket by default. Only disable it for buckets that genuinely need public access, and document why.
- Use bucket policies, not ACLs. Policies are more expressive and easier to audit.
- For public content, use CloudFront (or another CDN) in front of the bucket. The bucket itself stays private; the CDN has access.
- Scan your buckets regularly. AWS's S3 Bucket Insights and tools like ScoutSuite can flag public buckets automatically.
4. Databases without network controls
A database that's accessible from the internet is a database that's one credential leak away from a breach.
The problem: Security groups or firewall rules that allow inbound traffic from any IP (0.0.0.0/0) to a database port. This is often done during development for convenience and never tightened.
The fix:
- Databases should not be accessible from the public internet. Period. Use a VPC, private subnets, and security groups that allow access only from your application servers.
- For admin access, use a bastion host or a VPN, not a public security group rule.
- If you must expose a database externally (rare), require TLS and use IP allowlisting.
- Enable database audit logging. You should know who queried what and when.
5. No logging or monitoring
You can't respond to an incident you can't see. Many teams have no cloud audit logging enabled, or have it enabled but never look at it.
The problem: CloudTrail (AWS), Cloud Audit Logs (GCP), or Activity Log (Azure) are not enabled, or are enabled but not monitored. Security groups changes, IAM changes, and data access go unrecorded.
The fix:
- Enable audit logging in every region, for every account. This should be on by default, but verify it.
- Send logs to a centralized location (a logging account, a SIEM, or a service like Datadog or Sumo Logic).
- Set up alerts for the things that matter: IAM changes, security group changes, root account usage, failed login attempts, and large data transfers.
- Review logs regularly, not just after an incident. Anomaly detection tools can help, but a weekly manual review catches things that automated tools miss.
6. Missing or misconfigured backups
Backups that don't exist, or exist but have never been tested, are the same as no backups.
The problem: Automated backups are enabled but the retention period is too short. Or backups exist but are in the same region as the primary data, so a regional outage takes both out. Or backups have never been restored in a test, so no one knows if they actually work.
The fix:
- Enable automated backups with a retention period that matches your recovery needs (typically 7-30 days).
- Store backups in a different region than the primary data.
- Test restores regularly. A monthly restore test in a non-production environment is the minimum. If you've never restored from a backup, you don't have backups.
- Document the recovery process. In an incident, you don't want to be figuring out how to restore for the first time.
7. Unpatched infrastructure
Running outdated software is a known risk, but it keeps happening because patching is boring and feels low-priority until it isn't.
The problem: Container images with known vulnerabilities. Database engines several major versions behind. Load balancers and proxies that haven't been updated in a year. Dependencies with security patches that haven't been applied.
The fix:
- Automate patching where possible. Use managed services (RDS, Cloud SQL) that handle patching for you.
- For containers, scan images in CI and fail builds with critical vulnerabilities. Tools like Trivy or Snyk Container integrate well.
- Set a patching cadence for infrastructure you manage. Monthly is a reasonable starting point.
- Subscribe to security advisories for the software you run. If there's a critical vulnerability, you want to know before an attacker does.
The pattern
Every item on this list is a basic control. None of them require advanced security tooling or a dedicated security team. They require discipline: doing the boring work of configuration, auditing, and maintenance that prevents the incidents that make headlines.
The teams that get cloud security right are not the ones with the most sophisticated tools. They're the ones that consistently do the basics well. If you're not sure where to start, pick one item from this list per week and fix it. In two months, you'll be in a better place than most.