Selecting an Azure data store is an architecture decision, not a contest in which one service is declared the fastest or most scalable. For AZ-305, the useful question is: which combination of consistency, query capabilities, latency, recovery, operating model and cost will meet an application's actual service commitments? The answer changes with the workload. A globally distributed product catalog, a financial ledger and an archive of signed documents do not belong in the same database merely because each contains data.
Start with the operations the application must support
Suppose a subscription business receives orders, updates account balances, serves a frequently changing product catalog and retains invoice PDFs for seven years. Before selecting a service, separate those responsibilities. Order submission requires multi-record integrity and a durable decision about whether a payment was committed. Catalog browsing may favor flexible JSON documents, predictable low-latency lookups and distribution across regions. Invoice files are immutable business objects rather than rows to join. Session hints are ephemeral and should not become the authoritative customer record.
Document the read and write paths for each responsibility. Is the typical request a lookup by customer ID, a complex join over transactions, a range scan across events or a download of an object? How often will the schema change? How much data arrives daily, and what is the likely hot partition? Identify residency requirements, data sensitivity, read-after-write expectations and concurrency conflicts. A service that performs well in a happy-path demonstration may struggle when many users update one key or when a cross-region failure forces a controlled recovery.
An AZ-305 design answer should connect each choice to a constraint. "Use Cosmos DB because it scales" is incomplete. A stronger decision explains why its data and access model fit the queries, how a partition key distributes load, what consistency the application requires and what the workload will cost to provision and operate. If one of those conditions is unknown, record it as an assumption to test rather than manufacturing certainty.
Relational records, JSON documents, objects and caches do different jobs
For strongly relational operational records with joins, constraints and transactions, Azure SQL Database or Azure SQL Managed Instance may be appropriate. Managed Instance is particularly relevant when an existing SQL Server application depends on instance-level compatibility and features; it is not automatically the preferred service for every new database. SQL Server on Azure Virtual Machines may fit migration requirements that demand operating-system or instance control, but it shifts more maintenance responsibility to the team.
Azure Cosmos DB can fit an application that needs a document-oriented operational model, predictable access through its chosen API and distribution options. For a document stored with the API for NoSQL, SQL-like query syntax does not turn it into a conventional relational database. Joins, transactions and analytical patterns must be judged against the API's actual capabilities and partition boundaries. Designing a partition key around common queries and write distribution often matters more than choosing a service based on a marketing latency figure.
Azure Blob Storage is an object store for items such as images, exported reports, logs or invoices. It is not a drop-in replacement for a transaction database when the application needs relational joins, record constraints or multi-record business transactions. Azure Files is an option for shared file-system semantics when workloads require them; it solves a different problem from a global document catalog. A data lake or analytics platform may serve batch or exploratory processing of large datasets, but it should not be mistaken for the low-latency operational store that accepts the orders in the first place.
A cache such as Azure Managed Redis, where suitable and supported for the selected deployment, can accelerate repeated reads, but it introduces invalidation, eviction and recovery behavior. If the cache disappears, the application must know how to refill it from a trustworthy system of record. Do not call a faster response from an unvalidated cache a successful design when it can return expired permissions, stale prices or customer data to the wrong tenant.
A worked data-store decision for one application
Return to the subscription business. Place authoritative orders, payment state and account entitlements in a relational transactional store when the workflow relies on relational integrity. Model the order-write path to be idempotent: a client retry must not create a second charge. Use application-side retry and concurrency design consistent with the database's transaction guarantees. Store invoice PDFs in Blob Storage under an explicit retention and access policy, with durable metadata pointing to the correct customer and immutable invoice identifier.
The product catalog might use Azure Cosmos DB if the business needs regionally distributed, flexible document reads and its query patterns fit a partition strategy. But a modest, single-region catalog with relational editing requirements might be simpler and cheaper to keep in Azure SQL. If the user-visible catalog is searchable rather than just queryable by key, decide separately whether the workload needs a search index; database selection alone does not supply a full relevance-ranking system. A reporting pipeline can publish approved events to an analytical destination without making the operational store responsible for every aggregate report.
This design now has explicit consistency questions. If an order is accepted but the catalog cache has not refreshed, which price is authoritative? If the invoice object has uploaded but the transaction fails, how does the workflow identify an orphaned file? If a region becomes unavailable during payment confirmation, what prevents double processing on retry? The database diagram is incomplete without those answers, even when every resource has a high-availability setting enabled.
Design Cosmos DB around queries and partitions
The presence of JSON and SQL-like queries does not by itself prove Cosmos DB is the best choice. List the frequent requests first: look up one product by ID, retrieve a customer's recent activity, change one entity, filter products by attributes or run a cross-customer monthly aggregate. Determine which operations can be served efficiently inside a logical partition and which require cross-partition work. A partition key that puts every popular tenant into one hot logical partition can erase expected scalability benefits.
Provisioned throughput and request-unit consumption should be measured with representative documents, indexing rules, query predicates and response sizes. A small lookup and a complex query that scans many partitions do not cost the same. Verify the selected consistency model against the workflow; a globally distributed design may involve latency and consistency tradeoffs that application developers must consciously accept. Regional failover also needs an application retry and reconciliation strategy rather than a blanket claim that every write is automatically safe after a region change.
Before approving the design, measure throughput at peak load, inspect throttling and retry patterns, test the actual primary queries and validate a failover exercise in an authorized nonproduction environment. These are acceptance criteria for a future implementation; this article does not claim that such a deployment or test has been executed.
Choose the SQL deployment model and scaling process deliberately
Azure SQL Database is often the simpler managed choice for new relational workloads. Azure SQL Managed Instance provides a broader compatibility surface for many SQL Server migrations, but the database owner still needs to examine version compatibility, network isolation, backup recovery, service tiers and performance capacity. Instance compatibility does not mean every SQL Server feature behaves identically; perform a workload-specific assessment before migration.
For Managed Instance, General Purpose and Business Critical service tiers have different storage architectures, performance behavior, price points and availability characteristics. Compute and storage configurations have supported ranges and change procedures. Do not promise that Managed Instance automatically scales vCores in response to every traffic spike. An operator or an approved automation may have to request a compute change, and a scale operation can affect availability. Test how long the operation takes and whether its interruptions are acceptable for the workload.
Plan capacity using actual CPU, I/O, memory, storage-growth and connection metrics. If the bottleneck is an inefficient query, more vCores may not solve it. If the problem is a single hot transaction or lock contention, lifting the service tier could merely move the failure to a more expensive platform. Document indexes, query plans, maintenance responsibility and a performance baseline alongside the scaling decision.
Recoverability is not the same as high availability
A highly available data service can remain online while a user deletes the wrong data. A backup might protect that data while taking too long to meet the application's recovery-time objective. Write separate requirements for availability, accidental-delete recovery, point-in-time recovery, region loss and malicious modification. Attach a recovery-point objective (RPO) and recovery-time objective (RTO) to the scenarios that actually matter, then identify which Azure features provide the required evidence.
For Blob Storage, soft delete retains eligible deleted objects for a defined period; container soft delete is a separate setting. Blob versioning can retain earlier states, with feature support depending on account capabilities. Microsoft documents that blob soft delete, versioning and snapshots behave differently under overwrites and account configurations. Soft delete by itself does not protect against deletion of the entire storage account, nor does it provide an independent recovery copy after every possible compromise. Add backup, access controls, resource locks or immutability measures where the risk and feature support justify them. Test a restore with a known object and validate that users can find the restored data.
For SQL workloads, distinguish service availability from transaction-log-based recovery, failover groups, backup retention and recovery to another region. An application may resume database connections after a failover and still need to reconcile work that was in flight. Do not promise zero data loss without verifying the service's recovery mode and the designed write path. For multi-region application availability, DNS-based routing such as Traffic Manager is not itself a database-replication or state-recovery mechanism; clients may cache DNS answers, and health probing is only one part of failover behavior. Readers who need the wider distinction can compare high availability and disaster recovery as separate architecture requirements.
Security, governance and cost are part of the database choice
Decide who can administer a store, who can read a customer's records and how applications obtain short-lived credentials. Prefer appropriately scoped managed identities or service identities where supported, keep secrets out of source code and restrict public endpoints when a private network path is feasible. Encryption and network isolation are useful layers, but neither substitutes for row- or tenant-level authorization enforced in the application. Include audit events and retention appropriate to the data classification.
Model monthly cost from realistic traffic. Cosmos DB request units, region count and storage; SQL compute tiers and backup retention; Blob capacity, operations, redundancy and egress; and analytical pipelines can produce materially different bills. Every proposed "better performance" option has a cost and an operational burden. Take the candidate design through peak usage, small usage, failure recovery and unexpected data-growth scenarios before calling it economical.
Make the AZ-305 decision explainable and testable
A short architecture decision record should state the business operation, chosen data model, access patterns, durability and consistency guarantees, alternatives rejected, assumptions, expected recovery behavior and measurable acceptance tests. For the example application, a defensible decision may use a relational system of record for billing, Blob Storage for documents, an optional document database for a globally distributed catalog and an optional disposable cache for repeated reads. Another organization could reasonably choose a simpler combination because its operating constraints differ.
The AZ-305 objectives assess design decisions for relational, semi-structured and unstructured data, data integration, protection and scalability under the objectives effective April 17, 2026. The exam's questions are not a substitute for architecture evidence: a correct design explains not merely which Azure service is named, but what happens to the application when data changes, demand spikes, an operator makes a mistake or a region becomes unavailable.