AWS Certified Security – Specialty
Exam code SCS-C03. This single page holds two things: a fast high-level overview to orient you, and a brief study guide to understand which topics to study covering every exam domain, the in-scope services, decision tables, and community-recommended study materials. Overview items link straight into their deep-dive sections.
65 questions 170 minutes 750/1000 to pass $300 USD Valid 3 yearsPart 1 — High-Level Overview
What & Why
The AWS Certified Security – Specialty exam "validates a candidate's ability to effectively demonstrate knowledge about securing AWS products and services," per the official exam guide. It is a scenario-heavy exam aimed at people who actually operate security in AWS accounts day to day: detection and monitoring, incident response, infrastructure hardening, identity, encryption, and account governance.
This is not a beginner's exam. It assumes you can already navigate IAM, VPC, and the core compute/storage services, and it tests how to secure and audit them rather than how to use them. Expect long scenario stems where two answers are technically defensible and the "best" one hinges on a security nuance — least privilege, encryption-in-transit vs at-rest, or a specific service's blast-radius limits.
Exam at a Glance
| Attribute | Value |
|---|---|
| Exam code | SCS-C03 |
| Questions | 65 total — 50 scored + 15 unscored (pretest, not identified) |
| Question types | Multiple choice, multiple response, ordering, and matching (per the exam guide's response-type list) |
| Time | 170 minutes |
| Passing score | 750 out of 100–1000 (scaled, compensatory) |
| Cost | 300 USD |
| Delivery | Pearson VUE test center or online proctored |
| Validity | 3 years |
The 6 Domains
SCS-C03 replaced the older SCS-C02 domain structure with six domains. Identity and Access Management is the single biggest chunk, with Infrastructure Security and Data Protection tied for second.
| Domain | What it tests | Deep dive |
|---|---|---|
| 1 · Detection 16% | Monitoring & alerting design, logging solutions, troubleshooting detection tooling. | → §3 |
| 2 · Incident Response 14% | Designing/testing IR plans and runbooks, responding to and investigating security events. | → §4 |
| 3 · Infrastructure Security 18% | Edge services, compute workload hardening, network security controls. | → §5 |
| 4 · Identity and Access Management 20% | Authentication strategies (federation, MFA, temporary creds) and authorization strategies (policies, ABAC/RBAC, least privilege). | → §6 |
| 5 · Data Protection 18% | Encryption in transit, encryption at rest, and protecting secrets/credentials/key material. | → §7 |
| 6 · Security Foundations and Governance 14% | Multi-account strategy, secure deployment patterns, and compliance evaluation. | → §8 |
| SCS-C02 domain (retired) | Maps onto SCS-C03 domain(s) in this guide |
|---|---|
| Threat Detection and Incident Response | Split across Domain 1 (Detection) and Domain 2 (Incident Response) |
| Security Logging and Monitoring | Domain 1 (Detection) — §3.1/§3.2 |
| Infrastructure Security | Domain 3 (Infrastructure Security) — largely unchanged |
| Identity and Access Management | Domain 4 (Identity and Access Management) — largely unchanged |
| Data Protection | Domain 5 (Data Protection) — largely unchanged |
| Management and Security Governance | Domain 6 (Security Foundations and Governance) — renamed, plus RCPs/declarative policies added |
This crosswalk is this guide's own reading of the two structures for study purposes; for the authoritative version, see the exam guide's own "Appendix: Comparison of SCS-C02 and SCS-C03," which this guide did not fetch in full.
Core Services Snapshot
If you master this shortlist you cover the majority of questions. Each links to its detailed treatment.
Detection & Response
GuardDuty, Security Hub, Detective, Inspector, Macie, Config, Security Lake. → detailsLogging
CloudTrail (+ Lake), CloudWatch Logs, VPC Flow Logs, Route 53 Resolver query logs. → detailsNetwork & Edge
WAF, Shield/Shield Advanced, Network Firewall, Firewall Manager, Verified Access. → detailsIdentity
IAM, IAM Identity Center, STS, Cognito, IAM Roles Anywhere, Verified Permissions. → detailsEncryption & Secrets
KMS, CloudHSM, ACM / Private CA, Secrets Manager, S3/EBS/RDS encryption. → detailsGovernance
Organizations, SCPs/RCPs, Control Tower, Audit Manager, Artifact. → detailsRecommended Materials (community consensus)
SCS-C03 is a young exam version (the current exam guide supersedes the retired SCS-C02), so most existing course/practice-exam catalogs and community write-ups still refer to SCS-C02 by name. The service content overlaps heavily; treat course titles as approximate and cross-check against the domain list above.
Study Plan (Quick Version)
Built on learning science — active recall + spaced repetition beat passive re-watching. Test yourself early and often; don't just consume.
- Weeks 1–4: Watch a full video course, doing hands-on labs. After each domain, close the notes and recall it; make flashcards for every service you can't yet compare against its neighbors (WAF vs Shield vs Network Firewall, KMS vs CloudHSM, etc.).
- Weeks 5–6: Deep-dive IAM (20%) and Infrastructure Security / Data Protection (18% each) — together over half the exam. Teach each domain out loud; sketch an incident-response runbook from memory.
- Weeks 7–8: Practice exams in review mode, interleaved across domains; study every wrong answer's explanation and turn misses into flashcards. Repeat to consistent 80%+.
- Final days: Re-read the official exam guide's in-scope/out-of-scope lists, skim the Cram Jam, sleep well — don't cram new material.
→ Detailed retention-based plan (§12) · ⚡ Cram Jam one-pager · → Exam-day tips & traps (§13)
Part 2 — Thorough Study Guide
1 · Exam Details & Logistics
The exam guide describes the target candidate as someone who can:
- Apply specialized data classifications and AWS data protection mechanisms.
- Implement data-encryption methods and AWS encryption mechanisms.
- Implement AWS mechanisms to follow secure internet protocols.
- Use AWS security services and features to ensure secure production environments.
- Make decisions that account for tradeoffs between cost, security, and deployment complexity to meet a set of application requirements.
- Understand security operations and risks.
Scoring mechanics
- 65 questions, only 50 are scored. The other 15 are unscored "pretest" items AWS is trialing — they are not marked, so treat every question as if it counts.
- Scaled score 100–1000, pass at 750. It is compensatory: you do not need to pass each domain individually, only the overall exam. A strong domain can offset a weak one. Your score report may show a per-section breakdown for self-diagnosis, but it's informational, not a per-section pass bar.
- No penalty for guessing — never leave a question blank. Unanswered = incorrect.
- Question formats per the exam guide: multiple choice (1 correct + 3 distractors), multiple response (2+ correct of 5+ options), ordering (arrange 3–5 responses correctly to get credit), and matching (pair a list of responses against 3–7 prompts, all pairs must be correct).
Target candidate & recommended experience
The official exam guide's target-candidate description asks for the equivalent of 3–5 years of experience securing cloud solutions, with working knowledge of the shared responsibility model, identity at scale, multi-account governance, software supply chain risk, incident prevention/response, vulnerability management, layer 3–7 firewall rules, incident root cause analysis, audit response, logging/monitoring strategy, encryption at-rest and in-transit, and disaster recovery controls.
Explicitly out of scope
The exam guide lists job tasks the target candidate is not expected to perform: designing cryptographic algorithms, analyzing traffic at the packet level, architecting overall cloud deployments, managing end-user compute resources, and training machine learning models. If a question seems to demand one of these, re-read it — you're likely missing a simpler, service-configuration-level answer.
Logistics
| Item | Detail |
|---|---|
| Price | 300 USD (plus local taxes / FX). A 50% discount voucher is often available after passing another AWS exam. |
| Delivery | Pearson VUE testing center, or online proctored from home (quiet private room, webcam, ID check). |
| Recertification | Valid 3 years. Recertify by re-passing the current exam version. |
| Predecessor | SCS-C02 was the prior version of this exam; the exam guide ships an appendix comparing SCS-C02 and SCS-C03 for candidates transitioning between versions. |
2 · Security Foundations Refresher
Three mental models recur across every domain below. Get them solid before the domain deep-dives — most "trick" questions are really testing one of these three things.
Shared Responsibility Model
IAM policy evaluation logic (know this cold)
- Explicit Deny always wins over any Allow, from any policy type.
- Default is implicit deny; without an explicit Allow somewhere, access is denied.
- Effective permission is the intersection of identity policies, resource policies, permissions boundaries, SCPs, and (now) RCPs. A restriction anywhere in that stack can block an otherwise-allowed action.
- Same-account access: granted if either the identity policy or the resource policy allows it. Cross-account access: both sides must allow it — the caller's identity policy, and the resource/trust policy in the target account.
- IAM Access Analyzer continuously scans resource policies (S3, KMS, IAM roles, Lambda, SQS, Secrets Manager, and more) for access granted to entities outside your account or organization — the standard answer for "find unintended external access."
Policy anatomy
Every policy statement — identity-based, resource-based, SCP, RCP, or permissions boundary — is built from the same elements. Being able to read one fast pays off across the whole exam:
Effect—AlloworDeny.Action— the API calls covered (s3:GetObject,kms:Decrypt,iam:*).Resource— the ARNs the statement applies to.Principal— required on resource-based and trust policies (who this statement applies to); absent from identity-based policies, where the principal is implicit (the identity the policy is attached to).Condition— context tests such asaws:SourceIp,aws:MultiFactorAuthPresent,aws:PrincipalOrgID,aws:PrincipalTag/*(for ABAC), andkms:ViaService/s3:x-amz-server-side-encryptionfor service-scoped restrictions.
Cross-account role trust policy, with an external ID
{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::111122223333:root" },
"Action": "sts:AssumeRole",
"Condition": { "StringEquals": { "sts:ExternalId": "a-shared-secret-value" } }
}
The external ID defends against the confused-deputy problem: without it, a third party who is granted a role ARN by one customer could reuse that same ARN to trick your account into acting on behalf of a different customer. Requiring an external ID only that third party knows closes the gap.
Symmetric vs asymmetric cryptography
| Symmetric | Asymmetric | |
|---|---|---|
| Keys | One shared secret key encrypts and decrypts | A public key encrypts/verifies, a private key decrypts/signs |
| Speed | Fast — used for bulk data | Slower — used for key exchange, signing, and small payloads |
| KMS default | AES-256-GCM, the default KMS key spec | RSA and elliptic-curve (ECC) key specs, chosen explicitly for signing or when a private key must never leave AWS but a partner needs to encrypt with a public key you distribute |
| Typical exam use | Encrypting data at rest (S3, EBS, RDS) | Digital signatures, TLS certificates, code signing, external partners who can't call KMS themselves |
Hashing is not encryption — a hash (SHA-256) is one-way and used for integrity verification (CloudTrail log file validation, S3 ETag/checksum) rather than for confidentiality. If a question asks how to verify a file hasn't been tampered with rather than how to keep it secret, the answer is a hash/checksum or a digital signature, not an encryption mode.
KMS envelope encryption
Nearly every "how is data encrypted at rest" question boils down to envelope encryption: KMS never lets a plaintext data key leave the service unprotected. A data key encrypts your actual data locally (fast, works on large objects); KMS then encrypts that data key with your KMS key and returns both the ciphertext and the encrypted data key for storage alongside it. Decryption reverses the process. This is why KMS can encrypt arbitrarily large objects even though the API itself caps direct Encrypt calls at 4 KB of plaintext — you never send the whole object to KMS, only the data key.
| KMS key type | Who manages it | Rotation |
|---|---|---|
| AWS owned key | AWS, shared across many accounts, not visible in your account | Managed entirely by AWS |
AWS managed key (e.g. aws/s3) | AWS creates and manages it for a specific service, visible in your account's KMS console | Automatic, every year |
| Customer managed key (CMK) | You create, own the key policy, control access and rotation | Optional automatic annual rotation (AWS-generated material only), or manual/no rotation |
3 · Domain 1 — Detection 16%
Three official task statements: (1.1) design and implement monitoring/alerting for an account or organization, (1.2) design and implement logging solutions, and (1.3) troubleshoot security monitoring, logging, and alerting solutions.
3.1 · Monitoring & Alerting
| Service | What it detects / does |
|---|---|
| Amazon GuardDuty | Managed, agentless threat detection from CloudTrail management & S3 data events, VPC Flow Logs, DNS query logs, and (with the runtime-monitoring feature) EKS/ECS/EC2/Lambda process-level telemetry. Findings feed EventBridge for automation. |
| AWS Security Hub | Aggregates findings from GuardDuty, Inspector, Macie, IAM Access Analyzer, and partner tools into one place; scores accounts against standards (AWS Foundational Security Best Practices, CIS AWS Foundations Benchmark, PCI DSS, NIST). Supports cross-Region and cross-account (Organizations) aggregation with a delegated administrator. |
| Amazon Detective | Builds a graph of resource behavior over time from CloudTrail, VPC Flow Logs, and GuardDuty findings to speed up root-cause analysis — the answer to "visualize/investigate why this finding happened." |
| Amazon Inspector | Automated vulnerability scanning for EC2 (via SSM agent), container images in ECR, and Lambda functions/layers; reports CVEs and network reachability. |
| Amazon Macie | ML-based discovery and classification of sensitive data (PII, credentials, financial data) in S3. |
| Amazon Security Lake | Centralizes security data from AWS services, on-premises, and partner sources into a data lake in the Open Cybersecurity Schema Framework (OCSF) normalized format, so third-party SIEMs and native AWS analytics can query one schema. |
| AWS Config rules + conformance packs | Continuously evaluates resource configuration against rules; auto-remediates via SSM Automation documents when paired with a remediation action. |
| Security Hub severity label | Typical triage response |
|---|---|
| CRITICAL | Page on-call immediately; auto-remediate if a safe automation exists (e.g. revoke a public S3 ACL), otherwise open an OpsItem and isolate the affected resource. |
| HIGH | Notify the security team same-business-day; investigate with Detective before remediating. |
| MEDIUM / LOW | Track via a Config conformance pack or backlog; batch-review weekly rather than paging. |
| INFORMATIONAL | Log only — typically expected/benign activity that Security Hub still records for audit completeness. |
3.2 · Logging Solutions
| Log source | What it captures |
|---|---|
| AWS CloudTrail | Management events (control-plane API calls, e.g. CreateUser, RunInstances) are logged by default and free for the last 90 days via Event history. Data events (S3 object-level GetObject/PutObject, Lambda Invoke, DynamoDB item-level ops) are off by default and billed per event — turn them on deliberately for the resources you need to audit. CloudTrail Insights uses ML to flag unusual API call volume or error-rate spikes (a burst of failed AssumeRole calls, for example). |
| Organization trail | Created from the management account, applies to every member account automatically, and member accounts cannot disable or modify it — the standard control for guaranteeing every account is logged. |
| Log file validation | Enables SHA-256 hashing + digital signing of log files so you can cryptographically prove a CloudTrail log wasn't tampered with after delivery. |
| KMS-encrypted trails | CloudTrail can encrypt log files with a customer-managed KMS key (SSE-KMS) instead of the default SSE-S3 — required when a security policy mandates customer-controlled keys for audit logs. |
| VPC Flow Logs | Metadata (not payload) of IP traffic at VPC, subnet, or ENI level: source/destination IP and port, protocol, packets, bytes, action (ACCEPT/REJECT), and log-status. Deliverable to CloudWatch Logs or S3. Use the custom format to add fields like tcp-flags and flow-direction when troubleshooting asymmetric routing or rejected SYN packets. |
| Route 53 Resolver query logging | Logs every DNS query made by resources in a VPC — the source for detecting DNS-based exfiltration or command-and-control lookups; pairs with Resolver DNS Firewall to also block them. |
| ALB / S3 / CloudFront access logs | Per-request logs (client IP, request path, response code, latency) delivered to S3 — used for both operational troubleshooting and forensic reconstruction of what a client actually requested. |
| CloudWatch Logs subscription filters | Stream matching log events in near real time to Lambda, Kinesis Data Streams, or Firehose for further processing — the mechanism behind centralizing/normalizing logs across accounts. |
For analysis: CloudWatch Logs Insights and Athena (querying CloudTrail/Flow Logs stored in S3) are the two AWS-native log-query answers; OpenSearch Service and Lambda come up when the scenario needs custom parsing/normalization/correlation across heterogeneous sources, and Managed Grafana when the ask is dashboarding on top of that data.
Recognize a CloudWatch Logs Insights query
fields @timestamp, sourceIPAddress, eventName, errorCode | filter eventName = "AssumeRole" and errorCode = "AccessDenied" | stats count(*) as denials by sourceIPAddress | sort denials desc
You don't need to write this from scratch on the exam, but you should recognize the shape: fields selects columns, filter narrows rows, stats ... by aggregates — the same query pattern used to answer "which source is repeatedly failing to assume this role."
| Log destination question | Answer |
|---|---|
| Need SQL-style ad hoc queries over CloudTrail/Flow Logs in S3, pay per scan | Athena |
| Need near-real-time queries over recently ingested CloudWatch Logs | CloudWatch Logs Insights |
| Need full-text search, custom dashboards, alerting on log content | OpenSearch Service |
| Need to route/transform logs to multiple destinations as they arrive | CloudWatch Logs subscription filter → Kinesis Data Firehose/Lambda |
3.3 · Troubleshooting Detection
- Missing logs almost always trace to IAM or resource policy: a Lambda execution role without
logs:CreateLogStream/logs:PutLogEvents, a CloudWatch Logs agent whose instance role lacks permissions, or an S3 bucket policy that doesn't grant the CloudTrail/ALB log-delivery service principalPutObject. - "Health checks pass but the service can't be reached" is usually a security group or NACL problem, not the health-check config itself — verify the SG attached to the target, not just the ALB listener rule.
- CloudFront, API Gateway, and Lambda each have logging that must be explicitly enabled per resource (CloudFront standard logs, API Gateway execution/access logging, Lambda's IAM permissions for CloudWatch Logs) — a common exam scenario is "logs are missing" and the fix is turning on the resource-specific logging flag, not fixing IAM.
| Symptom | Likely cause to check first |
|---|---|
| GuardDuty finding never fires despite obvious malicious traffic | GuardDuty not enabled in that Region, or the specific protection plan (e.g. runtime monitoring, S3 protection) is off |
| Security Hub missing findings from a member account | Account not part of the Organizations aggregation, or the delegated administrator relationship isn't configured |
| CloudTrail shows no S3 object-level activity | Data events aren't enabled for that trail/bucket — management events alone don't cover them |
| Config rule shows "not applicable" everywhere | The rule's resource-type scope doesn't match the resource, or the recorder isn't tracking that resource type |
| Athena query against CloudTrail/Flow Logs returns nothing | Table partition not loaded/updated for the date range being queried |
4 · Domain 2 — Incident Response 14%
Two official task statements: (2.1) design and test an incident response plan, and (2.2) respond to security events.
4.1 · IR Plans & Runbooks
- Runbooks & response plans should be written and rehearsed before an incident, not improvised during one. Systems Manager OpsCenter centralizes operational issues (including security findings routed from EventBridge) for tracking through to resolution; investigation notebooks (e.g. SageMaker AI notebooks) are sometimes used to script and document forensic analysis steps.
- Prepare before incidents happen: pre-provision least-privilege "break glass" IR roles, pre-deploy forensic tooling, minimize blast radius through account/VPC segmentation, and configure Shield Advanced proactively for internet-facing resources you expect to be targeted.
- Test the plan, don't just write it: AWS Fault Injection Service (FIS) runs controlled fault-injection experiments; AWS Resilience Hub assesses whether an application meets its recovery objectives. Both are the exam-guide's named tools for "validate the effectiveness of an incident response plan."
- Automate remediation: Systems Manager Automation documents, the Automated Forensics Orchestrator for Amazon EC2 (an AWS-provided solution that isolates a suspicious instance, captures a memory/disk image, and tags it for investigation with minimal human steps), Step Functions state machines, Amazon Application Recovery Controller (routing traffic away from an impaired resource), and plain Lambda functions triggered by EventBridge.
Typical automated-response pipeline
GuardDuty/Security Hub finding → EventBridge rule matches the finding type/severity → target is either a Lambda function (fast, simple remediation such as revoking a security group rule) or a Step Functions state machine (multi-step: isolate → snapshot → notify → open an OpsCenter OpsItem for a human to close out) → SNS/User Notifications alert the on-call security engineer. This pattern — detect, route, automate, notify — is the shape of nearly every "design an automated response" question.
4.2 · Responding to Events
- Isolate, don't terminate. Move the instance to a quarantine security group that allows no inbound/outbound traffic (or only to a forensics subnet) — terminating it destroys volatile evidence.
- Tag it for tracking and to trigger automation that excludes it from Auto Scaling / load balancer rotation.
- Snapshot the EBS volume(s) for a forensic copy before any further action; if memory capture is needed, do it before powering off.
- Revoke IAM credentials associated with the instance profile / rotate any keys the instance had access to.
- Investigate with Detective/GuardDuty findings and CloudTrail/VPC Flow Logs to determine root cause and blast radius before deciding on eradication and recovery (restore from a known-good AMI/backup, not the compromised instance).
- Deactivate the access key immediately (don't delete yet — you may need it for the investigation trail), then delete once the investigation is complete.
- Review CloudTrail for every API call made with that key to determine what the attacker did.
- Rotate any secrets/resources the compromised identity could reach; check for newly created IAM users, access keys, or roles (a common persistence technique) and remove them.
- Attach an explicit Deny (via an inline policy or a quarantine policy) to the affected IAM identity while you finish the investigation, rather than relying only on key deactivation.
- Prevent recurrence: enable IAM Access Analyzer, consider requiring roles/temporary credentials instead of long-lived keys going forward, and set up GuardDuty (it specifically flags API calls from Tor exit nodes / unusual geography using access keys).
- Add an explicit Deny to the role's permissions (or attach a highly restrictive permissions boundary) to immediately cut off further use while preserving the role for forensics.
- Revoke active sessions using the console's "revoke active sessions" action (this attaches a policy denying access for any credentials issued before that moment — critical because temporary credentials from
AssumeRolecan't otherwise be individually invalidated before they expire). - Review the trust policy for how the role was assumable and by whom, then tighten it (external ID, source IP condition, shorter session duration).
- Correlate with CloudTrail/Detective to scope the blast radius, then remediate downstream resources the role touched.
- Restrict public access immediately — enable S3 Block Public Access on the bucket (and check whether the account-level setting was overridden), and remove the offending bucket policy/ACL statement that granted public access.
- Determine what was exposed and for how long using S3 server access logs or CloudTrail S3 data events, if either was enabled before the exposure — this is why enabling data events on sensitive buckets ahead of time matters.
- Run Macie against the bucket if data classification wasn't already in place, to find out whether the exposed data included PII or other sensitive content, which changes notification/compliance obligations.
- Prevent recurrence: apply an SCP/RCP that blocks public bucket policies org-wide, and add a Config rule (
s3-bucket-public-read-prohibitedstyle) with auto-remediation so a similar misconfiguration self-heals next time.
- Forensic artifacts: capture and preserve relevant logs and snapshots before remediation destroys evidence; store copies in a dedicated forensics account/bucket with restricted access and Object Lock.
- Root cause analysis: Amazon Detective is the exam guide's named tool for this — it correlates findings, IAM activity, and network flow over a rolling window to show how an incident unfolded.
- Recovery: restore from clean backups/AMIs, apply network containment (isolate first, understand blast radius second, remediate third), and only then return the environment to normal operation.
5 · Domain 3 — Infrastructure Security 18%
Three official task statements: (3.1) network edge services, (3.2) compute workloads, and (3.3) network security controls.
5.1 · Network Edge Controls
| Service | Protects against / does |
|---|---|
| AWS WAF | Layer-7 filtering of HTTP(S): SQL injection, XSS, rate-based rules, geo-blocking, and client fingerprinting (JA3/JA4-style signals) for bot mitigation. Attaches to ALB, CloudFront, API Gateway, AppSync, and Cognito. Managed rule groups cover the OWASP Top 10. |
| AWS Shield Standard | Free, automatic protection against common network/transport-layer (L3/L4) DDoS attacks for every AWS customer. |
| AWS Shield Advanced | Paid ($3,000/month per organization, 1-year commitment) tier adding L3/4/7 DDoS protection, near-real-time attack visibility, 24/7 access to the AWS DDoS Response Team (DRT), and DDoS cost protection (refunds scaling charges incurred during an attack) for resources like EC2, ELB, CloudFront, Global Accelerator, and Route 53. |
| AWS Network Firewall | Managed, stateful, deep-packet-inspection firewall for a VPC — supports Suricata-compatible rules, domain filtering, and intrusion prevention; deployed via subnet routing rather than attached to instances. |
| S3 CORS configuration | Controls which origins a browser may fetch bucket content from — the edge control for "block cross-origin requests to my bucket." |
Third-party integration is explicitly in scope: ingest findings in the OCSF format (the same normalized schema Security Lake uses) and support third-party WAF rule sets alongside AWS managed rule groups.
| Edge design decision | Consideration |
|---|---|
| Where to terminate TLS | At CloudFront/ALB for simpler cert management via ACM, or pass through/re-encrypt to the origin when a compliance requirement demands encryption all the way to the backend. |
| Which ELB security policy to select | Newer predefined policies drop older, weaker TLS versions/ciphers (e.g. excluding TLS 1.0/1.1) — pick the policy version that matches your minimum-TLS-version requirement rather than hand-rolling a cipher list. |
| Rate-based rule vs Shield Advanced for a volumetric spike | A WAF rate-based rule throttles by request rate per source IP at the application layer; Shield Advanced defends against much larger network/transport-layer volumetric attacks that a rate-based rule alone can't absorb. |
5.2 · Compute Workload Security
- Hardened images: build golden AMIs and container images with EC2 Image Builder, baking in patches, agents, and CIS-style hardening so every launched instance starts from a known-good state.
- Authorize workloads with roles, not keys: instance profiles for EC2, execution roles for Lambda, task roles for ECS/Fargate — never embed long-lived access keys in an AMI or container image.
- Vulnerability scanning: Amazon Inspector continuously scans EC2 (via SSM), container images pushed to ECR, and Lambda function code/layers for known CVEs; it also reports network reachability findings (is a vulnerable port actually exposed to the internet?). GuardDuty's runtime monitoring watches running EC2/ECS/EKS/Lambda workloads for suspicious process and file-system behavior.
- Patch automation: Systems Manager Patch Manager applies OS/application patches on a schedule against patch baselines, and can be paired with Inspector findings to prioritize what needs patching first.
- Secure admin access: prefer Systems Manager Session Manager (no inbound ports, no bastion host, every session logged to CloudWatch/S3) or EC2 Instance Connect (short-lived SSH keys pushed just-in-time) over a standing bastion host with open port 22/3389.
- Pipeline scanning: Amazon CodeGuru Security and Amazon Q Developer scan application code and IaC for vulnerabilities as part of the CI/CD pipeline, shifting detection left of deployment.
- IMDSv2: the session-oriented, token-required version of the EC2 instance metadata service. Enforce it (and optionally cap the hop limit at 1) to close off the classic SSRF-to-credential-theft path where a vulnerable web app on the instance is tricked into fetching IAM role credentials from
169.254.169.254. - Generative-AI workload guardrails: for Bedrock/SageMaker AI-based applications, apply protections aligned to the OWASP Top 10 for LLM Applications (prompt-injection defenses, output filtering, data leakage prevention) — a newly in-scope area versus the retired exam version.
| Compute hardening checklist item | Mechanism |
|---|---|
| Golden image with pre-baked patches/agents | EC2 Image Builder |
| No long-lived credentials on the instance | Instance profile / execution role |
| Metadata service can't be abused via SSRF | IMDSv2 enforced, hop limit 1 |
| Known vulnerabilities surfaced automatically | Inspector (EC2, ECR images, Lambda) |
| Runtime anomalies on a running workload | GuardDuty runtime monitoring |
| OS/app patches applied on schedule | SSM Patch Manager + patch baselines |
| No standing SSH/RDP bastion | SSM Session Manager or EC2 Instance Connect |
| Vulnerabilities caught pre-deploy | CodeGuru Security / Amazon Q Developer in the CI/CD pipeline |
Container-specific notes: scan images at rest in ECR with Inspector (triggered on push and on new CVE publication, not just once); use ECS task roles or EKS IAM Roles for Service Accounts (IRSA) so pods/tasks get least-privilege credentials rather than sharing the underlying node's instance role; GuardDuty's EKS protection watches Kubernetes audit logs for suspicious API server activity, layered on top of (not a replacement for) network-level controls.
5.3 · Network Security Controls
| Security Group | Network ACL | |
|---|---|---|
| Level | Instance / ENI | Subnet |
| State | Stateful (return traffic auto-allowed) | Stateless (must allow return traffic explicitly) |
| Rules | Allow only | Allow and Deny |
| Evaluation | All rules evaluated | Rules processed in number order, first match wins |
- VPC endpoints keep traffic to AWS services off the public internet: Gateway endpoints (S3, DynamoDB — free, route-table based) and Interface endpoints / PrivateLink (ENI in your subnet, billed, works for most other services and for exposing your own service to other VPCs/accounts). Attach an endpoint policy to further restrict which API actions/resources are reachable through the endpoint, independent of IAM.
- Gateway Load Balancer (GWLB) inserts third-party virtual appliances (deep-packet-inspection firewalls, IDS/IPS) transparently in a traffic path using GENEVE encapsulation — the standard pattern for centralized traffic inspection across many VPCs without re-architecting routing per-appliance.
- AWS Verified Access grants VPN-less, per-request access to internal applications based on identity and device posture signals (Zero Trust), replacing "connect via VPN, then trust the network."
- Route 53 Resolver DNS Firewall blocks or allows DNS queries from VPC resources against domain lists — the standard control for stopping DNS-based command-and-control or exfiltration.
- Hybrid connectivity: Site-to-Site VPN for a quick encrypted tunnel over the internet; Direct Connect for a dedicated private link with more consistent throughput/latency; MACsec for line-rate encryption on a Direct Connect connection when in-transit encryption of that dedicated link itself is required.
- TLS termination — decide deliberately where it happens: at the ALB/NLB (offloads compute from instances, simpler cert management via ACM) vs end-to-end to the instance/container (needed when a compliance requirement demands encryption all the way to the workload, not just to the load balancer).
- Network segmentation: isolate by tier and by trust boundary — north/south (internet ↔ VPC) vs east/west (VPC ↔ VPC, subnet ↔ subnet) traffic gets different controls. Use dedicated isolated subnets for the most sensitive workloads with no route to the internet at all.
- Find unnecessary access: Network Access Analyzer identifies unintended network paths against a set of access requirements you define; Inspector's network-reachability findings flag instances reachable from the internet that shouldn't be; Verified Access logs show exactly which access decisions were made and why.
| Connectivity need | Choose |
|---|---|
| Quick encrypted tunnel over the public internet | Site-to-Site VPN |
| Dedicated, consistent-latency private circuit to AWS | Direct Connect |
| Encrypt traffic on that dedicated circuit itself | Direct Connect + MACsec |
| Individual users need remote access into a VPC | AWS Client VPN |
| Per-request Zero Trust access, no client software | AWS Verified Access |
6 · Domain 4 — Identity and Access Management 20%
The single largest domain. Two official task statements: (4.1) authentication strategies, and (4.2) authorization strategies.
6.1 · Authentication
| Mechanism | Use for |
|---|---|
| AWS IAM Identity Center | Central workforce SSO across many AWS accounts and supported SaaS apps; integrates with an external IdP (Okta, Entra ID) or AWS Managed Microsoft AD via SAML/SCIM. Grants access via permission sets mapped to accounts. |
| SAML 2.0 federation | Enterprise IdP → temporary AWS credentials via AssumeRoleWithSAML, without creating IAM users per employee. |
| OIDC federation | Web-identity federation using an OpenID Connect-compatible IdP (Google, GitHub Actions OIDC providers, custom OIDC IdPs) via AssumeRoleWithWebIdentity — the standard pattern for CI/CD pipelines assuming a role without a stored access key. |
| Amazon Cognito User Pools | Customer-facing sign-up/sign-in identity for apps; issues JWTs after authentication, supports MFA and social/SAML/OIDC IdPs. |
| Amazon Cognito Identity Pools | Exchanges a User Pool token (or another supported identity) for temporary AWS credentials scoped by an IAM role — the bridge from "user is signed in" to "user can call AWS APIs directly," e.g. from a mobile app. |
| AWS IAM Roles Anywhere | Issues temporary IAM credentials to workloads running outside AWS (on-prem servers, other clouds) using X.509 certificates issued by a trusted CA — removes the need for long-lived access keys on non-AWS infrastructure. |
| AWS STS | Issues all temporary security credentials (AssumeRole, AssumeRoleWithSAML, AssumeRoleWithWebIdentity, GetSessionToken). Underlies every federation mechanism above. |
| S3 presigned URLs | Time-limited URLs granting temporary, credential-free access to a specific S3 object — used to let an unauthenticated client upload/download one object without an IAM identity of its own. |
Troubleshooting authentication failures usually means reading CloudTrail for the denied AssumeRole/Login event, checking Cognito user pool app-client settings, verifying IAM Identity Center permission set assignment, or checking AWS Directory Service trust/connectivity for AD-backed federation.
MFA options span a strength spectrum: SMS/security questions (weakest, largely deprecated), virtual MFA/TOTP apps, and FIDO2/WebAuthn security keys (phishing-resistant, the strongest option and the one to pick when a scenario says "resistant to phishing" or "hardware-backed"). Root user MFA is a baseline best practice regardless of which mechanism.
6.2 · Authorization
- Amazon Verified Permissions is a managed, fine-grained authorization service (built on the Cedar policy language) for building permission checks directly into your own applications — distinct from IAM, which authorizes calls to AWS APIs.
- IAM paths namespace users/roles for organization at scale and can be used in policy conditions to scope permissions to a subset of identities sharing a path prefix.
- IAM role trust policies control who may assume a role; resource policies (on S3, KMS, SQS, Secrets Manager, Lambda, etc.) control which principals may act on that resource directly, including cross-account. Use an external ID in a trust policy whenever a third party assumes a role into your account, to defend against the confused-deputy problem.
- ABAC (attribute-based access control): grant/deny based on tags on both the principal and the resource (e.g.
aws:PrincipalTag/projectmust equalaws:ResourceTag/project) — scales far better than writing a new policy per resource, and is the exam's usual answer for "many teams, many resources, minimal policy maintenance." A typical ABAC condition block:"Condition": {"StringEquals": {"aws:ResourceTag/project": "${aws:PrincipalTag/project}"}}— one policy attached to every role, no per-resource edits as new projects/resources appear. - RBAC (role-based access control): grant based on a role/job function assignment — simpler to reason about for smaller, more static environments.
- Least privilege in practice: permissions boundaries cap the maximum permissions an IAM entity can ever have (even if its identity policy grants more) — the standard control for "let a team create their own roles, but never let those roles exceed X." Session policies further restrict a specific
AssumeRolesession below what the role itself allows, without touching the role's permanent policy. Concretely: a developer withiam:CreateRole/iam:AttachRolePolicycan be required (via aConditionon those actions) to always attach a specific permissions-boundary ARN to any role they create — so even a role they define with an overly broad identity policy is capped by the boundary at evaluation time. - IAM Access Analyzer does double duty here: its external access findings catch unintended cross-account/public exposure, and its unused access findings (unused permissions, unused roles, unused access keys) drive right-sizing overly broad policies toward least privilege. IAM Policy Simulator tests what a policy actually allows before you attach it.
- Investigate and correct over-grants: when Access Analyzer or a manual review turns up unintended permissions, remediate at the source policy (identity, resource, boundary, or SCP/RCP) rather than layering a Deny on top as a permanent fix.
| STS API call | Used for |
|---|---|
AssumeRole | Cross-account access or switching to a role within the same account, given an IAM identity that's already authenticated |
AssumeRoleWithSAML | Enterprise IdP federation (SAML assertion → temporary credentials) |
AssumeRoleWithWebIdentity | OIDC federation — CI/CD pipelines, mobile/web apps using a public identity provider |
GetSessionToken | Temporary credentials for the currently-signed-in IAM user, mainly to support MFA-protected API calls |
GetFederationToken | Temporary credentials for a federated (non-IAM) user with a policy applied directly to the session — increasingly superseded by Identity Center/Cognito patterns |
6.3 · Policy Patterns You Must Be Able to Read
Specialty questions rarely ask "what does IAM do." They show you a policy and ask why a call is being denied, or which single condition key closes a gap. These are the patterns worth recognising on sight.
Confused deputy: aws:SourceArn and aws:SourceAccount
When an AWS service principal acts on your behalf, anyone else who can persuade that service to call your resource inherits your trust unless you pin the caller. This is the most reliably tested resource-policy pattern on the exam.
{
"Effect": "Allow",
"Principal": { "Service": "cloudtrail.amazonaws.com" },
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::my-log-bucket/AWSLogs/111122223333/*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"s3:x-amz-acl": "bucket-owner-full-control"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:cloudtrail:us-east-1:111122223333:trail/org-trail"
}
}
}
"Service": "cloudtrail.amazonaws.com" with no aws:SourceArn or aws:SourceAccount can be driven by any other account's trail. When one answer option adds one of those keys, that is almost always the correct one.Trust the whole organization without listing accounts
aws:PrincipalOrgID keeps working as accounts are added and removed. A hand-maintained list of account ARNs does not, and "without ongoing maintenance" in the stem is the giveaway.
{
"Effect": "Allow",
"Principal": "*",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::shared-config-bucket/*",
"Condition": {
"StringEquals": { "aws:PrincipalOrgID": "o-a1b2c3d4e5" }
}
}
Force encryption and TLS on the way in
Two separate controls that get conflated. aws:SecureTransport governs the transport; s3:x-amz-server-side-encryption governs what happens to the object at rest. A requirement for both needs both statements.
[
{
"Sid": "DenyUnencryptedUploads",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::secure-bucket/*",
"Condition": {
"StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" }
}
},
{
"Sid": "DenyPlaintextTransport",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::secure-bucket",
"arn:aws:s3:::secure-bucket/*"
],
"Condition": { "Bool": { "aws:SecureTransport": "false" } }
}
]
Allow that merely omits the unencrypted case does nothing useful: the default is already implicit deny, and some other policy may still allow it. Only an explicit Deny is unconditional.Constrain a KMS key: kms:ViaService and kms:EncryptionContext
kms:ViaService means the key can only be used when the request arrives through a named service, so a stolen credential cannot call Decrypt directly. kms:EncryptionContext binds ciphertext to additional authenticated data, so a blob encrypted for one tenant cannot be decrypted in another tenant's context.
{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::111122223333:role/app-role" },
"Action": ["kms:Decrypt", "kms:GenerateDataKey"],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": "s3.us-east-1.amazonaws.com",
"kms:EncryptionContext:tenant": "${aws:PrincipalTag/tenant}"
}
}
}
kms:Decrypt but the call still fails" is a key-policy question every time.ABAC: one policy that scales instead of one policy per team
Tag the principal, tag the resource, require them to match. A new team then needs a tag, not a new policy.
{
"Effect": "Allow",
"Action": ["ec2:StartInstances", "ec2:StopInstances"],
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/project": "${aws:PrincipalTag/project}"
}
}
}
Require MFA for the actions that matter
{
"Effect": "Deny",
"Action": ["iam:DeleteRole", "kms:ScheduleKeyDeletion", "s3:DeleteBucket"],
"Resource": "*",
"Condition": {
"BoolIfExists": { "aws:MultiFactorAuthPresent": "false" }
}
}
aws:MultiFactorAuthPresent at all. Plain Bool silently skips the statement when the key is absent; BoolIfExists treats absence as "no MFA" and denies.Condition keys that decide answers
| Condition key | What it pins | Classic question stem |
|---|---|---|
aws:PrincipalOrgID | Caller is inside my organization | "without maintaining a list of account IDs" |
aws:SourceArn / aws:SourceAccount | Which resource or account drove the service call | "prevent another customer's trail from writing here" |
aws:SecureTransport | TLS was used | "reject plaintext requests" |
aws:PrincipalTag / aws:ResourceTag | ABAC tag match | "scales as teams are added" |
kms:ViaService | Key reachable only through a named service | "the key must not be usable directly" |
kms:EncryptionContext:* | Ciphertext bound to authenticated context | "one tenant must not decrypt another's data" |
s3:x-amz-server-side-encryption | Object was encrypted on PUT | "reject unencrypted uploads" |
aws:SourceIp / aws:SourceVpce | Network origin of the request | "only from the corporate network, only via the endpoint" |
sts:ExternalId | The third party is the intended one | "a vendor needs access to my account" |
aws:MultiFactorAuthPresent | MFA on the session | "require MFA to delete" |
7 · Domain 5 — Data Protection 18%
Three official task statements: (5.1) data in transit, (5.2) data at rest, and (5.3) confidential data, credentials, secrets, and cryptographic key material.
7.1 · Data in Transit
- Require encryption on connect: ELB security policies pin minimum TLS versions/cipher suites; enforce TLS via bucket policies (
aws:SecureTransportcondition) and application-level redirects. - Private, non-internet paths: PrivateLink/VPC endpoints for AWS-service and cross-account private connectivity, Client VPN for user remote access into a VPC, Verified Access for per-request Zero Trust access without a VPN client at all.
- Inter-node/inter-resource encryption: EMR and EKS support encrypting traffic between cluster nodes; SageMaker AI supports inter-container encryption for distributed training jobs; the Nitro System encrypts traffic between Nitro-based instances and their attached storage by default at the hypervisor level.
7.2 · Data at Rest
| S3 encryption mode | Key management |
|---|---|
| SSE-S3 | AWS-owned keys, no configuration, the default for new buckets. |
| SSE-KMS | Customer-managed or AWS-managed KMS key; every request is auditable in CloudTrail. S3 Bucket Keys reduce KMS request volume/cost by reusing a time-limited bucket-level key to encrypt many object keys instead of calling KMS per object. |
| SSE-C | You supply and manage the encryption key yourself in each request; AWS never stores it. |
| DSSE-KMS | Dual-layer server-side encryption with KMS — applies two independent layers of AES-256 encryption, for workloads under compliance mandates that require defense-in-depth at the encryption layer itself. |
- EBS: enable account-level default encryption per Region so every new volume/snapshot is encrypted automatically. Re-encrypting an existing unencrypted volume means snapshot → copy the snapshot with a KMS key specified → create a new volume from the encrypted copy.
- RDS / DynamoDB / EFS: RDS/Aurora encryption is set at creation and can't be toggled on an existing unencrypted instance (same snapshot-copy-restore pattern as EBS); DynamoDB encrypts at rest by default (AWS-owned key, or switch to a KMS customer-managed key for auditability); EFS supports both encryption at rest (KMS) and in transit (TLS on mount).
- Data integrity controls: S3 Object Lock (WORM — governance or compliance retention modes) and S3 Glacier Vault Lock for immutable archive policies; versioning to recover from accidental overwrite/delete; digital code signing and CloudTrail log file validation for tamper-evidence elsewhere.
- Lifecycle & retention: S3 Lifecycle policies (transition/expire), EFS Lifecycle policies (move to EFS-IA), FSx for Lustre backup policies — automate moving/retiring data instead of manual cleanup, which also reduces the amount of sensitive data sitting in hot storage longer than necessary.
- Replication & backup: AWS Backup centralizes backup policy across services; Data Lifecycle Manager automates EBS snapshot schedules; DataSync moves/synchronizes data at scale; consider ransomware protection patterns like immutable, access-restricted backup vaults and cross-account backup copies.
7.3 · Secrets & Key Material
| Need | Choose |
|---|---|
| Secret with built-in automatic rotation (RDS/Redshift/DocumentDB native support) | Secrets Manager |
| Config value or secret without needing rotation, cost-sensitive | SSM Parameter Store (SecureString, via KMS) |
| Fully managed, dedicated single-tenant HSM (regulatory mandate, FIPS 140-2 Level 3) | CloudHSM |
| Public or private TLS certificate with auto-renewal | ACM (public) or AWS Private Certificate Authority (private/internal PKI) |
- Secrets Manager minimum rotation window: every 1 day at the shortest (you set the rotation schedule; the practical floor most guidance cites is daily rotation).
- KMS scheduled key deletion: 7–30 day waiting period (you choose the window) before a key is permanently and irrecoverably destroyed — the safety net against fat-fingering key deletion.
- GuardDuty free trial: 30 days per account/Region before billing starts.
- Shield Advanced: $3,000/month per organization (1-year commitment) plus usage-based data transfer fees.
- Imported key material: bring your own key material into a KMS key (instead of AWS generating it) when a compliance requirement mandates control over key generation. You are responsible for re-importing material before it expires (if you set an expiration) and for rotating it yourself — KMS's automatic annual rotation does not apply to imported key material.
- External key store (XKS): KMS keys backed by key material that never leaves an external key manager you control outside AWS, for the strictest "AWS must never possess my key material" requirements.
- AWS-generated vs imported key material: AWS-generated CMKs support automatic annual rotation and require no key-material lifecycle management from you; imported material gives you full control (and full responsibility) over the key's origin, expiration, and rotation.
- Data masking: CloudWatch Logs data protection policies automatically detect and mask sensitive data patterns (like credit card numbers) in log events at the time they're ingested; SNS message data protection does the equivalent for messages in transit through a topic.
- Multi-Region key management: KMS multi-Region keys let you encrypt in one Region and decrypt in another without re-encrypting data, useful for cross-Region DR and replication scenarios; ACM Private CA can similarly issue certificates usable across a multi-Region deployment.
Data classification underpins every choice above: define tiers (e.g. public, internal, confidential, restricted) and map each to a minimum control set — restricted data might mandate SSE-KMS with a customer-managed key, Object Lock, and Macie scanning, while public data needs none of that. Amazon Macie's classification job findings can be tagged back onto S3 objects to drive this automatically at scale.
8 · Domain 6 — Security Foundations and Governance 14%
Three official task statements: (6.1) centrally deploy and manage AWS accounts, (6.2) secure and consistent deployment strategy for cloud resources, and (6.3) evaluate the compliance of AWS resources.
8.1 · Multi-Account Strategy
| Service | Purpose |
|---|---|
| AWS Organizations | Central management of many accounts; consolidated billing; organize accounts into OUs for policy targeting. |
| AWS Control Tower | Automated setup of a governed multi-account landing zone with baseline guardrails, a Log Archive account, and an Audit account; supports deploying additional optional and fully custom controls on top of the baseline. |
| Service Control Policies (SCPs) | Org-wide guardrails that set the maximum available permissions in member accounts — they never grant access, only cap it. |
| Resource Control Policies (RCPs) | A newer org-wide guardrail type that restricts what principals — including those outside your organization — can do with a resource, regardless of that resource's own resource policy. Where SCPs constrain your principals, RCPs constrain access to your resources. |
| Declarative policies | Organization-wide policies that enforce a desired configuration state for certain account/network settings directly, without relying on a separately-evaluated guardrail — e.g. enforcing that a setting stays in a specific state across every account. |
| AI service opt-out policies | Org-wide policy controlling whether accounts can allow AI services to use their content for service improvement. |
- Centrally manage security services via a delegated administrator account (for GuardDuty, Security Hub, Macie, Firewall Manager, and others) so a dedicated security account — not the management account — operates day-to-day security tooling org-wide.
- Root user credential management: centralize/restrict root access for member accounts, enforce MFA on root, and design a documented break-glass procedure for the rare cases root access is genuinely required.
| Account setup decision | Pick |
|---|---|
| Fastest path to a governed multi-account baseline | Control Tower |
| Custom guardrail Control Tower doesn't ship out of the box | Control Tower custom control (backed by an SCP/Config rule) |
| Just need consolidated billing and OUs, no guardrail automation | Organizations alone |
| One security team operates tooling across every account | Delegated administrator |
8.2 · Secure Deployment
- Infrastructure as Code: CloudFormation StackSets deploy a template consistently across many accounts/Regions; CloudFormation Guard and cfn-lint (and equivalents for other IaC tools) validate templates against policy-as-code rules before deployment, catching misconfigurations pre-deploy rather than post-deploy.
- Tagging strategy: consistent tags (department, cost center, environment, data classification) enable both cost allocation and security automation — ABAC policies, Config rule scoping, and Firewall Manager policy targeting all key off tags.
- Example tag schema:
environment(prod/staging/dev),data-classification(public/internal/confidential/restricted),owner(team or cost center),compliance-scope(pci/hipaa/none). ABAC policies and Config rules then reference these keys directly instead of hardcoding resource ARNs, so newly created resources inherit the right controls automatically as long as they're tagged correctly at creation. - AWS Firewall Manager centrally deploys and enforces WAF rule groups, Shield Advanced protections, security group policies, and Network Firewall policies across every account/resource in an organization from one place — the standard answer for "apply this security policy everywhere, including to accounts created in the future." Its policy types map directly onto Domain 3's controls: a WAF policy attaches a common rule group to every in-scope ALB/CloudFront/API Gateway, a security group policy audits or auto-remediates SG rules that violate a defined baseline, and a DNS Firewall policy rolls out a common Route 53 Resolver DNS Firewall rule group fleet-wide.
- Securely sharing resources across accounts: AWS RAM shares infrastructure (subnets, Transit Gateway attachments, License Manager configurations) without duplicating them; AWS Service Catalog lets you publish pre-approved, governed product templates that other teams/accounts can self-service deploy without needing broad IAM permissions of their own.
8.3 · Compliance Evaluation
- AWS Config rules (and conformance packs, which bundle many rules and remediations as a single deployable unit) detect non-compliant resources and can auto-remediate or notify; Security Hub layers standards-based scoring (CIS, PCI DSS, NIST, AWS Foundational Security Best Practices) on top of that same resource/finding data.
- AWS Audit Manager continuously collects evidence mapped to a compliance framework (PCI DSS, HIPAA, SOC 2, and custom frameworks) to make audit prep an ongoing background process instead of a fire drill.
- AWS Artifact is the self-serve library for AWS's own compliance reports (SOC, PCI, ISO) and for reviewing/accepting AWS agreements (BAA, NDA) — the answer whenever a question asks "where do I get AWS's own audit reports."
- AWS Well-Architected Tool evaluates a workload's architecture against best practices (including the Security pillar) and produces a prioritized improvement plan.
Example conformance pack contents: a single conformance pack deployed to every account might bundle Config rules for "S3 buckets must not be public," "EBS volumes must be encrypted," "IAM users must have MFA enabled," and "CloudTrail must be enabled," each wired to an SSM Automation remediation — one deployable unit instead of managing dozens of individual rules per account.
9 · In-Scope Service Reference (by category)
Taken directly from the official exam guide's appendix. It is explicitly non-exhaustive: "security affects all AWS services," so a service can be relevant for its security configuration even if the service itself isn't on this list. ★ marks the heavy hitters that dominate scenario questions.
Analytics
Amazon Athena ★ (query logs in S3), Amazon OpenSearch Service (log search/analytics, SIEM-style dashboards).Application Integration
Amazon SNS ★ (fan-out, data protection policies), AWS Step Functions (IR automation orchestration).Compute
Amazon API Gateway (auth/throttling front door), Amazon EC2 ★ (+ Image Builder, Instance Connect), Amazon EKS, Amazon EMR, AWS Lambda ★, Amazon Data Lifecycle Manager (EBS snapshot automation).Developer Tools
AWS Fault Injection Service (test IR/resilience plans).Internet of Things
AWS IoT Core (device policies).Machine Learning
Amazon Bedrock (GenAI guardrails), Amazon CodeGuru Security, Amazon Q Business, Amazon Q Developer (pipeline scanning), Amazon SageMaker AI.Management and Governance
AWS CloudFormation (+ Guard), AWS CloudTrail ★ (+ Lake), Amazon CloudWatch ★, AWS Config ★, AWS Control Tower ★, Amazon Managed Grafana, AWS Organizations ★, AWS Resilience Hub, AWS RAM, AWS Service Catalog, AWS Systems Manager ★, AWS Trusted Advisor, AWS User Notifications, AWS Well-Architected Tool.Networking & Content Delivery
Amazon Application Recovery Controller, Amazon VPC ★ (Network Access Analyzer, NACLs, security groups, VPC endpoints, Site-to-Site VPN, Flow Logs, Verified Access), AWS Client VPN, Amazon CloudFront, Amazon Verified Permissions, Amazon Route 53 ★ (Resolver DNS Firewall), AWS Direct Connect, Elastic Load Balancing ★, AWS Transit Gateway.Security, Identity & Compliance
AWS Artifact, AWS Audit Manager, ACM ★, AWS CloudHSM, Amazon Cognito ★, Amazon Detective, AWS Directory Service, AWS Firewall Manager, Automated Forensics Orchestrator for Amazon EC2, Amazon GuardDuty ★, IAM ★, AWS IAM Identity Center ★, Amazon Inspector ★, AWS KMS ★, Amazon Macie ★, AWS Network Firewall, AWS Private Certificate Authority, AWS Secrets Manager ★, AWS Security Hub ★, Amazon Security Lake, AWS Shield / Shield Advanced ★, AWS STS ★, AWS WAF ★.Storage & Data Management
Amazon S3 ★, AWS Backup, AWS DataSync, Amazon EFS (+ lifecycle policies), Amazon FSx for Lustre.A handful of services show up under more than one hat in the exam guide's own text — worth calling out since it's easy to file them under only one category mentally:
- Amazon EC2 is both a Compute entry (Image Builder, Instance Connect) and the subject of half of Domain 3's compute-hardening task statement.
- Amazon VPC's sub-features (Flow Logs, endpoints, Verified Access, Network Access Analyzer) are individually named in the appendix precisely because each is tested as its own concept, not just as "part of VPC."
- AWS Systems Manager spans Patch Manager (Domain 3), Session Manager (Domain 3 admin access), OpsCenter and Automation (Domain 2 incident response), and State Manager (Domain 1 assessments).
10 · Decision Guides & "Which Service?" Tables
The exam constantly asks you to choose between similar-sounding services. Memorize these discriminators.
Threat detection & auditing by job
| Job | Service |
|---|---|
| Continuous threat detection from logs/network flow, no agents | GuardDuty |
| Aggregate findings across services, score vs. standards | Security Hub |
| Investigate root cause / visualize a security graph | Detective |
| Scan EC2/ECR images/Lambda for CVEs | Inspector |
| Find PII/sensitive data in S3 | Macie |
| Continuous config-compliance rules + remediation | Config |
| Who called this API / control-plane audit trail | CloudTrail |
| Central normalized security data lake for SIEM/analytics | Security Lake |
Key & secret management
| Need | Choose |
|---|---|
| Managed encryption keys, most services, envelope encryption | KMS |
| Dedicated single-tenant HSM, FIPS 140-2 Level 3 | CloudHSM |
| Key material must never leave an external manager | KMS external key store |
| Secrets with native automatic rotation (RDS etc.) | Secrets Manager |
| Config/secret value, no rotation needed, cheaper | SSM Parameter Store |
| Public TLS certs, auto-renew | ACM |
| Private/internal PKI issuing certificates | AWS Private Certificate Authority |
Network & edge protection
| Need | Choose |
|---|---|
| Block SQLi/XSS, rate-limit HTTP requests | WAF |
| DDoS protection (volumetric/protocol) | Shield (Advanced for 24/7 DRT + cost protection) |
| Stateful, VPC-wide network/domain filtering | Network Firewall |
| Insert third-party inspection appliance transparently | Gateway Load Balancer |
| Private connectivity to an AWS service | VPC endpoint (Gateway for S3/DynamoDB, Interface/PrivateLink otherwise) |
| Zero-trust access to an internal app, no VPN client | Verified Access |
| Block malicious DNS lookups from a VPC | Route 53 Resolver DNS Firewall |
| Central policy enforcement (WAF/Shield/SG) org-wide | Firewall Manager |
Identity & federation
| Scenario | Choose |
|---|---|
| Workforce SSO across many AWS accounts | IAM Identity Center |
| Customer sign-up/sign-in for an app | Cognito User Pools |
| Exchange a signed-in identity for temporary AWS credentials | Cognito Identity Pools |
| CI/CD pipeline assumes a role without stored keys | OIDC federation via AssumeRoleWithWebIdentity |
| Workload running outside AWS needs temporary AWS credentials | IAM Roles Anywhere |
| Third party needs to assume a role into your account | Cross-account role + external ID |
| Fine-grained authorization inside your own application | Amazon Verified Permissions |
Governance & guardrails
| Need | Choose |
|---|---|
| Cap max permissions for your own principals org-wide | SCP |
| Restrict access to your resources, even from outside your org | RCP |
| Enforce a specific configuration state directly | Declarative policy |
| Stand up a governed multi-account landing zone fast | Control Tower |
| Share infrastructure across accounts without duplicating it | AWS RAM |
| Publish self-service, pre-approved deployable products | AWS Service Catalog |
| Collect continuous audit evidence against a framework | Audit Manager |
| Get AWS's own compliance reports (SOC/PCI/ISO) | AWS Artifact |
Data-at-rest encryption, by requirement
| Requirement | Choose |
|---|---|
| Simplest, zero-config, no auditability needed | SSE-S3 |
| Need to see every decrypt/encrypt call in CloudTrail | SSE-KMS |
| Reduce KMS API cost/throttling at high request volume | SSE-KMS with S3 Bucket Keys |
| Full control of the encryption key, AWS never stores it | SSE-C |
| Compliance mandates two independent encryption layers | DSSE-KMS |
| Compliance mandates key material never touch AWS | KMS external key store |
Encryption in transit, by scenario
| Scenario | Choose |
|---|---|
| Public-facing web app, standard TLS termination | ACM cert on ALB/CloudFront |
| Compliance requires TLS all the way to the instance | End-to-end TLS, cert installed on the instance/container (Private CA-issued if internal) |
| Private access between VPCs/accounts, no internet | PrivateLink / VPC endpoints |
| Remote users need encrypted access into a VPC | Client VPN |
| Zero-trust per-request access without a VPN client | Verified Access |
| Encrypt traffic on a dedicated Direct Connect circuit | MACsec |
Incident-response automation, by question
| Question being asked | Service |
|---|---|
| "Test whether our IR plan actually works" | AWS Fault Injection Service |
| "Does this workload meet its recovery objectives?" | AWS Resilience Hub |
| "Automatically isolate and image a suspicious EC2 instance" | Automated Forensics Orchestrator for Amazon EC2 |
| "Track a security incident through to resolution" | Systems Manager OpsCenter |
| "Reroute traffic away from an impaired resource during an incident" | Amazon Application Recovery Controller |
| "Why did this happen — show me the timeline" | Amazon Detective |
Common reference architectures
Centralized security account
A dedicated account (often Control Tower's Audit account) is the delegated administrator for GuardDuty, Security Hub, Macie, and Firewall Manager, and receives copies of every member account's CloudTrail, Config, and VPC Flow Logs into a separate Log Archive account with Object Lock enabled.Zero-trust internal app access
Employees reach an internal app through Verified Access, which evaluates identity (via IAM Identity Center) and device posture per request — no VPN client, no standing network-level trust, and every access decision is logged.Inspected multi-VPC egress
All outbound traffic from spoke VPCs routes through a central inspection VPC via Transit Gateway, where a Gateway Load Balancer fronts a fleet of third-party firewall appliances before traffic reaches a NAT Gateway and the internet.Least-privilege CI/CD deploys
A pipeline authenticates via OIDC to assume a deploy role scoped by a permissions boundary; the role's trust policy restrictsAssumeRoleWithWebIdentity to a specific repository and branch, closing off use by any other workflow.11 · Recommended Study Materials (community consensus)
SCS-C03 launched too recently for its own deep catalog of exam-specific write-ups; the sources below are what could be directly verified. Course/practice-exam vendors are still selling and describing this material largely under the "SCS-C02" name, and community discussion follows the same pattern. Treat the underlying content as current — the domain names and weights changed, not most of the service knowledge. Source links are in the table at the end of this section.
1 · Video courses
| Course | Profile | Notes |
|---|---|---|
| #1Adrian Cantrill learn.cantrill.io | Theory-before-service teaching with hands-on labs, covering the same six broad areas (threat detection/incident response, logging/monitoring, infrastructure security, IAM, data protection, management/governance) that the retired SCS-C02 used as its domain names. | Deepest coverage of the underlying services; expect the course's domain labels to still say SCS-C02 rather than the newer six-domain SCS-C03 structure. |
| #1Stephané Maarek Udemy | The "fast, efficient pass" pick, exam-focused and concise, cheap on a Udemy sale. | Same caveat: sold and structured as an SCS-C02 course as of this writing. |
2 · Practice exams
- Tutorials Dojo publishes a dedicated SCS-C03 exam-guide study path page with bookmarked resources organized by the current domain structure — a useful way to sanity-check that a given topic is actually still in scope.
- Practice-exam review mode (detailed per-answer explanations for both the right and the wrong options) is the feature community write-ups credit most for retention, consistent with the same pattern seen on other AWS Specialty/Associate exams.
- Maarek's own practice tests (Udemy, bundled with or sold alongside the video course) are a second legitimate source, though comparison write-ups still rate Tutorials Dojo's explanations as more thorough.
- Never use "guaranteed" question dumps. Real exam questions sold online are brain dumps — high risk of failing and of a certification ban. Original practice questions (TD, Maarek) are fine; dumps are not.
3 · Official AWS resources
- AWS Security Learning Plan (AWS Training and Certification's Security learning path on Skill Builder) — a curated, self-paced set of digital courses on securing AWS workloads, identity, and compliance.
- AWS Security Ramp-Up Guide — a downloadable aggregation of digital courses, blogs, and whitepapers for building security expertise at your own pace, independent of any single certification's exam guide.
- The official exam guide itself (linked in the footer of this page) — read it once end-to-end; it is the only document that is guaranteed to reflect the current SCS-C03 scope.
4 · Hands-on
Community write-ups on the (SCS-C02-era) Security Specialty repeatedly stress hands-on practice over passive video-watching: build a small multi-account Organizations setup with SCPs, enable GuardDuty/Security Hub and trigger a sample finding, rotate a Secrets Manager secret, and walk through the compromised-IAM-role runbook in §4.2 yourself in a sandbox account with a billing budget set first.
Concrete lab ideas that map directly onto the highest-weight domains:
- IAM (20%): set up an OIDC provider trust to a GitHub Actions repo and assume a role from a workflow run; write an ABAC policy keyed on a
projecttag; attach a permissions boundary to a role you create and confirm it caps what that role can do even with a broader identity policy attached. - Infrastructure Security (18%): enforce IMDSv2 on an instance and confirm IMDSv1 calls are rejected; stand up a VPC endpoint for S3 and attach a restrictive endpoint policy; enable GuardDuty and review a sample finding it generates.
- Data Protection (18%): create a customer-managed KMS key, encrypt an S3 object with it, then try decrypting from a second account to see the cross-account KMS key-policy requirement fail until you fix the key policy.
5 · Notes & review aids
- Condensed personal notes — after each domain, write a one-page summary in your own words; the act of condensing is itself a recall exercise. Fold your notes into the Cram Jam format used on this site.
- Tutorials Dojo cheat sheets — repeatedly cited across AWS certifications as a strong pre-exam review aid; check whether an SCS-C03-labeled version exists yet, and fall back to the SCS-C02 cheat sheets (cross-checked against §9's in-scope list) if not.
- Books — generally discouraged for a fast-moving service catalog; anything published before SCS-C03 launched (December 2025, per secondary reporting — see the note in §1) will be using the old domain names.
Sources
| Source | What it provided |
|---|---|
| AWS Certification: SCS-C03 exam guide | Domain titles/weights, task statements, target-candidate description, in-scope/out-of-scope service appendices. |
| AWS Certified Security – Specialty product page | Question count, time limit, price, delivery method, validity period, recommended-experience wording. |
| Tutorials Dojo SCS-C03 study path | Confirms an SCS-C03-specific study path exists and is organized around the current exam guide. |
| Adrian Cantrill — AWS Certified Security Specialty course page | Course scope/structure, confirms current course material is organized around the six SCS-C02-style domain names. |
| CISObility — AWS Security training comparison | Maarek vs A Cloud Guru vs Tutorials Dojo cost/positioning comparison. |
| "How I passed the AWS Certified Security Specialty (SCS-C02) exam" — DEV Community | A real candidate's resource mix, study hours, and topics that appeared on their exam. |
| AWS Training and Certification — Security learning | Confirms the Security Learning Plan and Security Ramp-Up Guide as official, certification-agnostic study resources. |
12 · Full Study Plan (≈8 weeks part-time)
This plan is built on evidence-based learning science, not just "watch videos and cram." Passive re-watching feels productive but produces weak, short-lived memory. The methods below are what actually move knowledge into long-term memory.
The learning principles this plan uses
| Principle | Why it works | How to apply it to SCS-C03 |
|---|---|---|
| Active recall | Retrieving an answer from memory strengthens it far more than re-reading. | After each domain, close the notes and write everything you remember about that domain's decision tables from a blank page. |
| Spaced repetition | Reviewing at growing intervals beats massed cramming. | Review the WAF-vs-Shield-vs-Network-Firewall and KMS-vs-CloudHSM style discriminators at day 1, 3, 7, then weekly — they're the questions people miss on repeat exposure. |
| Interleaving | Mixing topics trains you to choose the right approach. | Don't drill IAM in isolation for a week; mix IAM + data-protection + incident-response questions together, like the real exam. |
| Elaboration / Feynman technique | Explaining why exposes gaps and builds durable understanding. | Talk through the three incident-response runbooks in §4.2 out loud from memory, step by step. |
| Concrete practice | Doing beats watching. | Build a sandbox Organizations setup with an SCP; enable GuardDuty/Security Hub; rotate a Secrets Manager secret. |
| Sleep & spacing over cramming | Memory consolidates during sleep. | Study most days for 45–60 minutes rather than one long weekend session; never pull an all-nighter before the exam. |
The weekly plan
| Phase | Focus | Actions |
|---|---|---|
| Weeks 1–4 Foundations & domains 1–3 | Shared responsibility, IAM evaluation logic, Detection, Incident Response, Infrastructure Security | Learn: first half of your video course. Retrieve: after each section, blank-page recall + flashcards for any "which service?" comparison. Apply: enable GuardDuty/Security Hub in a sandbox account, review a sample finding. |
| Weeks 5–6 Domains 4–5 (the biggest 38%) | IAM (20%) and Data Protection (18%) | Learn: finish the course. Apply: build a cross-account role with an external ID; rotate a Secrets Manager secret; encrypt an S3 bucket with SSE-KMS and inspect the CloudTrail data event. Retrieve: daily flashcard review of prior weeks. |
| Week 7 Domain 6 + decision tables | Governance, SCP vs RCP, and every decision-guide table in §10 | Read the exam guide's in-scope/out-of-scope appendices directly. Start interleaved topic quizzes across all six domains. |
| Week 8 Practice & polish | Full practice exams in review mode | Take Tutorials Dojo (or equivalent) sets. Read every explanation, even for questions you got right. Turn each miss into a flashcard. Retake fresh sets until consistent 80%+. Final 2 days: light flashcard review only, sleep well, skim the Cram Jam the morning of. |
13 · Exam-Day Tips & Common Traps
Technique
- Read the last sentence first. Identify what's actually being asked for — "most secure," "least operational overhead," "with the least disruption." That qualifier decides between two technically-correct-sounding options.
- Eliminate distractors first. Usually two options are clearly wrong on a factual basis (wrong service, wrong scope); decide between the remaining two on the optimization keyword.
- Flag & move on. 170 minutes / 65 questions ≈ 2.5 minutes each. Don't sink 8 minutes into one question — flag it and return later.
- Never leave a blank — there is no penalty for guessing.
Recurring traps
- SCPs and RCPs don't grant permissions — they cap them. You still need an explicit IAM Allow somewhere.
- WAF (app-layer rules) vs Shield (DDoS) vs Network Firewall (VPC-wide stateful filtering) — these are commonly conflated on the exam; match the attack type to the right layer.
- KMS (managed, multi-tenant) vs CloudHSM (dedicated, single-tenant, FIPS 140-2 L3) — only reach for CloudHSM when the scenario explicitly demands dedicated hardware or that compliance level.
- Gateway VPC endpoint (S3/DynamoDB, free) vs Interface endpoint / PrivateLink (most other services, billed).
- Secrets Manager (built-in rotation) vs Parameter Store (cheaper, no built-in rotation) — a scenario emphasizing "automatic rotation" almost always wants Secrets Manager.
- Same-account access needs either side to allow; cross-account access needs both sides to allow — a very commonly missed distinction in IAM evaluation-logic questions.
- Isolate a compromised instance before you investigate; investigate before you remediate; remediate before you restore normal service — answering out of this order is the classic wrong-answer trap in incident-response scenarios.
- Imported KMS key material does not auto-rotate — only AWS-generated key material supports automatic annual rotation.
- Revoking active sessions on a role is not the same as deleting the role or rotating its trust policy — it specifically invalidates temporary credentials issued before that action.
- Data events are billed and off by default in CloudTrail — a scenario complaining "we can't see who downloaded this S3 object" is missing S3 data events, not missing CloudTrail entirely.
- Permissions boundary vs SCP: a boundary caps one IAM entity (set by whoever creates it); an SCP caps an entire account/OU from the Organizations management account. A boundary can be self-service; an SCP cannot.
- DSSE-KMS vs SSE-KMS: DSSE adds a second, independent encryption layer — pick it only when a requirement explicitly asks for dual-layer/defense-in-depth encryption, not as a default upgrade.
- MACsec encrypts the Direct Connect link itself, not the application-layer traffic riding over it — don't confuse it with end-to-end TLS.
AssumeRoleWithWebIdentity · "customer sign-in identity" = Cognito · "temporary credentials for a non-AWS workload" = IAM Roles Anywhere · "immutable, tamper-evident logs" = S3 Object Lock + log file validation · "third-party firewall inline" = Gateway Load Balancer · "zero trust, no VPN client" = Verified Access.14 · Glossary of Acronyms
The exam guide itself is dense with acronyms. This is a fast lookup table, not a study section — use it when a task statement or a practice question drops an abbreviation you don't immediately recognize.
| Acronym | Stands for |
|---|---|
| ABAC | Attribute-Based Access Control |
| ACM | AWS Certificate Manager |
| CMK | Customer Master/Managed Key (KMS) |
| DRT | DDoS Response Team (Shield Advanced) |
| DSSE | Dual-Layer Server-Side Encryption |
| FIS | Fault Injection Service |
| GWLB | Gateway Load Balancer |
| IdP | Identity Provider |
| IMDS | Instance Metadata Service |
| IRSA | IAM Roles for Service Accounts (EKS) |
| KMS | Key Management Service |
| MACsec | Media Access Control Security |
| NACL | Network Access Control List |
| Acronym | Stands for |
|---|---|
| OCSF | Open Cybersecurity Schema Framework |
| OIDC | OpenID Connect |
| OU | Organizational Unit (Organizations) |
| RAM | Resource Access Manager |
| RBAC | Role-Based Access Control |
| RCP | Resource Control Policy |
| SAML | Security Assertion Markup Language |
| SCP | Service Control Policy |
| SG | Security Group |
| SSE | Server-Side Encryption |
| STS | Security Token Service |
| WORM | Write Once, Read Many |
| XKS | External Key Store (KMS) |
15 · Worked Example Questions
Three scenario-style questions, one per major weight tier, worked through the way you should approach the real exam: identify the optimization keyword, eliminate the wrong-service distractors, then pick between what's left.
Example 1 — Identity and Access Management
"A company runs a CI/CD pipeline in GitHub Actions that needs to deploy CloudFormation stacks into an AWS account. The security team requires that no long-lived AWS credentials be stored in GitHub. Which approach meets this requirement with the least ongoing credential-management overhead?"
- Eliminate: an IAM user with an access key stored as a GitHub secret — this is exactly the long-lived-credential pattern the requirement forbids.
- Eliminate: IAM Roles Anywhere — designed for workloads with an X.509 certificate and a private CA, not for a SaaS CI/CD runner authenticating via its own OIDC identity.
- Correct: configure GitHub Actions as an OIDC identity provider in IAM and create a role with a trust policy scoped to that repository/branch; the pipeline calls
AssumeRoleWithWebIdentityto get short-lived credentials per run. Zero long-lived secrets, no manual rotation.
Example 2 — Infrastructure Security
"An application on Amazon EC2 is vulnerable to server-side request forgery (SSRF). An attacker exploited the vulnerability and is attempting to retrieve temporary IAM credentials. Which single configuration change most directly closes this specific attack path with the least operational impact?"
- Eliminate: deploying AWS WAF — WAF operates on inbound HTTP requests to a web tier; it doesn't stop the vulnerable application itself from making an outbound metadata-service call once compromised.
- Eliminate: removing the instance role entirely — breaks the application's legitimate AWS access, failing "least operational impact."
- Correct: enforce IMDSv2 (require the session token, disallow IMDSv1) and set the metadata hop limit to 1. This is the standard, narrowly-scoped fix for exactly this SSRF-to-credential-theft chain.
Example 3 — Security Foundations and Governance
"A company's Organizations structure has dozens of member accounts. The security team wants to guarantee that no account — including ones created next quarter — can ever disable its Region's GuardDuty detector, while still letting individual account admins manage their own IAM users and roles freely. What should they implement?"
- Eliminate: an IAM permissions boundary — boundaries are applied per identity within a single account and must be attached individually; they don't automatically apply to future accounts or cap what account admins can do to security-service configuration org-wide.
- Eliminate: a Config rule that flags disabled GuardDuty — detects the problem after the fact, doesn't prevent it.
- Correct: attach a Service Control Policy at the OU level that denies
guardduty:DeleteDetector/guardduty:DisableOrganizationAdminAccount-type actions. Because SCPs apply to every account under that OU automatically — including ones created later — and only cap the security-tooling actions in question, IAM user/role management inside each account is untouched.
Example 4 — Detection
"A security team needs to be alerted within minutes whenever an IAM principal makes an unusually large number of failed AssumeRole calls, which could indicate a credential-stuffing attempt against a role's trust policy. Which combination of services provides this with the least custom code?"
- Eliminate: a daily Athena query over CloudTrail logs in S3 — technically finds the pattern eventually, but "within minutes" rules out a batch/scheduled query approach.
- Eliminate: writing a custom Lambda function that polls CloudTrail on a timer and computes a rolling failure count — works, but is exactly the "custom code" the question is steering you away from.
- Correct: CloudTrail Insights, which uses ML to baseline normal API call volume/error rates and automatically surfaces anomalies like an unusual spike in failed
AssumeRolecalls — no custom aggregation logic required. Route the Insights event through EventBridge to notify the team in near real time.
Example 5 — Incident Response
"An engineer accidentally commits an IAM user's access key to a public GitHub repository. CloudTrail shows the key has already made API calls the team didn't initiate. What is the FIRST action to take?"
- Eliminate: deleting the IAM user — destroys the audit trail (the CloudTrail events tied to that principal become harder to correlate) and is disproportionate before the scope of damage is known.
- Eliminate: rotating every secret in the account — reasonable eventually, but not the first action, and not scoped to what this specific key could actually reach.
- Correct: deactivate the compromised access key immediately to stop further use, then use CloudTrail to determine the blast radius before deciding what else that identity touched and needs rotating. Containment before investigation before broad remediation.
Example 6 — Data Protection
"A healthcare company must guarantee that backup copies of patient records in S3 cannot be deleted or overwritten by anyone, including an account administrator, for a regulatory-mandated 7-year retention period. Which S3 feature satisfies this?"
- Eliminate: versioning alone — protects against accidental overwrite by keeping prior versions, but a sufficiently privileged administrator can still delete versions or the bucket itself.
- Eliminate: a bucket policy denying
s3:DeleteObject— an IAM administrator can simply modify or remove that bucket policy, so it isn't tamper-proof against admins. - Correct: S3 Object Lock in Compliance mode with a 7-year retention period — once applied, no principal, including the root user, can shorten the retention period or delete the protected objects until it expires. This is the WORM guarantee the scenario is asking for.