Benchmark Results: The Fastest Time-Series Database on Azure

We evaluated real-time analytics performance using RTABench, an accessible benchmark featuring 181 million time-series events from a simulated e-commerce system highlighting real-time analytic queries. 

We tested three platforms on comparable Azure infrastructure:

• Vanilla Azure Database for PostgreSQL Flexible Server running on Standard_D8ds_v5 (8 vCores, 32GB RAM, Premium SSD)
• The same Postgres instance after enabling the TimescaleDB extension (TimescaleDB Apache 2 Edition)
• Tiger Cloud on Azure (8 vCores, 32GB RAM)

Tiger Cloud delivered dramatically superior performance. Across all 40 queries, Tiger Cloud's median query time was 280x faster than TimescaleDB and 1,200x faster than vanilla PostgreSQL. 

Query times ranged from milliseconds to sub-second on Tiger Cloud, while both PostgreSQL variants required seconds to minutes for the same operations. This is because Tiger Cloud is the only platform with complete time-series feature support:

• TimescaleDB lacks compression and continuous aggregates due to Apache license restrictions.
• Vanilla PostgreSQL has neither hypertables nor any time-series optimizations.

Raw Results

Detailed RTABench Summary (seconds, median of 3 runs)

Do It Yourself: RTABench on Azure

Expainer: RTABench

RTABench is an open-source, real-time analytics benchmark designed to measure how well a transactional database handles analytic queries, particularly those requiring joins and filtering over a normalized schema.

The dataset contains ~171 million events across 1,102 customers, 9,255 products, and 10,010,342 orders, providing a realistic, scalable application workload. RTABench supports a number of databases, and the benchmark has been written to take advantage of each database’s capabilities when appropriate, e.g., TimescaleDB features like hypertables, compression, and columnar storage.

Now that Tiger Cloud is launched on Azure, you can run these benchmarks yourself and observe comparable results. 

Setup: Client Host

1. For a client host, start a Standard_D2s_v3 instance running Linux (ubuntu 24.04) with 2 vCPUs and 8GB RAM. 

2. Increase its disk size to accommodate the data set.

Test 1: Tiger Cloud

1. Sign up for Tiger Cloud and select a “Real-time analytics” service type.

2. Spin up an 8 CPU 32GB dev service in Azure.

3. Note the connection string or save the config:

4. On the client host, git clone this fork of RTABench. The fork tweaks the benchmark invocation scripts to accept a connection string for Postgres rather than spinning it up with Terraform.
5. In the tigercloud-manual directory, edit benchmark.sh to provide your connection string.
6. To run the benchmark in the background and correct for inconsistent network connections between your cafe and your client host, use nohup and make it a background process:

nohup ./benchmark.sh > benchmark_output.log 2>&1 &

When done, in addition to a verbose report, the output should contain query times measured in very few seconds. One line per query, each query runs three times. 

Test 2: Azure Database for Postgres 

Now that we have a Tiger Cloud baseline, let’s compare it to Azure Database for Postgres. Presuming this is naive vanilla Postgres, we don’t have any timescale specific features such as hypertables, let alone continuous aggregates or vectorized storage. We use the Postgres test in RTAbench for this.

1. In the Azure portal, create an Azure Database for Postgres Flexible Servers instance in the same region as the client host, matching compute and storage settings for the Tiger Cloud instance. It’s expensive, so don’t leave it running for a long time.

You can view the connection string from the Azure portal as well:

2. On the client host, in the postgres-manual subdirectory:

Edit benchmark.sh and provide the connection string

Use nohup and make it a background process:

nohup ./benchmark.sh > benchmark_output.log 2>&1 &

After a while, your output should contain values measured in quite a few seconds:

Test 3: TimescaleDB Extension

The TimescaleDB extension that’s available with Azure Database for Postgres is the Apache 2 Edition. It lacks columnar storage, native compression, and incremental continuous aggregates. 

1. To enable the TimescaleDB extension on your Azure Database extension, click TIMESCALEDB on azure.extensions and shared_preload_libraries server settings:

This will require a restart of Postgres. That should take less than 5 minutes.

2. In the timescale-manual directory, edit benchmark.sh and provide the connection string.

Use nohup and make it a background process:

nohup ./benchmark.sh > benchmark_output.log 2>&1 &

Examine the output. You may see errors around unsupported functions such as continuous aggregates. This is to be expected due to the limitations with Apache Licensed TimescaleDB.

Resetting Postgres

Between tests, and if you need to restart due to an issue, you can wipe Postgres clean as follows:

psql "$CONNECTION_STRING" -c "DROP SCHEMA public CASCADE;"
psql "$CONNECTION_STRING" -c "CREATE SCHEMA public;"
psql "$CONNECTION_STRING" -c "GRANT ALL ON SCHEMA public TO myuser;"
psql "$CONNECTION_STRING" -c "GRANT ALL ON SCHEMA public TO public;"

Analyzing the Results

RTABench includes query performance results in its output. Each query is run three times and performance is reported one line per query, one value per issuance. Output should be scanned for errors and warnings that invalidate the results. Usage of unsupported features, such as continuous aggregates on TimescaleDB Apache 2 or hypertables on Vanilla Postgres may also be reported as an error.

For fun, you can upload the benchmark output files to an LLM and have a conversation. We were particularly amused at how excited Claude got by Tiger Cloud’s millisecond latency after seeing the Vanilla Postgres results:

Run Real-Time Workloads on Azure the Way They Were Meant to Run

Microsoft often recommends Azure Data Explorer for time-series workloads because of its rich user experience and optimizations for high-volume, timestamped data. We didn’t run that benchmark at this time because RTABench doesn’t yet support Kusto Query Language (KQL), although the non-standard query language might be a compelling reason to keep time-series workloads in Postgres.

This benchmark makes the broader point clear. If you’ve been held back by slow queries, storage tradeoffs, or the limitations of the Apache 2 Edition on Azure Database for PostgreSQL, Tiger Cloud changes what’s possible on Azure. You get:

• Postgres you already know
• The full TimescaleDB feature set
• Azure-native deployment and billing

And you get performance that is consistently measured in milliseconds, not seconds or minutes.

Resources:

• Azure documentation
• Get started on Azure Marketplace

Questions or want to discuss your architecture? Talk to our solutions team.

About the author

Jeff Bean, a Staff Technical Marketing Engineer at Tiger Data, has a career focused on data infrastructure, including distributed data and stream processing frameworks like Apache Flink, Kafka, and Hadoop. He specializes in understanding the performance of analytical queries and is frustrated by the continued need to move data between operational and analytical systems in 2025. With experience across roles like software engineer, solutions architect, and technical marketer, he lives with his wife, two dogs, and teenage daughter.