From a LAN party website to a Forge app: what 24 years of building taught me
Recently, I read a post from a developer who consolidated 15 years of writing from eight platforms onto his own website. This made me reflect not on where I wrote, but on what I built. I was surprised by the list. While the technology changed every few years, the core lessons remained consistent.
Here is a timeline with the main lesson from each stage:
2000: A website for our LAN parties
Lesson: Feedback speed is a design decision.
My first website told our friends when and where the next LAN party was and who was bringing what. To be honest, I did not choose those users. They were simply the people around me, and building for friends is convenience, not user research. What carried over was the feedback loop: if something was wrong, I heard about it at the next party. Every project since has been better when I deliberately built that kind of short loop, and worse when I did not.
2004: A webshop that was really an order form
Lesson: Small and simple bring a lot of value.
The company I worked for needed to save time on small supply orders, so we built a simple email-based online order form. There was no shopping cart or payment system. It was effective: we received orders and learned what customers actually needed before adding features. Today, this would be called an MVP, but at the time, it was simply practical.
It was also my last project as an employee. In the middle of 2004 I started my own company in parallel, and at the end of the year I left to run it full time. That company would carry me for the next 18 years.
2006: My first Jira installation
Lesson: Tools can change how teams talk to each other.
Setting up Jira for the first time was, at first, a technical task, but the impact was not at all. Work became instantly visible; discussions shifted from late, fully answered emails and long lists that needed to be merged manually to issues, and everyone accessed the same information. I recognized the true value of a tool lies in how it shapes work & conversations. Twenty years later, this remains central to my work.
2008: Digital signage for an international fast food chain
Lesson: Real-life conditions beat lab conditions every time.
In 2008, I built a digital signage player and a system to deliver content to screens over the internet. We tested it as an MVP in 11 restaurants for an international fast-food chain, as well as at additional locations. Restaurants are not demo environments: connections drop, devices restart, and staff does not have time to troubleshoot. Reliability proved more important than features. A screen that always displays content is better than one that occasionally shows something impressive.
2012: An exhibitor content management system for Deutsche Messe Interactive
Lesson: Immovable deadlines force clear priorities.
For Deutsche Messe Interactive, I built a content management system for exhibitors. Trade fairs like the Cebt open on a fixed date, so delays are not possible. This required making difficult decisions early and favoring essential features for opening day over optional ones. I learned that content management is more about workflow – who delivers what, when, and who approves it – than about technology.
End of 2012: The first Jira OnDemand with a non-technical team
Lesson: Adoption is the product.
At the end of 2012, I implemented Jira OnDemand, the cloud version of Jira at the time, for a non-technical team of over 100 people. Nobody cared about workflows or custom fields. They wanted to complete their work. Success depended on clear language, effective onboarding, and simplicity rather than advanced structures. This was also an early adoption of cloud solutions, before it became standard practice.
2012 to 2025: The part I usually skip
These thirteen years hold the most relevant experience, and they never fit into a neat “I built X” line. They were about running, scaling, and selling.
2015 to 2022: Scaling a European pet supplies retailer to 10,000+ users
Lesson: Operations is where architecture gets graded.
Between 2015 and 2020, my company scaled the Atlassian Data Center environment of a European pet supplies retailer from office users to all employees in stores across Europe: more than 10,000 unique users. The environment included two Jira instances, Crowd, Confluence, and Bitbucket, each with proper staging and test environments. From 2017, we also hosted these systems, a full webshop, several landing pages, and other applications. The retailer became our largest customer, and we were part of a project to build an employee assistant that used Jira as a backend for task management.
What went wrong: Pretty much everything you can imagine. Performance issues, updates that caused trouble, and once we deleted the wrong virtual server. Luckily, it was only the staging system.
What we learned: Monitor properly, with early warnings that fire before users notice anything. And renew the classic certificate that is due to expire.
2022: Selling my company
Lesson: Join forces, set priorities, and stop waiting for better times.
The exit: In 2022, I sold the company to what is now Eficode and stayed for one year as branch manager and ITSM lead. Transitioning from owner to manager in a larger organization changed how I work. After 18 years, I had done most things on my own. That year showed me that when you join forces with others, you can grow much stronger than you ever could alone. It also taught me to set priorities ruthlessly and to stop waiting for better times. There is never a perfect moment to start, change direction, or let go.
2025: My first Forge app used by customers
Lesson: AI changes how fast you write code. It does not change who is responsible for it.
In 2025, I built my first Forge app that customers actually use. It is a small tool: it shows the details of a linked work item right where you are, so you do not have to open it. That sounds trivial, but it saves the team using it about 15 minutes a day. Small app, simple idea: every click matters. Most of the code was written with AI assistance. That is the part people ask me about, so here is what it really looked like.
What changed with AI coding: The first working version was ready in 3 to 4 hours, with most of that time spent planning rather than generating code. Testing and writing user documentation took about the same amount of time. AI reduced the time spent coding, but planning, testing, and explaining the app to users remained unchanged.
What it got wrong: The app worked fine in the first tests in my development environment, but on the customer’s staging site it needed rework. More than once! The signage lesson from 2008 again: real conditions beat the lab, even when the code came from an AI.
Forge handled many tasks and reduced my workload, but the responsibility remained with me. App logic, requested scopes, data operations, and permissions are still developer responsibilities. With AI-generated code, this is even more important, as code you did not write yourself requires extra scrutiny.
What stayed the same in 24 years
- Start with your users. The shorter the feedback loop, the better your results.
- Start small, then expand. An order form can become a webshop, and an MVP can succeed in real environments.
- Technology is the easy part. Success relies on people, workflows, and adoption.
My technology stack has evolved from simple HTML pages to cloud platforms and serverless applications. However, the core approach remains: understand the problem, build something useful, and continue listening.
What was the first thing you built? I would appreciate hearing your story.