Skip to content

AWS Cloud Interview Questions: Multi-Account Identity and Access Governance

Prepare for AWS interviews with 14 questions on multi-account access, IAM policy evaluation, organization guardrails, audit trails, and operational design.

Ekanatha Reddy Urivakili16 min3,357 words

How to use this guide

These questions focus on a useful, often under-practised AWS sub-area: governing identity and access across multiple AWS accounts. That includes IAM policy evaluation, AWS Organizations, cross-account roles, workload identity, and auditability.

For each question, distinguish what grants access from what limits it, and explain how you would verify the result. Strong answers describe not only the AWS feature, but also its operational boundary: which account owns it, how it is changed, and how a mistaken change is detected.

The examples use AWS CLI and Python with Boto3. Replace placeholder values with your own account IDs and role ARNs, and scope permissions to the resources your workload actually needs.

Fundamentals

1. Why use multiple AWS accounts instead of separating environments with VPCs?

What the interviewer is really testing: Whether you understand account boundaries as governance and security boundaries, not just as a way to organize resources.

Model answer:

Separate accounts provide independent IAM administration, quotas, billing visibility, and many service-level controls. They reduce the impact of a compromised workload or an accidental change, and let teams apply different policies to production, development, security, and shared infrastructure.

VPCs are useful network boundaries, but they do not isolate account-level permissions, billing, or control-plane operations. Multiple accounts add operational overhead, so they need consistent provisioning, identity management, logging, and policy management to remain useful rather than becoming separate snowflakes.

A common pattern is an AWS Organization with accounts grouped by purpose, such as production, non-production, security, and shared services. The right account layout depends on regulatory boundaries, team ownership, and the need to contain risk.

Follow-up: When might separate accounts per application be worth the overhead?
Hint: Consider independent ownership, compliance boundaries, and blast radius.

2. What is the difference between an IAM identity policy and a resource-based policy?

What the interviewer is really testing: Whether you can reason about both sides of an AWS authorization decision.

Model answer:

An identity-based policy is attached to an IAM user, group, or role and states what that identity may do. A resource-based policy is attached to a resource, such as an S3 bucket or KMS key, and states which principals may access it.

For cross-account access, both sides commonly need configuration: the target resource or role must trust the caller’s account or principal, and the caller must have permission to make the relevant request. The exact evaluation depends on the principal type and service; do not reduce it to “both policies always need an Allow.”

Explicit Deny overrides Allow. Permissions boundaries, session policies, and organization policies can further restrict effective permissions. When access fails, inspect the principal, action, resource, conditions, and every applicable policy layer.

Follow-up: Can a bucket policy grant an external account access without that account changing its identity policy?
Hint: Distinguish a same-account principal from a cross-account principal.

3. What does a Service Control Policy (SCP) do—and what does it not do?

What the interviewer is really testing: Whether you know the difference between an organization-level limit and an access grant.

Model answer:

An SCP sets the maximum permissions available to principals in accounts governed by AWS Organizations policies. It can, for example, prevent member accounts from leaving the organization or restrict use of certain services in a particular organizational unit.

An SCP does not grant permissions. A role still needs an applicable identity-based or resource-based Allow. Effective access is constrained by all applicable policy layers, including SCPs.

SCPs apply to member accounts, including their root users, but do not restrict principals in the organization’s management account. Service-linked roles also have special treatment and are not restricted by SCPs. A good answer calls out these boundaries rather than suggesting SCPs are a universal deny-all mechanism.

Follow-up: How would you prevent member accounts from disabling a required security service?
Hint: Explain the guardrail and how you would test its effect before broad rollout.

4. How do trust policies and permissions policies work together with AssumeRole?

What the interviewer is really testing: Whether you can separate permission to enter a role from permission to act as that role.

Model answer:

A role’s trust policy controls which principals may assume it. The role’s permissions policies define what an assumed session can do. The caller also needs permission to call sts:AssumeRole, unless the applicable resource-based setup grants access in a way that changes the evaluation.

Once the role is assumed, the resulting temporary credentials identify the role session. The role session is limited by the role’s permissions and any applicable session policy or organization restriction. Trust conditions such as an expected external ID can be important for third-party access; an external ID is not a general-purpose replacement for good trust-policy design.

Use short-lived role credentials rather than distributing long-lived access keys. Give the session a meaningful name so it can be traced in audit records.

Minimal runnable example — set ROLE_ARN first; this requires AWS CLI credentials allowed to assume that role and jq installed.

: "${ROLE_ARN:?Set ROLE_ARN to the target role ARN}"

aws sts assume-role \
  --role-arn "$ROLE_ARN" \
  --role-session-name interview-check \
  --duration-seconds 900 |
  jq -r '.Credentials | [.AccessKeyId, .SecretAccessKey, .SessionToken] | @tsv'

Notice that AssumeRole returns temporary credentials; the caller still needs a valid trust and permission path.

Follow-up: Why might a third-party integration need an external ID?
Hint: Think about the confused deputy problem.

Intermediate

5. How would you use IAM Identity Center for workforce access across accounts?

What the interviewer is really testing: Whether you can describe centralized workforce access without distributing IAM users and keys to employees.

Model answer:

IAM Identity Center can connect workforce identities to AWS accounts through permission sets. Administrators assign users or groups to accounts and permission sets; AWS provisions the corresponding roles in those accounts. Workforce users use the portal or configured CLI authentication flow to obtain temporary credentials.

This makes access assignment and removal more consistent than managing separate IAM users in every account. Permission sets should reflect job responsibilities and be kept narrow. Identity lifecycle, group membership, MFA, emergency access, and permission-set changes still need defined owners and review.

Do not confuse workforce access with workload identity. Applications running on AWS should normally use an appropriate role or service identity rather than a human’s Identity Center session.

Follow-up: How would you handle a contractor who needs access to only one production account for a limited period?
Hint: Cover group assignment, scope, expiration, and review.

6. How is a permissions boundary different from an SCP?

What the interviewer is really testing: Whether you can place guardrails at the right level.

Model answer:

A permissions boundary is attached to an IAM user or role and limits the maximum permissions that identity-based policies can grant to that identity. It is useful when delegating role creation: a platform team can let an application team manage a role while constraining the maximum permissions the role can receive.

An SCP applies at the organization or account level and limits permissions for principals in the affected member accounts. It is suited to organization-wide or account-group guardrails.

Neither grants access. Each operates at a different scope, and both can intersect with the identity policies, resource policies, and session policies relevant to a request. Prefer the narrowest control that matches the requirement, then test the combined policy evaluation.

ControlApplied toPrimary purposeGrants access?
Identity policyUser, group, or roleDefine actions an identity may performYes, when applicable
Resource policyResourceDefine principals allowed to access a resourceYes, when applicable
Permissions boundaryUser or roleCap permissions an identity policy can grantNo
SCPOrganization, OU, or accountCap permissions available in member accountsNo
Session policyAssumed role sessionFurther restrict that sessionNo

Follow-up: What would you use to constrain roles that an application team is allowed to create?
Hint: Explain how the control applies to each role and how you prevent bypasses.

7. What does a session policy do when assuming a role?

What the interviewer is really testing: Whether you understand that temporary credentials can be narrower than the role itself.

Model answer:

A session policy is supplied as part of an STS role assumption request. It can restrict the permissions available to the resulting session, but it cannot add permissions beyond those allowed by the role and other applicable controls.

This can be useful when a trusted caller needs temporary access to only a subset of a role’s capabilities—for example, to a specific prefix in a bucket. It does not replace good role design: the role should still have a sensible maximum permission set, and the caller should not be able to choose a session policy that widens access.

Session policies are not the same thing as a permissions boundary. A boundary applies to an IAM identity; a session policy constrains a particular session.

Follow-up: Can a session policy grant an action that the role policy does not allow?
Hint: Treat it as an additional limit, not an additional grant.

8. How would you audit role assumptions and API activity across an organization?

What the interviewer is really testing: Whether you know the difference between an audit trail and application-level telemetry.

Model answer:

Use an organization-level CloudTrail trail, owned by a security or logging account, to centralize account activity records. Protect the destination with narrowly scoped bucket policies, encryption, and controls that prevent workload accounts from modifying the audit store. Define retention and access procedures as part of the design.

Management events record control-plane activity. Data events, such as selected S3 object-level activity, need to be configured for the relevant resources and can increase cost. Decide which data events matter rather than assuming they are included by default.

CloudTrail answers “which AWS API call happened, by whom, and when?” Application logs and traces answer different questions, such as why a request was slow. Use both when investigating an incident.

Follow-up: What would you add if you need to identify unexpected access to sensitive S3 objects?
Hint: Name the event category and how you would select resources to monitor.

9. How should an application running on AWS obtain credentials?

What the interviewer is really testing: Whether you can distinguish workload identity from manually managed secrets.

Model answer:

Use the identity mechanism provided by the runtime: for example, an instance profile for EC2, a task role for ECS, or an execution role and function role as appropriate for Lambda. The AWS SDK credential provider chain can retrieve and refresh temporary credentials without application code storing static keys.

Grant the workload only the actions and resources it needs. Keep deployment permissions separate from runtime permissions. If a workload needs cross-account access, have its source role assume a narrowly scoped target role rather than distributing a target-account access key.

For external systems, use an appropriate federation or secret-management design; do not assume that every service can use the same identity mechanism.

Follow-up: How would you investigate an application that works locally but receives AccessDenied in ECS?
Hint: Check the runtime role, task configuration, target resource policy, and the exact denied action.

Senior and system-design level

10. Design a multi-account AWS foundation for several product teams.

What the interviewer is really testing: Whether you can turn account governance into a workable platform rather than a policy document.

Model answer:

Start with clear ownership boundaries: a management account for organization administration, dedicated accounts for security and centralized logs, and workload accounts separated by environment or team needs. Use AWS Organizations organizational units to apply policy consistently, but keep exceptions explicit and reviewable.

Provide a repeatable account-provisioning path. It should establish baseline identity, logging, network expectations, tags, and security controls. Centralize workforce access through IAM Identity Center, and use roles for automation and workloads. Separate deployment authority from runtime authority.

Roll out guardrails in stages: test in a non-production account, measure the impact, and communicate the change. Avoid a large collection of undocumented SCP exceptions; they become a shadow access-control system.

Follow-up: How would you handle a product team that needs a service blocked by a baseline SCP?
Hint: Describe an exception process with scope, owner, duration, and review.

11. How would you design cross-account access for a central deployment pipeline?

What the interviewer is really testing: Whether you can limit trust and permissions across a role chain.

Model answer:

Keep the pipeline’s source identity in a tooling account and create a target deployment role in each workload account. The target role trusts the intended source principal and grants only the deployment actions and resource scope required for that environment.

Use explicit trust conditions where appropriate, separate production from non-production roles, and give sessions useful names. The pipeline should obtain temporary credentials through STS, not persist target-account secrets. The target account should still enforce organization guardrails, and the deployment process should not be able to change those guardrails.

Test both the successful path and the negative cases: an untrusted principal, an unapproved action, and a production role requested by a non-production pipeline.

flowchart LR
  Engineer["Engineer authenticates"] --> Tooling["Tooling account pipeline"]
  Tooling --> Assume["Assume deployment role"]
  Assume --> Dev["Development account"]
  Assume --> Prod["Production account"]
  Org["Organization guardrails"] --> Dev
  Org --> Prod
  Audit["Central audit account"] --> Tooling
  Audit --> Dev
  Audit --> Prod

Separate deployment identities from workload identities, and centralize the evidence needed to review their actions.

Follow-up: How would you prevent a compromised development pipeline from deploying to production?
Hint: Address trust, role separation, and the production approval path.

12. How would you design emergency, or “break-glass,” access?

What the interviewer is really testing: Whether you can balance emergency availability with strong accountability.

Model answer:

First define the emergencies that justify this path and the actions it permits. Prefer an emergency role with temporary credentials, tightly controlled authentication, and a documented approval or escalation process. Limit who can activate it and keep its permissions distinct from everyday administrator access.

Ensure the path remains usable during the incident it is meant to address. That means testing authentication and dependencies, and avoiding a design that depends on a single person or a failed production component. Record activation and activity centrally, notify the right responders, and review every use.

“Break glass” is not a reason to leave permanent, unmonitored administrator credentials lying around. Test the process regularly and verify that the audit trail reaches an account the affected workload team cannot alter.

Follow-up: What would you do if the normal identity provider were unavailable?
Hint: Describe an independently recoverable authentication path and how its use is audited.

13. How would you roll out a new SCP without disrupting production?

What the interviewer is really testing: Whether you treat policy rollout as a change-management and verification problem.

Model answer:

Translate the desired guardrail into a narrow, testable policy. Review it against representative workloads, including deployment, incident response, and security automation. Remember that an explicit Deny can block access that teams currently rely on.

Start in a test account or low-risk organizational unit. Observe failures using policy simulation where applicable, account telemetry, and workload tests. Expand gradually, communicate the effect, and define a rollback path. Track exceptions with an owner, rationale, and review date.

Do not rely on simulation alone: it may not cover every service-specific behavior or real-world resource policy. Validate the actual workflow in a representative account before making the policy broadly effective.

Follow-up: What signals would make you stop or roll back the rollout?
Hint: Include failed critical operations and unexpected denied API calls.

14. How would you investigate a cross-account AccessDenied that affects only one workload?

What the interviewer is really testing: Whether you debug authorization systematically instead of adding broad permissions.

Model answer:

Capture the exact principal, action, resource ARN, region, request time, and error details. Confirm which credentials the workload is actually using and identify the account that owns the target resource.

Then inspect the permission path in layers:

  1. Does the caller have permission to assume the target role?
  2. Does the role trust policy allow the caller and satisfy its conditions?
  3. Does the role allow the requested action on the target resource?
  4. Do resource policies, boundaries, session policies, or SCPs restrict it?
  5. Are there conditions involving tags, encryption context, source identity, or network context?

Compare the failing workload with a known-good one, but do not copy its broad policy as a fix. Reproduce the request with the same role, resource, and conditions; then add only the missing permission or correct the applicable constraint.

Realistic runnable example — set TARGET_ROLE_ARN and configure a source profile authorized to assume it. The role needs permission for s3:ListAllMyBuckets for this demonstration; use your workload’s least-privilege action instead.

import os
import boto3

role_arn = os.environ["TARGET_ROLE_ARN"]
source = boto3.Session(profile_name=os.getenv("AWS_PROFILE", "default"))
sts = source.client("sts")

response = sts.assume_role(
    RoleArn=role_arn,
    RoleSessionName="access-diagnostic",
    DurationSeconds=900,
)

credentials = response["Credentials"]
target = boto3.Session(
    aws_access_key_id=credentials["AccessKeyId"],
    aws_secret_access_key=credentials["SecretAccessKey"],
    aws_session_token=credentials["SessionToken"],
)

print(target.client("sts").get_caller_identity())

Notice that the diagnostic prints the assumed identity, helping verify which role the request actually uses.

Follow-up: What would you check if the role assumption succeeds but the S3 request fails?
Hint: Move from the STS trust path to the role’s effective permission on the target resource.

Common mistakes candidates make

  • Saying an SCP grants access. It limits permissions; it does not provide an Allow.
  • Treating “cross-account” as one policy edit. Check the caller, trust relationship, target permissions, and applicable restrictions.
  • Assuming every CloudTrail event type is captured automatically. Data events require deliberate configuration.
  • Recommending long-lived access keys for people or workloads when temporary credentials are available.
  • Solving AccessDenied by attaching AdministratorAccess before identifying the denied action and policy layer.
  • Describing break-glass access without explaining recovery, auditing, or regular testing.
  • Ignoring who can change the controls. A guardrail is weaker if the workload team can silently remove it.
  • Confusing centralized login with authorization. Authentication identifies the user; policies and assignments determine what that identity can do.

Observability for identity and governance

Treat AWS audit events and application telemetry as complementary. Use CloudTrail for AWS API activity, including role assumptions and policy changes. Send relevant events to a centrally controlled destination, and monitor delivery and retention. Do not assume that application traces replace an audit trail.

For an application or access broker that calls AWS APIs, emit structured logs with a request or trace identifier. Avoid logging credentials, session tokens, or sensitive payloads.

{
  "timestamp": "2026-11-01T10:15:00Z",
  "level": "INFO",
  "event": "aws_role_assumption",
  "source_account": "111122223333",
  "target_role": "arn:aws:iam::444455556666:role/ReadOnlyWorkload",
  "session_name": "reporting-job-42",
  "request_id": "8b9b1d2a",
  "result": "success"
}

For a role-assumption service, use RED metrics: request rate, error rate, and duration. For its runtime and dependencies, use USE metrics: utilization, saturation, and errors. Keep AWS API audit events as the authoritative record of AWS actions; instrument your application to understand the request path around those actions.

The following Python example configures OpenTelemetry tracing and Botocore instrumentation. Install the OpenTelemetry SDK, OTLP exporter, and Botocore instrumentation packages, and configure the OTLP endpoint for your collector.

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.botocore import BotocoreInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

provider = TracerProvider(
    resource=Resource.create({"service.name": "access-broker"})
)
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(provider)
BotocoreInstrumentor().instrument()

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("assume-workload-role"):
    import boto3
    boto3.client("sts").get_caller_identity()

Avoid putting credentials or sensitive resource data in span attributes. Propagate trace context through application boundaries, but do not mistake trace sampling for complete security auditing.

SLIExample SLO
Successful authorized requestsAt least 99.9% of valid requests succeed over a rolling 30-day window
Role-assumption latency99% complete within the service’s agreed latency budget
Audit delivery freshnessNew audit records are available centrally within the agreed operational window

These are example targets, not AWS guarantees. Set budgets based on workload requirements and observed behavior.

Page on sustained increases in failed role assumptions, unexpected policy or organization changes, loss of audit delivery, or a material increase in access-service errors. Alert on resource saturation when it threatens the service, but avoid paging on every isolated denied request; many are expected and should be handled through dashboards or security detections.

Quick-revision checklist

  • Explain account boundaries and why VPCs are not a substitute.
  • Distinguish identity policies, resource policies, boundaries, session policies, and SCPs.
  • State clearly that SCPs constrain access but do not grant it.
  • Describe both the trust policy and permission path for AssumeRole.
  • Prefer temporary credentials and workload identities over static keys.
  • Explain how IAM Identity Center supports workforce access across accounts.
  • Know what CloudTrail records and when data events need configuration.
  • Debug AccessDenied by checking the principal, action, resource, conditions, and applicable policy layers.
  • Include rollout, rollback, auditability, and ownership in governance designs.
  • Keep break-glass access limited, recoverable, tested, and reviewable.

Official documentation


This article was generated with AI. #AIGenerated