Estimate project
← All posts

Handling complexity and uncertainty in Software Development: recognize when to hit pause

Find out why it can sometimes be wiser to put a feature off until you have more data and a better grasp of the problem.

7 min read
Software DevelopmentDomain Driven DesignEvent StormingdddBig Picture Event Storming

When a new feature or a completely new system is on the table, we typically assume the job will be done by writing new software or modifying what already exists. In most cases that’s exactly right – it’s what we normally do: we build software that addresses business needs. Every now and then, however, it is invaluable to reach a point where we jointly conclude that no software is needed (or not much of it), or that building a particular thing right now would be too costly or too risky. Something that looks easy and straightforward on the surface may prove complex and complicated, not just technically but from a business standpoint as well. It may be wiser to put such a feature off until we have more data and a better understanding that allow an informed decision, and to concentrate instead on other backlog items that are better defined and explored and that also have a big impact on the product as a whole.

In this article, I’ll present a case from one of our projects where precisely this happened. To make a long story short, the business chose to pause a feature that had been requested and debated for a long time, because of what came to light during discovery sessions run as stripped-down versions of Big Picture and Process Level Event Storming.

Discover problems early and build the right thing

It’s common knowledge that the further along we are in building a system or feature, the harder it is to fix it and the more costly the fix becomes, in time as well as in actual money.

Catching a problem in the code during development is always better than finding out about it once it surfaces as a production bug affecting your users. The same goes for system design decisions: it’s better to foresee their weaknesses early, while designing or building, than to uncover their critical limitations after release.

You might notice a pattern here – and indeed there is one. If we step back and look at things on the level of a feature or a product, it becomes obvious that uncovering potential gaps, risks and uncertainties early, before deciding to build something and committing teams, time and resources, beats charging ahead on gut feeling only to learn later in development that things weren’t nearly as easy and simple as we had assumed.

Taking the risk is sometimes worth it, and moving fast can pay off handsomely, but just as often these decisions end up very expensive and lead to building the wrong things, which then have to be rebuilt or are dropped because they don’t work as expected.

The project in this story was a system already in operation, for which a number of new, ground-breaking features were being discussed. One of them was a feature (or a new “product” offering) that, conceptually, spanned several areas of the existing system, using and orchestrating some of its parts. The system belonged to the financial domain and handled real money, and both users and product people were eagerly waiting for the feature. The catch was that although the feature was easy for end users to grasp conceptually and fairly simple from a product point of view, it had to touch many areas, which made it quite complex at a lower level and in terms of a possible implementation.

Data backed decisions

We held countless meetings with product people and other teams, asked and answered plenty of questions to check and support our understanding, and so on, yet we still weren’t certain that we were all on the same page or that the business understood the risks around complexity, timeline and the like. And we badly wanted that confirmation, knowing it would be a long journey once we committed.

Since setting up ad-hoc meetings and simply firing questions and answers back and forth felt wrong and didn’t deliver much value, we opted for a longer session, which ended up loosely following Event Storming – we used only the parts we thought we needed. Our aim was to get everyone to agree on the process, its steps, how each of them would be carried out, and possible non-happy path cases.

We didn’t start from a blank slate, though. Instead, we prepared a foundation (a Miro whiteboard) with flows showing how we understood the feature at that point. This gave us something to build on instead of spending time recreating everything from scratch, especially since we knew some parts of the process had already been explored well.

As for participants, we decided to invite sponsors, product owners, and people from the accounting and legal departments. The latter two may come as a surprise, but remember that the system belonged to the financial domain, so everything had to comply with strict fiscal and legal regulations.

Over the course of an intense workshop lasting a few hours, we walked through the whole process piece by piece, discussing every part and raising concerns and questions between legal, accounting, product and engineering.

When the workshop ended, our original board was covered with notes, questions, and points we weren’t jointly sure about. Walking through the process in detail exposed places where people understood certain concepts slightly differently, as well as how things worked in other areas we needed to touch. While analyzing possible paths, it even turned out that things previously deemed fine and feasible were flagged as problematic by legal and accounting because of restrictions we had to follow, so we had to take different approaches.

Although we eventually reached a point where the whole process was mapped and everyone was on the same page, it also became clear that it was even more complex than any of us had assumed, and that many “hot spots” had come up with questions we had no good answers to.

It may sound discouraging: we went into the workshops hoping for a shared understanding and more data to kick off development, and we came out with more questions and a feature more complicated than before. But if you step back and look at it from a higher level, we had simply gained much more data to support an informed decision. We aligned our understanding of the feature, learned where we had been right and where wrong, and found a few chances to simplify things along with many new limitations and complexities we hadn’t known about.

Following that workshop, and given all the information now at hand, the product team chose to pause the feature, judging its cost, complexity, timeframe, and overall risk in that shape to be too high. They began exploring alternative approaches instead – less complex ones that could validate the general idea faster, at lower cost and risk, while still following all the rules.

Summary

It’s probably not the result business and product owners typically hope for after a workshop like this, but it’s worth noting that, simply by not committing to that feature, we in fact saved a great deal of time, effort, and money, and likely avoided extra complexity. All that money, time, and those teams and resources could be channeled into another product feature that strengthens our business’s competitive edge.

So although the job is usually about building software, it sometimes pays to spend long hours carefully workshopping the problem in a structured way with everyone involved, so that we don’t end up building software that clearly falls short of the expectations and all the requirements.