# Amazon Verified Permissions

Amazon Verified Permissions is a managed service for fine-grained application authorization using policies written in the Cedar policy language.

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/amazon-verified-permissions

> Amazon Verified Permissions evaluates whether an authenticated principal can perform an action on a resource, using application-defined policies, entity data, and request context. It centralizes authorization decisions for applications and APIs, while leaving authentication, application data storage, and enforcement to the application and its supporting services.

Practice exams covering Amazon Verified Permissions: [SAP-C03 AWS Certified Solutions Architect - Professional](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional).

## 8 key features of Amazon Verified Permissions

1. **Cedar policy evaluation**: Express authorization rules using principals, actions, resources, and conditions. Matching forbid policies override permits, and requests without a matching permit are denied.
2. **Managed policy stores**: Store and manage application authorization policies independently of application deployments. Use policy-store boundaries to separate environments, applications, or tenants where appropriate.
3. **Schema-based policy validation**: Define entity types, actions, and context structures in a schema, then enable strict validation to check policy changes against that model. Coordinate schema updates with the application code that constructs requests.
4. **Reusable policy templates**: Create parameterized policy templates and instantiate template-linked policies for particular principals or resources. This is useful for repeated sharing or delegation rules without maintaining separately authored policy text for every relationship.
5. **Role-based and attribute-based authorization**: Use entity relationships to represent roles or groups and attributes to express conditions such as tenant membership or resource ownership. Applications must supply trusted entity data required by the evaluation.
6. **Token-based authorization**: Configure an identity source for Amazon Cognito or a supported OpenID Connect provider and submit supported tokens through token-based authorization APIs. Policies can use the identity information exposed through the configured identity source.
7. **Batch authorization**: Evaluate multiple authorization requests through batch APIs where supported. For example, check which actions a user may perform on a resource before rendering controls, while still enforcing authorization when each action executes.
8. **Decision diagnostics**: Authorization responses include the decision, determining policies, and evaluation errors where applicable. Use this information to troubleshoot unexpected outcomes, without exposing sensitive policy details to end users.

## Where Amazon Verified Permissions is used

1. **Multi-tenant SaaS authorization**: Enforce tenant membership, tenant-specific roles, and resource ownership across application APIs. Model tenant separation explicitly in policies and trusted entity data rather than assuming a shared policy store provides automatic isolation.
2. **Document and project sharing**: Represent permissions such as viewing, editing, or administering a document or project. Use template-linked policies for repeated grants to individual users or groups.
3. **Consistent authorization across microservices**: Have multiple services evaluate access against a common authorization model instead of implementing separate permission rules. Standardize action names, entity identifiers, request context, and failure handling across callers.
4. **Context-sensitive business operations**: Require conditions such as an approved resource state or a trusted user attribute before allowing sensitive operations. Obtain condition values from authoritative application records or validated identity information.
5. **Permission-aware application interfaces**: Check available actions to determine which controls or workflows to display. Treat these checks as interface guidance only and repeat authorization on the server before accessing data or executing changes.

## How Amazon Verified Permissions is priced

- **Authorization request usage**: Usage-based charges apply to authorization requests. Estimate cost from the number of access decisions your applications make, and consult the applicable pricing schedule for rates and how batch requests are counted.
- **Policy management request usage**: Policy management API requests are a separate usage-based pricing dimension. Include policy provisioning, updates, and other billable management operations in cost estimates, especially when managing large numbers of tenant-specific policies.

## Services Amazon Verified Permissions works with

A common architecture combines Amazon Cognito for user authentication, Amazon API Gateway for request routing, and AWS Lambda for authorization and application logic. A Lambda authorizer or backend handler maps the incoming operation to a Cedar action, identifies the protected resource, and calls Verified Permissions. The enforcement component must reject denied requests and define fail-closed behavior for authorization failures.

Resource attributes and membership relationships usually come from an application database such as Amazon DynamoDB. The backend retrieves authoritative records and supplies the relevant entities and context to the authorization request. Token-based requests can obtain principal information from a configured identity source, but resource ownership and tenant boundaries still need explicit modeling. Avoid trusting client-supplied ownership or membership attributes.

Use AWS CloudFormation to provision policy-store infrastructure and coordinate its schema with application deployments. CloudTrail supports auditing management activity, while application logs provide operational context for authorization outcomes. When introducing caching or batch checks, preserve per-resource enforcement and account for changes to policies, entity relationships, and request context.

- **[Amazon Cognito](https://blowstack.com/tools/cloud-services-hub/amazon-cognito)**: Configure a Cognito user pool as an identity source for a policy store and use token-based authorization APIs. For example, a signed-in user can present a supported token while the application asks whether that user may edit a particular document. Supply trusted resource attributes and additional context required by the policy.
- **[AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda)**: Call Verified Permissions from a Lambda function using an AWS SDK and an execution role with the required API permissions. For example, a document-update function can load ownership information, evaluate the edit action, and write the update only after an Allow decision. Handle authorization-service failures explicitly and avoid performing protected side effects before the check.
- **[Amazon API Gateway](https://blowstack.com/tools/cloud-services-hub/amazon-api-gateway)**: Use a Lambda authorizer or backend authorization logic to connect API Gateway requests to Verified Permissions. For example, map a DELETE request to a Cedar action and a resource identifier, then reject the request when authorization is denied. If authorizer caching is enabled, ensure its cache key and lifetime cannot reuse decisions across different protected resources or contexts.
- **[Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb)**: Store application entity attributes and relationships in DynamoDB, then construct the relevant entity data for authorization requests. For example, retrieve a project's tenant, owner, and membership records before checking whether a user can modify it. Verified Permissions does not automatically fetch these records, so the application must manage retrieval and consistency.
- **[AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail)**: Use CloudTrail to audit supported Verified Permissions management API activity. For example, investigate which IAM principal changed a policy store or updated authorization policies. Complement these records with application-level authorization logs that identify the protected operation and outcome without recording tokens or unnecessary personal data.
- **[AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation)**: Use the AWS::VerifiedPermissions::PolicyStore resource to provision policy stores and their schema configuration through infrastructure as code. For example, deploy separate development and production stores with consistent validation settings. Coordinate policy lifecycle management and application configuration with the deployed policy-store identifiers.
- **[Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch)**: Amazon Verified Permissions publishes usage, latency, error, and throttling metrics to CloudWatch. You can use these metrics in dashboards and alarms to monitor authorization performance and detect operational problems.
- **[Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge)**: Amazon Verified Permissions API activity recorded by CloudTrail can be matched by EventBridge rules. For example, a rule can initiate a notification or review workflow when someone changes an authorization policy.
- **[Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc)**: Amazon Verified Permissions supports interface VPC endpoints, allowing applications in a VPC to reach its API privately without an internet gateway or NAT device.
- **[AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam))**: Amazon Verified Permissions uses IAM policies to control who can administer policy stores and submit authorization requests. You can give an application role permission to evaluate requests against a particular policy store while reserving policy changes for administrators.
- **[AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms))**: Amazon Verified Permissions uses AWS KMS with AWS owned keys to encrypt its stored data at rest. Verified Permissions manages this encryption without requiring you to provision or administer the encryption keys.
- **[AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink)**: Amazon Verified Permissions supports private API access through AWS PrivateLink interface endpoints. Applications can submit authorization requests over private connectivity rather than using the service's public endpoint.
- **[AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions)**: Amazon Verified Permissions APIs can be invoked through Step Functions AWS SDK integration tasks. A workflow can request an authorization decision and use a Choice state to continue or reject an operation based on the result.

## Amazon Verified Permissions exam questions

Real practice exam questions on Amazon Verified Permissions, with the correct answer and its explanation.

### Question 1 (SAP-C03)

**Question:**

A company operates a generative AI research assistant that calls document-reading tools on behalf of authenticated employees. The tool backend uses Amazon Verified Permissions to evaluate persistent, document-specific access grants. Employees authenticate through an OpenID Connect identity provider.

The current implementation constructs principal identifiers from employee email addresses and resource identifiers from document paths. A security review finds that email addresses can be reassigned after employees leave, and deleted document paths can be reused for unrelated documents. Employees can also change their email addresses, and documents can be renamed or moved.

The company requires existing grants to survive email changes and document moves, but grants must never transfer automatically to replacement accounts or unrelated documents. Principal and resource identifiers must not expose email addresses or document names in authorization audit records. The company wants to avoid rewriting grants after ordinary profile or location changes.

Which identifier design best meets these requirements?

**Correct answer:** Assign opaque, immutable, never-reused identifiers to each account incarnation and logical document. Map the validated token's issuer and subject to the account identifier, and resolve document locations to the document identifier through trusted application metadata. Reference these identifiers in policies, retaining them across renames and assigning new identifiers to replacement entities.

**Explanation:** This separates authorization identity from mutable attributes and locations. Validated issuer-and-subject mappings establish which account is acting, while stable document identifiers preserve grants across moves. Never reusing identifiers prevents residual policies from granting access to replacement accounts or unrelated documents. Opaque identifiers also avoid embedding sensitive names in authorization audit records.

## Practice Amazon Verified Permissions in a full exam

Questions on Amazon Verified Permissions in each practice exam, with every answer option and an explanation for each:

- [SAP-C03](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional): 3 questions

## What is Amazon Verified Permissions

Amazon Verified Permissions separates authorization policy from application code. An application submits a principal, action, resource, and optional context to the service, which evaluates the request against policies in a specified policy store. The application then uses the returned authorization decision to allow or reject the operation. Verified Permissions does not intercept application traffic or enforce its decisions automatically; enforcement must occur in the API handler, authorizer, or another trusted application component.

Policies use Cedar, a language designed for authorization. Cedar policies can express permissions based on identities, group membership, resource attributes, and contextual conditions. A permit policy grants access when its scope and conditions match. A matching forbid policy overrides matching permit policies, and requests without a matching permit are denied. This supports explicit restrictions alongside role-based and attribute-based access rules.

Use unique, never-reused principal and resource identifiers. Reusing an identifier can unintentionally grant access through policies that still reference its previous owner.

Do not put personally identifying, confidential, or sensitive information in principal or resource identifiers: these identifiers appear in log entries shared in CloudTrail trails.

A policy store contains policies, policy templates, and an optional schema describing the application's entity types, actions, and context structures. Configure strict policy validation to check policies against the schema when they are created or updated. Treat schema changes as application interface changes: coordinate them with policy deployments and the code that constructs authorization requests. Templates provide a reusable policy structure that can be instantiated with particular principals or resources.

The total size of policies referencing the same resource has a default quota of 1 MB. CreatePolicy or UpdatePolicy fails with ServiceQuotaExceededException if the new total exceeds that quota.

A separate, nonadjustable limit of 200,000 bytes applies to the total size of policies referencing the same principal and resource combination.

Verified Permissions is not a general-purpose directory or resource database. For entity-based authorization requests, the application supplies the relevant entity attributes and relationships needed for evaluation. For example, a document service might supply the document's owner and tenant, along with the requesting user's group memberships. Build this information from trusted records rather than accepting authorization attributes directly from an untrusted client. Keep the supplied entity graph limited to the relationships necessary for the decision.

Authentication remains a separate concern. An identity source can connect a policy store to Amazon Cognito or a supported OpenID Connect provider, allowing token-based authorization requests. The application still needs to provide resource information and any additional context required by its policies. Token-based authorization does not remove the need to check tenant boundaries, ownership, or action-specific conditions.

For production workloads, place authorization checks before protected side effects and define fail-closed behavior for service errors, timeouts, and malformed requests. Inspect evaluation errors during testing and observability rather than treating every denied request as a simple policy mismatch. Batch authorization can evaluate multiple related access checks, but applications must handle each decision independently. If caching decisions, explicitly account for policy changes, entity changes, token expiry, and context-sensitive conditions.

Design policy-store boundaries around isolation, administration, and deployment requirements. A shared store can support multiple tenants when policies and trusted attributes enforce separation, while separate stores can provide stronger administrative boundaries. Test both allowed and denied scenarios, including cross-tenant requests, before deploying policy changes.

## Learn Amazon Verified Permissions in lessons

2 short lessons on Amazon Verified Permissions in 1 certification course.

- SAP-C03: Amazon Verified Permissions: trusted application authorization (Premium), https://app.blowstack.com/lessons/amazon-verified-permissions-trusted-application-authorization-sap-c03
- SAP-C03: Amazon Verified Permissions vs Amazon Cognito: authorization and authentication (Premium), https://app.blowstack.com/lessons/amazon-verified-permissions-vs-amazon-cognito-authorization-and-authentication-sap-c03

## Concepts related to Amazon Verified Permissions

- [Confused Deputy Problem](https://blowstack.com/tools/cloud-concepts-hub/confused-deputy-problem): The confused deputy problem occurs when a privileged intermediary is tricked into using its authority on behalf of a caller who is not entitled to the requested access.
- [Cross-Account Access](https://blowstack.com/tools/cloud-concepts-hub/cross-account-access): Cross-account access lets a human, application, or system in one cloud account use explicitly authorized resources or roles in another account.
- [Identity Federation](https://blowstack.com/tools/cloud-concepts-hub/identity-federation): Identity federation allows one security domain to accept identities authenticated by a trusted identity provider instead of maintaining separate credentials for them.
