Why we built Crossdeck — and why every product we build helps test it

The wait we thought was the problem

Like everyone shipping apps, we spent a lot of time staring at App Store Connect. Submit, wait, refresh, wait. It felt like the bottleneck — the opaque days between done and live. For a while we organised our frustration around it, as if faster review would fix how it felt to run a portfolio of products.

It would not have. The wait was real, but it was a symptom. When we looked honestly at where time actually went — where questions went unanswered, where mistakes hid, where the same work got redone — the App Store was not the villain. Fragmentation was.

What fragmentation actually costs

Here is the shape of it, and it is boringly universal. A single human being interacts with one of your products, and they immediately fracture into pieces:

• their pageviews and sessions live in an analytics tool;
• their crashes and errors live in a different one;
• their payments and subscription live in a billing system;
• their support conversation lives somewhere else again;
• and their identity — the thread that says all of these are the same person — lives nowhere at all.

Each tool is individually fine. Together they are a filing system where every folder uses a different name for the same customer. So the questions that actually matter — the cross-layer ones — become impossible without a human doing detective work in five tabs.

Which paying customer just hit this error? Is the person churning the one who has been silently failing at checkout for a week? What is this user actually worth against what they cost us to serve?

None of those live inside a single tool, because each answer requires joining layers that were never designed to meet. Multiply that across several products and you do not have a data problem, you have a knowledge problem: you operate a business you cannot ask a straight question.

The decision: one SDK, one customer timeline

The fix was not another dashboard. It was to stop every product reinventing the same disconnected plumbing, and instead put one spine underneath all of them.

One SDK that captures analytics, errors, identity, revenue and cost — and, critically, joins them by identity into a single customer timeline. Not five systems you correlate by hand. One record per person, threaded through everything they did, everywhere they did it. The Crossdeck SDK documentation covers how that resolution actually works.

The important word is timeline, not dashboard. A dashboard shows you aggregates. A timeline lets you stand at one person and see the whole arc — the ad they arrived from, the signup, the checkout that failed twice, the error that cost them the session, the upgrade, the support ticket — as one story about one human, because it was joined by identity from the first event.

What Crossdeck is

Crossdeck is a developer platform that joins a product’s revenue, errors, identity, analytics and read-cost by identity — so you can answer cross-layer questions no single-layer tool can. Instead of five tools that each know a slice of a customer, there is one timeline that knows the whole person.

The payoff is the questions it makes trivial. Which of my highest-paying customers hit an error this week is a join across billing, error-tracking and identity — three systems in a normal stack, one query here. The value was never any single layer. It was the cross: the seam between owned layers, joined by the one thing that ties them together.

Why join data by identity?

Because identity is the only axis every layer shares. Revenue is about a person. An error happened to a person. A session belongs to a person. If you do not anchor on identity, you have parallel piles of events that never resolve into a customer, and every cross-layer question stays a manual investigation. Anchor on identity and the piles collapse into people.

That single decision is what turns scattered telemetry into a business you can interrogate in plain language. It is also, as we found out the hard way, the decision most people get wrong by anchoring on an email address.

Why every product we build helps test it

Here is the part that makes this a constellation rather than a company with a side project.

We did not build Crossdeck, ship it and hope. We built it underneath our own products — Biotree, Grid, Digital Hank, PricePage, ClaudeArchitect and PageSwipe — and ran the real business on it. Which means every product is not just a user of the platform. It is a stress test of it.

• When one product’s read costs blew up, we did not just fix that product — we built the tooling to see read cost, and every product inherited it.
• When identity resolution forked a single person into three records, the graph that fixes it got sharper for all of them.
• When we hit the App Store review black box on a native app, the identity-and-build-joined data that made it legible became a capability the whole portfolio shares.

Dogfooding is usually described as “we use our own product”. This is stronger. Each product runs a different kind of business — a link-in-bio tool, an iOS habit tracker, a book catalogue, an AI assistant — so each one exercises the platform along a different axis and finds the weakness the others never would. The portfolio is the QA suite.

That is the thesis of the whole company: a constellation of products over one shared, battle-tested customer timeline, where every new product both uses the infrastructure and hardens it for the next one.

What we learned

• Chase the symptom and you will optimise the wrong thing. The App Store wait was loud; fragmentation was quiet and far more expensive. The costly problems are usually the invisible ones.
• Build the thing that goes under everything, once. Every product reinventing analytics, identity and error-tracking is the same tax paid repeatedly, and it still does not join.
• Join by identity or do not bother. Without a shared identity anchor, more data just means more disconnected piles.
• Make every product test the platform. Infrastructure proven by one product is fragile. Infrastructure beaten on by several different real businesses is a moat.

We started out annoyed at a progress bar. We ended up building the layer that lets us ask our own business a straight question — and a portfolio where every product we ship makes that layer stronger.

And Biotree, in the other direction

One last relationship, running the opposite way. Crossdeck’s own public social and resource hub is a Biotree page, at crossdeck.biotree.bio. The intelligence layer uses the distribution product. Both directions are true, and each is recorded separately.