FIELD NOTE |
December 3, 2025
Your Tech Stack Is an Org Chart
Startups move fast by distributing authority. Their systems record what happens when all of those local decisions eventually have to become one organization
Technology stacks are often described as collections of tools.
I think they are also records of how an organization learned to work.
At one company, I started baselining the CRM and found 872 objects and 10,161 fields.
The number was startling. But the more interesting problem wasn't that there were ten thousand fields.
It was that nobody really knew why many of them existed.
There were something like thirteen fields on the account that were some version of ARR. None contained the same number. Different teams had created or relied on different versions for different purposes.
None of that necessarily meant someone had made a bad decision.
A team needed information. The existing system didn't represent it in a useful way. Someone created a field. A workflow began depending on it. A report used it. Maybe an integration wrote to it, or from it. Another team encountered a slightly different problem and solved that one too.
The organization kept moving.
Then a new CFO arrives and asks what should be a fairly ordinary question:
What's our average ARR across customer segments?
Or:
Which accounts expanded last year?
Now the problem isn't that Salesforce has too many fields.
The organization has multiple answers to what ARR is.
Somewhere along the way, a series of local solutions became an organizational fact.
This isn't particularly unusual. In one recent survey of senior data and technology leaders at large enterprises, 99 percent said their organizations struggled to define consistent business metrics across tools and departments.
That sounds like a data governance problem.
Sometimes it is.
But I think the more interesting question is how an organization ends up with thirteen definitions worth governing in the first place.
Moving fast leaves architecture behind
Startups are often deliberately designed to distribute operational authority.
Small teams move quickly. Managers solve the problem in front of them. Functions buy the tools they need. People create workflows without waiting for a central committee to approve every decision.
A lot of that is good.
I don't think the answer is to make young organizations behave like mature ones. A twenty-person startup probably shouldn't establish an enterprise data governance council before someone can add a field to Salesforce.
Speed matters. Local authority matters. The ability to solve the problem in front of you without waiting for consensus matters.
But distributed authority creates something besides speed.
It creates local decisions.
Marketing develops one way of understanding the customer. Sales develops another. Finance needs something more precise. Customer Success creates a process that reflects what it needs to know. Product has its own representation of an account, user, organization, or subscription.
For a while, those differences may not matter very much.
Then the company gets larger and starts asking questions that cross those boundaries.
Which customers are actually growing?
What did we promise them?
What products do they use?
What does it cost to serve them?
Which segment is most profitable?
Who owns the relationship?
Suddenly, the organization needs all of those locally reasonable decisions to add up to something.
Sometimes they don't.
We tend to call the resulting mess technical debt.
I think that description is incomplete.
Technical debt suggests that the problem lives in the technology. But the technology may be faithfully representing something true about the organization: different parts of the company developed different ways of understanding the same thing.
Cleaning up the fields doesn't resolve that.
Someone still has to decide what ARR means.
Technology makes organizational decisions executable
This is part of why I've always found technical architecture interesting.
I often end up in technical roles because technical systems make sense to me. But I've never thought of myself primarily as a technologist.
I'm a systems designer first, a process engineer second, and a technical architect third.
That order matters.
If I start with Salesforce, I have a problem with thirteen ARR fields.
If I start with the organization, I have thirteen pieces of evidence.
Why did thirteen versions need to exist?
Who was using them?
What were they trying to understand?
Which definition should be authoritative?
Does one definition even work for every purpose?
What happens to the workflows and reports built around the others?
Who has the authority to decide?
And who possesses the information necessary to make that decision well?
The technology isn't incidental to those questions. It makes their answers operational.
Who can change a customer record? Who can approve a discount? Who can see compensation? Who can create a workflow? Which system wins when two values disagree?
An org chart can say a team owns something. A process document can say who is accountable.
The architecture determines a surprising amount about what they can actually do.
And once those decisions have been encoded, they can continue operating long after the conditions that produced them have changed.
The past is still running
Imagine someone in HR chooses a system seven years ago.
It may have been exactly the right choice.
Then she leaves.
The organization restructures. The process changes. The company grows. Other systems get connected to it. Finance depends on an export. An integration relies on an identifier it generates. Someone builds a workflow around a limitation nobody remembers was a limitation.
Eventually someone asks:
Why do we still use this?
Nobody has a particularly good answer.
But they also can't turn it off.
The original decision has become infrastructure.
This happens at smaller scales too.
A CRM field can preserve a decision made three reorganizations ago. An integration can encode a handoff between teams that no longer exist. A permission model can preserve who was trusted when the system was built. A duplicate tool can mark the moment one function stopped believing another function would meet its needs.
The org chart changes faster than the architecture underneath it.
And unlike human memory, the architecture doesn't have to remember why a decision was made to continue enforcing its consequences.
It isn't merely a record of the past.
The past is still running.
Sometimes the system is holding the disagreement
This is why technology cleanup is rarely only technical.
Removing one of those ARR fields requires deciding whether the differences between them are meaningless duplication or whether they represent genuinely different concepts.
Removing a tool can require figuring out why a team stopped trusting the shared one.
Changing a permission can reopen a question about who actually owns a decision.
Automating a handoff can force two teams to agree about what is being handed off in the first place.
Sometimes what looks like technical debt is an organizational question that was never resolved.
The technology didn't create the ambiguity. It gave the ambiguity somewhere to live.
This is also why I don't think the goal is always standardization.
Thirteen definitions of ARR are probably a problem if the company cannot answer basic questions about its revenue.
But variation itself is information.
Before collapsing thirteen fields into one, I want to understand what produced thirteen.
Maybe twelve really are debris.
Maybe two represent distinctions the business actually needs.
Maybe Finance and Sales aren't disagreeing about a number at all. They're answering different questions and calling both answers ARR.
The archaeology matters more than the count.
Follow the data and you can often see the organization's actual dependencies.
Where does customer identity originate? Which system wins when two values disagree? What has to happen before Finance can invoice? Which team discovers a failure first? Where does someone export a spreadsheet because the official system cannot represent what they need?
Those sound like technical questions.
They aren't only technical.
An integration map is often a relationship map with APIs drawn on top.
A permission model is evidence about authority.
A duplicate application may contain a history of trust.
A field can preserve an organizational distinction long after anyone remembers making it.
And a database containing thirteen versions of ARR may be telling you something more important than the fact that the database needs cleaning.
The stack is not separate from the organization. It is one of the places the organization has been written down.
Which means scale doesn't just require adding more infrastructure.
At some point, the organization has to decide which local decisions now need to become shared ones. Which definitions have to converge. Which authority needs to move. Which distinctions still matter. Which workarounds have become infrastructure. Which pieces of the past should still be running.
Autonomy leaves artifacts.
Some are useful. Some are obsolete. Some contain information about the organization that would be lost if we cleaned them up before understanding them.
So if I want to understand how an organization actually works, I want to see the org chart.
Then I want to see the systems.
I'm especially interested in where they disagree.