Crunchy Bridge for AI Workloads: Managed Postgres with pg_parquet and Iceberg (2026)

TL;DR — Crunchy Bridge gives you fully managed Postgres with first-class Iceberg, Parquet, and an analytics engine alongside vanilla OLTP. For AI teams it means transactional + warehouse on one platform, and pg_duckdb-style speed on analytic queries.

What you'll build

A Crunchy Bridge cluster running OLTP workloads with pgvector and Iceberg tables on S3 — agents query both with ordinary SQL via the warehouse extension.

Schema

-- OLTP table
CREATE TABLE conversations (
 id BIGSERIAL PRIMARY KEY,
 org_id UUID,
 body TEXT,
 embedding vector(1536),
 created_at TIMESTAMPTZ DEFAULT now()
);

-- Iceberg-mounted analytics view
CREATE FOREIGN TABLE analytics_events ()
SERVER iceberg
OPTIONS (location 's3://callsphere-lake/events/');

Architecture

flowchart LR
 APP[App writes] --> CB[(Crunchy Bridge OLTP)]
 CB --> WAL[WAL]
 WAL --> PARQ[pg_parquet S3 dump]
 PARQ --> ICE[Iceberg tables]
 AGENT[AI agent] --> CB
 AGENT --> WH[Warehouse engine]
 WH --> ICE

Step 1 — Provision via API

curl -X POST https://api.crunchybridge.com/clusters -H "Authorization: Bearer $CB_TOKEN" -d '{
 "name": "callsphere-prod",
 "plan_id": "memory-2",
 "provider_id": "aws",
 "region_id": "us-east-1",
 "postgres_version_id": 17,
 "extensions": ["vector", "pg_parquet", "pg_partman"]
 }'

Step 2 — Enable pg_parquet

CREATE EXTENSION pg_parquet;

COPY (SELECT * FROM conversations WHERE created_at < now() - interval '30 days')
TO 's3://callsphere-lake/conversations_archive.parquet'
WITH (format 'parquet', compression 'zstd');

Step 3 — Mount as Iceberg

CREATE EXTENSION crunchy_iceberg;

SELECT iceberg_create_table(
 'conversations_archive',
 's3://callsphere-lake/conversations_archive/',
 schema => 'org_id uuid, body text, created_at timestamptz'
);

Step 4 — Hybrid query

-- Hot data + cold archive in one query
SELECT created_at, body FROM conversations
WHERE org_id = $1 AND created_at > now() - interval '30 days'
UNION ALL
SELECT created_at, body FROM conversations_archive
WHERE org_id = $1 AND created_at > now() - interval '180 days';

Step 5 — Vector index on hot

CREATE INDEX ON conversations USING hnsw (embedding vector_cosine_ops)
 WITH (m = 16, ef_construction = 128);

SET hnsw.ef_search = 100;
SELECT id FROM conversations
ORDER BY embedding <=> $1::vector LIMIT 10;

Hot, indexed vectors stay on Bridge SSD; cold transcripts live cheaply on S3 Iceberg.

Step 6 — Backups + disaster recovery

Bridge ships continuous WAL archiving + 10-day PITR by default. For longer retention, schedule pg_dump to S3:

pg_dump --format=custom $DATABASE_URL | aws s3 cp - s3://backups/cb-$(date +%Y%m%d).dump

Pitfalls

• Plan choice — memory plans matter for HNSW; io plans matter for analytic scans. Pick by workload.
• Iceberg manifest staleness — refresh after each archive job, otherwise queries miss new files.
• Connection pooling — Bridge ships PgBouncer; use the pooled URL not the direct one.
• Region match — keep the cluster and S3 bucket in the same region or pay egress.

CallSphere production note

Explore a live demo and compare current plans to find the right fit for your business.

FAQ

Q: Bridge vs RDS? Bridge ships extensions (pgvector, pg_parquet, pg_partman) RDS lacks; RDS wins on AWS-native integrations.

Q: Multi-region HA? Bridge supports cross-region replicas on Business plans.

Q: HIPAA? Both available on Business and above; BAA on request.

Q: Pricing model? Hourly compute + storage + transfer. Predictable, no per-query surcharges.

Q: How fast is failover? 30-60 sec with the HA add-on.

Sources

• Crunchy Bridge — managed Postgres
• Crunchy Data Warehouse docs
• BigDATAwire — Bridge spatial analytics release
• Tailscale — Crunchy Bridge integration

Crunchy Bridge for AI Workloads: Managed Postgres with pg_parquet and Iceberg (2026): production view

Crunchy Bridge for AI Workloads: Managed Postgres with pg_parquet and Iceberg (2026) is also a cost-per-conversation problem hiding in plain sight. Once you instrument tokens-in, tokens-out, tool calls, ASR seconds, and TTS seconds against booked-revenue per call, the right tradeoff between Realtime API and an async ASR + LLM + TTS pipeline becomes obvious — and it's almost never the same answer for healthcare as it is for salons.

Serving stack tradeoffs

The big fork is managed (OpenAI Realtime, ElevenLabs Conversational AI) versus self-hosted on GPUs you operate. Managed wins on cold-start, model freshness, and zero-ops; self-hosted wins on unit economics past a certain conversation volume and on data residency for regulated verticals. CallSphere runs hybrid: Realtime for live calls, self-hosted Whisper + a hosted LLM for async, both routed through a Go gateway that enforces per-tenant rate limits.

Latency budgets are non-negotiable on voice. End-to-end target is sub-800ms ASR-to-first-token and sub-1.4s first-audio-out; anything beyond that and turn-taking feels stilted. GPU residency in the same region as your TURN servers matters more than choosing a slightly bigger model.

Observability is the unglamorous backbone — every conversation produces logs, traces, sentiment scoring, and cost attribution piped to a per-tenant dashboard. HIPAA aligned isolation keeps healthcare traffic separated from salon traffic at the storage layer, not just the API.

FAQ

How does this apply to a CallSphere pilot specifically? Setup runs 24 hours, the trial is 7 days with no credit card, and pricing tiers are $49, $99, and $149 — so a vertical-specific pilot is a same-week decision, not a quarterly project. For a topic like "Crunchy Bridge for AI Workloads: Managed Postgres with pg_parquet and Iceberg (2026)", that means you're not starting from scratch — you're configuring an agent template that's already been hardened across thousands of conversations.

What does the typical first-week implementation look like? Day one is integration mapping (scheduler, CRM, messaging) and prompt tuning against your top 20 real call transcripts. Day two through five is shadow-mode running, where the agent transcribes and recommends but a human still answers, so you can compare side-by-side. Go-live is the moment your eval pass-rate clears your internal bar.

Where does this break down at scale? The honest answer: it scales until your tool catalog gets stale. The agent is only as good as the integrations it can actually call, so the operational discipline is keeping schemas, webhooks, and fallback paths green. The platform handles the rest — observability, retries, multi-region routing — without your team owning the GPU layer.

Talk to us

Explore a live demo and compare current plans to find the right fit for your business.