5 Heuristics to Decide When It’s Time to Stop Designing and Start Coding
Tags: programming, architecture, development, startup
Published: 2022-01-26 20:08:25

---
title: 5 Heuristics to Decide When It’s Time to Stop Designing and Start Coding
published: true
date: 2022-01-26 14:42:52 UTC
tags: programming,architecture,development,startup
canonical_url: https://betterprogramming.pub/how-to-decide-when-its-time-to-stop-designing-and-start-coding-eb9b6d8625c
cover_image: https://cdn-images-1.medium.com/max/1024/0*TvAAgVp9732sc_Gd
---

#### Techniques for balancing design and development planning

As engineers, we divide our work between designing solutions and building them. In this post, I'll focus on deciding how much time and effort should go into design work that happens before any execution (coding).

![](https://cdn-images-1.medium.com/max/443/1*Qc0MIpL85g9-I5oAZ6ukmg.png)
_Iterative Design Process_

I'm a big believer in the "Iterative Design Process" which means instead of working in distinctive stages, one after another, you advance in tiny adjustments to the design as you identify challenges, get feedback, or come up with innovative new ideas.

But here comes the question, how would the team know it's time for prototyping?

![](https://cdn-images-1.medium.com/max/492/1*mwpua4ofhzEPDsL9qQPiLg.png)
_Albert Einstein_

So how do you determine the amount of time that will go into design? Will it be 10%, maybe 90% (like our dear Albert)?  
When using agile methodology, this becomes a critical decision for software architects. Should you start iterating or wait for a complete solution?

### The knowns and unknowns framework

![](https://cdn-images-1.medium.com/max/479/1*4UDXf0MsYtGfcgncHmr06Q.png)
_Donald Rumsfeld_

In this framework, there are four levels of knowledge. These levels can help us measure how close we are to finishing our design and moving to implementation.

- **Known knowns** : Things you're aware of and understand  
_Example: Developing SAML Single Sign-on_
- **Known unknowns** : Things you're aware of but don't understand  
_Example: Integrating the SAML Single Sign-on with the exiting authentication flow_
- **Unknown knowns** : Things you're not aware of but understand  
_Example: Additional requirement of Two-factor authentication (that you know how to develop)_
- **Unknown unknowns** : Things you're neither cognizant of nor understand  
_Example: There is a security bug in the Single Sign-on library you are familiar with and planning on using_

We can work a lot on the first two levels in our upfront design. The last two will require implementation work, which can be the real deal or a PoC.

![](https://cdn-images-1.medium.com/max/340/1*ImEKlTuYpj2ASN-0B9xAPQ.png)

### Heuristics

> A heuristic, or heuristic technique, is any approach to problem solving or self-discovery that employs a practical method that is not guaranteed to be optimal, perfect, or rational, but is nevertheless sufficient for reaching an immediate, short-term goal or approximation. — [https://en.wikipedia.org/wiki/Heuristic](https://en.wikipedia.org/wiki/Heuristic)

We will start by defining our **_cost function_** _:   
How much time spent + level of risk._

Let's go over the desired expectation. We want a strategy that will allow us to decide when to **stop designing** and **start implementation** while **optimizing the cost function.**

#### Heuristic #1: There are enough "Known knowns."

_Do you have minimal knowledge to bring value?_

![](https://cdn-images-1.medium.com/max/368/1*R3rusPWi6cJP3MeiJMn6wQ.png)

Your project might be massive; therefore, there are many requirements, and it might be that some of them can be delivered without the others. In the "Iterative Design Process," we want to get back feedback as fast as possible. That's why, if you have something you can ship with low risk, do it.

![](https://cdn-images-1.medium.com/max/347/1*wAI3vDVeJp-4UzbQVaSyaQ.png)
_We want to balance the business value and the design maturity._

Pay attention to the level of risk. While you do want to iterate, you do not want to break the core components of your system.

#### Heuristic #2: There are no more "Known unknowns."

_Did you solve all your "open points"?_

![](https://cdn-images-1.medium.com/max/340/1*yvDZcaXJgm4zXRQjA1zRQA.png)

It's very recommended to start any project with some risk assessment. During the evaluation, the team should surface up any open points. It could be a module you didn't touch for a long time or a new technology required for the project.

A good heuristic that it's time to move on is when you have got one or more solutions for each one of your open point points.

#### Heuristic #3: There are too many "Known unknowns."

_You can't focus as you have too many "open points."_

![](https://cdn-images-1.medium.com/max/340/1*184HQsorBEKofp1wvnRTMQ.png)

There are so many open points you don't know where to start. This might be a good indication that you need more info. A prototype can focus your efforts. You will probably need to return to the design table again, but this time with much more information (and fewer open points).

#### Heuristic #4: You stop learning new things

_Do you keep discussing the same open point over and over?_

![](https://cdn-images-1.medium.com/max/340/1*L-_mCg6ci5t0RwLMTiyP6g.png)

So you did find solutions for all your "open points," but you can't decide on one particular point. There are multiple solutions, but the team keeps arguing which one is the best. You have a few discussions, but nothing sticks. It's time to code.

If the risk is reasonable, you might consider starting with one of the solutions and having a close follow-up. If the risk is higher, you can consider starting with multiple solutions and evaluating them iteratively.

#### Heuristic #5: F_alling_ _down the rabbit hole_

_Things start getting too complicated and abstract_

![](https://cdn-images-1.medium.com/max/340/1*ImEKlTuYpj2ASN-0B9xAPQ.png)

Yes, we are here to solve complex problems, and yes, some solutions require some pretty deep thinking but try asking yourself, Does my project need that level of complexity?

Engineers love solving problems. That's why we often invent new ones (Imaginary Problems Are the Root of Bad Software). If you notice the design starts questioning areas that are hardly related to your goal, it's time for a PoC or prototype to keep your feet on the ground.

### Final words

Remember that these are heuristics; hence they do not provide 100% accurate decisions. Your role is to use them wisely as a kick-starter and evaluate your specific situation with your team.

You will never find the optimal ratio of design/build, but you can train yourself and your team to have a better feeling when it is time to switch.

Good luck with your next project :)

* * *