TimescaleDB
Postgres for time series - hypertables, columnar compression, continuous aggregates - in a single internal-only node.
One-click deploy, from $13/mo on a Miget plan.
Time-series data has a way of arriving: metrics, sensor readings, prices, events. TimescaleDB is the answer for teams who want it in Postgres - real SQL, joins against business tables, every Postgres driver and ORM - with the time-series machinery (partitioning, compression, downsampling) handled by the extension.
Hypertables auto-partition by time behind a normal table interface. Columnar compression routinely cuts metrics-shaped data by 90%+. Continuous aggregates keep rollups (per-minute, per-hour) incrementally up to date so dashboards stop re-scanning raw data.
This template runs a single node with the extension preloaded, internal-only - databases never get a public domain - with a 20 GB volume. It exists precisely because managed Postgres offerings (Miget’s included) do not ship the timescaledb extension. One password and your apps connect at timescaledb:5432.
Upstream project: TimescaleDB
#what you get
- Hypertables: automatic time partitioning behind a plain-table interface
- Columnar compression - 90%+ typical on metrics-shaped data
- Continuous aggregates: incrementally maintained rollups
- Data retention policies: drop old chunks, not rows
- It is Postgres: every driver, ORM, and BI tool just works
- Internal-only single node + 20 GB volume
#topology
| Service | Role | Public |
|---|---|---|
| timescaledb | Postgres + timescaledb extension (:5432) | no (by design) |
#miget sizing
// this stack needs
2 GiB RAM · 20 GB disk · 1 service
2 GiB handles serious ingest for a single-team workload; compression keeps the 20 GB volume going far longer than raw Postgres would. Scale RAM with active chunk working set.
Hobby - recommended fit
$13/mo
1 vCPU · 2 GiB · 50 GiB disk
Headroom for your own apps: 2 GiB at $19/mo
Professional - production
$43/mo
2 vCPU · 4 GiB · 25 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. the managed service
What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.
| Service | Plan | Monthly | What you get |
|---|---|---|---|
| TimescaleDB on Miget ★ | 2 GiB plan | $13 | this whole stack, flat - no usage meters, and room left for your own apps |
| Tiger Cloud | Performance | ~$30 | published floor (hourly-metered compute) + storage ~$0.88/GB-mo post-compression; Timescale Inc. is now TigerData |
| InfluxDB Cloud | Serverless (usage) | usage-based | ~$10-15/mo small workload ($0.0025/MB in, ~$1.46/GB-mo stored, $0.012 per 100 queries) - scales with use |
Tiger Cloud has a genuinely useful free tier (750 MB/service); self-hosting wins once data is always-on and growing.
#vs. other PaaS
Estimated monthly cost of running this exact stack (2 GiB RAM, 20 GB disk, 1 container) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $13 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$100 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| Render | ~$30 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| DO App Platform | ~$29 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Railway | ~$23 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$15 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
timescaledb -
Set the required variable:
POSTGRES_PASSWORD, password for the app user (openssl rand -base64 24)
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/timescaledb
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
Why not just use the managed Postgres for time series?
You can, until the data grows: vanilla Postgres lacks automatic time partitioning, columnar compression, and incremental rollups, so tables bloat and dashboards slow down. The timescaledb extension is not available in managed Postgres offerings, which is exactly why this template exists.
How does this compare to Timescale (Tiger) Cloud pricing?
Managed Timescale prices compute per hour plus storage, which is excellent for elastic workloads and adds up for always-on ones. This node is $13/month flat (2 GiB hobby plan) - and your metrics never leave your project network.
Is TimescaleDB a real InfluxDB alternative?
For most workloads, yes - with the advantage that it is plain SQL in Postgres: joins against your business data, standard drivers, no new query language. InfluxDB still has an edge in ultra-high-cardinality edge collection; for app and infra metrics, hypertables win on ergonomics.
How do applications connect?
From the same Miget project: postgres://app:<password>@timescaledb:5432/app - any Postgres client works. The node is private with no ingress route; if you need external access, tunnel through your apps rather than exposing the database.
How much data fits in 20 GB?
With compression, typically hundreds of millions of metric rows. Add a retention policy (drop_chunks) for raw data you only need recently, keep continuous aggregates forever - the volume can be resized when you genuinely outgrow it.
Ship TimescaleDB today
One compose stack, 2 GiB of RAM, from $13/month flat, and it runs on your laptop with the same files.