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 years
⚡ Open the 1-page Cram Jam sheet

Part 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.

Who it's for AWS's target-candidate description calls for 3–5 years of experience securing cloud solutions, including managing identity at scale, multi-account governance, incident response, and encryption both at-rest and in-transit. If you're new to AWS security, build a foundation first — this is a Specialty-level exam, not an entry point. Full detail in §1 Exam Details.

Exam at a Glance

AttributeValue
Exam codeSCS-C03
Questions65 total — 50 scored + 15 unscored (pretest, not identified)
Question typesMultiple choice, multiple response, ordering, and matching (per the exam guide's response-type list)
Time170 minutes
Passing score750 out of 100–1000 (scaled, compensatory)
Cost300 USD
DeliveryPearson VUE test center or online proctored
Validity3 years

→ Deep dive: §1 Exam Details & Logistics

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.

20%
Domain 4 — Identity and Access Management
18%
Domain 3 — Infrastructure Security
18%
Domain 5 — Data Protection
16%
Domain 1 — Detection
14%
Domain 2 — Incident Response
14%
Domain 6 — Security Foundations and Governance
DomainWhat it testsDeep 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
If you studied SCS-C02 The old exam guide grouped this material as "Threat Detection and Incident Response," "Security Logging and Monitoring," "Infrastructure Security," "Identity and Access Management," "Data Protection," and "Management and Security Governance." SCS-C03 merges logging/monitoring and threat-detection/incident-response into separate Detection and Incident Response domains and folds in newer content (generative-AI guardrails, RCPs, declarative policies, Amazon Q Developer/CodeGuru Security scanning). Most C02-era courses and practice exams still use the old domain names — the underlying services overlap heavily, so that material is not wasted, but map it onto the domains above rather than trusting the label on the course.
SCS-C02 domain (retired)Maps onto SCS-C03 domain(s) in this guide
Threat Detection and Incident ResponseSplit across Domain 1 (Detection) and Domain 2 (Incident Response)
Security Logging and MonitoringDomain 1 (Detection) — §3.1/§3.2
Infrastructure SecurityDomain 3 (Infrastructure Security) — largely unchanged
Identity and Access ManagementDomain 4 (Identity and Access Management) — largely unchanged
Data ProtectionDomain 5 (Data Protection) — largely unchanged
Management and Security GovernanceDomain 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. → details

Logging

CloudTrail (+ Lake), CloudWatch Logs, VPC Flow Logs, Route 53 Resolver query logs. → details

Network & Edge

WAF, Shield/Shield Advanced, Network Firewall, Firewall Manager, Verified Access. → details

Identity

IAM, IAM Identity Center, STS, Cognito, IAM Roles Anywhere, Verified Permissions. → details

Encryption & Secrets

KMS, CloudHSM, ACM / Private CA, Secrets Manager, S3/EBS/RDS encryption. → details

Governance

Organizations, SCPs/RCPs, Control Tower, Audit Manager, Artifact. → details

→ Full in-scope service reference by category (§9)

Recommended 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.

The consensus stack: a Maarek or Cantrill video course (bought as "SCS-C02" today, content maps onto SCS-C03) → drill Tutorials Dojo practice exams → skim the AWS Security Learning Plan on Skill Builder and the official exam guide's in-scope service list to catch anything the course misses.

→ Full breakdown with sources (§11)

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.

  1. 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.).
  2. 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.
  3. 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%+.
  4. 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.

Two sources, slightly different numbers The AWS certification product page phrases the recommended background differently — "five years of IT security experience in designing and implementing security solutions, and two or more years of hands-on experience securing AWS workloads." Both describe the same seniority level; where the two disagree on wording, this guide follows the official exam guide as authoritative since it is the document that actually defines exam scope.

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

ItemDetail
Price300 USD (plus local taxes / FX). A 50% discount voucher is often available after passing another AWS exam.
DeliveryPearson VUE testing center, or online proctored from home (quiet private room, webcam, ID check).
RecertificationValid 3 years. Recertify by re-passing the current exam version.
PredecessorSCS-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.
On the retirement date The official exam guide (the authoritative source used throughout this page) does not itself state a retirement date for SCS-C02 in its body text. Secondary sources (training-provider blog posts covering the transition) report that SCS-C02 was retired on December 1, 2025 and SCS-C03 became the only version offered starting the next day. Treat that specific date as secondary-sourced, not primary-sourced — but the exam guide's own existence, its "SCS-C03" naming, and its SCS-C02-vs-C03 comparison appendix all independently confirm SCS-C03 is the current, live version.

↑ back to top

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

Security OF vs IN the cloud AWS secures the infrastructure, hardware, and managed-service software (security OF the cloud). You secure your data, IAM configuration, guest OS patching on EC2, network/firewall configuration, and encryption choices (security IN the cloud). The line shifts toward AWS as you move from EC2 → managed service (RDS) → serverless (Lambda, S3) — this is why "who patches what" questions are really shared-responsibility questions.

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 — Allow or Deny.
  • 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 as aws:SourceIp, aws:MultiFactorAuthPresent, aws:PrincipalOrgID, aws:PrincipalTag/* (for ABAC), and kms:ViaService/s3:x-amz-server-side-encryption for 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

SymmetricAsymmetric
KeysOne shared secret key encrypts and decryptsA public key encrypts/verifies, a private key decrypts/signs
SpeedFast — used for bulk dataSlower — used for key exchange, signing, and small payloads
KMS defaultAES-256-GCM, the default KMS key specRSA 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 useEncrypting 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 typeWho manages itRotation
AWS owned keyAWS, shared across many accounts, not visible in your accountManaged 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 consoleAutomatic, every year
Customer managed key (CMK)You create, own the key policy, control access and rotationOptional automatic annual rotation (AWS-generated material only), or manual/no rotation

↑ back to top

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

ServiceWhat it detects / does
Amazon GuardDutyManaged, 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 HubAggregates 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 DetectiveBuilds 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 InspectorAutomated vulnerability scanning for EC2 (via SSM agent), container images in ECR, and Lambda functions/layers; reports CVEs and network reachability.
Amazon MacieML-based discovery and classification of sensitive data (PII, credentials, financial data) in S3.
Amazon Security LakeCentralizes 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 packsContinuously evaluates resource configuration against rules; auto-remediates via SSM Automation documents when paired with a remediation action.
Automate the response "Create metrics/alerts/dashboards to detect anomalous data and events" and "create automations to perform regular assessments" are literal skills in the exam guide — expect questions where the correct answer wires a GuardDuty/Security Hub/Config finding to EventBridge, which then triggers a Lambda function, Systems Manager Automation document, or Step Functions workflow.
Security Hub severity labelTypical triage response
CRITICALPage 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.
HIGHNotify the security team same-business-day; investigate with Detective before remediating.
MEDIUM / LOWTrack via a Config conformance pack or backlog; batch-review weekly rather than paging.
INFORMATIONALLog only — typically expected/benign activity that Security Hub still records for audit completeness.

3.2 · Logging Solutions

Log sourceWhat it captures
AWS CloudTrailManagement 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 trailCreated 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 validationEnables SHA-256 hashing + digital signing of log files so you can cryptographically prove a CloudTrail log wasn't tampered with after delivery.
KMS-encrypted trailsCloudTrail 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 LogsMetadata (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 loggingLogs 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 logsPer-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 filtersStream 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.
Centralized logging pattern A dedicated logging/security account (often the Control Tower Log Archive account) receives an organization CloudTrail trail, aggregated CloudWatch Logs, and VPC Flow Logs from every member account. Combine with S3 Object Lock (WORM) and a bucket policy that denies delete/overwrite to give logs immutability and satisfy "logs must not be alterable, even by admins" requirements. Retention is then a lifecycle policy on that bucket, not on each source account.

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 questionAnswer
Need SQL-style ad hoc queries over CloudTrail/Flow Logs in S3, pay per scanAthena
Need near-real-time queries over recently ingested CloudWatch LogsCloudWatch Logs Insights
Need full-text search, custom dashboards, alerting on log contentOpenSearch Service
Need to route/transform logs to multiple destinations as they arriveCloudWatch 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 principal PutObject.
  • "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.
SymptomLikely cause to check first
GuardDuty finding never fires despite obvious malicious trafficGuardDuty 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 accountAccount not part of the Organizations aggregation, or the delegated administrator relationship isn't configured
CloudTrail shows no S3 object-level activityData events aren't enabled for that trail/bucket — management events alone don't cover them
Config rule shows "not applicable" everywhereThe 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 nothingTable partition not loaded/updated for the date range being queried

↑ back to top

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

Runbook: compromised EC2 instance
  1. 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.
  2. Tag it for tracking and to trigger automation that excludes it from Auto Scaling / load balancer rotation.
  3. Snapshot the EBS volume(s) for a forensic copy before any further action; if memory capture is needed, do it before powering off.
  4. Revoke IAM credentials associated with the instance profile / rotate any keys the instance had access to.
  5. 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).
Runbook: leaked IAM access key
  1. Deactivate the access key immediately (don't delete yet — you may need it for the investigation trail), then delete once the investigation is complete.
  2. Review CloudTrail for every API call made with that key to determine what the attacker did.
  3. 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.
  4. 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.
  5. 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).
Runbook: compromised IAM role
  1. 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.
  2. 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 AssumeRole can't otherwise be individually invalidated before they expire).
  3. Review the trust policy for how the role was assumable and by whom, then tighten it (external ID, source IP condition, shorter session duration).
  4. Correlate with CloudTrail/Detective to scope the blast radius, then remediate downstream resources the role touched.
Runbook: publicly exposed S3 bucket
  1. 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.
  2. 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.
  3. 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.
  4. Prevent recurrence: apply an SCP/RCP that blocks public bucket policies org-wide, and add a Config rule (s3-bucket-public-read-prohibited style) 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.

↑ back to top

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

ServiceProtects against / does
AWS WAFLayer-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 StandardFree, automatic protection against common network/transport-layer (L3/L4) DDoS attacks for every AWS customer.
AWS Shield AdvancedPaid ($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 FirewallManaged, 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 configurationControls which origins a browser may fetch bucket content from — the edge control for "block cross-origin requests to my bucket."
Don't mix these up WAF = application-layer rules on HTTP requests you write/manage yourself. Shield = DDoS absorption, mostly automatic. Network Firewall = VPC-wide stateful network/domain filtering, not HTTP-aware in the same way WAF is. A scenario asking to block SQL injection wants WAF; one asking to block a volumetric UDP flood wants Shield (Advanced if it needs 24/7 support and cost protection).

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 decisionConsideration
Where to terminate TLSAt 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 selectNewer 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 spikeA 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 itemMechanism
Golden image with pre-baked patches/agentsEC2 Image Builder
No long-lived credentials on the instanceInstance profile / execution role
Metadata service can't be abused via SSRFIMDSv2 enforced, hop limit 1
Known vulnerabilities surfaced automaticallyInspector (EC2, ECR images, Lambda)
Runtime anomalies on a running workloadGuardDuty runtime monitoring
OS/app patches applied on scheduleSSM Patch Manager + patch baselines
No standing SSH/RDP bastionSSM Session Manager or EC2 Instance Connect
Vulnerabilities caught pre-deployCodeGuru 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 GroupNetwork ACL
LevelInstance / ENISubnet
StateStateful (return traffic auto-allowed)Stateless (must allow return traffic explicitly)
RulesAllow onlyAllow and Deny
EvaluationAll rules evaluatedRules processed in number order, first match wins
SG-to-SG referencing Security groups can reference other security groups as their source/destination instead of IP ranges — the standard tier-to-tier pattern (an app-tier SG allows port 3306 only from the web-tier SG). This removes the need to track IP lists as instances scale in and out, and is frequently the "least operational overhead" answer for tier isolation questions.
  • 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 needChoose
Quick encrypted tunnel over the public internetSite-to-Site VPN
Dedicated, consistent-latency private circuit to AWSDirect Connect
Encrypt traffic on that dedicated circuit itselfDirect Connect + MACsec
Individual users need remote access into a VPCAWS Client VPN
Per-request Zero Trust access, no client softwareAWS Verified Access

↑ back to top

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

MechanismUse for
AWS IAM Identity CenterCentral 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 federationEnterprise IdP → temporary AWS credentials via AssumeRoleWithSAML, without creating IAM users per employee.
OIDC federationWeb-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 PoolsCustomer-facing sign-up/sign-in identity for apps; issues JWTs after authentication, supports MFA and social/SAML/OIDC IdPs.
Amazon Cognito Identity PoolsExchanges 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 AnywhereIssues 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 STSIssues all temporary security credentials (AssumeRole, AssumeRoleWithSAML, AssumeRoleWithWebIdentity, GetSessionToken). Underlies every federation mechanism above.
S3 presigned URLsTime-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.

IAM Identity Center permission sets A permission set is a template of IAM policies (managed, customer-managed, and/or an inline policy) that Identity Center provisions as an actual IAM role in each assigned account when a user or group is granted access. Update the permission set once and Identity Center re-provisions the change everywhere it's assigned — the reason it's the answer for "manage access to 50 accounts from one place" instead of hand-maintaining 50 separate IAM roles.

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/project must equal aws: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 AssumeRole session below what the role itself allows, without touching the role's permanent policy. Concretely: a developer with iam:CreateRole/iam:AttachRolePolicy can be required (via a Condition on 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.
Common trap "App on EC2 needs S3 access" → instance role, never hard-coded keys. "Third-party SaaS needs to assume a role into your account" → cross-account role + external ID, not a shared IAM user. "Limit what a self-service team's roles can ever do" → permissions boundary, not just careful code review.
STS API callUsed for
AssumeRoleCross-account access or switching to a role within the same account, given an IAM identity that's already authenticated
AssumeRoleWithSAMLEnterprise IdP federation (SAML assertion → temporary credentials)
AssumeRoleWithWebIdentityOIDC federation — CI/CD pipelines, mobile/web apps using a public identity provider
GetSessionTokenTemporary credentials for the currently-signed-in IAM user, mainly to support MFA-protected API calls
GetFederationTokenTemporary 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"
    }
  }
}
The trap A resource policy that names only "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" } }
  }
]
Why Deny, not Allow An 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}"
    }
  }
}
The KMS gotcha The key policy is the root of trust. If the key policy does not delegate to IAM (a statement whose principal is the account root) then no IAM policy in that account can use the key, however permissive it looks. "The IAM policy allows 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" }
  }
}
BoolIfExists, not Bool Some principals (service roles, certain federated sessions) never populate 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 keyWhat it pinsClassic question stem
aws:PrincipalOrgIDCaller is inside my organization"without maintaining a list of account IDs"
aws:SourceArn / aws:SourceAccountWhich resource or account drove the service call"prevent another customer's trail from writing here"
aws:SecureTransportTLS was used"reject plaintext requests"
aws:PrincipalTag / aws:ResourceTagABAC tag match"scales as teams are added"
kms:ViaServiceKey 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-encryptionObject was encrypted on PUT"reject unencrypted uploads"
aws:SourceIp / aws:SourceVpceNetwork origin of the request"only from the corporate network, only via the endpoint"
sts:ExternalIdThe third party is the intended one"a vendor needs access to my account"
aws:MultiFactorAuthPresentMFA on the session"require MFA to delete"

↑ back to top

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:SecureTransport condition) 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 modeKey management
SSE-S3AWS-owned keys, no configuration, the default for new buckets.
SSE-KMSCustomer-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-CYou supply and manage the encryption key yourself in each request; AWS never stores it.
DSSE-KMSDual-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.
Key policy vs IAM policy for KMS Every KMS key has a key policy — a resource policy that is the root authority for who can use/manage that key. Unlike most AWS resources, KMS keys default to the identity-and-resource-policy intersection rule only if the key policy grants the account root access to delegate through IAM; if a key policy doesn't include the standard "enable IAM policies" statement, IAM policies alone won't be enough. This is the source of the classic exam trap: "IAM says allow, but the KMS action still fails" → check the key policy, not just the IAM policy.

7.3 · Secrets & Key Material

NeedChoose
Secret with built-in automatic rotation (RDS/Redshift/DocumentDB native support)Secrets Manager
Config value or secret without needing rotation, cost-sensitiveSSM 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-renewalACM (public) or AWS Private Certificate Authority (private/internal PKI)
Hard numbers to memorize
  • 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.
ACM vs Private CA vs CloudHSM, one more time ACM issues and auto-renews free public TLS certificates for services AWS trusts by default (ELB, CloudFront, API Gateway). AWS Private Certificate Authority runs your own internal CA hierarchy for certificates that don't need public trust (internal service-to-service mTLS, IoT device certs, IAM Roles Anywhere client certs) — you manage the CA and its certificate rotation policy. CloudHSM is one level further down: dedicated hardware for when you must generate/store cryptographic key material yourself, including as the root of trust for a Private CA if regulations require it.

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.

↑ back to top

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

ServicePurpose
AWS OrganizationsCentral management of many accounts; consolidated billing; organize accounts into OUs for policy targeting.
AWS Control TowerAutomated 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 policiesOrganization-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 policiesOrg-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 decisionPick
Fastest path to a governed multi-account baselineControl Tower
Custom guardrail Control Tower doesn't ship out of the boxControl Tower custom control (backed by an SCP/Config rule)
Just need consolidated billing and OUs, no guardrail automationOrganizations alone
One security team operates tooling across every accountDelegated 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.

↑ back to top

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).
Explicitly out of scope The exam guide's out-of-scope appendix is short: Amazon Managed Workflows for Apache Airflow (MWAA) and AWS Payment Cryptography. Almost everything else in the AWS catalog is technically fair game for its security aspects even if it isn't a named focus area — the exam guide explicitly warns this in-scope list is non-exhaustive and subject to change, so don't treat it as a hard ceiling.

↑ back to top

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

JobService
Continuous threat detection from logs/network flow, no agentsGuardDuty
Aggregate findings across services, score vs. standardsSecurity Hub
Investigate root cause / visualize a security graphDetective
Scan EC2/ECR images/Lambda for CVEsInspector
Find PII/sensitive data in S3Macie
Continuous config-compliance rules + remediationConfig
Who called this API / control-plane audit trailCloudTrail
Central normalized security data lake for SIEM/analyticsSecurity Lake

Key & secret management

NeedChoose
Managed encryption keys, most services, envelope encryptionKMS
Dedicated single-tenant HSM, FIPS 140-2 Level 3CloudHSM
Key material must never leave an external managerKMS external key store
Secrets with native automatic rotation (RDS etc.)Secrets Manager
Config/secret value, no rotation needed, cheaperSSM Parameter Store
Public TLS certs, auto-renewACM
Private/internal PKI issuing certificatesAWS Private Certificate Authority

Network & edge protection

NeedChoose
Block SQLi/XSS, rate-limit HTTP requestsWAF
DDoS protection (volumetric/protocol)Shield (Advanced for 24/7 DRT + cost protection)
Stateful, VPC-wide network/domain filteringNetwork Firewall
Insert third-party inspection appliance transparentlyGateway Load Balancer
Private connectivity to an AWS serviceVPC endpoint (Gateway for S3/DynamoDB, Interface/PrivateLink otherwise)
Zero-trust access to an internal app, no VPN clientVerified Access
Block malicious DNS lookups from a VPCRoute 53 Resolver DNS Firewall
Central policy enforcement (WAF/Shield/SG) org-wideFirewall Manager

Identity & federation

ScenarioChoose
Workforce SSO across many AWS accountsIAM Identity Center
Customer sign-up/sign-in for an appCognito User Pools
Exchange a signed-in identity for temporary AWS credentialsCognito Identity Pools
CI/CD pipeline assumes a role without stored keysOIDC federation via AssumeRoleWithWebIdentity
Workload running outside AWS needs temporary AWS credentialsIAM Roles Anywhere
Third party needs to assume a role into your accountCross-account role + external ID
Fine-grained authorization inside your own applicationAmazon Verified Permissions

Governance & guardrails

NeedChoose
Cap max permissions for your own principals org-wideSCP
Restrict access to your resources, even from outside your orgRCP
Enforce a specific configuration state directlyDeclarative policy
Stand up a governed multi-account landing zone fastControl Tower
Share infrastructure across accounts without duplicating itAWS RAM
Publish self-service, pre-approved deployable productsAWS Service Catalog
Collect continuous audit evidence against a frameworkAudit Manager
Get AWS's own compliance reports (SOC/PCI/ISO)AWS Artifact

Data-at-rest encryption, by requirement

RequirementChoose
Simplest, zero-config, no auditability neededSSE-S3
Need to see every decrypt/encrypt call in CloudTrailSSE-KMS
Reduce KMS API cost/throttling at high request volumeSSE-KMS with S3 Bucket Keys
Full control of the encryption key, AWS never stores itSSE-C
Compliance mandates two independent encryption layersDSSE-KMS
Compliance mandates key material never touch AWSKMS external key store

Encryption in transit, by scenario

ScenarioChoose
Public-facing web app, standard TLS terminationACM cert on ALB/CloudFront
Compliance requires TLS all the way to the instanceEnd-to-end TLS, cert installed on the instance/container (Private CA-issued if internal)
Private access between VPCs/accounts, no internetPrivateLink / VPC endpoints
Remote users need encrypted access into a VPCClient VPN
Zero-trust per-request access without a VPN clientVerified Access
Encrypt traffic on a dedicated Direct Connect circuitMACsec

Incident-response automation, by question

Question being askedService
"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 restricts AssumeRoleWithWebIdentity to a specific repository and branch, closing off use by any other workflow.

↑ back to top

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.

TL;DR consensus stack: one video course (Maarek to move fast or Cantrill to go deep) + Tutorials Dojo practice exams drilled in review mode + the AWS Skill Builder Security Learning Plan and the official exam guide's service lists to plug the gap between what a C02-era course covers and what SCS-C03 actually tests.

1 · Video courses

CourseProfileNotes
#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.
Consensus takeaways Comparison write-ups of AWS security training consistently rate Maarek as the affordable, concise pick and Tutorials Dojo as the practice-exam specialist, and flag A Cloud Guru/Pluralsight as a pricier, lab-heavy alternative rather than a top recommendation. Never pay full Udemy list price — wait for a sale.

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 project tag; 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

SourceWhat it provided
AWS Certification: SCS-C03 exam guideDomain titles/weights, task statements, target-candidate description, in-scope/out-of-scope service appendices.
AWS Certified Security – Specialty product pageQuestion count, time limit, price, delivery method, validity period, recommended-experience wording.
Tutorials Dojo SCS-C03 study pathConfirms an SCS-C03-specific study path exists and is organized around the current exam guide.
Adrian Cantrill — AWS Certified Security Specialty course pageCourse scope/structure, confirms current course material is organized around the six SCS-C02-style domain names.
CISObility — AWS Security training comparisonMaarek vs A Cloud Guru vs Tutorials Dojo cost/positioning comparison.
"How I passed the AWS Certified Security Specialty (SCS-C02) exam" — DEV CommunityA real candidate's resource mix, study hours, and topics that appeared on their exam.
AWS Training and Certification — Security learningConfirms the Security Learning Plan and Security Ramp-Up Guide as official, certification-agnostic study resources.

↑ back to top

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

PrincipleWhy it worksHow to apply it to SCS-C03
Active recallRetrieving 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 repetitionReviewing 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.
InterleavingMixing 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 techniqueExplaining 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 practiceDoing beats watching.Build a sandbox Organizations setup with an SCP; enable GuardDuty/Security Hub; rotate a Secrets Manager secret.
Sleep & spacing over crammingMemory 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

PhaseFocusActions
Weeks 1–4
Foundations & domains 1–3
Shared responsibility, IAM evaluation logic, Detection, Incident Response, Infrastructure SecurityLearn: 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 §10Read 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 modeTake 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.
Readiness bar You're ready when you can explain why each wrong answer option is wrong across all six domains, and can walk through the compromised-EC2, leaked-key, and compromised-role runbooks from a blank page — recognition ≠ recall.

↑ back to top

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.
Keyword → intent "cap max permissions org-wide" = SCP · "restrict access to my resources even from outside the org" = RCP · "no long-lived keys for CI/CD" = OIDC + 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.

↑ back to top

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.

AcronymStands for
ABACAttribute-Based Access Control
ACMAWS Certificate Manager
CMKCustomer Master/Managed Key (KMS)
DRTDDoS Response Team (Shield Advanced)
DSSEDual-Layer Server-Side Encryption
FISFault Injection Service
GWLBGateway Load Balancer
IdPIdentity Provider
IMDSInstance Metadata Service
IRSAIAM Roles for Service Accounts (EKS)
KMSKey Management Service
MACsecMedia Access Control Security
NACLNetwork Access Control List
AcronymStands for
OCSFOpen Cybersecurity Schema Framework
OIDCOpenID Connect
OUOrganizational Unit (Organizations)
RAMResource Access Manager
RBACRole-Based Access Control
RCPResource Control Policy
SAMLSecurity Assertion Markup Language
SCPService Control Policy
SGSecurity Group
SSEServer-Side Encryption
STSSecurity Token Service
WORMWrite Once, Read Many
XKSExternal Key Store (KMS)

↑ back to top

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 AssumeRoleWithWebIdentity to 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 AssumeRole calls — 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.

↑ back to top

↑ back to top