SMART PRACTICES

There’s something beautiful about finding patterns where none seem to exist. It’s connected to the idea of bringing order out of chaos, something which our species, at its best, thrives on. You see this trait in action across just about every nameable discipline, STEM, philosophy, the arts… Here, I want to focus on one specific, ingenious technique for spotting patterns in seas of seemingly random data: Monte Carlo simulation.

Monte Carlo simulation (so named because it was first associated with finding win probabilities among the randomness and chance of casino gambling) is widely used across mathematics, computing, and physics. It was made (in)famous by the Manhattan Project, where it was used to predict how neutrons would act within the core of an atomic bomb—how those neutrons might scatter or be absorbed, whether other reactions would be triggered, etc.

Our concerns here aren’t quite as cataclysmic. Here, we’ll look at ways Monte Carlo simulation can be brought to bear on software project planning and management.

Monte Carlo simulation is a technique used to predict the probability of certain outcomes in scenarios involving a high degree of complexity or randomness.

In the abstract, Monte Carlo simulation works by:

Assigning a randomly chosen but

*historically valid*value to the variables in question, and solving for those values;Repeating this step

*n*number of times, swapping in a different set of randomly chosen, historically valid values each time;After enough repetitions—the more the better—a pattern emerges. This pattern depicts a small range of the most likely outcomes.

About that “historically valid” part: Monte Carlo simulation isn’t possible without having actual historical values to plug into the variables in question. Historical data provide the basis for defining the distribution or range of the randomly selected values used for the variables in question.

Monte Carlo simulation answers maybe the most intractable challenge in software development: forecasting when a given project is likely to finish. With sufficient historical data for a given project team, Monte Carlo simulation can predict how long their projects are likely to take to complete.

In this case, the necessary historically valid values are work actuals—that is, the actual historical average time to complete work by person. This is the bedrock variable. From there, other variables can be brought to bear: the number of people available, their current and future capacity, the team’s work efficiency, etc. Newsflash: there are *a lot* of variables at play when delivering software…

In cases like this, a commonly used random variable would be the time it takes for each task within a project, performed by a specific team, to be completed. However, this is a rudimentary setup, and more advanced models would use many other types of variables alongside it, such as resources being allocated, flow efficiently, and individual capacity. In reality, there are tons of variables that can be accounted for when it comes to project management.

The more historical data you have, the more variables you consider, and the more iterations you perform with different values, should lead to a more accurate and reliable result.

There’s an old econ-major joke, in which a group of economists are stranded on a desert island. They have a single can of food, and are discussing the best ways to open it. The first economist begins with, “Assume a can opener…”

You may hear echoes of that when I say that the dataset most important to Monte Carlo simulation is the historical actual average time to complete work, for every person on your team. Suffice to say, getting that is easier said than done. This is why Socratic discovers it automatically for you, by analyzing the entire history of work activity in your Jira projects.

So: assume a dataset of historical actuals…

With that, you’ll then determine your distributions. The historical actuals provide the historically valid ranges. For instance, if the longest duration to complete work was three weeks, that would form the upper limit. If the shortest duration to complete work was 30 minutes, that gives your lower limit.

What happens now? You assign a value that fits within your distribution to your equation, and then run it. Plot the result on a graph, and then run the equation again, and again, and again, with different values each time. The more times you do this, the more historically valid outcomes you generate, and the richer the pattern that emerges.

There are a few that leap to mind…

As described above. For a deeper dive, you can read more here. To see a simplified version of this in action, feel free to play around with our public forecaster.

Monte Carlo simulations can help project managers with budgeting. By analyzing the actual costs of past projects, it’s possible to predict the likely costs of future ones.

Naturally, this means having identified some key variables that drive project risk. Understanding changes in cycle time, for instance, is an interesting signal. So is knowing your project’s momentum. These variables, when coupled with actual historical outcomes—projects that finished closest to their target dates, say—provide a foundation for Monte Carlo simulation to suggest which projects have a higher risk profile.

The real turbocharging occurs when you pair Monte Carlo simulation with AI. This is exactly what Socratic offers. By discovering automatically in your Jira projects all of the bedrock historically valid values needed to predict project completion times, we can create forecasts in an instant. Beyond this, we use ML to understand how teams work, how this may impact forecasts, and where and how teams can work more effectively.