A companion module to the core service guides — this one deliberately skips "what does the service do" and goes straight to "what does the actual configuration look like." SCS-C02 scenario questions frequently describe a partially-built setup (a trust policy, a route table, a rotation Lambda, an SCP) and ask you to spot the missing piece. That skill requires having seen the literal artifact, not just the concept. Every topic here is also examined through a cross-account lens, since AWS disproportionately tests configuration mechanics at account boundaries.
Condition-block mechanics tested repeatedly across unrelated-looking questions.Each configuration below is written as "what has to be true, in order, before it works" — the same order AWS expects you to mentally check when a scenario says a configuration failed partway through. Cross-Account Patterns then re-synthesizes all six by mechanism, since recognizing WHICH cross-account mechanism a requirement calls for is itself a tested skill, independent of the underlying service.
A one-way trust where "on-prem trusts AWS" lets on-prem users authenticate into AWS resources — but does NOT let AWS-side identities reach into on-prem, and vice versa. A scenario describing a trust "already established" in the wrong direction is a common distractor; recognizing that a trust EXISTING isn't the same as it existing in the needed direction is the tested skill.
Used standalone (custom apps not going through Identity Center) or as the mechanical foundation Identity Center automates for you.
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::ACCOUNT_ID:saml-provider/ProviderName"
},
"Action": "sts:AssumeRoleWithSAML",
"Condition": {
"StringEquals": {
"SAML:aud": "https://signin.aws.amazon.com/saml"
}
}
}]
}NameID — the user identifierhttps://aws.amazon.com/SAML/Attributes/Role → IAM role ARN + SAML provider ARN, comma-separatedhttps://aws.amazon.com/SAML/Attributes/RoleSessionName → typically email or UPNhttps://aws.amazon.com/SAML/Attributes/SessionDuration (optional) → seconds, capped by the role's max session duration"Valid assertion received, but sts:AssumeRoleWithSAML is denied" → the trust policy's Principal or SAML:aud Condition is misconfigured — not the IdP.
"User authenticates but lands with the wrong/no permissions" → the IdP-side Role attribute claim rule is mapping to the wrong role ARN — not an AWS-side problem.
Subject/username.Identity Center supports only ONE identity source at a time. Switching sources does NOT migrate existing users/groups or permission set assignments — assignments are tied to identity references in the specific store. Best-practice timing: choose the identity source BEFORE creating any users/groups in the built-in directory.
https://oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID, as a trusted IdP in IAM).{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::ACCOUNT_ID:oidc-provider/oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID:sub":
"system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT_NAME",
"oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID:aud": "sts.amazonaws.com"
}
}
}]
}apiVersion: v1
kind: ServiceAccount
metadata:
name: my-service-account
namespace: default
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::ACCOUNT_ID:role/my-roleThe :sub condition is what restricts the role to ONE namespace + service-account pair. A wildcarded or mismatched :sub value is the classic "why can every pod in the cluster assume this role" root cause — it's a trust-policy misconfiguration, not an RBAC or network issue.
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": { "Service": "pods.eks.amazonaws.com" },
"Action": ["sts:AssumeRole", "sts:TagSession"]
}]
}aws eks create-pod-identity-association \ --cluster-name CLUSTER \ --namespace NAMESPACE \ --service-account SERVICE_ACCOUNT \ --role-arn arn:aws:iam::ACCOUNT_ID:role/my-role
targetRoleArn (Pod Identity only)roleArn (same-account) and targetRoleArn (different account) in the associationPrincipalIRSA has no native cross-account chaining feature — reaching another account requires the application itself to call AssumeRole a second time against a manually configured cross-account trust. A requirement for "simplest cross-account workload identity" is a strong signal toward Pod Identity over IRSA specifically because of this gap.
Secrets Manager invokes the SAME rotation Lambda four times, passing a different Step parameter each call:
Generate a new secret value; store it as a new version labeled AWSPENDING
Apply the AWSPENDING value to the target service (e.g. change the DB user's password)
Validate the AWSPENDING credential actually works (test login/connection)
Move the AWSCURRENT label to the AWSPENDING version; the old AWSCURRENT becomes AWSPREVIOUS
Because the live credential change (step 2) only affects the PENDING version, and the atomic cutover (step 4) is the only step that changes what "current" means, a failure at any step before finishSecret leaves the currently-active credential untouched — rotation can safely retry without locking anyone out.
Two DB users (clone A / clone B) alternate roles each rotation. Whichever user is NOT currently active gets its password rotated and tested; the currently-active user's credential is never touched mid-rotation. Contrast with single-user rotation, which briefly changes the password on the live user — a rotation failure there can cause a short connectivity gap that alternating-users avoids.
secretsmanager:GetSecretValue, PutSecretValue, UpdateSecretVersionStage, DescribeSecretkms:Decrypt / kms:GenerateDataKey — not needed for the default AWS-managed keyThis symptom points at VPC/security-group misconfiguration far more often than IAM — verify network reachability to the target database before assuming a permissions problem.
Sharing a secret across accounts requires BOTH of the following — missing either one causes a denial that looks identical from the requester's side:
secretsmanager:GetSecretValue."Account B can see the secret exists but GetSecretValue fails" is almost always the KMS key policy layer missing — the secret's resource policy alone is not sufficient when a CMK is involved.
{
"RateBasedStatement": {
"Limit": 2000,
"AggregateKeyType": "IP",
"ScopeDownStatement": {
"ByteMatchStatement": {
"FieldToMatch": { "UriPath": {} },
"PositionalConstraint": "STARTS_WITH",
"SearchString": "/login",
"TextTransformations": [{ "Priority": 0, "Type": "NONE" }]
}
}
}
}/login — so the rate limit doesn't apply site-wide.LabelMatchStatement to act only when an earlier rule already flagged the request, enabling "block only if managed-rule-flagged AND matches custom condition" logic.Rules in a Web ACL evaluate strictly in ascending priority order (0 first). WAF stops at the first TERMINATING action — Block, Allow, CAPTCHA, Challenge. Count is non-terminating — evaluation continues past it.
Placing an Allow rule at a LOWER priority number than a Block rule, for overlapping traffic, means the Allow wins and the Block never triggers — regardless of which rule "seems" more important. This is a recurring scenario pattern: "traffic that should be blocked is getting through" almost always traces to priority ordering, not a broken rule.
WCU capacity is consumed by every rule in the Web ACL continuously — regardless of whether that rule ever actually matches traffic.
A common wrong assumption: that a member-account admin retains override authority. When a Firewall Manager policy is set to mandatory enforcement, it does not — enforcement is centralized at the Organization level by design.
An attachment can propagate its routes into a route table it is NOT associated with. Spoke VPCs associate with a "spoke" route table; a separate "inspection" route table receives propagation from everything, forcing all inter-spoke traffic through a central firewall VPC before it can reach its destination.
VPC A's attachment is associated with Route Table 1. VPC C's routes are propagated only into Route Table 2. Both are attached to the same TGW — but Route Table 1 has no route to VPC C's CIDR, because propagation never happened into the table VPC A actually uses.
Propagate VPC C's attachment into Route Table 1 as well (or add a static route) — attaching to the same TGW is necessary but not sufficient for connectivity.
A participant account assumes that attaching to a shared TGW grants full connectivity by default. It does not — the OWNING account still decides whether that new attachment gets associated/propagated anywhere. Without owner action, the participant's VPC is attached but reaches nothing.
FullAWSAccess SCP stays attached even when you add a custom Deny-only SCP — a Deny always wins regardless of any Allow elsewhere, so no matching Allow statement is needed for a Deny SCP to take effect.{
"Version": "2012-10-17",
"Statement": [{
"Sid": "DenyLeavingOrgExceptBreakGlass",
"Effect": "Deny",
"Action": "organizations:LeaveOrganization",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::ACCOUNT_ID:role/BreakGlassAdmin"
}
}
}]
}The StringNotEquals condition is the mechanism — deny X unless the calling principal matches a specific admin/break-glass role ARN. This exact shape recurs across many unrelated-looking SCP scenario questions.
{
"Effect": "Deny",
"NotAction": [
"iam:*", "organizations:*", "sts:*",
"support:*", "cloudfront:*", "route53:*"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestedRegion": ["us-east-1", "eu-west-1"]
}
}
}NotAction + Deny, combined with aws:RequestedRegion, is the standard region-lockdown shape. Global services (IAM, Organizations, STS, Support, CloudFront, Route 53) must be excluded via NotAction since they don't operate in a single Region — omitting this exclusion list is the most common broken version of this SCP shown in exam scenarios.
aws:PrincipalOrgID in Resource PoliciesUsed inside a resource-based policy (S3 bucket policy, KMS key policy, SNS/SQS policy) to allow access from ANY principal within your own Organization — including accounts created in the future — without listing account IDs individually.
| Condition key | Scope |
|---|---|
aws:PrincipalOrgID | Entire Organization, current and future accounts, single condition |
aws:PrincipalAccount | One specific account only |
| Explicit account ID list | Only the accounts listed — does not auto-include new accounts |
SCPs constrain identity-side actions; Resource Control Policies (RCPs) constrain what a resource's own resource-based policy can grant, regardless of identity permissions. A request must clear EVERY applicable layer — identity policy, SCP, and (for resource-based access) the resource policy and RCP — with any explicit Deny anywhere overriding all Allows.
Recognizing WHICH cross-account mechanism a requirement calls for is a tested skill independent of the underlying service. Five mechanisms cover almost every cross-account scenario on the exam.
Shares actual infrastructure resources for the receiving account to ATTACH TO or USE — not administer. Covers: Transit Gateway, subnets in a shared VPC, License Manager configurations, Route 53 Resolver rules.
The owning account retains full administrative control (route tables, association/propagation, subnet-level NACLs). The participant gets usage rights only.
Grants cross-account access to a SPECIFIC resource without RAM: S3 bucket policies, KMS key policies, Secrets Manager resource policies, SNS/SQS policies, Lambda resource policies.
Both the resource policy AND (if the caller is using an IAM identity, not a service) an identity-side policy in the calling account must allow the action. When a CMK is involved (Secrets Manager, S3 with a customer-managed key), the key policy is a THIRD layer that must independently allow the cross-account principal.
For compute/workload identity crossing an account boundary: classic cross-account IAM roles, Pod Identity's targetRoleArn, or a SAML/OIDC federation flow that issues credentials scoped to a role in a specific account.
The TARGET role's trust policy must explicitly list the SOURCE role/principal ARN. IRSA has no built-in chaining — it requires the application to perform a second, manually configured AssumeRole itself.
SCPs, RCPs, and Firewall Manager policies apply org-wide from a single management-account (or FM-delegated-admin) action — no per-account trust setup needed.
SCPs/RCPs only CONSTRAIN, never grant. Firewall Manager policies, by contrast, actively PUSH and enforce configuration into member accounts — member admins cannot opt out of a mandatory policy. Don't confuse the two: one is a ceiling, the other is a mandatory push.
aws:PrincipalOrgID / aws:PrincipalOrgPathsThe "trust my whole org, not a fixed account list" condition key pattern — usable inside resource policies or SCPs, automatically covering future accounts without manual updates.
| Configuration topic | Cross-account mechanism | Who retains control |
|---|---|---|
| SAML / external IdP → Identity Center | Trust chaining (SAML assertion → specific account's role) | Identity Center admin defines permission sets per account |
| EKS Pod Identity | Trust chaining via targetRoleArn | Target account's role trust policy |
| Secrets Manager | Resource policy + KMS key policy (two-sided) | Secret owner account |
| WAF | Organization-wide push (Firewall Manager) — NOT RAM, NOT a resource policy | FM administrator account — mandatory on members |
| Transit Gateway | RAM (share the attachment point only) | TGW owner keeps route tables, association, propagation |
| SCP / bucket / key policies | Org-wide attachment + aws:PrincipalOrgID | Management account (SCP) / resource owner account (policy) |
(a VPC, a TGW, a Resolver rule) → RAM
(a bucket, a key, a secret, a queue) → Resource-based policy (check for a CMK layer too)
→ IAM role trust policy chaining (AssumeRole)
→ SCP/RCP (ceiling, never grants) or Firewall Manager (mandatory push)
Assuming ONE mechanism grants access when the real requirement needs TWO layers. Cross-account + a customer-managed KMS key is the repeat offender: the resource-side grant (bucket policy, secret policy, DynamoDB stream policy) is necessary but not sufficient — the KMS key policy must independently name the same cross-account principal, or decryption fails even though the resource-level grant looks completely correct.
Requirement → Keywords → Expected Answer → why every distractor fails.
AD Connector as the identity source
| Distractor | Why it's wrong |
|---|---|
| AWS Managed Microsoft AD | Stands up a new directory and requires a trust relationship — more than a single-domain, no-duplication need calls for |
| Migrate users into the built-in directory | Duplicates identity data, breaking the explicit "no duplication" requirement |
EKS Pod Identity with targetRoleArn
| Distractor | Why it's wrong |
|---|---|
| IRSA + manual cross-account AssumeRole in application code | Requires OIDC provider setup AND custom chaining logic — exactly the overhead the requirement rules out |
| Broad node instance role | Grants every pod on the node the same permissions, violating least privilege and providing no cross-account path at all |
Update BOTH the secret's resource policy AND the KMS key policy to grant Account B's principal
| Distractor | Why it's wrong |
|---|---|
| Update only the secret's resource policy | Leaves the KMS decrypt step denied — GetSecretValue will fail even though the secret-level grant looks correct |
| Switch the secret to the AWS-managed key | Removes the org's ability to control the key policy independently, a poor security trade just to sidestep the second layer |
Check rule priority — a lower-numbered Block rule for overlapping traffic is winning first
| Distractor | Why it's wrong |
|---|---|
| The Allow rule's statement syntax must be broken | A correctly-written rule at the wrong priority produces exactly this symptom — syntax isn't the first thing to check |
| WCU budget must be exceeded | Exceeding WCU changes cost, not which rule wins evaluation order |
Check propagation — one VPC's routes likely aren't propagated into the route table the other VPC is associated with
| Distractor | Why it's wrong |
|---|---|
| Assume the TGW attachment itself failed | Both being attached to the same TGW is necessary but not sufficient — association/propagation is the far more common root cause |
| Check security groups first | SGs matter, but the described symptom (total unreachability across a TGW) is a routing question first |
Deny SCP with NotAction excluding global services, Condition on aws:RequestedRegion
| Distractor | Why it's wrong |
|---|---|
| Deny SCP without excluding IAM/Organizations/STS/Support via NotAction | Breaks global services that don't operate in a single Region — the most common broken version of this pattern |
| Apply the restriction via 200 individual IAM policies | Doesn't scale and isn't centrally enforced the way an org-wide SCP is |
aws:PrincipalOrgID condition key in the bucket policy
| Distractor | Why it's wrong |
|---|---|
| List every current account ID explicitly | Doesn't auto-include future accounts, violating the stated requirement |
| aws:PrincipalAccount | Scopes to a single account only, not the whole Organization |
Not possible under mandatory enforcement — only the FM administrator account can change scope
| Distractor | Why it's wrong |
|---|---|
| The member account can disable the policy locally | Contradicts the deliberate design of mandatory FM enforcement — member accounts cannot opt out |
:sub condition key — Pod Identity removes this requirement entirely via agent-based association.targetRoleArn.aws:PrincipalOrgID in resource policies instead of maintaining explicit account-ID allowlists.Ignoring the KMS key policy layer whenever a CMK is involved — the single most repeated cross-account trap across Secrets Manager, S3, and DynamoDB streams scenarios.
Attachment ≠ connectivity (TGW propagation). Membership ≠ enforcement (an SCP must actually be attached to the right OU/account, not just exist somewhere in the Organization).
Only Pod Identity has native targetRoleArn chaining. A scenario emphasizing "simplest cross-account setup" for EKS is a strong signal toward Pod Identity specifically, not just "workload identity" generically.
Only priority number and terminating/non-terminating action type determine outcome — not which rule seems more critical to a human reader.
SCS-C02 scenario style, Easy → Specialty, cross-account emphasis throughout. Select an answer to reveal the explanation.