Everything you know about a client, before the call

Skein reads the records your business already has and writes the page you would have written yourself. On your own machine. No AI service called, nothing sent anywhere.

Try it on 1,009,300 records Or a smaller one, 155,388

No install · no account · the demo runs in this browser

15,699,911 source rows indexed on one laptop in 2.2 minutes, then re-indexed in 0.12 seconds. How

At scale, measured

Big is the easy part. Staying current is the hard part.

Every number below came off a run you can repeat from a command in the repository. Nothing here is a projection.

One live PostgreSQL, 15,699,911 rows across 2,124 MB, on a laptop

Source	15.7M rows, 2,124 MB
Graph built	900,000 nodes, 800,000 edges
First import, start to finish	2.2 minutes
Peak memory while doing it	278 MB
Re-index when nothing changed	0.12 seconds
Rolled up rather than copied	5M invoices, 10M events
Search on the finished graph	63 ms median
Assembling one brief	0.4 ms median

Fifteen million of those rows cost three seconds. Invoices and events are summarised per customer inside your database and never travel. The import is paid for by the 700,000 rows that become entities, and by nothing else. Seventeen source rows became one node.

It does not fall over as the graph grows

Four sizes, one process, nothing else running on the machine.

entity rows	nodes	rows/s	peak memory	wall clock
250,000	650,000	5,618	190 MB	1.5 min
1,000,000	1,400,000	5,144	192 MB	4.0 min
2,000,000	2,400,000	4,144	194 MB	8.8 min
4,000,000	4,400,000	3,989	194 MB	17.4 min

Memory is flat. 190 MB at a quarter of a million rows and 194 MB at four million, because the importer streams rather than holding your result set. Throughput falls 8.2% per doubling, which is index maintenance getting deeper. A slope, not a wall: sixteen times the rows costs 1.4 times the seconds per row.

The cadence, which is the part nobody asks about until later

A one-off import is a snapshot. It is right on the day it runs and wrong every day after, and a graph that is quietly wrong is worse than no graph, because somebody trusts it.

Every hourthe default for a live source. Small enough that nothing is ever more than an hour stale.

0.12 swhat an hourly run costs when nothing changed. That is why it can be hourly.

Watermarkwe record how far the last run got, on a column that reveals edits and not just new rows, and start there.

Edits, not just insertsa watermark on an autoincrementing key hides every change to a row that already existed. We say which kind each source gives us.

We run this on ourselves. Our own graph reads 1,367 documents off a second machine on an hourly timer: a full read takes 2.7 seconds, and a run where nothing changed takes 0.3 seconds and opens no files at all.

The full report, per table Try it on 1,009,300 records

The software

What you actually look at

Three screenshots of the running application, taken from the demo corpus. Not mockups: this is the window that opens when you double click it.

localhost:8787 — on your machine, not ours

The Skein console showing a brief for Cedarline Periodontics: 6 open and 2 overdue, a retainer of $2,800 a month that was $2,400 until March, figures on record, six open promises with owners and due dates, and what moved in the last sixty days.

The brief. Terms with what they replaced, figures, what is open and late with who owns it, and what moved. The two overdue items are amber because they are overdue.

localhost:8787 — graph

The graph view: 258 records and 302 connections drawn as a force-directed network, clients in green, people in blue, promises in amber, emails in grey, with a legend and counts along the bottom.

The graph. 258 records, 302 connections, 272 of them found by Skein rather than typed in by anybody. Colour is the kind of record; a dotted line was inferred.

localhost:8787 — sources

The sources view: four numbered steps for bringing data in, with buttons for a folder, a mail export, a spreadsheet or a live database, and a note that nothing is imported until the plan has been seen.

Bringing data in. A folder, a mail export, a spreadsheet or a live database. Nothing is written until you have seen the plan.

Or skip the pictures. The same software, running on a million records, in your browser.

Open the live demo Download it

Getting your data in

Four steps, and nothing is written until you say so

The database flow, as a customer sees it. A folder, a mailbox export or a spreadsheet is the same shape with fewer boxes.

STEP ONE

Type six things, not a connection string

Nobody outside this trade can write postgresql://user:pass@host:5432/db. The six values are on one page of whatever hosts the database, and Skein assembles the string, encoding the password properly.

KINDPostgreSQL HOSTdb.yourcompany.com PORT5432 DATABASEbilling USERreadonly_user PASSWORD••••••••

STEP TWO

See the plan before anything is read

Skein reads the schema and tells you what it intends to do with every table, and why. Nothing has touched your graph yet.

customersentity 2 tables point here, and it has a name

contactsrecord has a name column, one node per row

invoicessummary 5,000,000 rows, counted per customer

eventssummary 10,000,000 rows, two hops to a customer

sessionsskipped only keys and timestamps, nothing to name

STEP THREE

Import, and it tells you what it did

Read only, paced if you ask, and it checkpoints as it goes so a interruption resumes rather than restarts.

Credentials and tax identifiers never read into the graph
Fact tables summarised where they live, never copied
Every node keeps a pointer back to its source row
Re-index later reads only what moved

STEP FOUR

Rule on the names it will not guess

Where two records might be the same client, Skein asks instead of deciding. A few minutes once, and it is the difference between a graph you trust and one you do not.

Measured 1.00 precision against 0.82 for accepting everything
Every automatic link is reversible, and yours are never touched
Rulings are remembered, so you are never asked twice

Connecting needs nothing installed. The PostgreSQL and MySQL drivers ship inside the download.

Download it, 1.4 MB See what it did to 15.7M rows

What comes out

A brief, not a dashboard

Name a client. Get what you charge them and what that replaced, the figures on record, what is open and what is late, who is involved, and what the graph does not know.

Every other product in this category opens on a search box or a diagram of dots. Both serve the person who already knew what they were looking for, which is the person who did not need a graph.

Read one on real data

graph

client person promise decision email

What is underneath

Solid was stated. Dashed was inferred.

This is a real neighbourhood from the demo corpus, drawn live. Every connection carries whether it was read out of the data or worked out by us.

Nobody else in this category shows a buyer that difference. It is the honest version of "99% accurate", and it is why the entity review queue exists: where Skein cannot be confident, it asks you instead of guessing.

Walk the graph yourself

How it works

Index the source. Do not copy it.

The reason a 15.7 million row database takes two minutes rather than an afternoon.

What the category does

Copy every row into the graph

Ten million invoices become ten million nodes. The import runs for hours, the graph is stale the moment it finishes, and refreshing it costs an afternoon nobody spends.

What Skein does

Summarise them where they live

Ten million invoices become one summary per customer and a pointer back to the rows. Totals are real, computed over every row. The rows never move, so re-indexing takes a tenth of a second.

What you get

Features, not promises

Connect anything

A folder, a mail export, a spreadsheet, or a live PostgreSQL or MySQL database. Drivers ship inside, so connecting needs nothing installed.

Ask in plain words

Search the whole business, then open any subject and drill from a line on the brief back to the exact source row it came from.

Remembers what changed

When the retainer moves, the old figure is not overwritten. The brief says $4,200 a month, and $3,600 until May.

Nothing leaves the building

No model is called and no data is sent. A test fails the build if any module that could open a socket becomes reachable from the importer.

Asks instead of guessing

Where two records might be the same client, it puts the name in a queue for you. Measured more accurate than deciding automatically.

Prints and sends

Every brief is a page, a PDF, or a mail draft ready to send. For the person who will never open the software.

The objection your DBA will raise

Built for a database somebody depends on

"You are not running a full scan against my production server." Fair. So Skein is built to be told to take longer on purpose.

Paced on request

Turn on gently and the import pauses between batches so the source stays responsive for everyone else. An import that takes four times as long and nobody notices beats one that is refused.

Reads only what moved

Each table carries a watermark. Re-indexing a source where nothing has changed takes 0.12 seconds, not another full read. A refresh you will actually run twice.

Survives being interrupted

It checkpoints inside a table, not just between them. Killed thirty minutes into a long import, it resumes from where it stopped rather than starting again. Tested by killing it.

Opened read only

The connection is read only where the driver allows it. Skein cannot write to your database even if it were asked to, and nothing is imported until you have seen the plan and approved it.

Memory does not grow with your table

Rows stream in batches rather than arriving all at once. 190 MB at 250,000 rows and 194 MB at four million, so a table larger than your RAM is a longer import, not a failed one.

Never copies your fact tables

Ten million invoices become one summary per customer and a pointer back. Fifteen million of the fifteen point seven million rows in our largest run cost three seconds between them.