I’ve build a lot of websites throughout the years. At some point, I had to build my first though. Of course, I got nowhere close to what I’m capable of building nowadays. The only way to get there is by trying out new possibilities with experiments, testing every new feature to see how we can utilize them. The same thing goes for app development. I have a lot less experience building applications than building websites, so I spend a lot of free time on experimenting with apps.

Why experiments?

Trying something out for the first time always has some risks. You might not get it right on the first attempt, so you’d rather work in a test environment. Besides that, you will need to stress test whatever you build, so creating a proper experiment with the intent to basically ‘waterproof’ the product will help avoiding mistakes in a live environment.

Experiments allow you to make mistakes. Better yet, you need to make mistakes to learn from them. You don’t only want to find out what works, you need to find out what doesn’t work. When knowing the limits, you can build in ‘protection’ to make sure you can not go over the limits.

Doing experiments before applying anything to a live environment helps build the system in a way that limits the mistakes you can make. The simplest example is something that must have been found out with experiments in the past: A lot of online forms have obligated fields. When you don’t fill them in, you get a little notification saying you need to fill in the obligated fields. When this feature was implemented, the creative that came up with this probably tested some functionalities that required certain end-user information. If that information is missing, you can’t process the communication properly, but the end-user might never know without the indication that certain fields are obligated.

This is why in most experiments, you should let go of the idea of “this is how it’s supposed to be used” and purely focus on “this is how it can be used”. Any way a product can be used, should be covered. If you are able to create a post without a featured image, there should be a fallback anywhere you are using the featured image. If you are able to use 3 lines in a heading, the design should be able to display it nicely. I could go on and on with examples of why you should experiment, but I think this pretty much covers is.

Experiments Example 1: My own custom CRM

A great example of one of my biggest experiments so far, is my custom CRM. There are plenty of CRMs out there, but I usually miss 1 or more features I would like to have, or they are just pretty pricey. This is why I decided, I will build my own CRM. It will be a webapp, initially available to just me, where I can manage my customers, projects, products and finances.

At this moment, I can do most of that with a lot of ease. It only takes me about 5 clicks to generate a PDF invoice based on my projects and send it by e-mail to the customer. This saves me a bunch of time that I can spend on improving my services. Even though this is an experiment, I still decided to put it to the live test. So far, so good, I got compliments from my previous employer and he immediately starting thinking about where they can save time on their invoice process.

This is not where this experiment stops though. I want to expand this to create a portal for my customers, giving insight to their previous orders, active licenses and giving them access to a support channel that will give me instant notifications and the option to reply on my phone.

By building this as an experiment, but also putting it to the test with my customers, I will find the limits and challenges. This will allow me to create a CRM for you, as I now know a lot of these challenges I will run into or have already run into.

Experiments Example 2: Gitlab time tracker

Another example is my Gitlab Time tracker. I needed an easy way to log my time spend on Gitlab issues and decided I wanted to build a Chrome extension for it. This presented me with a massive challenge: I’ve never build a Chrome extension before. So where did I go to learn how to do this? You might have guessed it: Chat GPT! This is the first time I used Chat GPT for the entire core of a tool, as I had no clue yet on how to build this. With the core in place, I could expand the features using the React knowledge I already had.

Now when it comes to relying on Chat GPT, I only apply code to customers products when I fully understand the code. For my own projects, I dare to take a risk when I need to save some time, but I will get back to this project to fully dive into all the code created by Chat GPT. The reason why I only apply code I fully understand, is because I need to be able to repair products when updates or dependencies broke them. Without a proper understanding of the code, the debug process could take much longer than needed.

Want to share an experiment?

You heard it right: we can share experiments! If you want to be the most innovative party in your branch, it’s sometimes worth investing in experiments. If you have a great idea you need a developer for and I have never done it before, I will be straightforward with you and tell you this. But that creates an opportunity: We both can cover a part of the costs to run an experiment. This allows me to learn how to build it perfect, while you get a brand new, innovative product that sets you apart from your competitors.