☁️ AWS Certified Security - Specialty (SCS-C03) - Exam-Prep
Free exam-prep for AWS Certified Security - Specialty (SCS-C03), signed certificate $5. Learn the modules, pass the 10-question exam, EN/FR, no account.
AWS Certified Security - Specialty (SCS-C03) - Exam-Prep is a free, self-paced online. Free exam-prep for AWS Certified Security - Specialty (SCS-C03), signed certificate $5. It is independent exam-prep built from the syllabus published on this page. The course has 8 modules and a final exam (pass mark 70%). An optional verifiable certificate costs $5 (promo until 31 December 2026).
Last updated: June 2026
For cloud and security engineers preparing for the SCS-C03 exam: master AWS detection, incident response, infrastructure and data protection, IAM, and governance to pass with confidence. The course is organized into 8 modules, ending with a final exam (pass mark 70%). It is independent, free exam-preparation training — not an official or accredited review course.
What you'll learn
- Domain 1 — Detection: Logging, Monitoring & Threat Detection
- Domain 2: Incident Response — Containment, Forensics & Automated Remediation
- Domain 3: Infrastructure Security — VPC, Network Segmentation & Edge Protection
- Domain 3: Infrastructure Security — Compute, Host Hardening & Vulnerability Management
- Domain 4: Identity & Access Management — IAM Policies, Roles, Permission Boundaries & Least Privilege
- Domain 4: Federation, IAM Identity Center & Multi-Account Access
- Domain 5 - Data Protection: Encryption at Rest & In Transit, KMS, CloudHSM & Secrets Management
- Domain 6 - Security Foundations & Governance: Organizations, SCPs, Shared Responsibility & Exam Strategy
Learning objectives
- Design detection and monitoring with GuardDuty, Security Hub, CloudTrail, Config, and CloudWatch to surface and triage threats.
- Build and execute incident response playbooks, including credential compromise, isolation, and forensic data capture.
- Secure VPC networking and edge layers using security groups, NACLs, WAF, Shield, Network Firewall, and TLS termination.
- Engineer least-privilege access with IAM policies, roles, permission boundaries, SCPs, and federation across multiple accounts.
- Protect data at rest and in transit using AWS KMS, CloudHSM, Secrets Manager, and envelope encryption.
- Apply multi-account governance with AWS Organizations, control policies, and the shared responsibility model.
- Make cost, security, and complexity tradeoffs to choose the right AWS security control for a scenario.
- Decode SCS-C03 question styles and apply exam-day time and elimination strategies.
Frequently asked questions
What is the AWS Certified Security - Specialty (SCS-C03) - Exam-Prep course?
AWS Certified Security - Specialty (SCS-C03) - Exam-Prep is a free, self-paced online course from AMAADOR Academy. Free exam-prep for AWS Certified Security - Specialty (SCS-C03), signed certificate $5.
Who is the AWS Certified Security - Specialty (SCS-C03) - Exam-Prep course for?
It is independent exam-prep for learners working through the syllabus published on this page.
Is this course free, and how is it delivered?
Yes. The course is free, self-paced and online. You can work through the lessons at your own pace. An optional verifiable certificate costs $5 (promo until 31 December 2026).
Is this the official AWS Certified Security - Specialty (SCS-C03) - Exam-Prep course or exam?
It is independent, free exam-preparation training — not an official or accredited review course.
How do I get a certificate?
After you complete the course and pass the final exam (pass mark 70%), you can order an optional verifiable certificate of completion for $5 (promo until 31 December 2026).
Course facts
- Estimated study time
- about 2 hours
- Final assessment
- 65 questions · Pass mark 70%
- Available in
- English, Français
- Price
- Free. Optional verifiable certificate: $5
- Last updated
- Published by
- AMAADOR ACADEMY
Course content
1. Domain 1 — Detection: Logging, Monitoring & Threat Detection
Domain 1 of the SCS-C03 blueprint carries roughly 14% of the exam and tests whether you can design and implement detective controls. The four pillars you must know cold are CloudTrail (the API audit log), AWS Config (resource state & compliance), GuardDuty (intelligent threat detection), and Security Hub (the aggregation and posture plane). Knowing what each does not do is where most points are won or lost.
The four services — what each actually records
| Service | Records | Question it answers |
|---|---|---|
| CloudTrail | API calls (who/what/when/from where) | "Who did this?" |
| Config | Resource configuration over time | "What changed and is it compliant?" |
| GuardDuty | Malicious/anomalous behavior | "Are we under attack?" |
| Security Hub | Aggregated findings + standards | "What is our overall posture?" |
CloudTrail event types.Management events (control-plane: RunInstances, CreateBucket) are logged free for the last 90 days in Event History. Data events (S3 object-level GetObject, Lambda Invoke, DynamoDB) are high-volume, disabled by default, and billed. Insights events detect unusual write-rate patterns. Exam trap: if a question asks why an S3 object read was not logged, the answer is almost always "data events were not enabled."
2. Domain 2: Incident Response — Containment, Forensics & Automated Remediation
Incident response (IR) carries roughly 14% of the SCS-C03 exam, second only to Threat Detection. The exam tests whether you can prepare for an event, contain a compromised resource without destroying evidence, collect forensic data in the right order, and automate the response so it scales. AWS frames this through the NIST SP 800-61 lifecycle adapted to the cloud: Preparation → Detection & Analysis → Containment, Eradication & Recovery → Post-Incident Activity.
Preparation: build the response capability first
The exam loves the principle that you cannot improvise forensics during a breach. Key preparatory controls: a dedicated forensics/security account in AWS Organizations (isolated from production), pre-built IAM roles for responders, an SNS topic + runbooks, and EventBridge rules wired to GuardDuty findings. CloudTrail must be a multi-region organization trail with log-file validation enabled, delivering to an S3 bucket in the security account with Object Lock (WORM) so logs cannot be altered.
Exam trap: If a question asks how to guarantee CloudTrail logs survive an attacker with admin rights, the answer is cross-account delivery to a locked bucket the production account cannot touch — not encryption alone. Encryption protects confidentiality, not integrity/availability of evidence.
3. Domain 3: Infrastructure Security — VPC, Network Segmentation & Edge Protection
Infrastructure security carries the heaviest weight on the SCS-C03 exam. Roughly a quarter of your questions live here, and they are rarely trivia — they are scenario traps that reward engineers who truly understand how packets flow, where security controls evaluate, and which AWS edge service belongs at which layer. This chapter builds that mental model from the VPC outward to the internet edge.
The VPC as a Security Boundary
A Virtual Private Cloud (VPC) is a logically isolated network you fully control: CIDR ranges, subnets, route tables, gateways. Isolation is the foundation of segmentation. The two stateful/stateless controls inside a VPC are the heart of nearly every exam question.
Security Groups (stateful)
- Attach to ENIs (instances, RDS, Lambda-in-VPC)
- Allow rules only — no explicit deny
- Return traffic auto-allowed (stateful)
- Can reference other security groups as source
Network ACLs (stateless)
- Attach to subnets, evaluate every packet
- Allow AND deny rules, numbered, lowest first
- Return traffic needs explicit ephemeral-port rule (1024–65535)
- Cannot reference security groups — CIDR only
Exam trap: If you need to block a specific malicious IP, the answer is a Network ACL deny rule — security groups cannot deny. If traffic mysteriously fails one-way, suspect a NACL missing the ephemeral return rule.
4. Domain 3: Infrastructure Security — Compute, Host Hardening & Vulnerability Management
Domain 3 of the SCS-C03 blueprint carries one of the heaviest weightings on the exam. This chapter focuses on the compute layer: EC2 instances, the AMI lifecycle, host hardening, patch and vulnerability management, and the shared responsibility boundary that decides what AWS secures versus what you must secure yourself.
The compute responsibility boundary
For EC2 (an IaaS service), AWS secures the hypervisor, physical hosts, and the Nitro System; you own the guest OS, patches, user accounts, runtime, application code, and security group configuration. Misreading this line is the single most common exam trap.
Shared Responsibility — compute slice: AWS = "security OF the cloud" (hardware, Nitro, hypervisor isolation). You = "security IN the cloud" (OS patching, IAM roles on instances, host firewall, antivirus, data).
Eliminating SSH: Systems Manager
The exam strongly favors removing inbound SSH/RDP entirely. SSM Session Manager gives shell access with no open ports, no bastion, no key pairs — it works over the SSM agent making an outbound HTTPS call, supports full session logging to S3/CloudWatch Logs, and is gated by IAM. This is the canonical "how do I get least-privilege, audited host access" answer.
5. Domain 4: Identity & Access Management — IAM Policies, Roles, Permission Boundaries & Least Privilege
Identity and Access Management is the foundation of AWS security and one of the most heavily weighted areas of the SCS-C03 exam. The exam tests whether you can read a policy, predict the effective permission, and choose the right construct to grant exactly the access required — no more. This chapter unpacks the IAM policy engine, roles, permission boundaries, and the discipline of least privilege.
The IAM policy types you must distinguish
AWS evaluates several distinct policy categories. Knowing which is which is the single most exam-critical skill.
| Policy type | Attached to | Grants or limits? | Crosses accounts? |
|---|---|---|---|
| Identity-based | User, group, role | Grants | No (within account) |
| Resource-based | S3 bucket, SQS, KMS key, etc. | Grants (incl. Principal) | Yes — enables cross-account |
| Permission boundary | User or role | Limits max permissions | No |
| SCP (Organizations) | OU / account | Limits (guardrail) | N/A — filters all |
| Session policy | Passed at AssumeRole | Limits the session | No |
Exam trap: An explicit Deny in any applicable policy always wins — no other Allow can override it. Permission boundaries, SCPs, and session policies do not grant permissions; they only cap what an identity-based Allow can achieve. The effective permission is the intersection of all of them.
6. Domain 4: Federation, IAM Identity Center & Multi-Account Access
At scale, AWS is never one account. Real organizations run dozens or hundreds of accounts under AWS Organizations, and humans authenticate from an external corporate directory. This chapter covers how identities federate into AWS, how IAM Identity Center (formerly AWS SSO) brokers workforce access, and how trust flows across accounts. Expect heavy SCS-C03 question weight here.
Federation fundamentals: never create IAM users for people
The exam's golden rule: federate human access, do not create long-lived IAM users. Federation exchanges an external identity assertion for temporary AWS credentials issued by AWS STS. There are three patterns:
- SAML 2.0 federation — an external IdP (AD FS, Okta, Ping) posts a signed SAML assertion; you call
sts:AssumeRoleWithSAML. Trust is established by uploading the IdP metadata to an IAM SAML identity provider object. - Web identity / OIDC federation — for apps and mobile/web users via Cognito, Google, or any OIDC IdP; you call
sts:AssumeRoleWithWebIdentity. This is also how IRSA (IAM Roles for Service Accounts) on EKS works, using the cluster's OIDC provider. - Custom broker — your code calls
AssumeRole+GetFederationTokenand builds a sign-in URL.
7. Domain 5 - Data Protection: Encryption at Rest & In Transit, KMS, CloudHSM & Secrets Management
Data protection is the connective tissue of the SCS-C03 exam: roughly 18% of the scored content lives here, and the questions are rarely "which service encrypts data?" They are "which key type, which grant, which policy, and which failure mode?" This chapter walks the body of knowledge the way the exam frames it - cryptographic primitives, AWS KMS internals, CloudHSM, and secrets lifecycle.
1. The two states of data
Every exam scenario distinguishes data at rest (stored on disk - S3, EBS, RDS, DynamoDB, EFS) from data in transit (moving across a network). They demand different controls and the exam punishes conflating them.
Envelope encryption (memorize this). AWS does not encrypt large data directly with a KMS key. KMS generates a data key, returns it in plaintext and encrypted form. The service encrypts data with the plaintext data key, discards the plaintext from memory, and stores the encrypted data key alongside the ciphertext. To decrypt, the encrypted data key is sent to KMS, which decrypts it (this is the only crypto KMS performs on your bulk data path).
8. Domain 6 - Security Foundations & Governance: Organizations, SCPs, Shared Responsibility & Exam Strategy
This final chapter ties the SCS-C03 blueprint together at the account and organization level. Identity (Domain 3) controls who can do what inside an account; governance controls what is even possible across hundreds of accounts. Examiners love scenarios where the right answer is a guardrail at the org boundary, not another IAM policy.
The Shared Responsibility Model. AWS secures the cloud (hardware, the global network, the hypervisor, managed-service control planes). You secure what is in the cloud (your data, IAM, OS patching on EC2, network/firewall config, encryption choices). The split shifts by service type.
Responsibility shifts by service model
| Model | AWS handles | You handle |
|---|---|---|
| IaaS (EC2) | Hypervisor, host, physical | Guest OS, patching, security groups, app, data |
| Container (ECS/EKS data plane) | Underlying infra; control plane (EKS) | Image, task IAM role, secrets, network policy |
| Serverless (Lambda, S3, DynamoDB) | OS, runtime patching, scaling | Code, IAM, resource policies, encryption, data classification |
Exam trap. "Who patches the OS?" depends on the service. EC2 = you. RDS = AWS patches the engine, you schedule the window. Fargate/Lambda = AWS. Encryption of your data and correct IAM are always yours.
The full lesson continues in the interactive course on this page.