
Elastic pools split the difference. Databases with different demand patterns share one block of compute at a set price, so one database's quiet hour covers another's busy one.
This guide covers how pools work, how DTU and vCore pricing differ, how to size compute and storage, how to compare costs, and how to monitor the pool after launch.
Key Takeaways
- Pools pay off when many databases are variable and their peaks don't coincide.
- Size for concurrent demand, per-database limits, storage, growth, and headroom, not database count.
- Validate any savings estimate with the Azure Pricing Calculator and historical Azure Monitor data.
- Optimization is iterative: group, monitor, resize, repeat.
What Is an Azure SQL Elastic Pool and When Should You Use One?
An elastic pool is a shared resource boundary for multiple Azure SQL databases on the same logical server. Databases draw compute from the pool as they get busier and release it as they quiet down. Microsoft's documentation describes it as multiple databases with varying, unpredictable usage sharing a set amount of resources at a set price.
When Elastic Pools are a good fit
Pools suit low average utilization with relatively infrequent spikes. Typical examples:
- Multi-tenant SaaS, where each customer has its own database
- Development and test databases that are mostly idle
- Enterprise database groups with intermittent, non-overlapping peaks
Per-database minimum and maximum settings give you some governance. The maximum caps consumption, though only as far as pool resources are available. The minimum reserves capacity, and the default is 0. Both settings apply uniformly to every database in the pool; you can't set different values per database.
When a pool may not be the right choice
Skip the pool when:
- One database needs dedicated capacity
- Several databases sit at persistent medium-to-high utilization (Microsoft advises against pooling these)
- Peaks are synchronized
- Isolation or guaranteed performance independent of neighbors is mandatory
Also remember that every database in a pool must live on the same logical server. Cross-server membership isn't supported. Check current compatibility rules in Microsoft's docs before planning a migration.
How Azure SQL Elastic Pool Pricing Works
Your bill depends on the purchasing model, service tier, pool compute, storage, region, and any licensing, reservation, or discount arrangements. Confirm current prices for each on Microsoft's pricing page; numbers change.
DTU versus vCore pricing
| Factor | DTU pools | vCore pools |
|---|---|---|
| Resource model | Compute bundled as eDTUs (CPU, memory, reads, writes) | Compute and storage chosen independently |
| Tiers | Basic, Standard, Premium | General Purpose, Business Critical |
| Storage | Included amount; eligible extra storage billed separately | Billed separately per GB/month |
| Azure Hybrid Benefit | Not available | Available with eligible licenses and active Software Assurance |
DTU suits teams that want simple, bundled sizing. vCore suits teams that want to tune compute and storage separately or use existing SQL Server licenses. Neither is universally cheaper. Both are priced hourly.
What else shows up on the bill
The pool charge isn't the whole story. Check these separately:
- Backups: DTU pools include point-in-time restore storage. In vCore pools, free allowance equals max data size; excess is per GB/month.
- Long-term retention: Charged by storage consumed.
- Geo-replication: Secondaries in pools are billed at pool level. Active geo-replication has no extra primary-to-secondary transfer fee; other outbound transfer uses regular rates.
- Reservations: One- or three-year terms cover eligible compute only, not software, storage, or networking.
Building a pricing estimate
- Estimate the pool configuration you need.
- Record the region and currency (USD for US deployments).
- Model the equivalent standalone databases.
- Apply only discounts you've verified.
- Compare monthly and annual totals in the Azure Pricing Calculator.
Write down your assumptions: database count, average and peak demand, storage growth, availability needs, expected workload changes. Someone will ask later how you got the number.
How to Size an Azure SQL Elastic Pool
Start with data. For every candidate database, collect CPU, data and log I/O, storage used, storage growth, peak periods, and any latency or timeout signals.
Azure Monitor exposes cpu_percent, dtu_consumption_percent, physical_data_read_percent, log_write_percent, workers_percent, and storage metrics. For pools already running, sys.elastic_pool_resource_stats (queried from master) reports at 15-second intervals with 14-day retention.
Establish the compute baseline and concurrent peak
Adding every database's individual maximum overstates what you need. Sizing from averages alone invites contention. Microsoft's formula handles both:
Pool size = MAX(total databases × average utilization per database, concurrently peaking databases × peak utilization per database)
The same shape applies to DTU and vCore. Build a time series to see how many databases really peak together, then size to the highest credible aggregate plus headroom that matches your SLA.

Select per-database minimums and maximums
Keep the minimum at 0 for databases that can sit idle. A nonzero minimum reserves capacity even when a database is idle, and that reserved capacity is unavailable to active neighbors. It also limits how many databases fit: Microsoft's example of a 20-vCore pool with a 2-vCore minimum allows at most 10 databases.
Use maximums to stop one noisy database from swallowing the pool. Remember the cap is not a guarantee, so confirm contention behavior in current documentation.
Size total storage independently
Storage is its own calculation. Total current usage, expected growth, temporary expansion, and retention needs all count. Know the vocabulary:
- Used space: data size, excluding empty space in files
- Allocated space: total file size, including empty space
- Maximum pool storage: the ceiling; hitting it can cause out-of-space errors
You can only lower the configured maximum to a value at least equal to total allocated space. And pool storage isn't unlimited per database; each database has its own maximum.
Validate the proposed configuration
Test the candidate size against historical peaks and a representative load test before moving production. Microsoft's current portal instructions describe manual configuration in the Configure pool pane, so don't count on an automatic recommender.
For the first weeks after migration, track pool and database utilization, query latency, throttling, storage growth, and cost. Resize or regroup based on what you see.
Azure SQL Elastic Pool Cost Guide: Compare Options and Avoid Waste
Before you lock in spend, compare four deployment options:
- Individual standalone databases
- One shared pool
- Multiple pools grouped by workload behavior
- Dedicated capacity for consistently busy or sensitive databases
A hypothetical example
Microsoft illustrates the principle with 20 Standard S3 databases whose combined usage never exceeds 100 DTUs. A 100-eDTU pool replaces 20 individual S3 allocations, which Microsoft reports as a 20-fold DTU reduction and 13-fold price reduction.

That's an illustration, not a current quote. Savings can appear with as few as two S3 databases, depending on utilization.
Build your own version with labeled assumptions: database count, average demand, concurrent peak, storage, tier, region, and the Pricing Calculator totals for each option.
Find the break-even point
Compare the pool's recurring cost plus related charges against the standalone resources needed to meet the same performance and availability targets. Then rerun the math with different concurrency assumptions. If peaks synchronize, savings can shrink fast.
Account for overlooked costs and constraints
Factor in costs that often get missed:
- Backup retention and geo-redundancy
- Failover, monitoring, and data transfer
- Licensing, storage growth, and operational overhead
Verify how each is billed for your configuration.
A cheaper pool can still lose money overall. Contention, throttling, migration effort, compliance rules, or downtime risk can erase the savings.
Use cost signals to improve the pool over time
Open Cost analysis on the resource group, group by service name, and filter for Azure SQL Database. Set budgets with alerts, and export data to Excel or Power BI. Read cost alongside utilization so you can tell a pricing problem from a workload or configuration problem.
Lucidity complements this on the storage side. It gives enterprises visibility into Azure block storage and autonomously expands and shrinks disks around their applications, with savings of up to 70% on block storage. It doesn't replace elastic pool compute sizing or Microsoft's SQL billing tools.
Set Up, Monitor, and Govern an Azure SQL Elastic Pool
Set up the pool
In the portal:
- Choose or create the logical server.
- Select the purchasing model and service tier.
- Configure pool compute and storage.
- Set per-database limits.
- Add databases.
- Review the cost estimate and create the pool.

For automation, use the tooling that fits your pipeline:
- Azure CLI:
az sql elastic-pool createandupdate(with--db-min-capacityand--db-max-capacity) - PowerShell:
New-AzSqlElasticPoolandSet-AzSqlElasticPool - Bicep and ARM:
Microsoft.Sql/servers/elasticPools - REST API: Create Or Update via
PUT
Monitor and govern the pool after deployment
Track metrics at both pool and database level:
- Compute, storage, and throttling
- Query performance and connections
- Your own service-level indicators
Microsoft's alert guidance gives examples of CPU above 90%, data IO above 90%, and data space used above 95%. Treat them as starting points, not guarantees. Add alerts for cost spikes and any database taking a disproportionate share.
Rebalance and review
Move a database when it outgrows the pool's pattern. Options include:
- Shifting it to another pool or to standalone capacity
- Creating separate pools for incompatible workloads
- Adjusting min/max limits
- Resizing the pool
Moves use az sql db update --elastic-pool or Set-AzSqlDatabase, and same-server membership still applies.
For governance, use consistent naming and tags. The Cloud Adoption Framework suggests tags like costcenter and department, with Azure Policy to enforce them.
Also put in place:
- Change approvals
- Environment separation
- A recurring review of usage and pricing
Conclusion: Make Elastic Pool Sizing Evidence-Based
The best configuration matches shared capacity to real concurrent behavior, then validates storage, limits, availability, and total cost as separate checks.
Your next steps:
- Collect representative utilization data
- Model pooled and standalone options in the Azure Pricing Calculator
- Keep right-sizing from monitoring results
Frequently Asked Questions
What is the maximum pool size in SQL?
It depends on purchasing model, tier, hardware, and region. As of Microsoft's documentation, DTU Standard pools reach 3,000 eDTUs and 4,096 GB, and Gen5 vCore pools reach 128 vCores. Check the latest limits page before planning.
When should I use an Azure SQL elastic pool?
Use one for many databases with variable or bursty workloads whose peaks don't coincide. Avoid pools for consistently busy databases or those needing dedicated performance.
How do I size an Azure SQL elastic pool?
Gather historical utilization, find concurrent peaks, add storage and growth, set per-database limits, and add headroom. Validate in the Pricing Calculator and monitor after deployment.
What is the difference between DTU and vCore elastic pools?
DTU bundles CPU, memory, and I/O into eDTUs. vCore lets you choose compute and storage independently and supports Azure Hybrid Benefit. Compare current tier features and prices for your workload.
How are Azure SQL elastic pools billed?
Billing depends on model, tier, compute, storage, region, and related services or discounts. Use current Azure pricing data for an exact estimate.
Can databases in an Azure SQL elastic pool be on different servers?
No. All databases in a pool must share one logical server. Verify current placement and migration rules before moving databases.