TigerData pricing: what’s included in Free vs Performance vs Scale, and what will we actually pay?

Most teams looking at TigerData ask the same thing early on: what do we get in Free, Performance, and Scale—and what will we actually see on the bill? This guide walks through the plans in plain language, then ties it back to how you’ll actually run Postgres at telemetry scale.

Note: This overview is based on TigerData’s public docs and pricing posture. For exact current prices and Enterprise options, always confirm in Tiger Console or by contacting TigerData.

---

Quick Answer: TigerData pricing is built around transparent, consumption-based services with no per-query, ingest, or egress fees. You pick a plan (Free, Performance, or Scale), size your services, and pay only for active services and any clearly itemized add-ons (like production support).

The Quick Overview

• What It Is: A Postgres + TimescaleDB platform (Tiger Cloud plus extensions) priced per service, not per query, with plan tiers that unlock more performance, scale, and support.
• Who It Is For: Teams running time-series, event, and telemetry workloads on Postgres—everyone from side projects and POCs to high-throughput production systems in regulated environments.
• Core Problem Solved: Traditional “mystery-billing” telemetry stacks make costs unpredictable (per-query, per-GB scanned, hidden networking). TigerData keeps Postgres as the base and gives you transparent, resource-based pricing with clear plan boundaries.

How It Works

TigerData’s model is: choose a plan → create services → pay for the compute/storage you allocate and any explicit add-ons. There are no metered query charges and no ingest/egress surprises.

At a high level:

1. Pick your plan (Free, Performance, Scale, or Enterprise):
   The plan defines which features, performance envelopes, and support you get. You can start on a free trial of Performance or Scale, and even after the trial you can keep up to two free services (while free services are in beta).

2. Create and size services in Tiger Cloud:
   Each Tiger Cloud service is a Postgres + TimescaleDB instance. You choose:

   • CPU / memory size
   • Storage size
   • HA options (on paid plans)
   • Region (within TigerData’s supported cloud regions)
     You are charged for active standard services; pausing or deleting a service stops those charges.

3. Operate and scale with transparent billing:
   You see itemized usage in Tiger Console. Upgrading/downgrading between Performance and Scale is self-serve and prorated; Enterprise is customized via sales. Self-hosted TimescaleDB remains free.

Plan-by-plan: What’s included and how it feels in practice

Below, I’ll break this down as a product explainer so you can map each plan to real-world usage.

Free: experiments, POCs, and early-stage workloads

What’s included

• Up to 2 free services per account (currently in beta).
• Postgres + TimescaleDB hypertables, compression, continuous aggregates, and time-series SQL functions.
• Access to Tiger Console for:
  • Service creation and management
  • Basic monitoring and metrics
  • Manual backups and restores (within the limits defined for free services)
• Email-based support on a best-effort basis (for account and platform issues).

How it’s billed

• $0 for free services (within free limits).
• If you activate a 30-day free trial of Performance or Scale, you run on that plan with no charges for the trial period. After the trial:
  • You can keep up to 2 free services.
  • Any additional standard (non-free) services are billed per plan and size.

When Free makes sense

• You’re validating TigerData for a telemetry heavy workload.
• You’re testing schema design: CREATE TABLE …, converting to hypertables, experimenting with CREATE INDEX strategies, continuous aggregates, and retention policies.
• You don’t have strict SLAs or large data volumes yet.

Key constraints to assume

• Lower resource ceilings than paid plans.
• Not intended for critical production: reduced HA options, more limited support expectations, and smaller performance envelope.
• You’re still charged for any non-free services you create, even if you’re “just testing” them.

Important: You are charged for all active standard services, even if you are not actively using them. Pause or delete unused services to avoid unnecessary costs.

---

Performance: steady production workloads with clear growth paths

What’s included

Performance is the “default” paid plan for production workloads that need reliable throughput and observability without extreme scale requirements.

Typical inclusions:

• Postgres + TimescaleDB with all core telemetry primitives:
  • Hypertables for automatic partitioning by time and key.
  • Hypercore row-columnar storage for efficient writes and analytics.
  • Compression (up to ~98% size reduction on historical data).
  • Continuous aggregates (CREATE MATERIALIZED VIEW … WITH (timescaledb.continuous=true)) plus add_continuous_aggregate_policy.
• Disaggregated compute and storage:
  • Scale CPU/memory and storage independently.
  • Configure tiered storage policies to move cold chunks to cheaper storage.
• Availability & operations:
  • Managed backups and point-in-time recovery (PITR).
  • HA settings appropriate to the plan (e.g., multi-AZ HA on certain instance sizes; see current docs).
  • Automated updates and patching.
• Support:
  • Email support included.
  • Production support available as an add-on.
• Billing posture:
  • No per-query fees.
  • No additional costs to read or write data.
  • No ingest/egress charges for normal usage; any exceptional additional charges are clearly marked in the billing snapshot.

How it’s billed

• Pay for active services (size × hours in the month) with consumption-based compute and storage.
• Backups, PITR, and normal traffic are included; you don’t pay extra per query or per GB scanned.
• If you switch between Performance and Scale mid-month, billing is prorated from the time of the switch.
• If you sign up via AWS Marketplace, you can choose pay-as-you-go or annual commit per AWS pricing.

When Performance makes sense

• You’re running production apps with telemetry workloads (metrics, IoT, events) and need:
  • Predictable performance
  • Automated backups and recovery
  • Clear, non-surprise billing
• Your ingest volume is material, but not yet “3 trillion metrics/day” at the single service level.
• You want to consolidate operational Postgres and analytics patterns into one Tiger Cloud service rather than stitching Kafka/Flink/warehouse for every use case.

---

Scale: high-ingest, large retention, and advanced operations

What’s included

Scale extends Performance with more capacity, more aggressive scaling options, and additional platform capabilities for large telemetry estates.

Common inclusions beyond Performance:

• Higher resource ceilings:
  • Larger CPU/memory instances.
  • Higher storage and IO envelopes.
  • More aggressive autoscaling patterns.
• More replicas and HA options:
  • Multiple read replicas for fan-out analytics.
  • Stronger HA and RPO/RTO guarantees (check current plan matrix).
• Advanced data lifecycle:
  • More flexible tiered storage and retention for petabyte-scale telemetry.
  • Integration patterns for streaming into data lakes (e.g., Iceberg) with “native infrastructure,” instead of custom glue code.
• Support and onboarding:
  • Email support included.
  • Production support as an add-on (often standard at larger commitments).
  • JOIN services (Jumpstart Onboarding and INtegration) are available at a minimum spend.

How it’s billed

• Same no per-query, no ingest/egress posture as Performance.
• You pay for bigger/more services, replicas, and any support add-ons.
• Upgrade/downgrade between Performance and Scale at any time in Tiger Console; prorated pricing applies.

When Scale makes sense

• You’re pushing high-ingest workloads (e.g., hundreds of billions to trillions of metrics per day) and large historical retention on a single service.
• You need multiple read replicas for:
  • Dashboard fan-out
  • Heavy analytics
  • AI/RAG/vector workloads over time-series data
• You’re consolidating multiple fragile pipelines (Kafka, Flink jobs, custom S3 sync scripts) into a Postgres-native platform and need both ingest and analytics at petabyte scale.

---

Enterprise: regulated environments and organization-wide adoption

Enterprise is for teams with compliance requirements (GDPR, HIPAA) and strict SLAs.

What’s included (high level)

• Everything in Scale, plus:
  • Production support included with SLA-based response times.
  • Named account manager.
  • JOIN services included (or heavily leveraged) to migrate and optimize.
  • Compliance features: SOC 2 Type II reporting, GDPR support, HIPAA availability.
  • Enhanced networking setups (VPC peering, Transit Gateway, IP allowlists) and detailed security controls:
    • TLS 1.2+ for all client connections.
    • Mutual TLS for critical internal traffic.
    • Encryption at rest with per-service keys and documented rotation cadence.

How it’s billed

• Custom pricing via sales; often includes:
  • Volume discounts or committed usage.
  • SLAs tied to response times and availability.
  • Enterprise support and onboarding packaged in.
• You still get the same core posture:
  • No per-query fees.
  • Transparent, itemized invoicing.
  • Billed monthly in arrears (or per negotiated contract).

---

Features & Benefits Breakdown

Here’s how the pricing tiers map back to concrete Postgres primitives and outcomes.

Core Feature	What It Does	Primary Benefit
Hypertables & automatic partitioning	Partition tables by time and key inside Postgres, automatically managing chunks and indexes.	High ingest + fast queries on large time-series tables.
Hypercore row-columnar storage	Stores hot data row-oriented for writes and cold data columnar for scans and analytics.	Real-time ingest with analytics-speed queries on historical data.
Tiered storage & compression	Moves cold chunks to cheaper storage and compresses them (up to ~98% reduction).	Lower storage cost at long retention, without offloading to S3 + glue.
Managed HA, backups, and PITR	Handles replicas, failover, backups, and point-in-time recovery for you.	Production-grade resilience without homegrown ops.
Transparent, resource-based pricing	Charges per service resources, not per query or per GB scanned.	Predictable bills even as query volume and complexity grow.

Ideal Use Cases

• Best for Free:
  Because it lets you prototype schemas, ingestion patterns, and queries on TigerData at no cost (up to 2 services) before committing. Perfect for hack projects, early proofs-of-concept, and developer sandboxes.

• Best for Performance:
  Because it gives you a solid production footing—HA, PITR, time-series primitives, and Postgres-native tooling—with transparent, pay-as-you-go pricing. Ideal for SaaS apps, IoT platforms, and internal tools where workloads are meaningful but not yet “extreme scale.”

• Best for Scale:
  Because it’s tuned for high-ingest telemetry, long-term retention, and multiple read replicas, while still preserving Postgres simplicity. Ideal for observability platforms, industrial IoT, fintech tick/event data, and AI/search over large historical datasets.

• Best for Enterprise:
  Because it adds compliance, support SLAs, and governance on top of Scale. Ideal for healthcare, finance, and large organizations standardizing on “Postgres for live telemetry” across many teams.

Limitations & Considerations

• Active services always bill (outside free services):
  You are charged for all active standard services, even if there’s no traffic.
  Workaround: Use Tiger Console to pause or delete unused services. Regularly review the billing snapshot to remove stale environments.

• Feature sets differ by plan:
  Some capabilities (larger instance sizes, more replicas, JOIN services, Enterprise compliance features) are only available on Scale or Enterprise.
  Workaround: Start on Performance, monitor bottlenecks (CPU, IO, replica lag, analytics workloads), and upgrade to Scale or Enterprise when your actual usage justifies it. Upgrades between Performance and Scale are prorated and self-serve.

Pricing & Plans

TigerData’s plans are structured to grow with you:

• No per-query fees: You can hit the database as frequently as you need without worrying about mysterious “query-based” line items.
• No ingest or egress charges: Normal reads/writes are not a separate billing dimension; networking charges only appear if there are explicit, clearly marked extras.
• Disaggregated compute and storage: You size CPU/memory separately from storage and pay for each based on usage.
• Transparent billing: Any additional charges are clearly marked in your billing snapshot in Tiger Console.

You can:

• Activate a 30-day free trial of the Performance or Scale plan (no credit card required).
• Keep using up to 2 free services after the trial (while free services remain in beta).
• Upgrade or downgrade between Performance and Scale at any time; pricing is automatically prorated to the day you switch.
• Move to Enterprise with a customized quote by contacting TigerData.

Example plan mapping (conceptual):

• Free: Best for teams exploring TigerData, building POCs, or running non-critical dev environments that fit within free service limits.
• Performance: Best for teams needing production reliability and normal telemetry scale—steady metrics, events, or IoT data, with HA and PITR.
• Scale: Best for teams that know they will hit high ingest rates, long-term retention, larger instance sizes, and need more replicas and integration depth.
• Enterprise: Best for organizations that require compliance, SLAs, named account management, and organization-wide adoption support.

Frequently Asked Questions

Do I pay more when my query volume increases?

Short Answer: No. TigerData does not charge per query or per GB scanned.

Details:
You pay based on the resources of your active services (compute, storage, replicas) and any explicit add-ons (like production support). You can run more queries, more complex SQL, or heavier analytics workloads without triggering a separate meter. This is especially important for telemetry and analytics workloads where read volumes can spike dramatically; you scale your service size or replicas when necessary, but the billing model itself doesn’t punish you for usage patterns.

---

What happens to my pricing if I change plans mid-month?

Short Answer: Your charges are prorated to the time you switch.

Details:
When you move between Performance and Scale using Tiger Console:

• The portion of the month on your original plan is billed under that plan’s rates.
• The remaining portion after the switch is billed under the new plan’s rates.
• You see the breakdown in Tiger Console’s billing snapshot.
  If you’re moving to Enterprise, you’ll work with TigerData to define a new contract; from that point onward, the Enterprise terms apply. In all cases, free services remain free (within their limits) unless you explicitly convert them to standard services.

---

Summary

TigerData pricing is intentionally boring and transparent: you choose a plan (Free, Performance, Scale, or Enterprise), run Postgres + TimescaleDB services sized for your workload, and pay for the resources you use—without per-query or ingest/egress surprises.

• Free lets you validate the platform and run small workloads with up to 2 services at no cost.
• Performance covers most production use cases with managed HA, PITR, and disaggregated compute/storage.
• Scale adds higher ceilings, more replicas, and better fit for very high-ingest telemetry and large historical datasets.
• Enterprise layers in compliance, SLAs, and deep onboarding and support.

The result: you keep a Postgres-native stack while gaining the primitives you need for live telemetry—hypertables, Hypercore, tiered storage, lakehouse integration—on a pricing model you can actually reason about.

Next Step

Get Started