As we draw actively on the whiteboard in our office, it becomes clear. We have to throw everything out and start over. That’s the only way that we will achieve that next step and make this part of our software even simpler.
So we wipe out everything that we drew and were unsatisfied with and let go of how our product works now. With the knowledge of today, knowing the exact problems and power of our current approach, we start our new design.
We draw, discuss, argue, laugh at the stupid things we come up with and marvel at the good things we come up with. Every time any team member pitches an idea, we challenge ourselves whether it is the absolute minimum that we can do with.
Finally we are satisfied. This is the simplest design we can make for this part of the application, with the knowledge we have today. Quickly we take some pictures of the whiteboard before we wipe everything out and head home. We will work on putting it all to ‘paper’ tomorrow…
To give you an idea of how we simplified Triggre, let’s look at an example. We already implemented this specific simplification last year. It provides some insight in how to think about reducing complexity.
Triggre has three main parts for a user to design; a data model, processes and pages. Let’s have a quick look at how our design process has influenced how we treat the data model. Below is an example of a product which can be part of an order line, which in turn is in an order.
One of the things that we decided to do in this case, is remove the concept of keys. With the risk of becoming too technical, it means that Triggre has to manage the primary and foreign keys of the relations internally. Without the user specifying them.
The same is applied to the internal, technical representation of the fields. In Triggre we simply use numbers, text and so on. But at some level, the technical aspect has to be addressed. We just think that this should never be the user.
And this is true for all the things that we leave out. They will have to be handled by very good software.
Everything is a prototype
This provides you with a glance at how we approach product development at Triggre. We take simplicity extremely serious. There is no ultimate solution, only the next one that out-simplifies the current one. And to reach it, we sometimes have to drastically change the application.
In that sense, we view every version of our application as a prototype. Not because it isn’t complete, or because it is unstable, those things are all covered. No, we view each version as a prototype because if we have to, if it really comes down to it, we are ready to throw it all out the window. That is how much we care about making things as simple as they can be.