TLDR
The short answer: this is a hard problem to solve, because it comes from how software is built and how its costs are structured, and the client has little control over either. Of course, if nothing could be done, there would be no point in writing this article. Avoiding changes entirely is unlikely, but we can talk about how to reduce the risk.
As software development consultants, we often meet clients who have already spent a large budget on an outsourcing team, only to get stuck in a swamp of requirement changes halfway through the project. Every change needs more budget, and the schedule keeps slipping. Both sides feel they are in the right: the client sees these as "small changes", while the development team says every change affects the existing architecture.
So where does the problem actually come from?
After years of advising clients, I have found that the root cause is usually not communication skills or project management methods. It is a lack of structured thinking when the requirements are being defined. Many companies, before outsourcing development, do not know which of their requirements are core and should not change easily, and which can stay flexible. Without that, they cannot make sensible arrangements when the contract and specifications are drawn up.
Below, I start from a real case I worked on to show how analysing the structure of requirements helps a company control risk when it outsources a system.
A manufacturing company wanted a production scheduling system. The requirement looked simple: sequence the work orders on the production lines, taking into account delivery dates, material preparation time and similar factors. The company extracted the basic rules from the Excel sheets it had been using, and the outsourcing team built the first version of the system based on them.
Less than a month after launch, the sales department asked for something new: scheduling should allow for "rush orders" to be inserted. This reasonable-sounding "small change" actually touched the core logic of the system. The original scheduling rules were built on fixed capacity planning. Supporting dynamic adjustment meant changing not only the data structures, but also several modules, including capacity calculation and material requirements calculation.
This case shows a common problem: business requirements tend to "extend". A requirement raised today usually implies changes that may come later. In this case, "rush orders" reflected a more fundamental issue: the company needed to balance "production efficiency" against "order flexibility". That balance point keeps shifting with market conditions, so the system architecture should have allowed for such adjustments from the start.
This is why I always advise clients to do a "structured" analysis when they define requirements.
A structured analysis of requirements looks at three dimensions:
Core business principles
- This is the lowest and most stable layer, usually tied to the basic logic of how the business operates
- Changing this layer costs the most, because it affects the whole system architecture
- It must be settled early in system design
Operating rules
- This layer defines how the business principles are carried out
- There is some room for adjustment, but changes should stay within reasonable limits
- The system design needs to leave room for flexibility here
Runtime variables
- This is the outermost layer and the one most likely to change
- It can usually be adjusted through settings or simple code changes
- The system should provide a complete settings interface
Let's apply this to the production scheduling system:
Core business principles:
- Capacity is a limited resource and must be allocated sensibly
- Orders must be completed before their delivery date
- Material requirements must be calculated accurately
Operating rules:
- Scheduling priority rules
- How capacity is calculated
- The logic for calculating material requirements
Runtime parameters:
- Standard capacity of each production line
- Standard hours for each process step
- Safety stock levels
Seen this way, the "rush order" requirement is much more than adding one feature. It challenges the original core principle that "capacity is a fixed resource" and replaces it with "capacity is a resource that can be adjusted dynamically". A change to a core principle naturally ripples into the calculation logic in the operating rules layer.
So how do you spot requirements like this, the ones that can have a large impact, early on? In years of consulting, I have seen one pattern again and again: companies tend to assume their own way of working is "the industry standard". When a company asks to "support rush orders", it often assumes this is a standard feature that "everyone in the industry has".
In reality, every company defines and handles "rush orders" differently:
- Some reserve capacity for them
- Some move the delivery dates of other orders
- Some make up the difference with overtime or subcontracting
To identify these special requirements early in the project, I suggest looking from three angles:
Compare with off-the-shelf solutions
- Can packaged software on the market fully meet the requirements?
- Is the part that would need modifying too large?
- If you find you need heavy customisation, those requirements are very likely ways of working specific to your company
Check how the problem is described
- Can the requirement be described clearly as a complete process?
- Do different departments understand the same process the same way?
- If even the people asking for it struggle to explain it, or departments read it differently, those areas need closer clarification
Look at exception handling
- What special situations exist outside the normal process?
- How often do these situations happen?
- Exception handling often reveals a company's special requirements
Take an e-commerce system as an example. The client said: "The quoting feature is simple. It just calculates the unit price from the quantity." Digging deeper, we found that:
- Different customer tiers get different kinds of discounts
- Some products can have special promotion rules
- Sales staff can adjust prices under certain conditions
- Some products are priced using live exchange rates
On the surface it was a simple quoting feature, but underneath it held a lot of business logic specific to the company. That logic has to be identified early in system design so the right architecture can be planned.
With this kind of analysis, we can tell more clearly at the start of a project which requirements are core needs the system must support, and which are flexible needs that may change. Knowing this lets us:
- Plan the system's flexibility boundaries from the start
- Separate out the parts that genuinely need customisation
- Avoid over-engineering that adds unnecessary cost
One last point: the cost of building a system is usually not in the initial development but in the modifications that follow. With better requirements analysis, we can make sure every dollar goes to features that genuinely need customising, rather than to repeatedly reworking parts that should have been flexible in the first place.