Software is cheaper to write than ever. AI assistants can produce a working screen in minutes, and a prototype that once took a sprint can now take an afternoon. Yet the hardest problems in software delivery have barely changed. Projects still miss deadlines, systems still get rebuilt a year after launch, and users still keep their own spreadsheets on the side because “the system doesn’t really work the way we do.”
The reason lies in what software actually is. Every application is a representation: a model of how a business works, what it deals with, and what its people want to achieve, written in a language a machine can execute. Code is only the last step of that translation. If the understanding behind it is wrong, the code faithfully reproduces the mistake, however well it is written.
In the latest episode of The Performance-led AI Log, Nam Ly, our BA Lead, takes a step back to the work that should happen before the first line of code. He introduces six questions that help teams understand how a business actually works, and explores how AI can accelerate that process without replacing the human conversations and judgment it depends on.

About Nam Ly
Nam Ly is BA Lead at Synodus, where he leads a team of business analysts on large-scale government and enterprise systems. He studied biology at Hanoi-Amsterdam High School for the Gifted and graduated in Information Systems from the Posts and Telecommunications Institute of Technology (PTIT), then moved from technical support into business analysis, where he has spent around five years on outsourcing projects. He is drawn to process and order, and to finding the universal patterns behind how the world works, which is what business analysis now lets him do every day. Self-taught and obsessed with UX/UI, he believes a system is only as good as the experience of the people using it. He holds the PMP certification and is pursuing CBAP.
The shortcut we all know
Much of the outsourcing industry, including in Vietnam where we work, follows a familiar pattern. A client sends a list of features and a few screen mock-ups. The team estimates, builds, and ships as quickly as possible. Deep analysis of how the client’s business actually works is treated as a cost to minimize, or something to sort out later during testing. Agile is often cited to justify this: development starts on day one, and “working software over comprehensive documentation” becomes a reason to skip analysis. Yet the same manifesto asks business people and developers to work together daily, which a remote team working from a feature list rarely does.
We understand why. Speed is what clients ask for, and analysis is hard to bill. We have worked this way ourselves. But the cost does not disappear. It moves downstream, into rework, change requests, and long acceptance cycles, where every misunderstanding has to be found, argued over, and fixed in something that is already built.
Where software actually fails
When we analyzed the defects from one of our own large projects, specified the conventional way, around two in three did not come from faulty code. They came from the specifications. The developers built exactly what was written, and what was written was incomplete, contradicted itself, or was simply wrong about how the business worked.
The first two are problems of writing, and discipline can fix them. The third is different. No amount of careful writing helps when the understanding behind the document is wrong.
The patterns are familiar to anyone who has run a project. A rule nobody wrote down, so each screen enforces it differently. A status that means one thing to operations and another to finance. An edge case everyone handles by hand, so nobody thought to mention it. A step that normally waits three days for approval, quietly turned into a button that “just submits.”
None of these can be solved by writing better code. The answers rarely live in one document or with one person. The business owner understands the purpose, the operations team knows the exceptions, and the finance team knows the rules that cannot be broken. Sometimes they do not even agree on what the same term means. Someone has to bring those perspectives together, ask the uncomfortable questions, and resolve the contradictions before they become software behavior.
How the pioneers turned the world into software

It was not always this way. In 1951, the British catering company J. Lyons & Co. began using LEO I for routine business computing. Its team had spent years studying how the company actually operated, from orders and stock to payroll. The computer came second. Understanding the business came first.
COBOL, at the end of the 1950s, was designed around English-like statements so that business people could read what the programs did. In 1968, a NATO conference popularized the term “software engineering” in response to a “software crisis” of large systems delivered late, over budget, or not at all. In 1970, Winston Royce published the paper later associated with the waterfall model, though he actually warned against building without enough design and early validation.
The following decades produced many of the modeling approaches still used today: Peter Chen’s entity-relationship model in 1976, David Harel’s statecharts and John Zachman’s architecture framework in 1987, Ivar Jacobson’s use cases, and later Eric Evans’s Domain-Driven Design. Japanese system integrators, meanwhile, built large systems on disciplined design documents that traced every screen back to business requirements.
Not all of them were invented for business software, but each gave us a more precise way to describe how something works before committing it to code. The Agile Manifesto of 2001 rightly pushed back against documentation for its own sake; it never asked anyone to stop understanding the business.
Six layers of a business
None of what follows is new. Standards such as ISO/IEC/IEEE 29148 and Japan’s Common Frame have long separated business requirements from system design, and every technique below is decades old. What is new is the context. As AI takes over more of the labor in software delivery, with people kept in the loop, it is leading us back to basics: to the business itself, and to the root problem the software is meant to solve.
Our team organizes that understanding into six layers, each answering a question every organization has an answer to, whether or not anyone has written it down. Each layer borrows a familiar notation.

1. Why: Problem, purpose and legal basis
What are we solving, for whom, under which mandate, and how will we know it worked?
Artifact: a business requirements document (BRD).
2. How: Business processes
How does work move from a starting event to a result, and where does it wait?
Artifact: BPMN process models.
3. What: The domain
Which things does the business deal with, and how do they relate?
Artifact: conceptual and logical ERDs, with a glossary.
4. Who: Actors and what they do
Which people and systems take part, and what may each of them do?
Artifact: UML actor and use case diagrams.
5. When: lifecycles
How does each important thing change over time, and who may move it from one state to the next?
Artifact: state machines.
6. Rules: the constraints that drive the business to its goals
What must always hold true, whichever screen or integration handles the data?
Artifact: a business rule catalog and decision tables.
These notations are borrowed from engineering, because they are precise and both people and machines can check them. What they describe is purely the business: no architecture, no database design, no technology choices. That is the approach we are building at Synodus. Only then do we describe the software: use cases, screens, and prototypes, each pointing back to the part of the business it represents. Whatever a client provides, from laws and forms to meeting notes, ends up in the same structure.
Why not just prototype and iterate?
It is a fair question, and Fred Brooks asked it first. In his 1986 essay “No Silver Bullet,” he argued that clients cannot fully specify what they want in advance, and recommended rapid prototyping and step-by-step refinement. With AI, prototypes are cheaper than ever, and we rely on them: they are still the best way to check screens, flows, and the experience of the people who will use the system.
But a prototype shows only what is on the screen. It does not reveal that two regulations conflict, that a rule applies once a year, or that nobody has decided who may approve an exception. And on a fixed-scope contract, every iteration after sign-off is a change request. So we do both: model the business first, then prototype against that model.
What AI changes, and what it does not
For decades, the main argument against this level of analysis was cost. Describing a business and designing from it meant months of interviews and diagrams drawn by hand, and the documents went stale soon after sign-off. AI changes that. In our approach, AI assistants read regulations, forms, and meeting notes, draft the six layers, cross-check them against one another, and ask the questions an analyst would ask when something is missing or contradictory. When new information arrives, they update the affected layers, so the business model stays alive for the whole project instead of being written once and forgotten. The specification behind it, from use cases to screens, can then be regenerated from that model, with people reviewing every step.
We also learned the limits of AI the hard way. When our teams first used AI to generate code from specifications, the work became noticeably faster, and one kind of defect almost disappeared: code that did not match the specification. We did not track this formally, but our engineers estimate those bugs fell by close to 90 percent. AI is very good at building what it is told to build. Bugs that came from misunderstanding the business barely moved. They now make up most of what is left. Where the understanding was wrong, we simply built the wrong thing sooner.

AI is very good at building what it is told to build. It did nothing to make what we told it more correct.
That is the part no AI changes. AI can help us describe a business; it cannot establish what is true about it. It cannot tell whether a document matches practice, which reading of an ambiguous policy is correct, or which trade-off the business will accept. Those answers come from people talking to each other: an analyst sitting with the people who do the work, asking why, and helping leaders and staff agree on how things should run. Sometimes the most important discovery is not a missing requirement, but a disagreement nobody knew existed.
AI does not make business analysis optional. It makes doing it properly affordable.
What this means for leaders
Given the nature of our work, this approach is not optional for us. Our projects are large and often in the public sector, where requirements come from a dense body of laws and regulations, stakeholders number in dozens, the work runs for years, and every change after sign-off becomes a formal change request. Raising quality and efficiency at that scale meant building an AI-assisted framework that keeps all six layers of a client’s business in one living model, one that outlasts the meetings and the people that produced it.
On smaller projects we run a lighter version: a short brief, the main processes, a shared glossary, and a list of rules, with state machines only where something has a real lifecycle. With fewer stakeholders and rules, clients can validate prototypes directly, and a misunderstanding costs days rather than months to fix. A full model there would cost more than the mistakes it prevents.

An approach that hides its costs is not worth trusting, so here are ours.
What it gives
- Problems surface earlier: Missing requirements, conflicting rules, and unclear responsibilities are found while they are still on paper, not in a released product.
- One shared language: Business owners, analysts, developers, and testers refer to the same things in the same way.
- Consistent rules: Constraints defined once are enforced the same way across screens, integrations, and reports.
- Change you can assess: When a law or policy changes, the links between rules and system behavior show what needs review and what it will cost.
What it costs
- An upfront investment: Even with AI, modeling a business takes time before users see the first working screen.
- Stronger analysts: The role shifts from recording feature requests to understanding how the business works and challenging what does not add up.
- Time from your people: Models cannot validate themselves. The people who run the business still need to review prototypes and answer questions.
Three questions to ask your own team
- Of last quarter’s defects, how many came from code that did not match the specification, and how many from a specification that did not match the business?
- When two departments use the same word, where is its agreed meaning written down?
- When a regulation changes, how long does it take to list every rule and screen it affects?
What we know so far, and what we do not. This approach is young. On the first small systems where we modeled the business before specifying anything, such as class management and small-scale inventory, our teams saw fewer bugs caused by misunderstanding. We do not have numbers yet. The bugs that remained came from analysis that did not go deep enough and questions nobody asked, which is work only people can do. We are now tracking defects by origin, change requests after sign-off, and analysis effort, on projects with and without the six layers.
Understanding somes first
The first business computer was built by people who studied the business before they built the machine. In that same 1986 essay, Brooks wrote that “the hardest single part of building a software system is deciding precisely what to build.” Forty years and one AI revolution later, the coding has become almost free. The hardest part has not moved.
Code is cheap now. Understanding never was.
How useful was this post?
Click on a star to rate it!
Average rating / 5. Vote count:
No votes so far! Be the first to rate this post.
