Parseable
A single-binary log lake on object storage - lean, S3-native, SQL-queryable, for $5/month.
One-click deploy, from $5/mo on a Miget plan.
Parseable takes the most disciplined position on log storage: ingest over HTTP, write compressed Parquet straight to object storage, query with SQL. No JVM, no cluster, no local index to outgrow - a single Rust binary that treats S3 (Miget Buckets) as the database.
It is the leanest entry in the catalogue’s logging lane: 512 MB, one container, and stateless the moment you set the S3 variables (a thin entrypoint switches it to bucket mode, since Parseable starts via subcommand). For teams who want a focused, cheap log lake rather than a full observability platform, this is it.
Ship logs in from Vector, Fluent Bit, OTLP→HTTP, or app SDKs; dashboard and query in the UI.
Upstream project: Parseable
#what you get
- HTTP log ingest; SQL query; built-in UI
- Compressed Parquet on object storage (Miget Buckets)
- Stateless with S3 - the bucket is the database
- Single Rust binary, ~512 MB, no JVM
- Schema-flexible, high-cardinality friendly
- AGPL-3.0
#topology
| Service | Role | Public |
|---|---|---|
| parseable | log ingest + query + UI (:5000) | yes |
#miget sizing
// this stack needs
512 MiB RAM · 5 GB disk · 1 service
The lightest logging option here - 512 MB. In S3 mode the volume is only a staging buffer; logs live in the bucket.
Hobby - recommended fit
$5/mo
1 vCPU · 512 MiB · 10 GiB disk
Headroom for your own apps: 1 GiB at $7/mo
Professional - production
$22/mo
1 vCPU · 2 GiB · 10 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 |
|---|---|---|---|
| Parseable on Miget ★ | 512 MiB plan | $5 | this whole stack, flat - no usage meters, and room left for your own apps |
| Datadog Logs | ingest + index | usage-based | ~$0.10/GB + ~$1.70 per million events |
| Better Stack | Logs (retained) | usage-based | ~$0.50/GB-mo retained (annual) |
#vs. other PaaS
Estimated monthly cost of running this exact stack (512 MiB RAM, 5 GB disk, 1 container) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $5 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$25 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| DO App Platform | ~$11 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Render | ~$8 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| Railway | ~$6 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$4 | 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
parseable -
Set the required variables:
P_PASSWORD, admin login (with P_USERNAME)P_S3_* (a Miget Bucket), recommended: switches to S3-native mode, stateless storage
- 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/parseable
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
Parseable or OpenObserve?
OpenObserve is the broader platform - logs, metrics, and traces with a rich UI. Parseable is the lean, logs-only lake: lighter (512 MB vs 1 GiB) and laser-focused on cheap, SQL-queryable log storage on buckets. Pick OpenObserve for all telemetry, Parseable for the minimal log store.
How does it stay so light?
It does not keep a local search index - it writes columnar Parquet to object storage and queries it directly. Compute is stateless and storage is the bucket, so the container itself stays tiny regardless of how much you retain.
How do logs get in?
A simple HTTP ingest API (POST /api/v1/ingest), plus first-class support from Vector, Fluent Bit, and any OTLP→HTTP pipeline. Structure logs into streams and query each with SQL.
Ship Parseable today
One compose stack, 512 MiB of RAM, from $5/month flat, and it runs on your laptop with the same files.