SOC 2 compliant managed Postgres for time-series / observability data

A lot of teams outgrow DIY Postgres the moment observability, metrics, and event data start to look like a production system—and that’s exactly when SOC 2, uptime SLAs, and “no surprises” operations become non‑negotiable. This page explains how TigerData gives you a SOC 2 compliant, fully managed Postgres platform purpose‑built for time‑series and observability workloads.

Quick Answer: TigerData is a managed Postgres + TimescaleDB platform that combines SOC 2 Type II controls, encryption, HA, and backups with time-series primitives like hypertables, row‑columnar storage, and tiered storage—so you can store and query observability data at scale without building fragile, high‑maintenance pipelines.

The Quick Overview

• What It Is: A managed, SOC 2 compliant Postgres platform optimized for time-series, event, and observability workloads, powered by TimescaleDB and TigerData’s Hypercore storage.
• Who It Is For: SRE and platform teams, SaaS observability vendors, IoT and telemetry platforms, and engineering orgs that need regulated‑grade Postgres for high‑ingest metrics, logs, and traces.
• Core Problem Solved: Plain Postgres becomes slow, expensive, and operationally risky when you push observability workloads to production scale. TigerData keeps everything Postgres‑native while giving you time-series performance, predictable operations, and compliance.

How It Works

At its core, TigerData is still Postgres—boring, reliable, and endlessly extensible—but it’s extended with TimescaleDB and TigerData primitives specifically for live telemetry, then wrapped in a managed, SOC 2 audited cloud service.

Under the hood, TigerData adds:

• Hypertables for automated time- and key-based partitioning
• Hybrid row‑columnar storage (Hypercore) for fast writes and compressed analytics
• Tiered storage that moves cold data to object storage while keeping a single Postgres interface
• Time-series SQL functions and continuous aggregates for real-time rollups
• Cloud‑native operations: HA, backups, point-in-time recovery, and security controls that meet SOC 2 Type II standards

From your side, you connect to Postgres using standard drivers, create schemas with CREATE TABLE, and then opt into time-series behavior via TimescaleDB functions (for example, create_hypertable, compression policies, and continuous aggregates).

1. Ingest & model your observability data

   • Use the Postgres wire protocol with your existing agents and services.

   • Model metrics, logs, and traces as normal tables:

     CREATE TABLE metrics (
       time        TIMESTAMPTZ       NOT NULL,
       service     TEXT              NOT NULL,
       metric_name TEXT              NOT NULL,
       value       DOUBLE PRECISION  NOT NULL,
       labels      JSONB             NOT NULL,
       cluster     TEXT              NOT NULL
     );
     

   • Convert to a hypertable so TigerData handles partitioning for you:

     SELECT create_hypertable(
       'metrics',
       by_range('time'),
       partitioning_key => 'cluster'
     );
     

   TigerData takes it from there: automatic chunking, partition management, and index behavior tuned for time‑based workloads.

2. Store more data for less with Hypercore and tiered storage

   • Recent data stays in rowstore for fast inserts and point lookups.
   • Older chunks are converted into columnar storage and compressed (up to ~95% in standard TimescaleDB docs, often higher—TigerData cites up to 98% in production).
   • Tiered storage can automatically move cold chunks to low‑cost object storage, while queries still target the same hypertable.

   Example: compress chunks older than 7 days:

   SELECT add_compression_policy('metrics', INTERVAL '7 days');
   

   The result: petabyte‑scale observability datasets in a single Postgres service, without the typical index bloat and storage shock.

3. Operate with SOC 2, HA, and real SRE‑grade controls

   • Encryption in transit (TLS 1.2+ and mutual TLS for critical internal traffic).
   • Encryption at rest with per‑service keys.
   • High availability with automatic failover and multi‑AZ replication (plan‑dependent).
   • Automated backups and point‑in‑time recovery.
   • Access control via IP allow lists and private networking options (VPC peering, etc.).
   • SOC 2 Type II compliance, GDPR support, and HIPAA on Enterprise.

   You get observability‑grade Postgres with the same operational posture you’d expect for your core application database—without running the cluster yourself.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Hypertables & automatic partitioning	Partitions tables by time (and optional key) into chunks, with Postgres‑native queries.	Keeps high‑ingest observability tables fast and manageable as they grow, without manual sharding.
Hybrid row‑columnar storage & compression	Stores recent data in rowstore for writes, older data in compressed columnstore.	Up to ~95–98% compression and fast analytical scans on historical metrics and logs.
Tiered storage to object stores	Moves cold chunks to low‑cost object storage while keeping them transparently queryable.	Retain long‑term observability data (months/years) without blowing up storage costs.
Continuous aggregates	Materializes and incrementally refreshes aggregate views over hypertables.	Real‑time rollups (1m, 5m, 1h) for dashboards and SLOs without hammering the raw data.
Cloud-native observability & Insights	Deep database observability beyond pg_stat_statements via TigerData Insights.	See slow queries, bottlenecks, and growth patterns to tune schemas and indexes.
Managed, SOC 2 compliant operations	HA, backups, PITR, encryption, access controls, and audited processes.	Use Postgres for regulated telemetry workloads without building an internal DB ops team.

Ideal Use Cases

• Best for central observability platforms:
  Because it lets you ingest metrics, events, and traces directly into Postgres with hypertables, keep months or years of history compressed and tiered, and satisfy SOC 2 requirements for the platform itself.

• Best for SaaS products built on telemetry data:
  Because you can run customer‑facing analytics, SLO dashboards, and alerting on the same SOC 2 compliant Postgres foundation, with predictable performance at “billions of rows per day” scale and without stitching Kafka, Flink, and a separate lakehouse together.

Limitations & Considerations

• Not a log shipper or agent:
  TigerData is the database layer, not a replacement for your log agents or metrics collectors. You still use tools like Prometheus remote‑write, OpenTelemetry, Vector, or custom services to send data into Postgres.

• Time-series opinionated defaults:
  Hypertables, compression, and continuous aggregates are optimized for time‑based workloads. For purely OLTP-style transactional workloads you may want separate logical databases or services, or more conservative use of time-series features.

Pricing & Plans

TigerData keeps pricing simple and transparent: you pay for provisioned compute and storage for each service, with no per‑query fees and no extra charges for automated backups or ingest/egress networking. Usage is itemized and billed monthly in arrears, so you can connect cost directly to your telemetry scale.

While exact numbers depend on region and configuration, plans roughly map to:

• Performance: Best for teams needing a SOC 2 aware, managed Postgres for observability POCs, internal SRE platforms, or lower‑traffic SaaS telemetry features. You get TimescaleDB features, HA options, and automated backups with straightforward scaling.
• Scale / Enterprise: Best for teams needing multi‑AZ high availability, strict SLOs, and regulated‑environment support (SOC 2 Type II, GDPR support, and HIPAA on Enterprise). Ideal when you’re running customer‑facing observability or compliance‑sensitive workloads and need 24/7 operations support with SLA‑based response times.

For exact pricing, region options, and plan capabilities (HA, PITR windows, support tiers), contact TigerData directly.

Frequently Asked Questions

How does TigerData meet SOC 2 requirements for managed Postgres?

Short Answer: TigerData combines technical controls (encryption, HA, backups, access control) with audited processes and monitoring to achieve SOC 2 Type II compliance for its managed Postgres platform.

Details: On the technical side, TigerData enforces encryption in transit (TLS 1.2+ and mutual TLS for critical internal traffic) and encryption at rest with per‑service keys. Network access is restricted via IP allow lists and private networking options. High availability and automated backups with point‑in‑time recovery help meet availability and resilience controls. Operationally, TigerData maintains SOC 2 Type II compliance, aligns with GDPR, and offers HIPAA support on Enterprise plans. Combined with fine‑grained Postgres role management, auditability, and TigerData’s 24/7 operations, this forms a compliant foundation for storing observability and telemetry data.

Can I run both real-time dashboards and long-term analytics on the same service?

Short Answer: Yes. Hypertables, continuous aggregates, and tiered storage are designed to support both real‑time dashboards and deep historical queries on a single Postgres service.

Details: Recent data lives in rowstore, where inserts and low‑latency queries (for example, “last 5 minutes for this service”) stay fast. Continuous aggregates pre‑compute rollups like 1m or 5m averages, which you query directly from dashboards to avoid scanning billions of raw rows. As data ages, compression policies convert chunks into columnstore and optionally tier them to object storage. Because TimescaleDB ensures all of this remains visible through the same hypertable, you write one query for “last 24h” or “last 90 days”—TigerData handles which chunks are scanned and how. This setup is ideal for observability workloads where engineers want a consistent SQL surface for both incident response and trend analysis.

Summary

If you’re trying to run serious observability or telemetry workloads on Postgres, the trade‑off usually comes down to: build a fragile, high‑maintenance pipeline around your own clusters, or accept a black‑box, non‑SQL system that doesn’t fit the rest of your stack. TigerData offers a third path: a SOC 2 compliant, fully managed Postgres service with native time-series capabilities. Hypertables keep ingest fast, hybrid row‑columnar storage and compression keep costs in check, tiered storage extends retention, and continuous aggregates power real‑time dashboards—all while you keep writing SQL against Postgres. With HA, backups, PITR, encryption, and audited operations, it’s a database platform you can run production and regulated observability workloads on without building your own DB SRE team.

Next Step

Get Started