My client runs a commercial real estate firm. Their whole business ran on scattered CRMs, spreadsheets, email inboxes, the whole suite, plus a handful of people who each held a different part of the operation in memory. Nothing was broken in a way you could point at. The company was growing, and the growth itself was the problem.
Most of their day happens in the field: meetings, lunches, dinners. So by the time they get home and sit at the computer, the last thing they want to do is jump from platform to platform trying to find where they saved Billy's number and his property requirements. Most folks would set office hours and log off at a certain time. In an ideal world, that would be the way to live. But when you're closing multi-million dollar deals, money does not sleep.
My job was to get them their time back. Finding Billy's contact info had to become a ten-second lookup instead of a twenty-minute hunt.
Before we wrote any code, we watched the operation run. We traced a single deal from the first call to the close and noted every place a person had to remember something, look something up, or wait for someone else. That map became the real specification. The code came later, and most of it was obvious once the map existed.
The map showed where the strain actually lived: the handoffs. A number lived in one person's head. A status lived in a message thread. A decision waited on someone who was at a lunch across town. Each handoff was small, and together they set the ceiling on what the firm could do in a day. So the platform we built removed handoffs. Every deal got one place to live, one status everyone could see, and one set of rules that decided what happened next.
We designed for the person doing the work, because the people who run an operation are fluent in it. They know the exceptions, the edge cases, the client who always needs the odd thing. If the system fights that fluency, they route around it, and within a month you have two systems: the official one and the real one in the spreadsheets. Our rule for adoption was simple. Make the platform faster than the workaround, and people take the correct path without being told to.
We also resisted modeling everything at once. When you can finally see the whole operation on one page, the temptation is to encode all of it, and that instinct produces systems that are complete and unused. We built the spine first: the path every deal travels, every day, without exception. The rare cases got handled as they arrived.
What SYMCRG has now is an operation you can see. Anyone can look at the pipeline and know where things stand. Work that used to depend on a specific person now depends on the system, so the people are free for the judgment calls that actually need them. Fewer subscriptions, one login, and the firm can take on more deals without adding proportional strain. The deliverable was never the application. We handed them back their evenings.