Not long ago, while designing a new software feature for a client, I was heavily criticised.
The request itself seemed straightforward. The client was building a software system and wanted to add some industry-specific features. For example, a logistics company might need a freight calculator that works out shipping costs based on weight, volume and distance.
It doesn’t sound complicated, does it? Just add a couple of database tables, write some code, and build a calculation page — done.
But given the client’s longer-term business direction, I suggested a different approach: Why not consider a plugin system?
The client was not happy.
Client: “You keep talking about architecture. Isn’t it just adding two database tables? Why are you making it so complicated?”
The conversation that followed was uncomfortable. I tried to explain why this design would better support future growth, but after a long discussion the client still felt I was over-complicating a simple problem.
Later I discovered he enjoyed video games. So I changed the example.
“You’ve played GTA 5, right? Do you know about the flying-car mod?”
That time, he finally understood.
This story is not meant to prove that my proposal was automatically correct. Instead, it made me rethink an important question: When should we prepare software for the future, and when are we simply wasting the client’s budget?
The client was actually right: Isn’t it just adding one feature?
Let’s start with the conclusion. If a logistics company came to me and said they needed a freight calculator, I would probably recommend building that feature directly. They simply need a calculator. Enter the weight, volume and distance, and the software returns the shipping cost. When the requirement is that clear and limited, why spend extra money building a complex plugin system?
This project, however, had an important background. The client was not building software that would only serve the logistics industry. They were building a platform intended to support dozens of different industries over time.
Today logistics needs a freight calculator.
Tomorrow retail might need inventory management.
The day after, construction might need material quantity calculations.
Later, other industries could bring completely different requirements.
What happens if every new feature is simply added into the existing codebase? At first it may seem fine. One calculator, then an inventory page, then a quoting tool — each looks like a small request. Over time, however, more and more industry-specific rules become mixed together. Software that was originally responsible only for core business functions gradually turns into a large system containing every industry’s special logic.
This does not mean the software will necessarily fail. Well-designed systems can support many features in one place. The real problem is that when everything is tangled together, each future addition may require more time to check and modify existing code. For developers this means the work becomes steadily more difficult. For the business owner it means something simpler: a change that once took three days may later take a week.
Of course this is only an illustration — actual costs depend on the software itself. But if development and maintenance efficiency keep declining, the company ultimately pays for that extra time. What I worried about was not writing a few more lines of code today, but whether every future upgrade would become more expensive for the client.
The question was: how do I explain this to the client without asking him to study software engineering first?
Later, I used the GTA 5 flying-car mod to explain plugins
Since the client liked games, I decided to put the technical jargon aside for a moment.
I asked him:
“You’ve played GTA 5, right?
You should know what game mods are.”
For readers who are not familiar with the game, Grand Theft Auto V is an open-world title. Players can drive around a city, explore the map, or complete missions. Under normal circumstances a car stays on the road — it cannot fly freely like an aircraft.
What if a player one day wants the car to fly? One approach is to modify the game’s own code and add flying capability directly to the vehicles. GTA 5, however, also supports another approach: installing mods.
By installing a flying-car mod, a player can make an ordinary ground vehicle take to the sky. Players can also install many other kinds of mods — character appearance mods that change how people look, vehicle mods that add new cars, or gameplay mods that introduce features the original game never had. These new capabilities do not all have to be built by the official developers, nor do they all have to become permanent parts of the base game.
So I told the client:
“Think about it. If every new play style in GTA 5 required redesigning the entire game, how much trouble would that be? Why not let your software work more like GTA 5 — adding new features through relatively independent modules?”
The original software is like the base GTA 5 game. It handles login, core business logic and data management.
The logistics calculator is like the flying-car mod.
When construction features are needed later, add a construction module.
When retail needs inventory management, add a retail module.
This way we avoid stuffing every industry’s special features into the main application.
More importantly: not every GTA 5 player wants a flying car. Some just want the original experience, some enjoy flying vehicles, and others only care about changing character appearance. Business software works the same way. A logistics company may need a freight calculator, but a retail shop may not. A construction firm may need material calculations, while a beauty salon has no use for them. If the software can enable the relevant features according to each customer’s needs, users are not forced to face large amounts of irrelevant functionality.
Of course, enterprise software plugins are not identical to GTA 5 mods. Game mods can still modify original files and sometimes conflict with one another. What I wanted the client to understand was the underlying design idea: the base software provides the common capabilities everyone needs, while special features can be developed and managed more independently.
This time the client understood. We stopped arguing about technical terms and began discussing the real question: if the platform is truly going to support dozens of industries, how can we make adding new features simpler?

Wait — isn’t this just over-engineering?
If you have read our earlier article on Vibe Coding and over-engineering, you may notice an apparent contradiction. In that piece we discussed how a simple feature can generate large amounts of unnecessary code through over-design. Yet here I was recommending that the client consider a plugin system in advance. Isn’t that inconsistent?
The key point is this: preparing for the future does not mean building every possible future feature today.
Consider a real-life example. Suppose you are about to open a restaurant. At present you only plan to serve dine-in customers, but you already intend to launch delivery in six months. When fitting out the space, it is reasonable to think about where delivery riders will collect orders and how to keep them from interfering with dine-in guests. You may only need modest adjustments to the layout.
But if the restaurant has not even opened yet and you start worrying, “What if I eventually have a hundred branches?”, then decide to build a central kitchen, a national delivery network and a complex warehouse system first, you risk spending large amounts of time and money while the first restaurant never opens. That is likely over-engineering.
Software development follows the same logic. If it is already clear that different industry features will be added later, it is reasonable to consider how those features can be kept separate. But if the only justification is “we might need it someday”, and months are spent building a complex system, the budget is probably being wasted.
What is the difference?
| Reasonable advance planning | Over-engineering | |
|---|---|---|
| Requirements considered | Already clear business direction | Imagined requirements that may appear |
| What is done now | Leave necessary room for future extension | Build large amounts of functionality not yet needed |
| Investment approach | Add capability step by step according to real needs | Try to solve every future problem in one go |
| Restaurant example | Reserve space for delivery collection | Build a national delivery network before the first shop opens |
| Software example | Keep different industry features managed separately | Build a complete plugin store and automatic update platform upfront |
Returning to this project: supporting dozens of industries was a business direction the client had already stated clearly. That does not mean we must develop every industry feature now, nor that we need to build a full plugin ecosystem in one step. Reasonable extensible design means leaving a door open for the future, not constructing the entire building outside that door today. What matters is that when new features are eventually required, we do not have to pay unnecessary costs because of earlier design decisions.
How can a small-business owner decide whether the extra spend is worthwhile?
Technical solutions can be complicated, but for a business owner the decision of whether the investment is worth it can start with three practical questions.
First: Will this feature really be needed in the future?
Suppose you run a retail shop with only one location, but you have already signed a lease for a second store that will open in six months. When building inventory management software, it is reasonable to consider multi-store capability. This is not an imaginary requirement; it is a concrete business plan. Saying “I hope one day my business will reach the whole world” is an admirable goal, but it does not justify spending money today on a system designed for ten thousand stores worldwide. A confirmed commercial plan and a distant commercial dream are two different things.
Second: If we ignore it today, how expensive will the later change be?
Some features are easy to add later. If a website currently exists only in Chinese and the future need is simply a few basic English pages, there is usually no reason to build a complex multi-language management system today. Other decisions become very costly once the software is live. Imagine a management system originally designed for a single company. Years later you want to turn it into a platform serving hundreds of companies, each managing its own customers, orders and staff independently. If the original system never clearly separated each company’s data, the later transformation may involve extensive code changes, database restructuring and data migration. Handled poorly, it can even risk data leakage between companies. Considering data isolation properly at an early stage is usually far easier. Whether advance planning is needed depends not only on whether the future event will occur, but also on how expensive the later change would be.
Third: How much extra does the advance preparation cost today?
This is the question business owners should care about most. Suppose a new feature has two options. Option A can be built in three days. Option B, designed to make similar future features easier, takes five days. If similar features are likely to be added repeatedly, the extra two days may be a reasonable investment. But what if Option B takes three months instead of five days? Then the decision requires careful thought. How many similar features will really appear? Do they genuinely need such a complex system? Are there simpler alternatives?
Software architecture is not free. More complex designs mean more development, testing and maintenance work, all of which can eventually turn into costs the business must pay. We should not only ask “Is this technically more advanced?” We should also ask “Is the benefit worth paying for today?”
Plugin systems sound complicated — do they really need to be that complex?
After explaining the GTA 5 mod idea, a practical question remained: Do we really need to build something as complex as a full game-mod manager?
Not necessarily.
A complete plugin platform can include many capabilities: an online plugin store users can browse, one-click installation, the ability to enable or disable plugins at any time, and even independent updates published by different developers. It sounds attractive. But for the first stage of this project, were all those features necessary?
My view was that the immediate need was to keep different industry features relatively independent, not to rush into building a full plugin platform. The logistics calculator can have its own code, pages and data. When a construction materials calculator is added later, it can also be developed as a relatively independent module. Changes to the logistics feature then do not require constant interference with the construction code. Features such as a plugin store, online installation and automatic updates can be considered only when real demand appears.
There is another point that is often overlooked: the ability to extend software conveniently does not automatically mean a plugin system is required. For many small and medium-sized business applications, ordinary modular development is already sufficient. In simple terms, there are three different approaches:
| Development approach | Simple explanation | Suitable situations |
|---|---|---|
| Add features directly | Insert the required capability into the existing software | One-off small requirements with limited future expansion |
| Modular development | Keep different business capabilities managed separately | Long-term maintenance and the likelihood of adding multiple features |
| Full plugin platform | Independent installation, updating and management of plugins | Clear dynamic extension needs or plans to allow third-party plugins |
These three options are not ranked from basic to advanced. They simply suit different business needs. A single restaurant does not need a central kitchen to serve excellent food; a multi-outlet chain may need more sophisticated supply-chain management because of its scale. For this client’s project, if evaluation showed that ordinary modular development already met the requirements, there was no need to incur extra cost simply for the sake of the name “plugin system”.
Technology should serve the business, not force the business to serve the technology.

Good software design should save the business money, not cost more
Many people hear the words “software architecture” and immediately think of complex technology, large amounts of code and expensive development fees. In my view, the real question good software design needs to answer is practical: How can the software meet today’s needs without creating unnecessary problems for tomorrow?
This does not mean that designing earlier and more complexly is always better. Over-engineering itself can become a burden. You may spend months building a highly flexible system, only for the business direction to change so that the pre-built features are never used. What was intended to save future cost becomes today’s waste. Conversely, ignoring the future entirely can also be costly. Saving a little development time today by putting every feature together can leave the software increasingly complex years later, so that every change requires extensive checking of other parts — or even a costly rewrite.
Neither outcome is desirable. Good software design finds a balance between today’s development cost and tomorrow’s maintenance risk. Sometimes the best choice is simply to build a straightforward feature. Sometimes it is worth spending a little extra time to keep different business capabilities separate. And sometimes the most responsible advice is: “You do not need to build this software at all right now — an existing off-the-shelf product is already enough.”
For example, a small beauty salon that only needs appointment booking and client reminders may be well served by an existing booking system. Building a fully custom management system from scratch for those needs is unlikely to be the most cost-effective choice. But if the business has unique workflows, needs to connect multiple existing systems, or finds that no off-the-shelf product adequately covers its core requirements, then custom development can deliver real value.
The goal of software development should not be to sell the client more code. It should be to solve the business problem at a reasonable cost.
What this experience taught me: Clients do not need to understand architecture — they need to know why they are paying
Looking back, the client’s initial objection was reasonable. From his perspective the situation was simple. He needed to add a feature. The developer started talking about a lot of architecture he did not understand. Of course he would worry: “Are you over-complicating a simple problem?” He might even suspect: “Are you trying to make me spend more money?”
As a developer I cannot assume that because I understand the technology the client should simply trust my judgement. I have a responsibility to explain clearly: Why is this design needed? How much extra cost does it add compared with a simpler approach? What practical value does that extra investment bring? What risks exist if we do not do it? Are there cheaper or simpler alternatives?
The mistake I made at the beginning of this conversation was rushing to explain the technical solution. I talked a great deal about code organisation and future extensibility, but what the client really cared about was one sentence: “Why should I pay today for a requirement that has not yet happened?”
That question deserves a serious answer rather than being buried under more technical language.
Later, once I used the GTA 5 flying-car mod as an explanation, we finally reached a shared understanding. The client did not need to know which technologies sat behind the plugins, nor did he need to grasp complex software design principles. He only needed to understand why different industry features should be kept separate and how that separation could reduce future development and maintenance costs. Understanding a proposal, however, does not automatically mean the proposal is worth the investment. The final decision still depends on actual requirements, budget and long-term benefit. That is a decision the developer and the client need to make together.
Closing: Do not only think about today, and do not pay for an imaginary tomorrow
If you are a business owner considering software development, here is a simple suggestion. The next time a developer tells you, “We need to plan for future extensibility,” you can ask: “If we do not do this now, what specific problems will appear later?” If the answer clearly describes the likely future requirements, the cost of later changes, and how much the advance preparation costs today, the suggestion is worth serious consideration. If the answer is only “because it is more advanced,” “because big companies do it this way,” or “because we might need it someday,” you have every right to keep asking questions.
Likewise, if a developer says, “Just build something quick for now and worry about it later,” you can ask: “If the business grows, will this software still be usable?”
Good software development should not blindly chase the fastest possible delivery, nor should it turn every simple project into a complex engineering exercise simply to display technical skill. We do not need to prepare for every possible future. We need to prepare for the futures that are genuinely worth considering.
That is the biggest lesson this client conversation left me with.
Good software architecture is not about how advanced the system looks. Good technical communication is not about how many professional terms the client understands. It is about helping the client see why we are doing something today and what value that investment can bring to the business. After all, the client is not buying code or architecture. The client is buying a software system that can solve today’s problems and has a realistic chance of growing with the business.
About Snowsy Software
Snowsy Software is a Sydney-based software development studio that helps small and medium-sized businesses and startup teams build, improve and maintain software systems. We believe professional software engineering should not be reserved only for large enterprises. Whether you need a simple automation tool, improvements to an existing system, or a business platform that can grow over time, we prioritise real requirements, budget and long-term maintenance cost rather than chasing complex technical solutions for their own sake.
Software should not be more complicated than the business problem it is meant to solve. If you are considering new software development, or if an existing system is becoming harder to maintain, we would be happy to talk.
[Learn more about Snowsy Software →]
This article is adapted from a real client conversation. To protect client privacy, some business details, dialogue and technical specifics have been adjusted.

