[CASE FILE ITEM: Deposition exhibit, background profile compiled by forensic accounting team during the post-takeover audit.]
They don’t tell the story in one place. You hear pieces of it in hallways, in onboarding decks that skip a slide too fast, in jokes people make when something inexplicable works.
“You know Jeff didn’t want a company, right?”
The new hire looks up from his laptop. “I thought - wasn’t this his startup?”
“It was,” the director says. “But not because he wanted to be a founder.”
“Then why?”
The director thinks for a moment. “Because nobody else was doing it correctly.”
“That’s… subjective.”
She smiles. “Not to him.”
Back then, there weren’t roles. There were problems.
Jeff was right out of school - top program, the kind professors still name-drop - and already exhausted by people telling him to simplify. To average soil profiles. To assume symmetry. To ignore edge cases because they were “unlikely.”
He didn’t argue much. He just stopped listening.
He built the first version at night. Not a product - just a model. Fortran, because that’s what the structural packages talked to. Ugly, brittle, exact. It took inputs nobody else wanted to deal with because collecting them was annoying.
When it got too slow, he rewrote parts in C. Then C++. Not because it was elegant, but because the geometry demanded it. Python came later, when automation mattered more than performance.
“Did he code all of it?” someone asks.
“No,” the director says. “He hated that part.”
“So who did?”
“He hired people. Contractors. An IT guy who knew how to make things stable. Paid them well. Borrowed money to do it.”
“Borrowed?”
“A lot,” she says. “Jeff was allergic to partners.”
“Why?”
“Partners want opinions,” she says. “Jeff wanted correctness.”
The company accreted around the model.
Cities wanted it because it worked. Startups wanted it because regulators trusted it. Private equity noticed because failure rates were low enough to monetize.
Jeff didn’t like running anything. He gave away management first. Then titles. Then equity, piece by piece, every time someone told him this is just how companies scale.
“What did he keep?” the new hire asks.
The director taps the table. “The algorithm.”
“But the company owns it.”
She gives him a look. “On paper.”
The codebase is… difficult.
No comments. No documentation. Raw formulas, unlabeled variables, dependencies pinned manually because Jeff didn’t trust auto-updates.
“He checks them himself,” someone from IT says. “Every time.”
“That’s insane,” another says.
“It’s consistent,” the IT guy replies.
There was a head of IT once. Brilliant coder. Helped translate Jeff’s logic into something machines could run. When the system stabilized, he left. Cashed out. Bought a house in Marin.
Jeff stayed.
He maintained it. Adjusted it. Patched it when edge cases appeared. Refused to let anyone abstract it too far away from the math.
“Why doesn’t he explain it?” the new hire asks.
The director shrugs. “Nobody asked the right questions.”
By the time the company corporatized, Jeff was already half gone.
He sat in meetings, said very little, corrected things that mattered, ignored things that didn’t. People learned to route around him socially and depend on him technically.
“He’s… intense,” HR says, diplomatically.
“He’s reliable,” engineering replies.
When private equity came in, they bought dashboards, contracts, revenue streams.
They didn’t realize they were also buying a machine with a proprietary engine.
And the only maintenance manual lived in Jeff’s head.