Most questions about operational data get answered the slow way. Someone wants the p99 latency, this month’s AI bill or the error count per endpoint, and a query goes off to read the raw data, all of it, again. The raw data keeps growing, so the questions keep getting slower and more expensive.
Precomputing flips it around. You decide the questions first. A short policy file names the streams of events, the answers to keep, counts, percentiles, price candles, invoices, log dashboards, AI agent costs, and how long each level of detail is kept. Every event that arrives updates those answers in one SQLite file. When someone asks, the answer is already there. The question becomes a lookup.
The Pitch in Four Numbers
- 7.9 times smaller file for three hours of API traffic kept as ready answers, with every p99 within 0.65%.
- 100 kills of the engine while it ingested a trading day, and no acknowledged trade was lost.
- $5,804.56 for a month of AI usage, invoiced to match a separate recount to the billionth of a dollar.
- 120 times fewer bytes sent upstream for a log dashboard, with every point checked against the raw lines.
How It Works
The policy language is small. It says what comes in, what to keep ready and how long to keep detail. A policy compiles into the engine that maintains the answers. As events arrive, each one updates the stored answers in a single SQLite file. Raw detail fades on the schedule you set, while unusual events are kept, so the interesting outliers don’t vanish with the routine noise.
You get at the answers three ways: plain SQL against the file, a Go engine to embed, and an MCP interface so AI agents can ask questions directly and get small answers instead of raw dumps. Applications and OpenTelemetry Collectors can send logs and metrics straight in, and a running file can change its policy without starting over.
The case studies show the range: coding-agent traces 14 times smaller that still rebuild byte for byte, AI agent answers in a few hundred tokens each, and returning incidents recognised within ten seconds. Eight live demos on the site repeat their checks in the browser.
Who It’s For
- Teams doing usage-based billing who need invoices that match to the last fraction of a cent.
- Log and metrics owners tired of paying to scan raw data for the same dashboards.
- Trading and market data teams keeping candles and statistics current tick by tick.
- AI product teams tracking agent costs and feeding agents compact context.
Limits
It’s alpha. The published numbers come from simulated data. And the core trade is the same as any precomputed system: you have to decide your questions up front. A question you didn’t plan for can’t be answered from detail that has already faded.
The Four-Question Screening
Every project featured here gets the same four questions, the way you’d screen a startup idea.
1. Where is the money in it?
Precomputing is open source under Apache 2.0, with no paid tier. Its strongest money lives in billing and observability. Usage-based billing is a growing business, and getting invoices exactly right is something companies pay for. Log and metrics storage is a large market where customers pay by volume, and Precomputing cuts volume sharply. The paid paths are a hosted engine, ready-made policies for billing and observability, and support for teams putting it in front of real invoices.
2. What real problem does it solve?
Answering the same questions by rereading ever-growing raw data. It’s slow, expensive and gets worse every day. Computing the answers as data arrives keeps them current and cheap, and keeps the file small.
3. The technology in plain words
Think of a shop that keeps a running tally on a board behind the till: today’s sales, the biggest sale, how many customers. Each sale updates the board. When the owner asks how the day went, nobody digs through the receipts. The answer’s already on the board.
4. Moat and differentiation
Stream processors are powerful and heavy, and databases answer by scanning. Precomputing sits in between: a small policy language, one SQLite file and answers that are always ready, with access through SQL, Go and MCP. The billing-grade accuracy is a strong proof point. The moat that can grow is the policy language and a library of ready policies for common jobs, which turns setup into something a team can do in an afternoon.
Why It Matters
Most dashboards, bills and agent questions ask the same things again and again. Computing those answers once, as the data arrives, saves money on every query after that and makes the answers instant.
Follow the Project
Read the introduction, how it works and the policy language, try the live demos, see the roadmap, or get the code from the Precomputing repository on GitHub. Precomputing is listed with the other open-source projects on SoftDevStudio.com, and more featured projects are in the Projects section.