
Database, cloud, and FinOps teams tend to ask the same things. What does "storage" mean in Hyperscale? Which resources get billed? Do replicas and backups change the total? Will serverless actually cost less?
This guide answers those questions using current Microsoft documentation. Rates and feature availability change, so confirm any figure in the Azure Pricing Calculator before you commit. We use no static dollar rates here for that reason.
Key Takeaways
- Estimate costs across compute, storage, replicas, backups, networking, and discounts
- Hyperscale storage is allocated capacity, not a disk you size yourself
- Serverless savings depend on memory and cache behavior, not CPU alone
- Test the workload and monitor billing before choosing a tier
What Is Azure SQL Hyperscale?
Hyperscale is a vCore service tier of Azure SQL Database with independently scalable compute and storage. It supports OLTP and hybrid workloads, in provisioned or serverless compute. Microsoft's Hyperscale overview lists a maximum of 128 TB per database.
It differs from SQL Server on a virtual machine, where you manage the OS and disks, and from Managed Instance, which targets lift-and-shift instance compatibility. Hyperscale is a single-database PaaS tier.
Capabilities worth knowing
- Independent compute scaling
- 0-4 high-availability (HA) replicas, up to 30 named replicas, and one geo-replica
- Fast, snapshot-based restore with point-in-time recovery of 1-35 days (default 7)
- Automatic storage growth
Hardware options include standard-series (Gen5), Premium-series, and Premium-series memory optimized. The 160/192-vCore Premium-series options are still documented as preview, so don't treat the maximum as generally available. Premium availability varies by region, so check the regional matrix.
Qualify before you migrate
- Memory-optimized tables,
DBCC CHECKDB, Elastic Jobs job databases, and Data Sync hub databases are unsupported - Existing databases can convert to Hyperscale, but reverse migration is limited: only databases converted within the last 45 days, back to a General Purpose single database with at least 2 vCores
- Databases created as Hyperscale cannot be reversed
- Confirm your application can work within the Azure SQL Database platform model
How Azure SQL Hyperscale Storage Architecture Works
How the decoupled architecture is organized
Microsoft's architecture documentation describes four layers:
| Layer | Role |
|---|---|
| Compute nodes | Run the relational engine and handle queries and transactions |
| Log service | Accepts log records and propagates changes to secondary compute and page servers |
| Page servers | Cache data on local SSD and supply pages to compute |
| Azure Storage | Holds durable data files and snapshot backups |
Compute nodes also keep a local SSD cache called RBPEX, which cuts remote page-server fetches. Reads come from cache first, then page servers. Writes flow through the log service.
Because of this split, database growth is handled by the storage layer rather than by the vCores you pick. You still pay for whatever compute, replicas, and features you configure.

How growth and caching affect performance
Several quantities sound alike but are not interchangeable:
- Logical database size
- Durable data in Azure Storage
- Page-server caches
- RBPEX
- Temp space
- Log components
Only some of these are billed. Ample capacity does not guarantee speed either. Cache locality, query patterns, indexing, and data distribution all influence how often compute must reach out to page servers.
Replicas, backups, and restore
Hyperscale replaces the traditional full, differential, and log backup chain with storage snapshots plus retained logs. Same-region restores finish in minutes, even for multi-terabyte databases. Geo-restore is a size-of-data operation and takes longer.
Fast restore does not mean free retention. Backup consumption, long-term retention, geo-redundancy, and data transfer can all be billed.
Operational implications
Compared with self-managed SQL Server, you stop planning disks and start watching:
cpu_percentworkers_percentlog_write_percent- Allocated versus used storage
Architecture diagrams and limits in older articles may no longer match current SKUs or billing rules.
Azure SQL Hyperscale Pricing: What You Pay For
Compute pricing
Provisioned compute is priced per replica. Variables include hardware, region, vCores, running hours, and redundancy. Azure Hybrid Benefit is not available for new Hyperscale databases; existing provisioned single databases can keep it until December 2026.
Reservations apply to provisioned Hyperscale. Serverless gets no reservation or Hybrid Benefit discount, though the newer savings plan for databases covers Hyperscale and serverless.
Serverless bills per second, using this formula from Microsoft's billing documentation:
vCore-second rate × max(min vCores, used vCores, min memory GB/3, used memory GB/3)
So memory sets a floor. A low CPU average does not guarantee a low bill. Serverless is Gen5 only, and Premium-series does not support it.

Storage and database-size charges
- Data storage bills per GB/month on allocated capacity, not used rows or maximum size
- Minimum allocation is 10 GB, and data files grow in at least 10 GB steps
- Live log storage is not charged separately
- Short-term backup storage equal to database size is included; beyond that, backup consumption is billed per GB/month
- Long-term retention (up to 10 years) is priced separately
- Redundancy options (LRS, ZRS, RA-GRS, RA-GZRS) are chosen at creation and affect data and backup cost
Storage and compute are separate drivers. Adding vCores does not enlarge your data, while replicas and retention can raise the total.
Replicas, availability, and networking
| Replica | Compute | Storage |
|---|---|---|
| HA (0-4) | Billed at the primary compute rate | Shares page servers, no secondary storage charge |
| Named (up to 30) | Billed as compute, with its own service objective | Shares primary page servers |
| Geo (1) | Confirm rates on the pricing page | Independent copy on separate page servers |
Zone redundancy requires at least one HA replica plus ZRS or geo-zone-redundant backup storage, so the HA compute is chargeable. Cross-region outbound transfer is billed per GB, and inbound is free. Check Azure bandwidth pricing for current rates.

Read routing is mainly a design choice: ApplicationIntent=ReadOnly sends connections to a read-only HA replica, and falls back to the primary if none exists.
A practical cost-estimation formula
Monthly total = compute + storage + replicas and availability + backup and retention + networking, minus reservations, savings plans, or enterprise discounts.
Gather these inputs first:
- Azure region and currency
- Purchasing agreement
- Service tier, hardware generation, and vCores
- Provisioned or serverless mode
- Database size and growth rate
- Replicas, backup retention, and redundancy
- Data transfer and operating hours
Label every example as illustrative and note the date you pulled prices.
Azure Pricing Calculator workflow
- Add Azure SQL Database, choose single database, vCore, and Hyperscale
- Set region, hardware, compute mode, and vCores
- Enter storage, replicas, backup redundancy, and retention
- Sign in to see agreement-specific pricing, then export or share the estimate

Build separate scenarios: steady, bursty, read-heavy with replicas, and large with extended retention. Compare full monthly totals, not just the compute line, and write down your assumptions.
When you compare Hyperscale with General Purpose and Business Critical, base the choice on workload requirements, not database size alone. Microsoft positions General Purpose for less demanding, budget-oriented workloads (up to 4 TB) and Business Critical for low-latency OLTP (also up to 4 TB).
How to Estimate and Control Azure SQL Hyperscale Costs
Monitor the actual billing drivers
Correlate Azure Cost Management with database metrics:
cpu_percentandworkers_percentapp_cpu_billedfor serverless billed computeapp_memory_percentstorageversusallocated_data_storagelog_write_percent
Average CPU alone hides memory-driven billing and replica or retention costs. Pair that with basic cost controls:
- Set budgets and alerts (they notify but do not stop spend)
- Tag resources by application and environment
- Review spend monthly
Manage compute and serverless settings
Provisioned compute is more predictable for steady load. Serverless suits intermittent or bursty use. Hyperscale auto-pause is still in preview, with a 60-minute minimum delay, and does not support named replicas or geo-replication. Paused databases still incur storage charges.
Microsoft notes that active cache can stay high when CPU is low, which blocks memory reclamation. A seemingly idle database may never reach its expected serverless savings. Validate against app_cpu_billed, not CPU graphs.
Right-size on sustained load. Scale in controlled steps, allow stabilization, test the application, and keep a rollback plan.
Reduce avoidable storage and retention costs
- Review retention policies, archives, historical tables, staging data, and unused indexes
- Enable geo-redundancy and long retention according to recovery objectives, not by default
- Avoid risky restructuring just to shrink allocated storage
Hyperscale shrink reached general availability in January 2025, but test it carefully before trying it on a large database.
Extend visibility to adjacent block storage
Many enterprises run Azure VMs with attached block storage next to Azure SQL Database. Lucidity provides autonomous visibility and optimization for eligible cloud block storage across AWS, Azure, and Google Cloud, and can cut those block storage costs by up to 70%. That work sits beside Azure SQL Hyperscale and does not change its managed PaaS pricing.
Validate savings with a workload test
Run a proof of concept across your shortlisted tiers. Measure latency, throughput, CPU, memory, workers, storage growth, restore behavior, replica usefulness, and total cost.
Cover peak, average, and low periods, plus bulk loads, reporting queries, failover, and maintenance events. Then repeat a simple cycle: take a baseline, change one variable, observe billing and performance, document the result, and revisit.

When Should You Use Azure SQL Hyperscale?
Hyperscale is a strong fit when you need any of the following:
- Large or unpredictable database growth
- Heavy write throughput
- Read scale-out across replicas
- Microsoft-managed storage and fast restores
Look elsewhere when:
- Databases are smaller and growth is predictable
- Workloads depend on features Hyperscale does not support
- Strict latency or regional constraints rule it out
- General Purpose or Business Critical delivers a better cost balance
Decision checklist:
- Current and projected size, and growth rate
- Read/write mix and peak concurrency
- Recovery objectives and replica needs
- Feature compatibility and migration path
- Regional availability
- Fully loaded monthly cost
Run a documented proof of concept before production. Get sign-off from database engineering, application, security, operations, and FinOps.
Frequently Asked Questions
When should I use Azure SQL Hyperscale?
Use it for large or fast-growing databases, demanding write workloads, and read-scale needs. Validate feature compatibility and total monthly cost first.
Is Azure SQL different from SQL?
Yes. SQL is a query language. Azure SQL is Microsoft's family of managed cloud database services built on the SQL Server engine, including Azure SQL Database.
What is Hyperscale in Azure SQL Database?
It is a service tier with separate compute, storage, and logging layers that scale independently for large or demanding databases.
What is the architecture of Azure SQL Hyperscale?
Hyperscale uses compute nodes, a log service, page servers, and durable Azure Storage. Confirm current details in Microsoft's documentation.
How is Azure SQL Hyperscale priced?
Bills combine compute, allocated storage, replicas, backups and retention, networking, and discounts. Rates vary by region and configuration.
Is Azure SQL Hyperscale serverless automatically cheaper?
No. Billing uses the higher of CPU and memory usage or minimums, so low CPU does not guarantee savings. Check billed vCore-seconds in your own data.