SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
SAA-C03 · Domain 1

Design Secure Architectures practice questions

Design Secure Architectures is worth 30% of the SAA-C03 exam — the heaviest of the 4 domains. Secure access to AWS resources, secure workloads and applications, and the right data-security controls. 6 fully worked examples are further down this page, answers included.

Exam weight
30%
the heaviest of the 4 domains
Questions
168
across 3 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Design Secure Architectures questions, fully explained

Questions from the SAA-C03 bank mapped to domain 1, with the answer key and the reasoning behind every option. None of them repeat the examples on the main SAA-C03 practice page.

Question 1Design Secure Architectures

A security team attaches a service control policy to the root of its organization that denies all actions in AWS Regions other than eu-west-1 and eu-central-1. One month later, a review finds new EC2 instances running in us-east-1 that administrators launched after the SCP took effect. All of the instances are in a single account. What is the MOST likely explanation?

Choose one.

  • a
    The administrators launched the instances as the account's root user, and SCPs do not restrict the root user of an account.

    SCPs do restrict the root user of member accounts. Signing in as root would not bypass the Region deny in a member account.

  • b
    SCPs attached to the organization root are inherited by OUs but not by accounts placed directly under the organization root.

    An SCP attached to the organization root applies to every member account, whether the account sits in an OU or directly under the root.

  • c
    The administrators used a role whose permissions boundary allows us-east-1, which takes precedence over the SCP for that role.

    A permissions boundary can only narrow permissions further. It cannot override an SCP deny; the effective permissions are the intersection of every layer.

  • d
    The account that runs the instances is the organization's management account, which the Region-deny SCP does not restrict. Correct

    Correct. SCPs have no effect on the management account, including its root user, so the Region deny never applied there. All instances being in one account points to this.

The concept

SCPs apply to member accounts only. The management account is outside their reach, so it is the one account where an organization-wide guardrail does not hold. Inside member accounts, SCPs restrict every principal, including the root user.

Why that’s the answer

Only one account is affected, and the deny was attached at the organization root, so the guardrail failed in exactly one place: the management account, which SCPs never affect. The root-user explanation is the tempting inversion of the rule; SCPs do bind member-account root users. Accounts directly under the root inherit root-level SCPs like any other account. A permissions boundary cannot loosen an SCP because every guardrail layer must permit an action for it to succeed.

How to reason it out
  1. Note the clue: the policy failed in a single account, not across the organization.
  2. Recall the SCP scope: all member accounts, including their root users, but not the management account.
  3. Rule out boundary or root-user bypasses: layers intersect, and member root users are bound.
  4. Conclude the workloads ran in the management account, and keep workloads out of it.

Exam tip: SCPs bind member-account root users but never the management account, so keep workloads out of the management account.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

Question 2Design Secure Architectures

A financial services company stores compliance logs in an S3 bucket in a dedicated audit account within its AWS organization. Regulators require assurance that no principal that runs the company's workloads, including member-account root users, can delete the bucket. A platform team also proposes running a new log-processing workload in the organization's management account. Which combination of actions should a solutions architect take? (Select TWO.)

Choose TWO.

  • a
    Attach an SCP that denies s3:DeleteBucket on the audit bucket to the OUs that contain every member account. Correct

    Correct. An SCP on the OUs is inherited by each member account and restricts every principal there, including the root user, and member-account administrators cannot detach it.

  • b
    Attach an SCP that denies s3:DeleteBucket on the audit bucket to the OU that contains the audit account only.

    This binds principals in the audit account, but principals in other member accounts that a bucket policy lets in would sit outside the guardrail, so the assurance is incomplete.

  • c
    Run the proposed log-processing workload in a member account rather than in the organization's management account. Correct

    Correct. SCPs do not apply to the management account, so a workload there would sit outside the guardrail. Running it in a member account keeps it covered.

  • d
    Attach the same SCP to the organization's management account so the proposed workload there is restricted too.

    An SCP has no effect on the management account, so the workload there would remain unrestricted. Moving the workload to a member account is what closes the gap.

  • e
    Apply a permissions boundary that denies s3:DeleteBucket on the audit bucket to each member account's root user.

    Permissions boundaries attach to IAM users and roles only, not to the root user, and account administrators could remove them.

The concept

Two SCP scope rules combine here: SCPs bind every principal in member accounts, including root users, and SCPs do not affect the management account at all.

Why that’s the answer

The deny SCP on the OUs that contain every member account blocks the deletion for every principal in those accounts, root included, and is inherited by accounts added to those OUs later. Attaching it only to the audit account's OU is the near-twin: it covers the bucket's own account but not principals in other member accounts. The proposed management-account workload is the second risk. Attaching the SCP to the management account looks like a fix but does nothing, because SCPs never apply there, so the workload must run in a member account. Permissions boundaries cannot be attached to the root user, and account administrators could remove them anyway.

How to reason it out
  1. Identify who must be restricted: every workload principal in member accounts, including root users.
  2. Choose the layer that binds root users from above: an SCP on the OUs that contain every member account, not just the bucket's account.
  3. Check the coverage gap: SCPs do not reach the management account.
  4. Close it by running the proposed workload in a member account.

Exam tip: SCPs cover member accounts and their root users; the management account is outside every SCP, so no workloads there.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

Question 3Design Secure Architectures

An application running on Amazon EC2 instances reads and writes objects in an S3 bucket. A security review finds an IAM user's access key and secret key stored in a configuration file on each instance. What is the MOST secure way for the application to access the bucket?

Choose one.

  • a
    Attach an IAM role to the instances through an instance profile and give the role read and write access to the bucket. Correct

    Correct. The role supplies temporary credentials through the instance metadata service and they rotate automatically, so no long-lived keys remain on the instances.

  • b
    Rotate the IAM user's access keys on a 30-day schedule and push the new keys to the configuration file on each instance.

    Rotation shortens the exposure window but the instances still hold long-lived keys in a file that can leak.

  • c
    Store the IAM user's access keys in AWS Secrets Manager and have the application on the instances read them at startup.

    This moves the keys out of the file, but the application still uses long-lived IAM user credentials, and the instances need credentials to call Secrets Manager in the first place.

  • d
    Encrypt the configuration file on each instance with an AWS KMS key so that the access keys for the bucket are protected.

    Encryption protects the file at rest, but the application still decrypts and uses the same long-lived access keys.

The concept

Workloads running on AWS compute should get credentials from an IAM role, not from IAM user access keys. For EC2, the role is attached through an instance profile and the SDK picks up temporary STS credentials from the instance metadata service.

Why that’s the answer

An instance profile role removes the long-lived access keys entirely: the application receives short-lived credentials that AWS rotates for it, and there is nothing to store, copy or rotate. The other three options each manage the keys better (rotate them, vault them, encrypt them) but keep long-lived IAM user credentials in use, which is the actual risk the review found.

How to reason it out
  1. Identify the actor: an application on EC2, which can use a role.
  2. Prefer eliminating long-lived credentials over protecting them.
  3. Attach the role with an instance profile and scope it to the one bucket.
  4. Delete the IAM user's access keys once the application uses the role.

Exam tip: If it runs on AWS compute, give it a role: removing access keys beats rotating, vaulting or encrypting them.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

Question 4Design Secure Architectures

A developer is deploying an AWS Lambda function that must read and write items in a DynamoDB table. The developer proposes creating an IAM user, generating access keys, and storing them in the function's environment variables encrypted with AWS KMS. Which alternative meets the requirement with the LEAST operational overhead?

Choose one.

  • a
    Store the IAM user's access keys in AWS Secrets Manager and retrieve them at function initialization.

    This keeps long-lived keys alive and adds retrieval code, Secrets Manager cost, and a rotation process — all overhead the execution role makes unnecessary.

  • b
    Keep the encrypted environment variables and add a scheduled process that rotates the access keys monthly.

    Rotation machinery is ongoing operational work and redeployment risk, and the credentials remain long-lived between rotations.

  • c
    Delete the IAM user and its access keys, and grant the needed permissions to the function's execution role. Correct

    Lambda already injects temporary credentials for the execution role into every invocation, so the function needs no stored keys, no rotation, and no extra code.

  • d
    Have the function call sts:AssumeRole at startup using the stored access keys to obtain temporary credentials.

    This still depends on stored long-lived keys to bootstrap the assume call and adds an unnecessary hop; the execution role already provides temporary credentials natively.

The concept

Every Lambda function runs with an execution role whose temporary credentials AWS supplies automatically. Granting permissions to that role is the native, zero-maintenance way for function code to access AWS services.

Why that’s the answer

The execution role wins on both security and overhead: the SDK picks up temporary credentials automatically, they rotate without any action, and there is nothing to store, encrypt, retrieve, or leak. Secrets Manager storage secures the wrong thing — the static keys still exist and now carry retrieval code and monthly cost. Scheduled rotation is exactly the recurring operational burden the question asks to avoid, and keys are still exposed between rotations. The assume-role-from-stored-keys option is circular: it uses long-lived credentials to obtain temporary ones, when the platform already hands the function temporary credentials for free.

How to reason it out
  1. Recognize the actor: code running on AWS compute (Lambda), which always has a native role mechanism.
  2. Apply the rule that compute gets roles, never IAM users with access keys.
  3. Attach a least-privilege DynamoDB policy to the function's execution role.
  4. Remove the proposed IAM user and its keys so no static credential path remains.
  5. Compare overhead: the role needs zero ongoing maintenance; every other option adds storage, code, or rotation work.

Exam tip: Lambda code gets its AWS access from the execution role — any design that mints access keys for a function is wrong before you weigh the details.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

Question 5Design Secure Architectures

A Lambda function in account A must read messages from an Amazon SQS queue in account B and, within the same invocation, write the processed results to a DynamoDB table in account A. The security team requires a design with no long-lived credentials and the fewest moving parts. What should a solutions architect recommend?

Choose one.

  • a
    Have the function assume an IAM role in account B for each invocation and do the queue and table work with that role's credentials.

    While the function uses the assumed role's credentials it acts as the account B role and no longer has its own permissions on the DynamoDB table in account A. The write then fails unless the table also gets a resource-based policy for that role or the function juggles two sets of credentials, which is more moving parts.

  • b
    Create an IAM user in account B with SQS permissions and keep its access keys in Secrets Manager for the function to read.

    This keeps long-lived access keys in use, which the security team has ruled out.

  • c
    Deploy a second Lambda function in account B that reads the queue messages and invokes the function in account A for each one.

    This works but adds another function and a cross-account invoke permission, which is more moving parts than the requirement allows.

  • d
    Add a queue policy in account B that lets the function's execution role receive and delete messages from the queue. Correct

    Correct. The resource-based policy grants the account A execution role access to the queue, and the function keeps its own permissions to write to its home-account table.

The concept

Assuming a role swaps your permissions for the role's permissions for that session. A resource-based policy instead lets the caller keep its own identity and permissions while gaining access to one resource in another account.

Why that’s the answer

The queue policy in account B lets the function's existing execution role receive and delete messages, so a single identity reads the queue and writes the DynamoDB table in account A with no stored credentials. Assuming a role in account B is the tempting answer, but the function would then act as the account B role and lose its account A table permissions for that session. The IAM user breaks the no-long-lived-credentials rule, and a relay function in account B works but adds moving parts.

How to reason it out
  1. Check whether the target service supports resource-based policies: SQS does (queue policies).
  2. Notice that the function must also act in its home account during the same invocation.
  3. Recall that assuming a role replaces the caller's permissions for that session.
  4. Grant the execution role access through the queue policy and keep the table permissions on the role.

Exam tip: Need one remote resource while keeping your own permissions? Use the resource's policy, not an assumed role.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

Question 6Design Secure Architectures

An external audit firm uses its own AWS account. Each quarter, its auditors need read-only access to review configurations across EC2, S3, RDS, and IAM in a company's production account. The company wants each access to be individually auditable and wants to be able to revoke the firm's access immediately. Which design meets these requirements MOST securely?

Choose one.

  • a
    Create an IAM user for each auditor in the production account with a read-only policy and MFA enabled.

    This works, but it creates long-lived credentials for outsiders in the production account, and revoking the firm means finding and disabling every user.

  • b
    Attach resource-based policies that grant the audit firm's account read access on each resource the auditors review.

    Many of the services in scope, such as EC2, RDS and IAM, do not support resource-based policies for these read actions, and per-resource policies are hard to revoke at once.

  • c
    Create a read-only IAM role in the production account with a trust policy that names the audit firm's account. Correct

    Correct. Auditors assume the role with AWS STS and get temporary credentials; each AssumeRole call is logged in CloudTrail with the caller's identity, and editing one trust policy stops any new assumption.

  • d
    Create a read-only IAM role in the audit firm's account with a trust policy that names the company's production account.

    This reverses the trust. A role grants access to resources in the account where it lives, so a role in the audit firm's account cannot read the company's production resources.

The concept

Cross-account access for people from another AWS account is granted with a role in the account that owns the resources. Its trust policy names the other account, and the other account allows its own principals to call sts:AssumeRole.

Why that’s the answer

A read-only role in the production account trusted by the firm's account gives auditors temporary credentials and records every assumption in CloudTrail. Editing or deleting its trust policy stops new assumptions at once, and the role's revoke-active-sessions action invalidates any sessions already issued. Per-auditor IAM users would work but add long-lived outsider credentials and make revocation a cleanup task. Resource-based policies do not cover EC2, RDS or IAM reads. A role in the auditor's account is the near-twin with the trust reversed: a role can only act on its own account's resources.

How to reason it out
  1. Identify the actor: people who already have identities in another AWS account.
  2. Put the role in the account that owns the resources (production).
  3. Name the auditor account in the role's trust policy and attach a read-only policy.
  4. Revoke by editing the trust policy (and revoking active sessions); audit with CloudTrail AssumeRole events.

Exam tip: The role lives where the resources are; its trust policy names who may assume it.

Designing Secure Access: IAM Best Practices, Roles, and AWS Organizations — the lesson that teaches this.

What SAA-C03 domain 1 tests, topic by topic

The official exam guide breaks Design Secure Architectures into 3 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published SAA-C03 practice questions per topic in Design Secure Architectures
TopicWhat it coversQuestions
Design secure access to AWS resourcesExam guide task 1.1. Multi-account access control with AWS Organizations, Control Tower, and SCPs; federated and role-based access (IAM, IAM Identity Center, STS, role switching, cross-account roles); least privilege, root-user hardening and MFA, resource policies, directory federation, and the shared responsibility model.56
Design secure workloads and applicationsExam guide task 1.2. VPC security architecture: security groups, network ACLs, route tables, NAT gateways, and public/private subnet segmentation; application-security services (Cognito, GuardDuty, Macie, Shield, WAF, Secrets Manager); securing external connections (VPN, Direct Connect); external threat vectors (DDoS, SQL injection); service endpoints and credential security.56
Determine appropriate data security controlsExam guide task 1.3. Encryption at rest with AWS KMS and in transit with ACM/TLS; key access policies, key rotation, and certificate renewal; data access and governance, classification, retention, and recovery; backups, replication, and data lifecycle/protection policies that meet compliance requirements.56
Total168

Revise Design Secure Architectures before you drill it

Other SAA-C03 domains

Design Secure Architectures: your questions

Design Secure Architectures is domain 1 of the SAA-C03 exam guide and carries 30% of the scored content — the heaviest of the 4 domains. On a 65-question paper that works out to roughly 20 questions, though AWS does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official SAA-C03 exam guide.