Snowflake Postgres Delivers More Headroom for High-Throughput Workloads vs. Databricks Lakebase
William McKnight and Jake Dolezal
TL;DR:
- Snowflake Postgres delivered a decisive 4x throughput lead over Databricks Lakebase (peaking at 659,139 vs. 162,996 TPM) on equivalent compute baselines.
- As concurrency increased from 72 to 96 virtual users, Snowflake Postgres throughput rose from 530,145 to 621,975 TPM, while Databricks Lakebase rose from 130,944 to 142,083 TPM. Lakebase’s smaller throughput gain means less additional capacity to process transactions as demand grows – a constraint customers should evaluate against their peak workload requirements.
- Both engines reached their highest measured throughput at 144 virtual users: 659,139 TPM for Snowflake Postgres versus 162,996 TPM for Databricks Lakebase.
- For both Snowflake Postgres and Databricks Lakebase, the tested 384 WH configuration did not deliver higher transactional throughput than the 96 WH configuration.
- While Snowflake held resilient across larger cluster sizes (~620K–640K TPM), Databricks degraded sharply by ~38% at 384 WH due to severe inter-node contention.
- For high-throughput transactional workloads, Snowflake Postgres delivered approximately 4x the peak throughput of Databricks Lakebase in the tested configurations, providing more headroom to meet peak transaction demand.
Executive Overview
This benchmark report evaluates the transactional throughput and scalability of Snowflake Postgres (configured on HIGHMEM_4XL compute) against Databricks Lakebase (configured on 64 CU compute) under simulated enterprise operational load using the HammerDB TPROC-C workload, an OLTP workload derived from the TPC-C specification. The quantitative findings demonstrate a decisive performance differential: Snowflake Postgres established a ~4x throughput advantage over Databricks Lakebase, achieving a peak transactional velocity of 659,139 TPM compared to Databricks Lakebase’s peak of 162,996 TPM. While both engines ran on matched compute baselines (32GB–128GB RAM profiles), Snowflake Postgres sustained near-linear scale under heavy concurrency where Databricks Lakebase hit early operational ceilings.
For enterprise data architects and engineering leadership, modern data platform design is undergoing a structural shift toward the convergence of transactional processing (OLTP) and analytical processing (OLAP). Traditionally, organizations maintained distinct database stacks for operational systems and analytical data warehouses. However, maintaining dual systems introduces substantial operational overhead: complex ETL pipelines, elevated data storage duplication, state drift risk, and persistent data synchronization latencies that hinder real-time decision-making.
Bringing PostgreSQL-compatible transactional processing into a broader data platform makes operational workload capacity a key evaluation criterion. This benchmark focuses on that requirement: how much transactional throughput each tested configuration delivers as concurrency increases. It does not evaluate simultaneous transactional and analytical workloads or pipeline elimination.
Testing Methodology and Benchmark Environment
To validate whether these consolidation claims hold under real-world enterprise pressure, we put this unified architecture to the test against isolated workloads in a controlled head-to-head benchmark.
To ensure empirical rigor, repeatable execution, and platform neutrality, our Postgres benchmarking environment established strict configuration parity and identical cloud operating conditions across both platform architectures.
| Parameter | Specification / Configuration | Technical Rationale |
| Framework | HammerDB | Utilized as the standard, trusted open-source benchmark framework for running the TPROC-C OLTP workload. |
| Workload Operations | HammerDB TPROC-C (derived from TPC-C): New-Order, Payment, Order-Status, Delivery, Stock-Level. | Simulates a realistic e-commerce operational data model with complex, multi-table transactions involving continuous read/write mutations and strict ACID integrity. |
| Execution Protocol | 5-minute warm-up followed by a 20-minute timed execution window | Eliminates startup cache cold-start artifacts and ensures database engine memory structures, buffer pools, and thread pools reach steady-state before metric capture. |
| Scale & Concurrency | Incremental scaling across 12, 24, 36, 48, 72, 96, 144, and 192 virtual users | Evaluates concurrency scaling curves, throughput inflection points, and engine stability from light operational load to heavy resource contention. |
| Infrastructure Parity | Compute and data colocated within the same cloud region and Availability Zone (AWS/Azure) | Eliminates cross-region and cross-AZ network round-trip latencies, isolating pure engine execution and storage layer efficiency. |
| Compute Specs | Snowflake Postgres (HIGHMEM_4XL, 32GB–128GB RAM) vs. Databricks Lakebase (64 CU, 32GB–128GB RAM) | Standardizes memory profiles and compute baselines across both serverless SQL Postgres-compatible interfaces. |
Test Environment Note: Testing was conducted in April 2026, when both Snowflake Postgres and Databricks Lakebase were generally available. Results reflect the GA versions of each platform at the time of testing.
Throughput Performance & Concurrency Scaling Analysis
The benchmark evaluated transactional throughput measured in Transactions Per Minute (TPM) across an escalating range of virtual user concurrencies using the standardized 96 Virtual Warehouse (WH) baseline.
HammerDB TPROC-C Throughput Results (TPM)
| Virtual Users (Concurrency) | Databricks Lakebase 64 CU (96 WH) | Snowflake Postgres HIGHMEM_4XL (96 WH) | Snowflake Throughput Advantage |
| 12 | 46,172 | 184,816 | 4.00x |
| 24 | 77,696 | 264,248 | 3.40x |
| 36 | 98,150 | 343,841 | 3.50x |
| 48 | 114,891 | 434,766 | 3.78x |
| 72 | 130,944 | 530,145 | 4.05x |
| 96 | 142,083 | 621,975 | 4.38x |
| 144 (~150 Peak) | 162,996 | 659,139 | 4.04x |
| 192 | 161,226 | 639,567 | 3.97x |
Concurrency Milestones & Scaling Trajectory
- Low Concurrency (12–36 Virtual Users): Snowflake Postgres establishes an immediate baseline performance lead, generating 184,816 TPM at 12 users compared to Databricks Lakebase’s 46,172 TPM.
- Mid Concurrency (48–96 Virtual Users): Snowflake maintains a near-linear throughput trajectory, climbing from 434,766 TPM (48 VUs) to 621,975 TPM (96 VUs). Databricks Lakebase’s growth curve flattens significantly past 72 VUs (130,944 TPM), signaling internal concurrency throttling.
- Peak Concurrency (144 Virtual Users): Both platforms achieve peak operational throughput at approximately 144 to 150 virtual users. Snowflake Postgres reaches its maximum velocity at 659,139 TPM, whereas Databricks Lakebase plateaus at 162,996 TPM.
- High Contention (192 Virtual Users): Snowflake Postgres delivered 639,567 TPM, compared with Databricks Lakebase’s 161,226 TPM. For a workload requiring 500,000 TPM, Snowflake exceeded that throughput requirement in this test, while the tested Lakebase configuration did not. The customer implication is whether the database can meet peak transaction demand – not simply which engine is faster. These results apply to the tested workload and configurations; meeting application latency requirements requires separate validation.
Database Engine Scaling Mechanics
The structural variance in throughput curves stems from how each platform’s transactional engine handles PostgreSQL write concurrency. In PostgreSQL architectures, scaling write-heavy transactional workloads requires managing row-level lock contention, Write-Ahead Logging (WAL) flush bottlenecks, shared-memory buffer pool synchronization, and process/thread context switching overhead.
Snowflake Postgres exhibits a highly optimized distributed memory and transaction coordinator architecture. It minimizes thread contention and WAL append latencies, enabling near-linear throughput gains up to 96 concurrent clients. Conversely, Databricks Lakebase encounters early architectural ceilings. As concurrent client connections increase beyond 72 virtual users, inter-thread synchronization overhead and storage layer commit serialization introduce latency bottlenecks that cap transaction execution rates.
Tail Latency (P95) and Operational Business Impact
Beyond aggregate TPM metrics, P95 tail latencies and price/performance directly influence enterprise application outcomes:
- User Experience Stability: Lower P95 tail latencies prevent request queueing under sudden concurrency spikes (e.g., promotional flash sales or high-volume financial clearing windows), ensuring sub-second UI responsiveness for customer-facing portals.
- Real-Time Operational Ledgers: Stable transactional tail latencies permit concurrent analytical micro-queries to read fresh state without locking operational tables or driving write transactions into deadlock timeouts.
- Price-Performance Efficiency: Snowflake’s ability to process 4x more transactions per minute on equivalent compute footprints dramatically lowers the net cost per transaction, reducing total cost of ownership (TCO) for enterprise hybrid workloads.
Compute Allocation Insights: Coordination Overhead vs. Raw Scale
Testing across virtual warehouse allocations (96 WH, 192 WH, and 384 WH) revealed a critical architectural insight regarding transactional scaling versus analytical scaling:

- The OLAP vs. OLTP Scaling Paradox: In analytical processing (OLAP), scaling out warehouse node allocations (e.g., from 96 WH to 384 WH) yields near-linear query acceleration because analytical workloads rely on embarrassingly parallel table scans and read-only aggregations across partitioned files. In contrast, transactional processing (OLTP) involves multi-row mutation dependencies, fine-grained row-level locking, and distributed state consensus.
- Coordination Overhead Outweighs Raw Compute: Across both platforms, provisioning a 384 WH configuration failed to yield higher transactional throughput than a 96 WH configuration. Expanding the compute cluster horizontally introduces inter-node state synchronization overhead, network messaging delays between distributed lock managers, and cross-node two-phase commit consensus protocols.
- Asymmetric Architectural Degradation: While the 96 WH configuration routinely outpaced larger allocations across both engines, the performance degradation under 384 WH was drastically asymmetric:
- Snowflake Postgres Resilience: Snowflake’s 192 WH and 384 WH configurations remained tightly clustered near its 96 WH baseline (holding steadily at ~620,000–640,000 TPM at 192 virtual users), demonstrating robust distributed lock handling and memory management.
- Databricks Lakebase Degradation: Databricks Lakebase’s 384 WH configuration suffered severe performance degradation under high concurrency. At 192 virtual users, Lakebase throughput dropped down to ~100,000 TPM—representing a ~38% throughput loss relative to its own 96 WH peak of 162,996 TPM due to severe inter-node coordination contention.
Strategic Recommendations for Enterprise Data Architects
Based on the empirical findings of this benchmark evaluation, cloud data architects and technical leaders should apply the following guidelines when designing unified data architectures:
- Optimize Compute Sizing to Prevent Coordination Bottlenecks: Avoid automatically provisioning oversized compute warehouses (e.g., 384 WH) for PostgreSQL transactional engines under the assumption that larger nodes improve write speed. Right-sizing virtual database instances to moderate allocations (e.g., 96 WH) eliminates cross-node coordination overhead, prevents transactional lock degradation, and significantly optimizes compute expenditures.
- Prioritize Price-Performance and Total Cost Efficiency: Incorporate price-performance (cost per transaction) alongside aggregate throughput metrics when evaluating total platform cost. Selecting an engine that delivers a 4x throughput advantage on matched infrastructure allows enterprises to consolidate operational datamarts and analytical reporting onto a single cost-effective footprint without sacrificing transaction velocity or latency SLA compliance.
- Evaluate Architectural Ceilings under High Concurrency: Match platform engine capabilities directly to maximum anticipated peak transactional concurrency. Platforms that hit early operational ceilings (such as Databricks Lakebase at ~163K TPM) introduce severe transactional queuing risks during peak business hours. For mission-critical OLTP applications requiring high transaction density, select engines capable of scaling to ~660K TPM to ensure operational headroom.
Snowflake’s performance in the benchmark proves that its architecture delivers superior execution speed, lower total compute costs, and rock-solid operational stability in Postgres. For enterprise technology leaders seeking to eliminate architectural complexity, consolidate disparate data systems, and maximize return on data infrastructure investments, Snowflake represents a solid premier unified data platform for modern enterprise workloads.
FAQ
What workload and compute baselines were tested to ensure a fair comparison?
The benchmark evaluated pure transactional performance using HammerDB TPROC-C (derived from TPC-C) under strict configuration parity in the same cloud region and Availability Zone. Both engines ran on equivalent compute and memory profiles (Snowflake Postgres on HIGHMEM_4XL vs. Databricks Lakebase on 64 CU, each within 32GB–128GB RAM). Each run followed a 5-minute warm-up and a 20-minute timed steady-state test across 12 to 192 virtual users.
What was the primary performance takeaway from the benchmark?
Snowflake Postgres established a decisive ~4x throughput advantage over Databricks Lakebase across all tested concurrencies. Snowflake peaked at 659,139 Transactions Per Minute (TPM) at 144 virtual users, whereas Databricks Lakebase peaked at only 162,996 TPM at the same concurrency. This 4x differential held consistently from light client loads all the way through peak saturation.
How did the two platforms handle increasing concurrency?
Snowflake demonstrated near-linear throughput scaling from 12 through 96 virtual users, maintaining smooth execution before peaking at 144 users and gracefully tapering at 192. In contrast, Databricks Lakebase encountered an operational ceiling early, flattening noticeably past 72 virtual users due to internal concurrency throttling. As client contention escalated, Lakebase struggled with storage-layer commit serialization and thread-synchronization bottlenecks.
Why did larger compute warehouse allocations (384 WH) fail to improve OLTP throughput?
Unlike analytical processing (OLAP), which scales out near-linearly by parallelizing read-only scans, transactional processing (OLTP) requires distributed consensus and fine-grained row-level locking. Scaling cluster footprints to 384 WH introduced severe inter-node coordination and messaging overhead that outweighed the benefits of additional compute. As a result, both platforms delivered higher transactional throughput on moderate 96 WH configurations than on oversized clusters.
How did the two engines differ when running on oversized (384 WH) configurations?
Snowflake showed strong distributed state management, holding resiliently within the ~620,000–640,000 TPM range on 192 and 384 WH allocations. Conversely, Databricks Lakebase suffered acute performance degradation under 384 WH, plummeting to roughly 100,000 TPM at 192 virtual users. That represents a ~38% throughput collapse from its own 96 WH peak due to cross-node consensus contention.
What are the key architectural and cost implications for enterprise leaders?
Delivering 4x the transactional density on matched hardware gives Snowflake Postgres a dramatically lower net cost per transaction, improving overall transactional workloads. Furthermore, its higher concurrency ceiling (659K vs. 163K TPM) provides critical operational headroom, preventing query queuing and lockouts during sudden enterprise traffic surges. Organizations should avoid automatically oversizing clusters and instead right-size instances to moderate footprints like 96 WH to minimize lock contention.