Original research · Open method

Apps and Softwares Aliensync: A Measurable Model of How Your Tools Fit Together

Every article about apps and softwares Aliensync describes the idea and stops there. None of them tell you how to measure it. This one does, with a formula you can run on your own stack in two minutes, and the combinatorial reason your tool sprawl got expensive faster than you expected.

Three words that describe three different layers

The phrase bundles together things that are not the same kind of object, which is part of why it is written about so vaguely.

Apps are endpoints. A CRM, a helpdesk, a spreadsheet, a chat tool. Each one owns some slice of your operation and holds its own copy of the truth about it.

Software, in the sense that matters here, is the logic that moves work forward inside those endpoints. Rules, workflows, automations, the things that fire when a condition is met.

Aliensync is neither. It is the connective layer: the set of agreements about which system is authoritative for which record, how changes propagate, and how fast. It has no interface of its own. You only notice it when it is missing.

That last point is the reason this is hard to discuss. A missing integration produces no error message. It produces a person, quietly retyping a phone number into a second system, every Tuesday, for three years.

The part nobody states plainly: integration surface grows quadratically

Here is the fact that makes tool sprawl behave the way it does, and it is pure combinatorics rather than opinion.

If you run n systems and any of them might need to talk to any other, the number of distinct pairs is:

C(n,2) = n(n−1) / 2

That is the integration surface: the complete set of relationships that could, in principle, need to exist. Meanwhile the minimum number of connections needed to link everything through a single hub is only n − 1.

Those two numbers diverge brutally.

050100150190 25811141720 Number of tools (n) 66 possible pairs 11 hub links at 12 tools Full mesh, n(n−1)/2 Hub and spoke, n−1
Integration surface against tool count. The gap at 20 tools is 190 possible pairs versus 19 hub links.

Read the table rather than the curve if you prefer numbers:

ToolsPossible pairsHub links neededNew pairs created by adding one more tool
51045
82878
12661112
161201516
201901920

Look at the last column, because that is the uncomfortable one. Adding the thirteenth tool to a twelve-tool stack does not create one new integration question. It creates twelve. Nobody budgets for that, because the purchase decision is framed as one tool, one subscription, one onboarding.

This is the same shape as Metcalfe’s observation about network value scaling with the square of its nodes, turned unpleasantly on its head. In a communications network the n² term is the upside. In a software estate it is the maintenance bill.

Why most stacks sit between the two curves, badly

Almost nobody builds the full mesh. It would be absurd. But almost nobody builds a clean hub either. What happens in practice is a partial mesh: six or seven ad hoc connections made at different times by different people for different reasons, with no model behind them.

That is the worst of both. You carry the complexity of a mesh in the places where connections exist, and the gaps of an unconnected estate everywhere else. And because the connections were made opportunistically, nobody can draw the diagram.

A quick diagnostic that costs nothing: ask three people in different departments to name the system that holds the authoritative customer email address. If you get three answers, you have found your problem, and no software purchase will fix it.

Three ways to wire an estate, and what each costs

Because the integration surface is combinatorial, the shape you choose matters more than the number of tools. There are only three shapes in common use, and each fails differently.

Point to point. Each pair that needs to talk gets its own connection. Fast to build the first time, and it is what almost every estate drifts into because each individual decision is reasonable. The cost is that connections scale toward n(n−1)/2 and each one is a separate thing to maintain, authenticate and debug. Replacing one tool means rewriting every connection it touched.

Hub and spoke. Everything connects to one central system, which holds the canonical records. Connections drop to n−1. Replacing a spoke affects one link. The costs are real though: the hub becomes a single point of failure, and it must be capable of representing every record type well, which is why using a CRM as a hub works until you need to model inventory.

Event bus. Systems publish changes to a shared stream and subscribe to what they care about. Producers and consumers do not know about each other, so adding a tool is additive rather than combinatorial. The price is a genuinely harder mental model, eventual consistency rather than immediate agreement, and infrastructure that somebody has to run.

Point to pointHub and spokeEvent bus
Connections at n toolsUp to n(n−1)/2n−1n
Adding a toolUp to n new links1 new link1 subscription
Removing a toolUnpick every link it hadRemove one linkStop one subscriber
Single point of failureNoYes, the hubYes, the bus
ConsistencyWhatever each link doesStrong, through the hubEventual
Who it suitsTwo or three tools, permanentlyMost organisationsHigh volume, many consumers

The index does not ask which shape you have, because it does not need to. It measures connections against the n−1 target, so a hub scores well automatically, an event bus scores well, and a partial mesh with gaps scores badly regardless of what anyone calls it.

One practical consequence worth naming. Migrating from a drifted point-to-point estate to a hub is almost never done as a project with that title. It gets done by declaring a master record, then connecting the next three things to it instead of to each other, and repeating. The topology changes underneath you without anybody approving an architecture.

Borrowing a tool from information theory

There is a clean way to put a number on that last point, and it comes from an unexpected place.

Claude Shannon’s measure of entropy quantifies how spread out a distribution is. Applied to a record rather than a message, it answers: how uncertain is the location of the truth?

H = − Σ pi log2(pi)

If a customer record exists in exactly one system, there is no uncertainty at all and the entropy is zero. If it exists in four systems with no declared master, any of the four could be right, and the entropy is 2 bits. Normalising against the maximum possible spread across your whole estate gives a figure between 0 and 1 that we can use directly.

Systems holding the same recordRaw entropy (bits)Normalised, in a 12-tool estateWhat it means in practice
10.000.00One master. Conflicts are impossible.
21.000.28One copy. Usually survivable with a clear direction of flow.
31.580.44Reconciliation becomes somebody’s job.
42.000.56Nobody can answer “which one is right” without checking.
62.580.72The record has no owner. It has witnesses.
83.000.84Reporting disagrees with itself and no one trusts the dashboard.

The jump that matters is from one to two, not from six to eight. The first duplicate is where the concept of a master record quietly dies.

The swivel chair, counted

The third ingredient is the one everybody feels and nobody measures: work that exists only because two systems do not talk. Reading a value off one screen and typing it into another. The industry nickname is swivel-chair integration, and it is invisible in every budget because it never appears as a line item. It appears as headcount.

It is trivially countable. Re-entries per week, multiplied by minutes each, multiplied by 52. At twenty-six re-entries a week taking four minutes each, that is 90 hours a year — more than two working weeks, spent moving data between systems that already have it.

Staleness is the companion metric. If a change made in system A reaches system B once nightly, then for up to twenty-four hours two systems disagree, and any decision taken in that window is taken on stale information. Expressed as a fraction of a week it becomes directly comparable with everything else.

The Aliensync Index

Those three ideas — connectivity, entropy and manual load, plus staleness — are each measurable, each bounded, and each independently meaningful. Combining them gives a single figure.

This is our own construction. It is not a standard, nobody else uses it, and we are publishing the whole formula rather than hiding it behind a quiz, so you can disagree with the weights and recalculate.

SymbolWhat you countTurned into
nDistinct systems in the workflowScale of the estate
cAutomated connections that actually existConnectivity deficit, CD = max(0, (n−1−c)) / (n−1)
rSystems holding the same core recordRecord entropy, RE = log2(r) / log2(n)
mManual re-entries per weekSwivel factor SF = m / n, then ML = e−SF/3
tHours before a change propagatesStaleness, S = min(1, t / 168)

And the index itself:

ASI = 100 × [ 0.30(1−CD) + 0.25(1−RE) + 0.30·ML + 0.15(1−S) ]

Four notes on the design, because the choices are arguable and you should be able to argue with them.

Connectivity is measured against the hub minimum, not the mesh maximum. Scoring against n(n−1)/2 would punish every sane architecture, since nobody should build a full mesh. The target is n−1.

Manual load decays exponentially rather than linearly. The step from zero re-entries to a few is a real change in kind: somebody now owns a recurring chore. The step from forty to fifty is more of the same. The constant of 3 in e−SF/3 puts the half-way point at roughly two re-entries per tool per week.

Entropy is normalised by estate size. A record living in three systems out of four is a worse situation than the same record living in three out of twenty, and the logarithmic normalisation reflects that.

Staleness carries the lowest weight because it is usually the cheapest thing to fix. Changing a nightly job to hourly is a configuration change. Removing a duplicate master is a project.

Run it on your own stack

Six numbers, honestly estimated. Nothing is sent anywhere — the calculation runs in your browser and the page stores nothing.

—
Aliensync Index
—

The index describes how well a set of systems is joined up. It says nothing about whether you picked good systems, and a tidy estate of the wrong tools will score well. Treat it as a measure of plumbing, not of judgement.

Four stacks, scored

The same formula run on four shapes we see repeatedly. The numbers are illustrative inputs, not survey data, and you can reproduce every row in the calculator above.

Shapencrm / weekLagASIHours lost / year
Small team, tidy54231 h83.710
Enterprise, hub model18172815 min89.928
Growing, fragmented11452624 h46.790
Accumulated neglect1419601 week13.7208

The row worth staring at is the second. Eighteen systems scores better than eleven. That result is counter-intuitive and it is the single most useful thing the model produces: the number of tools is not the problem. The eighteen-tool estate is disciplined, hub-shaped and has one master record. The eleven-tool estate is a partial mesh with five copies of the customer and somebody retyping things twenty-six times a week.

Which is why “we have too many tools” is usually the wrong diagnosis, and consolidation projects launched on that basis so often fail to deliver the promised relief. You can remove four applications and move the index barely at all, because you did not touch the topology or the duplicate masters.

How to read your score

BandRangeWhat is usually trueWhat usually moves it next
Joined up85–100One master per record, hub topology, automation covers the routine pathsLatency tuning, and keeping it this way as you add tools
Workable70–84Mostly connected, one or two duplicate records, a tolerable amount of retypingDeclare masters for the duplicated records
Fraying50–69Partial mesh, several copies of core data, a person has an unofficial reconciliation jobPick the hub, then connect the three highest-traffic paths to it
Fragmented30–49Most systems isolated, reporting disagrees with itself, manual load is structuralStop buying tools. Map what exists before anything else.
Disconnected0–29Integration is a human beingTreat it as an operations problem, not a software purchase

What actually moves the number

Ranked by effect per unit of effort, which is not the order most people attempt them in.

Declare a master for one record

Pick the record that causes the most arguments. Write down, in one sentence, which system is authoritative for it. Change nothing technical. The entropy term improves immediately, and so does the number of arguments.

Pick the hub

One system becomes the place everything connects through. It is usually whichever already holds the most records, not whichever is newest or most liked.

Automate the three highest-traffic paths

Not all of them. Count where the re-entries actually happen for one week, then connect the top three. The manual-load term is exponential, so the first removals pay the most.

Shorten the lag last

Nightly to hourly is usually a configuration change, and it is the cheapest point in the model. Do it after the structural work, not instead of it.

Where this model is wrong

Publishing a formula means publishing its limits, so here they are.

  • It treats all connections as equal. A link carrying ten thousand records a day counts the same as one carrying three. Weighting by volume would be more accurate and much harder to estimate honestly.
  • It assumes one core record. Real estates have several — customer, order, product, employee — each with its own entropy. Run it separately per record for a sharper picture.
  • The weights are a judgement. They are ours, defended above, and not derived from a dataset. Change them if your situation argues otherwise; the formula is in the open.
  • Deliberate duplication is penalised. A read-only reporting replica raises entropy in the model while being entirely sensible in reality.
  • It cannot see data quality. Perfectly synchronised wrong data scores 100.

Questions

Is Aliensync a product I can buy?

Not in the sense the phrase is usually used online. Most of what is written about apps and softwares Aliensync describes a product that does not exist, and the descriptions contradict each other — file sync in one article, workflow automation in the next. We use the word for the connective layer itself, and the index above is our attempt to make that layer measurable rather than rhetorical.

Why not just count integrations?

Because a count has no ceiling and no meaning on its own. Four connections is excellent across five tools and close to nothing across twenty. Every term in the index is normalised against the size of your estate, which is what makes two different companies comparable.

Our score is high but things still feel broken.

Then your problem is probably data quality, process, or the tools themselves, none of which this measures. A high score means the plumbing is sound. It makes no claim about what is flowing through it.

Should we consolidate tools to raise the score?

Look at the four-stack table before deciding. Removing tools without fixing topology or duplicate masters moves the number far less than people expect, and it costs migration effort and goodwill. Declaring one master record is free and usually moves it more.

Can we use this formula ourselves?

Yes. It is published in full above specifically so you can. Run it internally, change the weights, argue with it. We would rather it was used and criticised than treated as proprietary.

How often should we re-run it?

Quarterly, and every time somebody proposes adding a system. The second one matters more: it turns “it is only thirty dollars a month” into a conversation about the twelve new relationships the tool creates.

In short

Integration surface grows as n(n−1)/2 while sensible architecture needs only n−1 connections, which is why the thirteenth tool costs more than the twelfth did. Where a record lives can be measured with Shannon entropy, and the expensive step is from one copy to two. Manual re-entry is countable in hours per year and almost never counted. Put those together, normalise for the size of the estate, and you get a number you can act on, track and argue with.

Tool count is not the problem. Topology, duplicate masters and the people silently absorbing the difference are the problem.

If the number is low

We map estates like this for a living

Running the index takes two minutes. Fixing what it reveals is a project, and the first step is always the same: write down what connects to what, and which system owns which record. We do that work, and the scope and price are agreed in writing before anything starts.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top