For quant research teams on PostgreSQL
Find the look-ahead in your research data before it trades.
A free, 20-minute audit of one research dataset. Spine scans your schema and shows where signals are dated before the data they used, where test data leaks into training, and where history can be rewritten in place.
Read-only, on a scratch copy of your schema. We never need production credentials, and a clean result is a useful answer.
Synthetic research schema, 5 tables, with issues planted on purpose. Open a finding to see the evidence.
3 rowsSignals dated before the data they usedCausal order
signals.effective_atis earlier thanfundamentals.published_at. One signal was effective on 20 May 2024 but used a revision published on 19 June 2024.2 eventsTest events that also appear in trainingTrain/test
The same
event_idsits on both sides ofsplit, so validation scores built on those rows overstate the model.1 triggerA change log that stops during restoresOff switch
fundamentals_auditfires in origin mode only, so it is skipped under replica mode, which replication,pg_restoreand many bulk loaders use.5 tablesHistory that can be rewritten in placeAppend-only
Every table accepts UPDATE, DELETE and TRUNCATE today. Once you accept the plan, corrections land as new rows and originals stay put.
CleanNo rows pointing at missing recordsReferences
Both foreign keys checked with no orphans. Parent deletes would be guarded once you accept the plan.
Real output from Spine Lite v3.2.5. It found exactly the 3 look-ahead rows and 2 leaked events we planted, and passed the clean checks. Accepting the plan would govern 5 of 5 tables with 14 rules.
Three ways research data goes wrong without anyone noticing
A signal quietly uses tomorrow's number.
A restatement or backfill lands, and a signal dated earlier picks it up. The backtest looks better than it will ever trade.
The test set already trained the model.
The same event or label window sits on both sides of the split, so validation scores stop meaning anything.
The safety net switches off during restores.
Ordinary triggers skip replication, restores and bulk loads, which is exactly when history gets rewritten. Few teams check.
What the audit checks
Spine finds these on its own from your foreign keys, timestamps and split columns. You review the plan, and nothing is enforced until you accept it.
| Check | What it catches | How |
|---|---|---|
| Causal order | A row dated before the record it depends on, such as a signal earlier than the data it used | Scans your current data |
| Train/test isolation | The same entity on both sides of a split | Scans your current data |
| References | Rows pointing at records that don't exist, and parents deleted out from under their children | Scans your current data |
| Backdating | Write clocks such as created_at set into the past | Guards new writes |
| Append-only | UPDATE, DELETE or TRUNCATE on sealed tables. Corrections become new rows | Guards new writes |
| Quiet off switches | Triggers that won't fire during replication, restores or bulk loads | Reports every one |
After you accept the plan, new tables in the schema are enrolled automatically.
Watch one rule catch look-ahead
A signal can't be dated before the data it used.
Illustration with made-up records, running in your browser. Not an executed test.
The offer: start free, pay when it's working
Three steps. You can stop after any of them.
-
Free audit
Twenty minutes, one dataset. We walk through Spine's audit on a scratch copy of your schema, and you see real findings with the rows behind them.
No cost, and nothing installed on production.
-
Pilot on one dataset
Install Spine Lite, which is plain SQL on the Postgres you already run, with no fork or agent. Accept the audited plan, then run your real corrections and backfills through it.
Fixed fee, agreed before work starts.
-
Keep it governed
Updates, support, new datasets as you add them, and an attestation for any period that you can hand to allocators and auditors.
Annual subscription per protected dataset.
What we promise, and what we don't
A claim you can check is the only kind worth buying, so here is exactly where the line sits.
What Spine gives you
- Look-ahead and leakage caught at the source, before they reach a backtest.
- No quiet rewrites from apps, scripts or pipelines. Sealed tables are append-only, and corrections are new rows.
- Rules that keep firing during replication and restores, plus a report of any trigger that doesn't.
- An attestation for any period: what was governed, what was refused, and what changed.
- Admin actions limited to named roles and logged. There's no silent developer bypass.
What we won't claim
- That it's unbreakable. Spine runs inside your database, so an administrator with full rights can still switch it off.
- That it's proof against your own admins. Receipts live in the database they protect, so they're evidence against mistakes and ordinary writers, not a determined superuser. We'll show you where that line sits for your setup.
- A finding we didn't find. If the audit comes back clean, that's the answer.
Book the 20-minute audit
Bring one dataset and whoever owns the research database. Here's all we need:
- One dataset and what it's used for
- A scratch copy of it (a recent snapshot is fine)
- Twenty minutes with the person who owns it
Tell me about one recent correction or backfill, and we'll start there.