Research learns that businesses frequently choose products with too many features that they later find difficult to use or will not be used at all. Feature rich software products are often fuel for business complexity.
When you have analysed your problem into one or more architecture building blocks you have a clear insight in the capabilities your software solution needs. Architecture building blocks describe what the requirements for your solution must be. So the needs and features.
When you search for solution building blocks there are two extremes:
- Feature rich building blocks. These are solutions that meet your requirements but also offer a lot more functionality. Often you have not thought of this functionality before, but it seems nice to have. At least for possible future use. In software terms these kinds of solutions are called ‘batteries’ included. An example are famous FOSS content management systems with user management, user authorization, forum and dynamic look & feel functionality built in.
- Feature poor. These kinds of solutions do exactly what is needed. But nothing more. This means that for other functionality you have to find another solution or try to integrate it with the bare minimum solution found.
Even if you adopt principles to avoid complexity a choice between using a feature rich or feature poor solution is often difficult to make.
An approach to make such a decision is to create a complex decision matrix. A simpler method is to start with a table.
| Feature rich solution (batteries included) | Feature poor solution (bare minimum) | |
|---|---|---|
| Maintainability | Can get complicated. | Simple. |
| Security risks | Demands full risk analysis and continuous effort. | Clear threat model and simple to incorporate in security processes. |
| Usability | Excellent. These kinds of solutions are created with end users and administrators in mind. | It just works. But often without fancy UI or usability features in mind. |
| Flexibility and Extensibility | Excellent. Often such a solution is a Swiss army knife. You can run a lot of business processes using such a solution thanks to various integration options. | Poor. New functionality must be custom made. |
Feature rich solutions often lead to even more requirements. Feature poor solutions require you to think and evaluate your requirement in depth.
Note: You can use this simple (free!) online Causal Loop Diagram tool too!
Simple solutions should be feature poor. It fills in the exact need. Nothing more. No overhead. No extra cost involved. The fallacy with feature rich solutions is that you think you are going to need the embedded features and functionality in the future. However history learns that also you will not need those features in future. This is because your future needs are dynamic and influenced by customers, technology trends, budgets and many other internal and external factors. The related simple principle is called YAGNI (You Ain’t Gonna Need It). But make sure that the simple solution can evolve in future, since systems and needs will change.
An approach that is often seen is to use a platform solution. The promise with a platform or pluggable framework is that you only pay or implement the functionality that you need now. And of course platforms are always promoted as endless flexibility with low overhead. But evaluating also a platform for your current needs and using simple principles will give you an answer right away.