# AWS Certified Solutions Architect - Professional (SAP-C03) Free Practice Exam and Practice Test

SAP-C03 · PROFESSIONAL. Page: https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional

> Prepare for the AWS Certified Solutions Architect - Professional (SAP-C03) exam with realistic practice questions on architecture, security, cost, resilience and automation, with detailed explanations.

Exam version SAP-C03: current, release Nov 17, 2026. All exam dates: https://blowstack.com/tools/cloud-certifications/aws

## Exam at a glance

- Question bank: 767 practice questions
- Questions updated: 2026-11-15
- Free SAP-C03 practice exam (20 questions weighted by domain, in the exam simulator on this page, no sign-up): https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional
- SAP-C03 exam simulator (full-length or custom exams with explanations and a pass probability indicator): https://app.blowstack.com/practice-exams/configurator/aws-certified-solutions-architect-professional
- Questions: 75
- Duration: 180 min
- Passing score: 72%
- Domains: 5
- Interactive SAP-C03 course (594 lessons built around exercises, no videos): https://blowstack.com/courses/aws-certified-solutions-architect-professional
- Official SAP-C03 exam guide (the AWS document listing every domain, task and service in scope): https://docs.aws.amazon.com/aws-certification/latest/solutions-architect-professional-03/solutions-architect-professional-03.html

## SAP-C03 example questions

One example question per domain from the SAP-C03 question bank, with the correct answer and its explanation.

### Architecture Design and Implementation Built for the Cloud

**Question:**

A financial information provider uses an Amazon API Gateway WebSocket API to deliver live market updates. Clients subscribe to specific instruments, and an existing authorization component verifies each subscription. Updates arrive independently of client messages. A client connection can remain open across many backend invocations.

During market openings, update volume increases sharply. The provider must buffer delivery work, retry transient delivery failures, and prevent disconnected clients from causing repeated delivery attempts. Clients can tolerate duplicate updates. The architecture must use AWS Lambda for delivery processing without keeping functions running while clients are idle.

Which solution best meets these requirements?

**Correct answer:** Store authorized instrument subscriptions and connection IDs in DynamoDB. Expand updates into per-connection delivery jobs in an SQS queue. Use a Lambda event source mapping with bounded concurrency to send each job through the API Gateway Management API. Report transiently failed jobs as partial batch failures. For GoneException responses, remove the stale connection and its subscriptions and acknowledge the job.

**Explanation:** API Gateway maintains the connections independently of Lambda invocations. DynamoDB provides shared subscription state, and per-connection SQS jobs buffer delivery work. Lambda sends unsolicited updates by calling PostToConnection through the Management API. Bounded concurrency protects downstream capacity, partial batch responses allow transient failures to be retried, and GoneException identifies connections that should be removed rather than retried.

### Security, Compliance, and Governance

**Question:**

A healthcare company is replacing ECDSA signatures on short-lived treatment authorization decisions. A central service signs each decision by using AWS KMS, and downstream services verify the signature before acting. The new signatures must provide at least NIST security category 3 protection against quantum attacks. Signing private keys must remain in AWS KMS.

The downstream services already support the required post-quantum verification algorithms. However, an integration gateway imposes two fixed transport options: a Base64-encoded signature in a response header with a maximum value length of 4,096 ASCII bytes, or an unencoded signature in a binary response-body field with a maximum length of 4,096 bytes. These limits apply to the signature alone. Compression, fragmentation, and external signature retrieval are not permitted.

Which implementation meets all the requirements?

**Correct answer:** Create an AWS KMS ML-DSA-65 signing key and return each signature as unencoded bytes in the binary response-body field.

**Explanation:** ML-DSA-65 provides NIST security category 3 protection and produces 3,309-byte signatures. An unencoded signature fits within the 4,096-byte binary field. AWS KMS performs signing without exporting the private key.

### Cost-Optimized Architecture Design

**Question:**

A company provides interactive image enhancement through a single public hostname. It has identical application stacks in three AWS Regions. Each stack includes an internet-facing Application Load Balancer (ALB), application servers, and an Amazon SageMaker AI real-time inference endpoint. Each stack has sufficient capacity to serve the entire workload, and requests require no shared session state or remote datasets.

Currently, the hostname resolves to a central proxy fleet in one Region. The proxies forward requests to the regional stacks and relay the responses. Large request and response payloads generate substantial inter-Region data transfer charges.

Testing shows that clients in the same country can experience different network performance to the regional stacks. The best-performing Region for a client network can also change over time, and the geographically closest Region is not always fastest. Model processing times and operating costs are equivalent across the stacks.

The company wants clients to connect directly to a responsive, healthy regional stack while eliminating routine inter-Region payload forwarding. It must retain the existing hostname and minimize routing administration. DNS caching and DNS-based failover convergence are acceptable.

Which solution best meets these requirements?

**Correct answer:** Create Route 53 latency alias records for the hostname, associating each regional ALB with its AWS Region. Configure target-health evaluation and have each stack invoke its local SageMaker AI endpoint and return results directly to clients.

**Explanation:** Route 53 uses its Region-associated latency measurements to select an eligible endpoint for the querying client network or resolver. Target-health evaluation helps exclude unhealthy ALBs. Clients then connect directly to the selected stack, which performs inference locally, eliminating the central proxy's routine inter-Region payload transfers. DNS selection is not a fresh measurement of every request or of model processing time.

### Resilience, Migration, and Business Continuity

**Question:**

A financial services company is preparing to migrate 600 on-premises servers to two AWS Regions. The company has used AWS discovery and migration-tracking services since 2024. AWS Application Discovery Service agents have collected six weeks of process, utilization, and network-connection data, including a month-end financial close. The application inventory is outdated, and several applications communicate with a shared settlement database that must remain on premises for another year. Some application components cannot tolerate additional network latency between them. The migration team must establish application boundaries, plan migration waves that preserve business operations, and centrally track migrations performed by multiple tools. Which approach best meets these requirements?

**Correct answer:** Use AWS Migration Hub network visualization to examine the discovered connections, and validate critical relationships and latency constraints with application owners. Group servers into applications, use the validated dependencies to keep tightly coupled components in the same migration wave, and assess connectivity to the retained database before scheduling each wave. Track migrations to both destination Regions from one Migration Hub home Region.

**Explanation:** Migration Hub brings discovered server information, application grouping, and migration tracking together. Network observations provide evidence for dependency assessment, but application-owner validation is needed to establish business criticality and latency constraints. These validated relationships inform application boundaries and migration waves, including whether workloads dependent on the retained database are ready to move. The Migration Hub home Region stores discovery and tracking information; it does not require every workload to migrate to that Region.

### Operational Excellence and Automation

**Question:**

A company is standardizing AWS CloudFormation templates for new Amazon RDS for PostgreSQL DB instances across its application accounts. Each database must have a unique, automatically generated master password that rotates every 7 days. The selected RDS configuration supports service-managed master credentials.

Security policy prohibits the deployment pipeline and the CloudFormation execution role from retrieving plaintext passwords. Passwords must not be supplied as stack parameters or resolved into resource properties by CloudFormation. Applications already support retrieving database credentials at runtime from a secret ARN. The templates must expose this ARN to the application configuration.

Which solution meets these requirements with the LEAST operational overhead?

**Correct answer:** Set ManageMasterUserPassword to true on the AWS::RDS::DBInstance resource and omit MasterUserPassword. Use Fn::GetAtt with MasterUserSecret.SecretArn to supply the RDS-managed secret ARN to applications. Use the default RDS-managed rotation schedule.

**Explanation:** RDS generates and manages the master password in Secrets Manager and rotates it every 7 days by default. CloudFormation does not need to retrieve or resolve the plaintext password. The MasterUserSecret.SecretArn attribute provides the nonsecret identifier that applications can use for authorized runtime retrieval, without custom password-generation or rotation automation.

## Exam domains

The SAP-C03 questions are grouped into 5 domains divided into 21 tasks.

### Architecture Design and Implementation Built for the Cloud (25% of the exam)

- Design architectures built for the cloud
- Integrate AI and ML services into architectures
- Design hybrid cloud integration patterns
- Design network architectures
- Design data, storage, and database architectures

### Security, Compliance, and Governance (25% of the exam)

- Design identity security architectures
- Design solutions to implement encryption and key management strategies
- Design multi-account governance and compliance solutions
- Design architectures to meet compliance requirements
- Design security and responsible AI controls

### Cost-Optimized Architecture Design (15% of the exam)

- Design architectures based on AWS pricing models
- Optimize data transfer and network costs
- Design cost allocation and visibility solutions
- Optimize storage and database costs

### Resilience, Migration, and Business Continuity (15% of the exam)

- Design migration strategies by using AWS frameworks
- Design disaster recovery architectures
- Design solutions to meet business continuity and resiliency requirements

### Operational Excellence and Automation (20% of the exam)

- Design infrastructure as code
- Design CI/CD and DevSecOps pipelines
- Design observability and monitoring solutions
- Design operational automation and resilient systems

## Exam mode and practice mode

| | Exam mode | Practice mode |
|---|---|---|
| Questions count | 75 | 1 - 75 |
| Time limit | 180 minutes | Optional, 10 - 300 minutes |
| Exam scope | 5 domains with the official questions ratio | Selected domains with the official questions ratio |
| Correct answers | After exam submission | After exam submission or after each answer |
| Question types | Single answer and multiple answer | Single answer, multiple answer or all types |
| Question hints | Never | Optional |
| Question domain | Revealed after exam submission | Revealed after submission or during the exam |
| Scoring | 15 of 75 questions do not count towards the result | Official AWS method or mathematical mean |

See all simulator features on the AWS Exam Simulator page: https://blowstack.com/practice-exams

## Technologies and concepts

- **7 Rs of Migration**: The framework classifies workloads as rehost, relocate, replatform, repurchase, refactor or re-architect, retain, or retire. It helps engineers choose an approach that balances business value, migration effort, operational risk, and long-term architecture goals rather than assuming every application should move unchanged.
- **Access Control**: Access control turns security requirements into enforceable permissions for people, applications, and cloud services. It limits unauthorized activity while preserving legitimate operations, including the ability to deliver logs, run health checks, and investigate incidents.
- **ACID Transactions**: ACID properties help applications update shared data correctly despite concurrent requests, processing errors, and infrastructure failures. They apply to relational databases, some NoSQL operations, and transactional lakehouse tables, but their scope and isolation guarantees depend on the implementation.
- **Active-Active Architecture**: Active-active architecture combines availability and scalability by keeping two or more environments actively serving production requests rather than reserving one solely for recovery. Across cloud Regions, it can reduce user latency and support regional disaster recovery, but it requires deliberate traffic management, data consistency, and capacity planning.
- **Adapter Pattern**: An adapter isolates differences in request formats, authentication, responses, and errors behind a consistent contract. In generative AI architectures, adapters let applications use different foundation models while configuration controls which supported model or provider handles a request.
- **AI Guardrails**: Guardrails help AI applications produce appropriate responses, protect sensitive information, and avoid unauthorized actions. They combine prompt engineering with independently enforced checks, permissions, and operational monitoring because model instructions alone cannot reliably enforce every requirement.
- **Anomaly Detection**: Anomaly detection compares observed activity with an established baseline, statistical model, or expected pattern to identify unusual behavior. In cloud security, it helps engineers detect potentially compromised identities, unexpected network activity, and abnormal resource usage that fixed rules alone might miss. An anomaly is evidence for investigation, not proof of an attack.
- **Asymmetric Routing**: Routing decisions are made independently in each direction, so a connection does not necessarily return through the devices that handled its outbound packets. This can be harmless in ordinary IP forwarding but can disrupt stateful firewalls, network address translation, and security inspection that depend on seeing both directions of a flow.
- **Asynchronous Inference**: Request submission and result delivery are separate operations, usually connected through a queue, background workers, and durable result storage. This pattern supports long-running predictions and uneven workloads when applications can tolerate delayed results, but it requires explicit handling of job status, failures, and capacity.
- **At-Least-Once Delivery**: At-least-once delivery uses retries, acknowledgments, and durable buffering to favor delivery reliability over duplicate avoidance. It is common in real-time log ingestion, where consumers must tolerate repeated records without inflating metrics, duplicating alerts, or corrupting downstream state.
- **Attribute-Based Access Control**: ABAC expresses access rules using attributes such as project, department, environment, or data classification instead of maintaining separate permissions for every identity and resource. In cloud environments, trusted identity attributes and resource tags can make permissions scale with changing teams and infrastructure, provided attribute assignment and modification are tightly controlled.
- **Audit Logging**: Audit logging creates an evidence trail showing who or what performed an action, when it occurred, which resource was affected, and what the outcome was. In cloud environments, effective auditing requires selecting complementary log sources and protecting their delivery, retention, and accessibility across accounts, Regions, and workloads.
- **AWS shared responsibility model**: AWS and its customers have distinct responsibilities for protecting systems, data, and operations, with the boundary changing according to the services used. Understanding that boundary helps engineers implement appropriate controls and collect the right evidence instead of assuming that AWS compliance certifications automatically make a workload compliant.
- **Backup Isolation**: Backup isolation creates independent security and failure boundaries around backup data, retention settings, administrative identities, and encryption keys. It matters because ransomware, stolen credentials, accidental deletion, and infrastructure failures can otherwise affect both live data and the copies needed to recover it.
- **Batching**: Batching spreads fixed overhead across multiple items instead of handling every item independently. It can reduce request costs and improve ingestion throughput, but introduces buffering delays and requires careful handling of failures, retries, and resource limits.
- **Blast Radius**: Blast radius describes both the potential reach of an incident and the impact actually observed during investigation. Cloud architectures reduce it through isolation, restricted permissions, and controlled dependencies, while incident responders use evidence to determine which boundaries an event has crossed.
- **Blue-Green Deployment**: Two independently deployable environments allow engineers to validate a replacement release while the existing release continues serving users. Switching traffic rather than modifying the live environment reduces deployment disruption and can enable fast rollback, provided data and dependencies remain compatible.
- **Border Gateway Protocol**: Border Gateway Protocol (BGP) lets networks advertise IP prefixes, select paths, and withdraw routes when connectivity changes. In cloud environments, it supports dynamic routing across private circuits, VPNs, and routing appliances, making it central to troubleshooting hybrid connectivity and failover.
- **Bulkhead Pattern**: Bulkheads contain failures by assigning workloads, tenants, or dependencies separate, bounded resources such as worker pools, connection pools, queues, or compute capacity. They preserve useful service during partial failures and make automated recovery safer by limiting how much capacity or how many components an incident can affect.
- **Cache Invalidation**: Caches reduce latency, backend load, and cost, but cached copies can become outdated when source data, application logic, or access permissions change. Invalidation defines when those copies must expire, be removed, or be replaced so that performance improvements do not violate freshness, correctness, or security requirements.
- **Cache-Aside**: Also called lazy loading, cache-aside stores data in the cache only when an application requests it. It can reduce read latency and database load, but the application must manage cache population, expiration, invalidation, and failure handling.
- **Caching**: A cache serves repeated requests without always accessing the original data source or recomputing a result. In cloud architectures, caching can reduce latency, origin load, and data transfer, but it requires deliberate decisions about freshness, capacity, security, and failure behavior.
- **Canary Deployment**: A canary deployment runs the current and candidate versions concurrently, exposing only a limited share of real requests or users to the candidate. Engineers use production metrics and explicit acceptance criteria to decide whether to promote the candidate or redirect traffic to the stable version, reducing the impact of faulty releases.
- **Capacity Planning**: Capacity planning translates expected traffic, data growth, and processing requirements into measurable resource needs. In the cloud, it combines forecasting, benchmarking, scaling policies, service quota management, and failure testing because elastic infrastructure is neither unlimited nor instantaneous.
- **Chain of Trust**: Trust is established by validating each link back to a trusted starting point rather than accepting an isolated signature or assertion. In DNSSEC, this connects signed DNS answers through parent-zone delegations to a resolver's trust anchor, helping detect forged or modified DNS responses.
- **Change Data Capture**: Change Data Capture (CDC) lets systems process incremental changes instead of repeatedly copying an entire dataset. It supports low-downtime migrations, continuously updated analytics, and current search or vector indexes, while requiring careful handling of ordering, retries, deletions, and recovery.
- **Chaos Engineering**: Chaos engineering uses explicit hypotheses, realistic faults, and measurable outcomes to uncover weaknesses before an unplanned incident exposes them. In cloud environments, it validates both technical resilience and incident response procedures, including detection, escalation, containment, recovery, and communication.
- **Chargeback**: Chargeback turns cloud consumption into an internal financial responsibility using documented ownership, allocation rules, and pricing policies. Unlike showback, which reports attributed costs without transferring budget responsibility, chargeback creates an internal accounting charge. Reliable implementation requires traceable usage data, agreed treatment of shared expenses, and reconciliation with provider billing.
- **Checkpointing**: A checkpoint records enough information to recover a task without restarting all of its work, such as source positions, intermediate calculations, or an agent's workflow state. It reduces recovery time and repeated computation, but reliable recovery also depends on retained inputs, compatible state, and safe handling of repeated side effects.
- **CI/CD**: Continuous integration validates frequently merged code changes through automated builds and tests, while continuous delivery or continuous deployment automates the path toward production. Together, these practices shorten feedback cycles, make releases more repeatable, and reduce the risks associated with large, manually executed changes.
- **Circuit Breaker**: A circuit breaker tracks dependency failures and stops sending requests when a configured threshold is exceeded, preventing repeated failures from exhausting caller resources. It supports fast failure, graceful degradation, and controlled recovery, making it useful for foundation model invocations, agent tools, and other remote services.
- **Classless Inter-Domain Routing (CIDR)**: CIDR defines how many leading bits identify an IP network and how many remain for addresses within that network. Engineers use it to size subnets, conserve address space, summarize routes, and prevent overlapping networks from disrupting cloud and hybrid connectivity.
- **Code Refactoring**: Refactoring makes applications easier to understand, test, maintain, and extend while preserving their existing contracts. In cloud and generative AI applications, it helps engineers separate model integration from business logic, consolidate repeated code, and improve development workflows with automated tests and AI-assisted tooling.
- **Commitment Discounts**: Cloud providers offer lower rates when customers commit to eligible resource usage or spending, commonly for one or three years. These discounts can reduce the cost of predictable workloads, but unused commitments can offset or eliminate the savings.
- **Concurrency**: Concurrent tasks can execute simultaneously or take turns using shared resources while other tasks wait for input, output, or dependencies. In cloud applications, understanding concurrency helps engineers size capacity, improve throughput, protect downstream systems, and diagnose throttling or resource contention.
- **Conditional DNS Forwarding**: Conditional DNS forwarding connects separate DNS namespaces without copying their records into every environment. In hybrid and multicloud networks, it lets cloud workloads resolve corporate names and on-premises clients resolve private cloud names through explicitly configured DNS paths.
- **Conditional Forwarding**: A DNS resolver matches a query name against configured domain suffixes and forwards matching queries to specified upstream servers. This allows cloud and on-premises environments to resolve each other’s private namespaces without publishing private records or copying entire DNS zones.
- **Configuration Drift**: Configuration drift occurs when running infrastructure, operating systems, or applications no longer match their intended configuration, often because of manual changes, competing automation, or incomplete deployments. Detecting and managing drift helps engineers preserve security controls, reproduce environments, and investigate unexpected changes before they cause incidents.
- **Confused Deputy Problem**: A service or application can authenticate a request correctly yet misuse its own permissions because it fails to verify whose authority the request should exercise. Cloud defenses bind delegated access to the intended customer, source resource, and operation rather than trusting the intermediary’s identity alone.
- **Container Orchestration**: An orchestrator continually reconciles running workloads with a declared desired state, such as the required number of application replicas and their resource requirements. It helps engineers operate containerized applications reliably, but selecting a hosting platform also requires decisions about infrastructure ownership, application compatibility, security, and cost.
- **Containers**: Containers provide a repeatable way to build, distribute, and run software across development and cloud environments. They improve deployment consistency and resource utilization, but require explicit controls for image security, runtime isolation, networking, identity, and persistent data.
- **Content-Based Routing**: Instead of distributing requests solely by availability or load, content-based routing selects a destination suited to each request’s characteristics. In generative AI applications, it can match tasks to specialized foundation models while balancing quality, latency, cost, and security constraints.
- **Cost Allocation**: Cost allocation turns a cloud bill into an accountable view of who consumed resources and which business activities incurred costs. Engineers apply account boundaries, resource metadata, and allocation rules to support budgeting, showback, chargeback, and informed architecture decisions.
- **CPU Architecture**: CPU architecture affects software compatibility, execution performance, and the cost of running workloads in the cloud. Choosing compute resources requires matching the processor architecture, instance family, and instance size to application requirements rather than comparing virtual CPU counts alone.
- **Credential Rotation**: Passwords, access keys, tokens, and application secrets can be exposed through compromised systems, accidental disclosure, or excessive distribution. Rotation limits how long a persistent credential remains usable, but it must coordinate changes across the identity system, secret storage, and consuming applications to avoid outages.
- **Cross-Account Access**: Cloud accounts create administrative and security boundaries, but shared services, deployment pipelines, and operational teams often need controlled access across them. Cross-account access establishes that authorization without requiring shared credentials or moving resources into the same account.
- **Crypto Agility**: Crypto agility makes cryptographic change a planned operational capability rather than an emergency application rewrite. It matters when vulnerabilities, policy changes, expiring trust relationships, or post-quantum requirements make existing cryptography unsuitable.
- **Data Egress**: Data egress describes outgoing traffic relative to a specified source; the same transfer is ingress at its destination. Cloud providers often charge for outgoing transfers based on volume, destination, and network path, making data movement an important part of architecture and cost planning.
- **Data Locality**: In cloud architectures, locality can mean using the same Region, Availability Zone, or processing environment, depending on the workload. It matters because network boundaries affect performance and billing, while replication and geographic distribution introduce trade-offs involving resilience, consistency, and data residency.
- **Data Masking**: Data masking reduces unnecessary exposure of confidential information in logs, messages, query results, and nonproduction datasets. It complements encryption and access control by limiting which sensitive values users and downstream systems can actually see.
- **Data Mesh**: Data Mesh distributes responsibility for analytical data to the teams that understand its business meaning, rather than making a central data team responsible for every dataset. It combines domain ownership, data as a product, self-service infrastructure, and federated computational governance to support scalable, controlled data sharing.
- **Data Replication**: Replication helps systems preserve data and continue operating when hardware, servers, or entire locations fail. Its effectiveness depends on where replicas are placed, how changes are acknowledged and synchronized, and whether applications can switch to a usable replica.
- **Data Residency**: Data residency connects the physical location of data to legal, contractual, and organizational requirements. Cloud architectures must account for primary databases, replicas, backups, logs, and downstream systems because choosing a deployment Region alone does not establish compliance.
- **Data Retention**: Retention policies balance business needs, recovery requirements, legal obligations, privacy, and storage cost. In the cloud, engineers implement them through lifecycle rules, backup schedules, retention periods, deletion controls, and exceptions such as legal holds.
- **Data Sovereignty**: In cloud architecture, data sovereignty influences where data can be stored and processed, who can access it, and whether it can cross jurisdictional boundaries. Engineers translate these obligations into Region selection, access controls, replication policies, and operational procedures rather than assuming that a particular hosting location guarantees compliance.
- **Declarative Programming**: Instead of prescribing each operation in order, engineers define resources, relationships, constraints, or interface states that a tool interprets. This approach supports repeatable infrastructure provisioning, reusable application components, API contracts, and visual AI workflows, but still requires testing, security controls, and lifecycle management.
- **Deep Packet Inspection**: Deep Packet Inspection (DPI) uses protocol parsing, traffic reassembly, signatures, and other analysis techniques to understand what network traffic contains and how it behaves. In cloud architectures, it supports threat detection, intrusion prevention, application-aware filtering, and investigation, but its effectiveness depends on traffic visibility, encryption handling, and correct network routing.
- **Defense in Depth**: Defense in Depth combines preventive, detective, and response controls across network boundaries, identities, applications, hosts, and data. It reduces dependence on any single safeguard and limits the impact of successful attacks, configuration mistakes, and compromised credentials.
- **Dependency Mapping**: A dependency map connects workload components to the systems and services they consume, showing relationship direction, criticality, and operational constraints. During cloud migration, it helps engineers assess application readiness, evaluate the portfolio, and sequence migration waves without breaking required connections or business processes.
- **Deployment Rollback**: Rollback limits the impact of a faulty release by returning workloads to a known-good deployment state. It depends on preserved artifacts, compatible dependencies and data, reliable failure signals, and a tested recovery procedure rather than simply undoing a source-code change.
- **Digital Signatures**: A digital signature allows a recipient to detect changes to signed data and verify that the signature was produced by the holder of a particular private key. In cloud environments, signatures help validate software releases, stored files, and audit records, provided that verifiers trust the signing key and enforce verification.
- **Distributed Tracing**: A distributed trace connects individual operations across services into a single view of a request's execution. It helps engineers troubleshoot cloud applications whose behavior cannot be understood from one server's logs or metrics alone.
- **Document Chunking**: In retrieval-augmented generation (RAG), document chunking determines which passages are embedded, searched, and supplied to a language model as supporting evidence. Effective chunking balances retrieval precision, contextual completeness, model token limits, and operational cost while preserving metadata needed for filtering and citations.
- **Dual-Stack Networking**: Dual-stack networking supports IPv6 adoption while preserving connectivity for IPv4 clients, applications, and dependencies. It enables incremental migration, but requires engineers to design, secure, test, and monitor two distinct protocol paths rather than treating IPv6 as an automatic extension of IPv4.
- **Edge Computing**: Edge computing distributes selected application tasks to devices, local gateways, nearby infrastructure, or provider-operated edge locations. It can reduce response latency, network traffic, and centralized processing costs, but introduces distributed infrastructure, security, and operational trade-offs.
- **Effective Permissions**: Assigned permissions do not necessarily equal usable access: authorization combines grants with organizational controls, resource policies, session restrictions, and request context. Understanding the resulting permissions helps engineers design least-privilege access and diagnose why an apparently allowed operation fails.
- **Elasticity**: Elasticity aligns available capacity with actual demand, adding resources during busy periods and releasing them when demand falls. In the cloud, automated provisioning and usage-based pricing can reduce idle capacity and avoid purchasing infrastructure for occasional peaks, while helping applications maintain performance.
- **Encryption**: Encryption helps prevent unauthorized parties from understanding data stored in cloud systems or transmitted over networks. Its effectiveness depends on protecting cryptographic keys, controlling decryption permissions, and applying encryption wherever sensitive data travels or persists.
- **Encryption at Rest**: Encryption at rest protects data stored in objects, disks, databases, snapshots, and backups from disclosure when the underlying storage is accessed without the required keys. In cloud environments, it combines storage encryption with key management and access controls, but it does not replace authorization, backups, or encryption in transit.
- **End-to-End Testing**: End-to-end testing checks whether an application achieves the intended user outcome when its components work together under realistic conditions. For foundation model applications, it evaluates the combined behavior of prompts, retrieval, models, tools, safeguards, and workflows rather than relying on model benchmarks alone.
- **Envelope Encryption**: Envelope encryption separates bulk data encryption from the protection and management of encryption keys. It combines efficient local encryption with centralized key controls, allowing cloud systems to protect large datasets without sending every byte through a key management service.
- **Error Budgets**: An error budget translates a reliability target into an allowance for failed requests, excessive latency, or unavailable time. Teams use that allowance to balance delivery speed against operational risk, prioritize resilience work, and protect customer-facing service-level commitments.
- **Event Streaming**: Producers append events to a stream, while consumers read and process those events independently, often within seconds or less. This decouples event generation from downstream processing and supports incident detection, operational analytics, and automated responses without requiring producers to know every consumer.
- **Eventual Consistency**: A successful write does not necessarily become visible immediately through every replica or read path. This model supports asynchronous replication and scalable reads, but engineers must account for stale results, replication lag, and possible data loss when failing over to an asynchronous replica.
- **Evidence Integrity**: Reliable incident response depends on logs and other artifacts remaining authentic, traceable, and protected throughout collection, storage, transfer, and analysis. Evidence integrity combines tamper detection, preservation controls, and documented handling so engineers can reconstruct events and support defensible conclusions.
- **Explicit Deny Precedence**: In a deny-overrides authorization model, a request fails whenever an applicable policy explicitly denies it, even if another policy allows it. This enables enforceable security guardrails, but troubleshooting requires identifying the denying statement and its evaluation context rather than simply adding permissions.
- **Exponential Backoff**: Exponential backoff gives an overloaded or temporarily unavailable dependency time to recover instead of receiving immediate repeated requests. In cloud systems, it is typically combined with randomized delays, retry limits, and safe request semantics to handle throttling and transient failures without amplifying an outage.
- **Externalized Configuration**: Applications obtain settings from deployment inputs, environment variables, configuration files, or configuration services instead of hard-coding them into business logic. This enables artifact reuse across environments and independent configuration changes, but requires validation, access control, and explicit rules for when applications load updated values.
- **Extract, Transform, Load**: ETL turns data from databases, files, APIs, and document repositories into consistent, usable datasets. In the cloud, it supports analytics, operational integration, and generative AI retrieval pipelines by separating source access, transformation logic, and destination loading.
- **Failover**: Failover uses redundant resources, health detection, and a mechanism for transferring work to reduce interruptions when components fail. In cloud architectures, distributing those resources across multiple Availability Zones helps maintain availability when an instance or an entire zone becomes unavailable.
- **Fan-Out**: Fan-out lets a producer trigger several independent activities without performing each activity itself. It supports parallel processing and independently scalable consumers, but requires deliberate handling of delivery failures, duplicate messages, ordering, and downstream capacity.
- **Fault Isolation**: Cloud systems use fault isolation to limit the scope of infrastructure failures, software defects, and resource exhaustion. Separating components into independent failure domains reduces correlated outages, but applications also need healthy alternatives and recovery mechanisms to remain available.
- **Fault Tolerance**: Fault-tolerant systems use redundancy, failure isolation, and automated handling of faults to keep component failures from becoming service failures. In the cloud, this capability also determines which workloads can safely use interruptible compute capacity and which need a more predictable capacity strategy.
- **Geographic Routing**: Geographic routing maps locations such as countries, continents, or geographic areas to selected destinations, commonly through DNS responses. It helps engineers deliver localized applications and control regional traffic distribution, but its accuracy depends on how location is inferred and it does not independently enforce data residency.
- **Health Checks**: Health checks turn observations about infrastructure and applications into signals for traffic routing, deployment decisions, and automated recovery. Their value depends on testing the right behavior and connecting failures to appropriate actions without causing unnecessary restarts or cascading outages.
- **Heterogeneous Migration**: Heterogeneous migration changes the database technology as well as moving the data, such as migrating from Oracle Database to PostgreSQL. It can support licensing changes, modernization, and adoption of managed cloud databases, but requires assessment of schema compatibility, application changes, and operational risk.
- **High availability**: High availability reduces service interruptions by combining redundant components, isolated failure domains, health monitoring, and recovery mechanisms. In the cloud, it commonly involves distributing workloads across multiple Availability Zones so that a failure in one location does not stop the entire application.
- **Homogeneous Migration**: A homogeneous migration changes where a database runs without changing its underlying engine family. It generally reduces schema conversion and application rewrite work compared with moving between different engines, but still requires compatibility checks, data validation, and a controlled cutover.
- **Horizontal Scaling**: Instead of making one machine larger, horizontal scaling distributes work across multiple resources. It helps applications handle changing demand and can improve resilience, while requiring suitable workload distribution and state management. When automated to match demand, it provides elasticity.
- **Hub-and-Spoke Topology**: The hub provides a common routing point for otherwise separate networks, reducing the number of connections needed compared with a full mesh. In cloud architectures, this simplifies connectivity across accounts, regions, and on-premises environments, but introduces cost, resilience, and performance trade-offs around the shared transit layer.
- **Human-in-the-Loop**: Human-in-the-Loop combines AI’s ability to process information at scale with people’s ability to interpret context, resolve ambiguity, and exercise judgment. It supports assisted decision-making and responsible automation by giving people meaningful opportunities to correct outputs, challenge decisions, and improve system behavior.
- **Human-in-the-Loop Evaluation**: Human-in-the-loop evaluation combines structured human judgment with repeatable testing to measure how well foundation models meet application requirements. It complements automated metrics by assessing qualities such as usefulness, factual correctness, safety, and appropriateness that a single numerical benchmark may not adequately capture.
- **Idempotency**: Idempotency makes retries safe when requests time out, events arrive more than once, or automation restarts after a failure. In incident response, it prevents repeated remediation attempts from creating duplicate resources, reversing containment, or causing additional disruption.
- **Identity Federation**: Federation separates where an identity is authenticated from where that identity accesses resources, using established trust and verifiable identity assertions or tokens. It enables centralized sign-in for employees, customers, and workloads while letting each application or cloud account retain control over authorization.
- **Immutable Backups**: Backup immutability preserves recovery points even when production systems or administrative credentials are compromised. It helps defend against ransomware and accidental deletion, but must be combined with isolated administration, protected encryption keys, and tested recovery procedures.
- **Immutable Infrastructure**: Changes to operating systems, application dependencies, and security configuration are built into tested machine or container images and deployed as replacements. This reduces configuration drift and makes recovery more repeatable, provided that persistent data, secrets, and incident evidence are managed separately.
- **Imperative Programming**: Imperative programming specifies how an operation should happen through commands, conditionals, loops, and state changes. In cloud engineering, it underpins application code, operational scripts, and infrastructure automation, giving engineers direct control while requiring deliberate handling of retries, dependencies, and partial failures.
- **Incremental Transfer**: Incremental transfer reduces recurring data movement by identifying differences between a source and a previously transferred state. It can shorten synchronization windows, reduce bandwidth consumption, and keep cloud destinations current, but it requires reliable change detection, progress tracking, and recovery handling.
- **Inference Latency**: Inference latency determines how quickly an AI-powered application responds and whether it meets user expectations or processing deadlines. For generative AI, input length, generated output length, model choice, and available serving capacity affect latency, while token-based pricing links much of that work to inference cost.
- **IOPS**: IOPS describes storage operation rate, not the amount of data transferred or the latency of each request. Engineers use it alongside throughput, latency, and workload characteristics to choose storage configurations that meet application performance requirements without unnecessary cost.
- **IPv6**: IPv6 provides a much larger address space than IPv4 and enables cloud workloads to communicate over IPv6-only or dual-stack networks. Engineers must coordinate addressing, routing, security, and DNS, especially the AAAA records that publish IPv6 addresses and the PTR records used for reverse lookups.
- **JSON Web Tokens**: A JSON Web Token (JWT) carries claims about a subject, its issuer, and its validity, allowing an API to evaluate a request without retrieving a server-side session for every call. Secure use requires verifying the token and enforcing authorization rules; merely decoding its contents does not establish trust.
- **Key Custody**: Key custody separates possession of cryptographic material from permission to administer or use a key. It matters because key generation, storage, backup, revocation, and recovery choices determine both the confidentiality and the availability of encrypted data.
- **Key Rotation**: Key rotation limits how long a cryptographic key is used to protect new data and supports security policies, compliance requirements, and incident response. A safe rotation process directs new operations to fresh key material, retains older material when necessary for decryption or verification, and retires it only after its dependencies are resolved.
- **Latency-Based Routing**: Latency-based routing selects among multiple application endpoints using measured or estimated network latency rather than geographic distance or fixed traffic percentages. It helps distributed applications reduce connection and response times, but its effectiveness depends on measurement quality, endpoint health, DNS behavior, and the application's data architecture.
- **Least privilege**: Least privilege reduces the damage that compromised credentials, software defects, and operational mistakes can cause. In cloud environments, it applies to identity permissions, workload roles, administrative access, network connectivity, and organizational guardrails, and requires ongoing review as requirements change.
- **Log Normalization**: Applications, operating systems, network devices, and cloud services describe events using different field names, formats, and meanings. Log normalization reconciles those differences so centralized detection rules and incident-response queries can operate across sources without repeatedly implementing source-specific logic.
- **Log Retention**: Log retention determines how long operational, security, and audit records remain available for monitoring, investigation, and compliance. An effective policy balances required history and retrieval speed against storage cost, privacy obligations, and protection from unauthorized alteration or deletion.
- **Loose Coupling**: Loosely coupled components communicate through explicit contracts rather than depending on each other's internal implementation, deployment, or execution timing. This supports independent scaling and fault isolation, but requires deliberate handling of message delivery, data consistency, interface evolution, and operational visibility.
- **Message Ordering**: Message ordering ensures that related events are delivered or processed in the sequence required by an application. It matters when later actions depend on earlier ones, such as applying account transactions, updating inventory, or reconstructing device state from a stream.
- **Metric Cardinality**: A metric such as request latency becomes many separate time series when it is partitioned by service, environment, endpoint, or instance. Controlling cardinality preserves useful diagnostic detail while limiting ingestion volume, storage costs, query work, and operational complexity.
- **Microservices and component delivery**: Microservices divide an application into services organized around business capabilities, while component delivery provides the processes and automation needed to release those services safely. This approach supports independent team ownership and targeted scaling, but introduces distributed-system complexity and requires disciplined interface design, observability, and deployment practices.
- **ML-DSA**: ML-DSA lets a private-key holder sign data so that anyone with the corresponding trusted public key can verify its origin and detect modification. Standardized in NIST FIPS 204, it provides a post-quantum alternative to RSA and elliptic-curve signatures for software distribution, signed records, and other authenticity-sensitive cloud workflows.
- **ML-KEM**: ML-KEM, standardized in NIST FIPS 203, uses module-lattice cryptography to establish secrets that are designed to resist attacks from both classical and quantum computers. In cloud architectures, it helps protect key establishment against harvest-now, decrypt-later attacks, commonly through hybrid TLS that combines ML-KEM with a classical key exchange.
- **Model Context Protocol**: MCP provides a common interface between an AI application's integration layer and external systems, reducing the need for custom connectors for every application–tool combination. In agentic applications, it helps agents discover available capabilities and access relevant information or request actions, while leaving reasoning, orchestration, and authorization enforcement to the surrounding system.
- **Model Drift**: A model learns patterns from historical data, but those patterns may no longer represent the environment in which it operates. Monitoring for drift helps teams identify changing conditions, investigate performance problems, and decide whether to fix data pipelines, adjust the model, or retrain it.
- **Model Evaluation**: Model evaluation uses representative data, defined metrics, and human judgment to determine whether a model meets technical and business requirements. It supports model selection and release decisions throughout the foundation model lifecycle, helping engineers balance output quality, safety, latency, cost, and environmental impact.
- **Model Inference**: Inference puts a model's learned patterns to work, such as estimating delivery times, identifying suspicious transactions, or generating a customer-support response. It is distinct from training and requires engineering decisions about response time, cost, capacity, output quality, and data protection.
- **Multi-Agent Orchestration**: Multiple specialized agents can collaborate on work that requires different responsibilities, data sources, or decision steps. Orchestration defines how tasks are assigned, how agents communicate, and how the application controls state, failures, permissions, and completion.
- **Mutual TLS**: Ordinary HTTPS typically authenticates only the server, whereas mutual TLS also requires the client to prove its identity using a certificate and its corresponding private key. This helps cloud workloads reject untrusted peers, but it requires certificate lifecycle management and separate authorization policies.
- **NAT64**: NAT64 provides a compatibility path when workloads adopt IPv6 before all their dependencies support it. Commonly paired with DNS64, it lets IPv6-only applications reach IPv4 services without assigning IPv4 addresses to every client, while retaining IPv4 connectivity at the translation boundary.
- **Network Address Translation**: Network Address Translation allows workloads to communicate using addresses different from those assigned to their network interfaces. Cloud architectures commonly use it to give private workloads outbound IPv4 connectivity, conserve public addresses, or connect networks that require address remapping.
- **Network Peering**: Peering provides direct network-to-network connectivity without combining the networks into a single administrative domain. In cloud architectures, it commonly enables private communication between virtual networks, but its routing limitations, address requirements, and traffic charges influence whether direct peering or a transit topology is the better design.
- **Network Segmentation**: Network segmentation separates workloads by trust level, function, environment, or data sensitivity, then permits only the traffic required between them. It reduces exposure and limits lateral movement after a compromise, but effective segmentation requires enforced traffic controls rather than merely separate address ranges.
- **Noisy Neighbor**: The noisy neighbor problem occurs when competing workloads share constrained resources such as CPU, memory, storage throughput, database connections, or service quotas. It matters in both provider infrastructure and application-level multi-tenancy because one tenant’s burst, expensive query, or background job can disrupt others unless resource consumption is controlled.
- **OAuth 2.0**: OAuth 2.0 separates the application requesting access, the server issuing tokens, and the API enforcing permissions. In cloud applications, it enables scoped API access for users and workloads, but bearer tokens must be protected because possession is generally sufficient to use them.
- **OLTP Versus OLAP**: Online transaction processing (OLTP) supports application operations such as placing orders and updating account balances, while online analytical processing (OLAP) supports reporting, aggregation, and historical analysis. Matching the database engine, storage format, and capacity model to the workload reduces cost and prevents analytical queries from disrupting transactional performance.
- **OpenID Connect**: OpenID Connect (OIDC) standardizes authentication and identity claims so applications can rely on a shared identity provider instead of managing separate credentials. In cloud environments, it supports application sign-in and identity federation, including exchanges of trusted workload tokens for temporary cloud credentials.
- **Output Validation**: Generative AI responses must be treated as untrusted data, even when they come from a trusted model endpoint. Output validation helps prevent unsafe content, sensitive-data disclosure, injection attacks, and unauthorized actions by checking responses at the boundaries where applications consume them.
- **Parameterization**: Parameterization lets the same infrastructure code provision different environments without editing its underlying resource definitions. For cloud networking, it reduces the deployment failures, configuration inconsistencies, and security mistakes caused by hardcoded CIDR blocks, resource identifiers, account numbers, and Region-specific settings.
- **Partition Pruning**: Partitioned datasets divide data into groups using keys such as date, region, or tenant, and query engines use those boundaries to avoid reading irrelevant groups. Effective pruning depends on suitable partition design, usable query predicates, and accurate partition metadata, making catalog synchronization important for both performance and complete query results.
- **Patch Management**: Patch management keeps operating systems, applications, and dependencies updated through repeatable policies and deployment workflows. In cloud environments, responsibility depends on the service model: providers patch infrastructure they operate, while customers patch the software layers they control. Effective patching combines automation with risk-based prioritization, availability safeguards, and continuous validation.
- **Path Diversity**: Multiple connections provide meaningful resilience only when they avoid shared failure points such as routers, fiber conduits, carrier facilities, and cloud access locations. In hybrid cloud networks, path diversity combines independent connectivity with routing policies that move traffic onto surviving paths when a failure occurs.
- **Pay-as-You-Go Pricing**: Cloud providers meter resources such as compute runtime, stored data, and requests, then charge according to the applicable rates. This helps organizations replace large upfront infrastructure investments with variable operating expenses, while making resource management and cost monitoring essential.
- **Phased Rollout**: A phased rollout starts with a limited deployment that delivers measurable value, then expands through defined stages toward broader adoption. For enterprise AI, it connects short-term wins to repeatable technical, operational, and organizational capabilities while limiting the impact of failures.
- **Pilot Light**: A pilot light environment maintains the minimum foundation required to rebuild a production workload after a disaster, typically including continuously replicated data and predefined infrastructure. It balances ongoing cost against recovery speed, usually recovering faster than backup and restore but requiring more activation work than warm standby.
- **Policy as Code**: Policy as Code turns written requirements into executable checks against infrastructure definitions, deployment plans, requests, or running resources. It helps teams apply consistent controls across accounts and environments, detect violations early, and retain reviewable evidence of policy changes and evaluation results.
- **Policy Inheritance**: Cloud platforms use policy inheritance to apply common governance requirements across organizational hierarchies without configuring every account, project, or resource separately. The effective result depends on the policy type: some policies impose permission ceilings, while others merge configuration settings or allow controlled overrides.
- **Price-Performance Ratio**: In cloud systems, price-performance comparisons relate spending to outcomes such as successful requests, processing throughput, or model responses that meet quality and latency requirements. For generative AI applications, this means selecting models and inference patterns by their cost per acceptable result rather than by token price or model capability alone.
- **Prompt Injection**: Language models process instructions and reference material together, creating opportunities for attackers to disguise malicious commands as ordinary content. In cloud applications, successful injection can manipulate responses, expose sensitive context, or trigger unauthorized tool actions, so defenses must combine model-level guardrails with independently enforced security controls.
- **Public Key Infrastructure**: Public Key Infrastructure (PKI) allows systems to verify that a public key belongs to the expected server, user, device, or organization. In cloud environments, it supports authenticated TLS connections, mutual TLS, and digital signatures while requiring careful protection of private keys and management of certificate lifecycles.
- **Publish-Subscribe Messaging**: Publishers do not need to know which applications or people receive their messages, allowing producers and consumers to evolve independently. This pattern supports event distribution, application integration, and operational alerts, especially when one event must reach multiple independent recipients.
- **Quality Gates**: A quality gate turns testing, evaluation, and operational requirements into enforceable promotion criteria. In cloud delivery, gates prevent unacceptable application, infrastructure, or generative AI changes from reaching broader environments while providing an auditable explanation for each release decision.
- **Random I/O**: Random I/O commonly occurs when applications retrieve individual records, traverse indexes, or update scattered data blocks. Recognizing this pattern helps engineers choose storage based on operations per second, latency, and cost rather than capacity or throughput alone.
- **Rate Limiting**: Rate limiting protects shared resources by restricting traffic according to a measured request rate, an allowed burst, and an enforcement policy. At the cloud edge, it helps reduce application-layer abuse and backend overload, but effective policies must distinguish legitimate traffic spikes from harmful behavior.
- **Read/Write Splitting**: Read/write splitting separates database traffic according to whether an operation changes data or only retrieves it. It helps read-heavy applications increase throughput and isolate reporting workloads, but requires deliberate routing and consistency handling because replicas may lag behind the primary.
- **Real-Time Inference**: Real-time inference turns a trained model into a prediction capability available during an application workflow, such as evaluating a payment or generating a chat response. Engineers typically expose it through a managed model API or a self-hosted API, balancing response time, availability, cost, and operational control.
- **Recovery Point Objective**: RPO defines how far back in time an organization can tolerate recovering its data after an incident. It guides backup frequency, replication design, and disaster recovery strategy, balancing the business impact of lost changes against protection costs.
- **Recovery Time Objective**: RTO expresses how long a business can tolerate a workload being unavailable before the impact becomes unacceptable. Engineers use it to select recovery architectures, automate recovery procedures, and verify that applications and their dependencies can resume service within the required time.
- **Regression Testing**: Regression testing reruns a maintained set of tests after changes and compares results with approved expectations or a trusted baseline. For generative AI applications, it helps detect unintended changes in answer quality, safety, tool use, latency, and cost when prompts, models, retrieval data, or application code change.
- **Resource Tagging**: Tags describe business and operational attributes such as ownership, department, cost center, application, and environment without changing a resource’s function. A consistent tagging strategy supports cost allocation and resource management, while policy controls help prevent missing, misleading, or unauthorized tags.
- **Resource Utilization**: Resource utilization shows how workloads consume CPU, memory, storage, network bandwidth, and other capacity. It informs rightsizing: selecting resource types, sizes, and quantities that meet performance and availability requirements without paying for unnecessary capacity.
- **Response Streaming**: For generative AI applications, response streaming lets users begin reading model output while generation continues. It improves perceived responsiveness, but does not inherently reduce model computation, total completion time, or inference cost.
- **Retrieval Latency**: Retrieval latency determines whether stored data can support interactive requests or must be recovered through a slower, asynchronous process. It is a key storage-selection criterion because lower storage prices can come with longer retrieval delays, additional retrieval charges, or restoration requirements.
- **Retrieval-Augmented Generation**: RAG connects a foundation model to information outside its learned parameters, such as enterprise documents, product catalogs, or operational records. It helps applications answer questions using organization-specific or recently updated information without retraining the model, although accuracy still depends on retrieval quality and how the model uses the evidence.
- **Right-Sizing**: Right-sizing uses observed demand and application requirements to choose appropriate compute, memory, storage, and throughput capacity. It reduces waste while preserving performance and reliability, and it requires regular review as workloads change.
- **Rightsizing**: Rightsizing uses measured demand to identify resources that are overprovisioned, underprovisioned, or poorly matched to their workloads. It reduces unnecessary spending without sacrificing required service levels and should be repeated as applications and usage patterns change.
- **Risk Matrix**: A risk matrix maps identified risk scenarios to consistently defined likelihood and consequence levels, producing categories such as low, medium, high, or critical. In AI governance, it helps teams allocate oversight across the lifecycle while keeping business risk prioritization separate from mandatory legal classifications and obligations.
- **Rollback**: Rollback limits the impact of defective deployments, unsafe configuration changes, and unsuccessful infrastructure updates by restoring an earlier working version or configuration. Effective rollback requires retained artifacts, compatible data and dependencies, clear failure signals, and a tested recovery procedure.
- **Rolling Deployment**: A rolling deployment gradually updates or replaces running instances, tasks, or pods instead of changing the entire fleet at once. It limits simultaneous disruption and can avoid maintaining a complete second environment, but requires sufficient capacity, reliable health checks, and compatibility between application versions.
- **Row-Level Security**: Row-level security allows multiple users or tenants to share tables and dashboards while seeing only the records they are authorized to access. It combines identity or trusted session attributes with data attributes, such as tenant, department, or region, to enforce access without maintaining separate datasets for every audience.
- **Runbooks**: A runbook defines when to act, what steps to perform, how to verify success, and what to do if a step fails. In cloud recovery, tested runbooks reduce improvisation and help teams restore service within recovery time objective (RTO) and recovery point objective (RPO) requirements.
- **SAML 2.0**: Security Assertion Markup Language 2.0 enables users to access cloud accounts and applications using an existing organizational identity rather than separate credentials for each destination. It supports centralized authentication and single sign-on, while the receiving service remains responsible for deciding what the user can access.
- **Schema Evolution**: Data schemas change as applications add fields, revise types, restructure records, or integrate new sources. Schema evolution defines how those changes are introduced, validated, and interpreted so that ingestion pipelines, transformations, tables, and downstream applications continue to work correctly.
- **SCIM**: System for Cross-domain Identity Management (SCIM) automates the creation, update, and deactivation of accounts as people join, move within, or leave an organization. It complements sign-in federation by keeping application identity records synchronized with an authoritative identity source, reducing manual administration and orphaned accounts.
- **Security Quality Gates**: A security quality gate turns vulnerability findings and security policy checks into an explicit decision to permit, block, or require approval for a change. In cloud delivery pipelines, it helps prevent vulnerable code, dependencies, container images, and infrastructure configurations from reaching production while preserving an auditable exception process.
- **Separation of Duties**: The idea is to prevent one identity from initiating, approving, executing, and concealing a sensitive action without independent oversight. In cloud environments, separate administrative roles, account boundaries, approval workflows, and protected audit records reduce the risk of fraud, mistakes, and compromised credentials.
- **Sequential I/O**: Sequential I/O commonly occurs when applications scan large files, stream media, write logs, or create backups. It typically emphasizes sustained throughput rather than small-operation latency, making it an important factor when selecting cost-effective storage.
- **Serialization**: Serialization allows applications written in different languages and running on different systems to exchange data through an agreed format. In cloud data pipelines and foundation model integrations, correct serialization preserves data meaning and ensures that consumers receive the structure, types, and encoding they expect.
- **Serverless**: Serverless shifts infrastructure operations to the cloud provider so engineers can focus on application behavior, data, and configuration. It can reduce operational work and align costs with usage, but scaling behavior, billing, execution limits, and customer responsibilities vary by service.
- **Service Discovery**: Service discovery maps a logical service name to connection information that changes as workloads scale, restart, move, or fail. It lets applications communicate without tracking individual instances, while requiring careful handling of registration, health, caching, and access boundaries.
- **Service Level Indicators**: A Service Level Indicator (SLI) measures an aspect of service behavior, such as successful request rate, response latency, or data freshness. Selecting SLIs from business requirements helps engineers evaluate availability, detect user-impacting failures, and determine whether resilient architecture investments deliver the intended results.
- **Service Level Objectives**: A service level objective (SLO) translates business expectations into a measurable target, such as successful request percentage or response time. SLOs guide architecture, monitoring, incident response, and spending by defining how much reliability a workload actually needs.
- **Service Mesh**: A service mesh provides consistent controls for service-to-service traffic without requiring every application to implement those controls independently. It helps engineers manage discovery, routing, connection security, resilience, and observability as services scale and change, although capabilities vary by implementation.
- **Showback**: Showback connects cloud spending to owners, workloads, and business activities so teams can understand the financial impact of their technical decisions. It requires consistent ownership data, transparent allocation rules, and reports that distinguish directly attributable costs from shared expenses and estimates.
- **Split-Horizon DNS**: Split-horizon DNS maintains separate views of a shared namespace, commonly returning private addresses to internal clients and public endpoints to internet clients. It lets applications use consistent names across environments while controlling which endpoints each audience discovers, but requires careful resolver configuration and coordination between DNS views.
- **Stateful and Stateless Filtering**: Stateful filters remember permitted traffic flows and use that context to recognize return traffic, while stateless filters evaluate each packet without remembering earlier exchanges. This distinction determines how engineers configure bidirectional access, troubleshoot blocked responses, and combine workload-level controls with subnet boundaries and inspection firewalls.
- **Statelessness**: A stateless component processes each request using information supplied with that request and, when necessary, state retrieved from external systems. This makes processing instances interchangeable, simplifying horizontal scaling, failure recovery, and deployment without requiring the overall application to stop storing data.
- **Static Analysis**: Static analysis evaluates artifacts against language rules, resource schemas, security checks, and organizational policies before changes reach production. In cloud engineering, it helps teams detect unsafe infrastructure definitions early and apply consistent deployment standards across accounts, although it cannot establish that deployed resources will behave securely in every environment.
- **Storage Tiering**: Storage tiering balances storage cost against access latency, retrieval charges, and retention requirements. Cloud platforms implement it through explicit storage-class selection, lifecycle policies, or automatic movement based on access patterns, helping engineers avoid paying premium storage rates for rarely used data.
- **Strangler Fig Pattern**: The pattern lets legacy and replacement implementations coexist while functionality moves across a controlled routing or integration boundary. It reduces the scope of individual migration steps and enables earlier delivery, but requires deliberate management of data ownership, compatibility, operational complexity, and eventual retirement of the old implementation.
- **Strong Consistency**: Strong consistency lets applications read current data after a write succeeds, rather than temporarily receiving an older value from a lagging replica. It matters when stale information could cause incorrect decisions, but it does not replace transactions, conditional updates, or concurrency control.
- **Structured Logging**: Structured logs attach explicit context, such as severity, job identifiers, processing stages, and error codes, to each event. This makes distributed data pipelines easier to troubleshoot, query, monitor, and test without depending on fragile text parsing.
- **Subnetting**: Subnetting uses IP prefixes to divide address space into networks sized for particular workloads and operational needs. In cloud environments, it supports scalable network design across accounts, Regions, and virtual networks, while helping engineers avoid address conflicts and establish routing and security boundaries.
- **Synchronous Replication**: Synchronous replication places replication on the write acknowledgment path, protecting successfully acknowledged changes against failures covered by the replication configuration. It can support a recovery point objective of zero for those failures, but adds write latency and makes write availability dependent on replica connectivity and acknowledgment rules.
- **Synthetic Transactions**: Synthetic transactions actively exercise application endpoints and workflows on a schedule, providing repeatable measurements even when real users are absent. They help detect broken journeys, regional connectivity problems, and performance regressions that infrastructure health checks alone can miss.
- **Tabletop Exercises**: Participants work through a realistic incident scenario, explain their decisions, and identify gaps in responsibilities, communications, access, and response procedures. These exercises validate organizational readiness at relatively low operational risk, but they must be complemented by technical tests to establish whether controls and recovery mechanisms actually work.
- **Task Completion Rate**: Task completion rate measures whether an AI application helps users accomplish their intended goals, rather than merely producing plausible responses. It connects foundation model performance to business objectives and should be evaluated alongside user satisfaction, cost per interaction, latency, and safety.
- **Temporal Aggregation**: Temporal aggregation turns streams of measurements or events into time-based summaries for dashboards, alerts, capacity planning, and historical analysis. Choosing the right interval and statistic determines whether engineers detect short-lived failures, interpret rates correctly, and retain useful information without unnecessary storage and processing costs.
- **Temporary Credentials**: Temporary credentials let people and workloads access cloud resources without distributing permanent access keys. They reduce the lifetime of exposed credentials, support federation and role-based access, and shift credential renewal to identity services and supported client libraries.
- **Tenant Isolation**: A tenant is a customer, organization, or other administrative group that uses an application under a distinct security context. Tenant isolation preserves those boundaries across identity, application logic, storage, networking, and operations, whether infrastructure is dedicated or shared. It reduces cross-tenant data exposure and limits how failures, misuse, and resource contention affect other customers.
- **Threat Modeling**: Threat modeling connects a workload’s architecture, valuable assets, trust boundaries, and likely attackers to concrete security requirements. It helps engineers prioritize preventive controls, collect useful telemetry, and design alerts around plausible attack scenarios rather than enabling security features indiscriminately.
- **Throughput**: Throughput measures the rate at which storage, networks, applications, and data pipelines deliver results, commonly expressed as bytes, operations, or records per second. It matters when selecting storage configurations, sizing ingestion and transformation workloads, and determining whether a system can meet processing deadlines without accumulating a backlog.
- **Time to Live**: Time to Live (TTL) controls the lifetime of cached responses, DNS records, and other temporary data. Engineers use it to balance freshness, latency, backend load, and storage consumption, but expiration behavior depends on the system implementing it.
- **TLS Termination**: A load balancer, reverse proxy, or edge service can terminate TLS to centralize certificate management and inspect application traffic. The connection from that intermediary to the backend is a separate design decision: it can use plaintext or a new TLS connection, with different security and operational consequences.
- **Token Validation**: Cloud applications and identity systems validate tokens before trusting the identities or claims they contain. Correct validation prevents forged, expired, misdirected, or inappropriate tokens from being accepted, while separating authentication failures from authorization problems.
- **Tool Calling**: Tool calling connects a generative AI model to capabilities such as database queries, calculations, business APIs, and infrastructure operations. It enables agents to use current information and perform actions, while application code remains responsible for execution, authorization, validation, and error handling.
- **Trace Sampling**: Distributed tracing follows a request across services, while sampling determines which requests contribute detailed trace data. A well-designed sampling policy controls telemetry volume without losing too much visibility into failures, latency, and important application workflows.
- **Transitive Routing**: Connectivity from network A to B and from B to C does not necessarily allow A to reach C; the intermediate infrastructure must support transit and have the required routes and forwarding policies. This distinction determines whether cloud networks need direct peering connections, a shared routing hub, or another supported transit architecture.
- **Transport Layer Security**: TLS protects data while it moves between clients, load balancers, applications, and other resources. Effective protection requires more than enabling an encrypted listener: engineers must enforce acceptable protocol versions, validate identities, and protect every required network hop.
- **Trust Boundaries**: A trust boundary marks where a system must reassess whether an interaction is authentic, authorized, and safe rather than inheriting trust from its origin. Identifying these boundaries helps engineers choose network, identity, and application controls that address the threats created by a particular architecture.
- **Vector Search**: Embedding models represent text, images, audio, or other data as vectors whose relative positions can reflect meaningful relationships. Vector search uses these representations to find related content even when exact words differ, supporting semantic retrieval, recommendations, and retrieval-augmented generation.
- **Vulnerability Assessment**: A vulnerability assessment determines which weaknesses exist, which resources they affect, and how urgently they need attention. In cloud environments, recurring assessments help engineers address vulnerable dependencies, exposed workloads, and insecure configurations as deployments and threat information change.
- **Warm Standby**: The recovery environment maintains current application components and replicated data, but normally has less capacity than the primary environment. During a disaster, engineers promote data stores where necessary, increase capacity, and redirect traffic, balancing recovery speed against the cost of keeping duplicate infrastructure running.
- **WebSockets**: Unlike ordinary HTTP request-response exchanges, a WebSocket connection lets either endpoint send messages without waiting for a new request. This makes it useful for interactive AI applications, live notifications, and collaborative systems where low-latency updates and client commands must flow continuously.
- **Workflow Orchestration**: An orchestrator maintains the execution state of a process and determines which task runs next, including parallel work, waits, retries, and exception paths. In cloud applications, this separates business coordination from individual functions and services, making integrations easier to operate, recover, and audit.
- **Workload Identity**: Workload identity lets software prove who it is and receive permissions appropriate to its function and execution environment. Cloud implementations commonly combine runtime identity, federation, and short-lived credentials to reduce reliance on stored secrets while supporting least privilege and auditable access.
- **Workload Predictability**: Predictability helps engineers decide how much compute usage they can safely commit to and how much should remain flexible. Matching purchasing options to measured demand reduces costs without confusing predictable usage with interruption tolerance or guaranteed capacity.
- **Write-Through Caching**: Write-through caching populates or refreshes cached data when that data is written, rather than waiting for a later read miss. It can improve subsequent read performance and reduce database read load, but adds work to the write path and requires explicit handling of failures and concurrent updates.
- **Zero Trust**: Zero Trust treats internal and external networks as potentially hostile and requires authentication, authorization, and appropriate protection for each resource interaction. It reduces the impact of stolen credentials and compromised devices by combining least-privilege access, workload identity, segmentation, encryption, and ongoing evaluation of security signals.

## Services on the exam

The 119 AWS services the SAP-C03 exam covers.

[Amazon API Gateway](https://blowstack.com/tools/cloud-services-hub/amazon-api-gateway), [Amazon AppFlow](https://blowstack.com/tools/cloud-services-hub/amazon-appflow), [Amazon Application Recovery Controller (ARC)](https://blowstack.com/tools/cloud-services-hub/amazon-application-recovery-controller-(arc)), [Amazon Athena](https://blowstack.com/tools/cloud-services-hub/amazon-athena), [Amazon Augmented AI (Amazon A2I)](https://blowstack.com/tools/cloud-services-hub/amazon-augmented-ai-(amazon-a2i)), [Amazon Aurora](https://blowstack.com/tools/cloud-services-hub/amazon-aurora), [Amazon Aurora Serverless](https://blowstack.com/tools/cloud-services-hub/amazon-aurora-serverless), [Amazon Bedrock](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock), [Amazon Bedrock AgentCore](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock-agentcore), [Amazon CloudFront](https://blowstack.com/tools/cloud-services-hub/amazon-cloudfront), [Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch), [Amazon Cognito](https://blowstack.com/tools/cloud-services-hub/amazon-cognito), [Amazon Data Firehose](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-firehose), [Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb), [Amazon EC2](https://blowstack.com/tools/cloud-services-hub/amazon-ec2), [Amazon EC2 Auto Scaling](https://blowstack.com/tools/cloud-services-hub/amazon-ec2-auto-scaling), [Amazon ECS Anywhere](https://blowstack.com/tools/cloud-services-hub/amazon-ecs-anywhere), [Amazon EKS Anywhere](https://blowstack.com/tools/cloud-services-hub/amazon-eks-anywhere), [Amazon Elastic Block Store (Amazon EBS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-block-store-(amazon-ebs)), [Amazon Elastic Container Registry (Amazon ECR)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-registry-(amazon-ecr)), [Amazon Elastic Container Service (Amazon ECS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-service-(amazon-ecs)), [Amazon Elastic File System (Amazon EFS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-file-system-(amazon-efs)), [Amazon Elastic Kubernetes Service (Amazon EKS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-kubernetes-service-(amazon-eks)), [Amazon ElastiCache](https://blowstack.com/tools/cloud-services-hub/amazon-elasticache), [Amazon EMR](https://blowstack.com/tools/cloud-services-hub/amazon-emr), [Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge), [Amazon FSx](https://blowstack.com/tools/cloud-services-hub/amazon-fsx-(for-all-types)), [Amazon GuardDuty](https://blowstack.com/tools/cloud-services-hub/amazon-guardduty), [Amazon Inspector](https://blowstack.com/tools/cloud-services-hub/amazon-inspector), [Amazon Kinesis Data Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-streams), [Amazon Managed Grafana](https://blowstack.com/tools/cloud-services-hub/amazon-managed-grafana), [Amazon Managed Service for Prometheus](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-prometheus), [Amazon Managed Streaming for Apache Kafka](https://blowstack.com/tools/cloud-services-hub/amazon-managed-streaming-for-apache-kafka), [Amazon MQ](https://blowstack.com/tools/cloud-services-hub/amazon-mq), [Amazon OpenSearch Service](https://blowstack.com/tools/cloud-services-hub/amazon-opensearch-service), [Amazon QuickSight](https://blowstack.com/tools/cloud-services-hub/amazon-quicksight), [Amazon RDS](https://blowstack.com/tools/cloud-services-hub/amazon-rds), [Amazon Redshift](https://blowstack.com/tools/cloud-services-hub/amazon-redshift), [Amazon Route 53](https://blowstack.com/tools/cloud-services-hub/amazon-route-53), [Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3), [Amazon S3 Glacier](https://blowstack.com/tools/cloud-services-hub/amazon-s3-glacier), [Amazon SageMaker](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker), [Amazon Security Lake](https://blowstack.com/tools/cloud-services-hub/amazon-security-lake), [Amazon Simple Notification Service (Amazon SNS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-notification-service-(amazon-sns)), [Amazon Simple Queue Service (Amazon SQS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-queue-service-(amazon-sqs)), [Amazon Verified Permissions](https://blowstack.com/tools/cloud-services-hub/amazon-verified-permissions), [Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc), [AWS Application Discovery Service](https://blowstack.com/tools/cloud-services-hub/aws-application-discovery-service), [AWS Application Migration Service](https://blowstack.com/tools/cloud-services-hub/aws-application-migration-service), [AWS AppSync](https://blowstack.com/tools/cloud-services-hub/aws-appsync), [AWS Artifact](https://blowstack.com/tools/cloud-services-hub/aws-artifact), [AWS Audit Manager](https://blowstack.com/tools/cloud-services-hub/aws-audit-manager), [AWS Auto Scaling](https://blowstack.com/tools/cloud-services-hub/aws-auto-scaling), [AWS Backup](https://blowstack.com/tools/cloud-services-hub/aws-backup), [AWS Billing and Cost Management](https://blowstack.com/tools/cloud-services-hub/aws-billing-and-cost-management), [AWS Billing Conductor](https://blowstack.com/tools/cloud-services-hub/aws-billing-conductor), [AWS Budgets](https://blowstack.com/tools/cloud-services-hub/aws-budgets), [AWS Certificate Manager (ACM)](https://blowstack.com/tools/cloud-services-hub/aws-certificate-manager-(acm)), [AWS Clean Rooms](https://blowstack.com/tools/cloud-services-hub/aws-clean-rooms), [AWS Cloud Development Kit (AWS CDK)](https://blowstack.com/tools/cloud-services-hub/aws-cloud-development-kit-(aws-cdk)), [AWS Cloud Map](https://blowstack.com/tools/cloud-services-hub/aws-cloud-map), [AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation), [AWS CloudHSM](https://blowstack.com/tools/cloud-services-hub/aws-cloudhsm), [AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail), [AWS CodeBuild](https://blowstack.com/tools/cloud-services-hub/aws-codebuild), [AWS CodeCommit](https://blowstack.com/tools/cloud-services-hub/aws-codecommit), [AWS CodeDeploy](https://blowstack.com/tools/cloud-services-hub/aws-codedeploy), [AWS CodePipeline](https://blowstack.com/tools/cloud-services-hub/aws-codepipeline), [AWS Command Line Interface (AWS CLI)](https://blowstack.com/tools/cloud-services-hub/aws-command-line-interface-(aws-cli)), [AWS Compute Optimizer](https://blowstack.com/tools/cloud-services-hub/aws-compute-optimizer), [AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config), [AWS Control Tower](https://blowstack.com/tools/cloud-services-hub/aws-control-tower), [AWS Cost and Usage Report](https://blowstack.com/tools/cloud-services-hub/aws-cost-and-usage-report), [AWS Cost Explorer](https://blowstack.com/tools/cloud-services-hub/aws-cost-explorer), [AWS Database Migration Service (AWS DMS)](https://blowstack.com/tools/cloud-services-hub/aws-database-migration-service-(aws-dms)), [AWS DataSync](https://blowstack.com/tools/cloud-services-hub/aws-datasync), [AWS Direct Connect](https://blowstack.com/tools/cloud-services-hub/aws-direct-connect), [AWS Distro for OpenTelemetry](https://blowstack.com/tools/cloud-services-hub/aws-distro-for-opentelemetry), [AWS Elastic Disaster Recovery](https://blowstack.com/tools/cloud-services-hub/aws-elastic-disaster-recovery), [AWS Fargate](https://blowstack.com/tools/cloud-services-hub/aws-fargate), [AWS Fault Injection Service](https://blowstack.com/tools/cloud-services-hub/aws-fault-injection-simulator-(aws-fis)), [AWS Firewall Manager](https://blowstack.com/tools/cloud-services-hub/aws-firewall-manager), [AWS Global Accelerator](https://blowstack.com/tools/cloud-services-hub/aws-global-accelerator), [AWS Glue](https://blowstack.com/tools/cloud-services-hub/aws-glue), [AWS IAM Identity Center (AWS Single Sign-On)](https://blowstack.com/tools/cloud-services-hub/aws-iam-identity-center-(aws-single-sign-on)), [AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam)), [AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms)), [AWS Lake Formation](https://blowstack.com/tools/cloud-services-hub/aws-lake-formation), [AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda), [AWS Local Zones](https://blowstack.com/tools/cloud-services-hub/aws-local-zones), [AWS Mainframe Modernization](https://blowstack.com/tools/cloud-services-hub/aws-mainframe-modernization), [AWS Migration Evaluator](https://blowstack.com/tools/cloud-services-hub/aws-migration-evaluator), [AWS Migration Hub](https://blowstack.com/tools/cloud-services-hub/aws-migration-hub), [AWS Network Firewall](https://blowstack.com/tools/cloud-services-hub/aws-network-firewall), [AWS Organizations](https://blowstack.com/tools/cloud-services-hub/aws-organizations), [AWS Outposts](https://blowstack.com/tools/cloud-services-hub/aws-outposts), [AWS Private Certificate Authority](https://blowstack.com/tools/cloud-services-hub/aws-private-certificate-authority), [AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink), [AWS Resilience Hub](https://blowstack.com/tools/cloud-services-hub/aws-resilience-hub), [AWS Resource Access Manager (AWS RAM)](https://blowstack.com/tools/cloud-services-hub/aws-resource-access-manager-(aws-ram)), [AWS Resource Groups and Tag Editor](https://blowstack.com/tools/cloud-services-hub/aws-resource-groups-and-tag-editor), [AWS Schema Conversion Tool (AWS SCT)](https://blowstack.com/tools/cloud-services-hub/aws-schema-conversion-tool-(aws-sct)), [AWS Secrets Manager](https://blowstack.com/tools/cloud-services-hub/aws-secrets-manager), [AWS Security Hub](https://blowstack.com/tools/cloud-services-hub/aws-security-hub), [AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts)), [AWS Signer](https://blowstack.com/tools/cloud-services-hub/aws-signer), [AWS Site-to-Site VPN](https://blowstack.com/tools/cloud-services-hub/aws-site-to-site-vpn), [AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions), [AWS Storage Gateway](https://blowstack.com/tools/cloud-services-hub/aws-storage-gateway), [AWS Systems Manager](https://blowstack.com/tools/cloud-services-hub/aws-systems-manager), [AWS Transfer Family](https://blowstack.com/tools/cloud-services-hub/aws-transfer-family), [AWS Transform](https://blowstack.com/tools/cloud-services-hub/aws-transform), [AWS Transit Gateway](https://blowstack.com/tools/cloud-services-hub/aws-transit-gateway), [AWS Verified Access](https://blowstack.com/tools/cloud-services-hub/aws-verified-access), [AWS WAF](https://blowstack.com/tools/cloud-services-hub/aws-waf), [AWS Well-Architected Tool](https://blowstack.com/tools/cloud-services-hub/aws-well-architected-tool), [AWS X-Ray](https://blowstack.com/tools/cloud-services-hub/aws-x-ray), [Elastic Load Balancing (ELB)](https://blowstack.com/tools/cloud-services-hub/elastic-load-balancing-(elb)), [Service Quotas](https://blowstack.com/tools/cloud-services-hub/service-quotas)

## Concepts on the exam

The 210 cloud concepts the SAP-C03 exam covers, each explained with the AWS services for it: https://blowstack.com/tools/cloud-concepts-hub?certification=aws-certified-solutions-architect-professional

## Other practice exams

- [AIF-C01 AWS Certified AI Practitioner](https://blowstack.com/practice-exams/aws-certified-ai-practitioner)
- [SAA-C03 AWS Certified Solutions Architect - Associate](https://blowstack.com/practice-exams/aws-certified-solutions-architect-associate)
- [CLF-C02 AWS Certified Cloud Practitioner](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner)
- [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional)
- [DEA-C01 AWS Certified Data Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate)
- [SCS-C03 AWS Certified Security - Specialty](https://blowstack.com/practice-exams/aws-certified-security-specialty)
- [AIB-C01 (beta) AWS Certified AI Business Strategist](https://blowstack.com/practice-exams/aws-certified-ai-business-strategist)
- [AIP-C01 AWS Certified Generative AI Developer - Professional](https://blowstack.com/practice-exams/aws-certified-generative-ai-developer-professional)
- [MLA-C02 (beta) AWS Certified Machine Learning Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate)
- [SOA-C03 AWS Certified CloudOps Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-cloudops-engineer-associate)
- [ANS-C01 AWS Certified Advanced Networking - Specialty](https://blowstack.com/practice-exams/aws-certified-advanced-networking-specialty)
- [DVA-C02 AWS Certified Developer - Associate](https://blowstack.com/practice-exams/aws-certified-developer-associate)
