Twenty-six years ago, in the desert town of Swakopmund in Namibia, I jumped out of a plane without a parachute.
This is not a metaphor. It was a tandem skydive.
I was strapped to the front of a huge South African rugby player who, reassuringly, seemed very comfortable with the idea of throwing both of us out of a rattling Cessna that looked like it had been assembled from spare parts and optimism.
At the time I thought it might be the most reckless decision I would ever make.
It turns out that helping to start an open source project can feel remarkably similar.
The plane had no seats. Everyone sat on the floor. It rattled and shook as it climbed. At some point the place where a door should have been simply… wasn’t. Instead there was an opening and a lot of sky.
When it was time, we shuffled to the edge. I stepped outside, stood on the wheel, grabbed the wing, and looked down.
In a tandem skydive you are, technically speaking, jumping out of a plane without a parachute on your back. The straps that would normally connect you to a parachute are instead connected to your partner — in my case, the giant rugby player — and he’s the one who actually has the parachute.
It’s a strange kind of trust exercise: your life is literally in someone else’s hands, and you hope they know what they’re doing.
The Plane
Before the jump you spend a lot of time thinking about the plane. Is it safe? Is it supposed to make that noise? Should that panel be vibrating like that?
But the truth is that the plane isn’t the point. The plane just gets you to the place where the real experience begins.
Open source projects are the same. People often obsess over the structure, the governance, the processes, and the infrastructure. Those things matter, of course, but they’re just the aircraft. They get you to altitude.
The real experience begins when you step out of the door.
The Moment of Commitment
Standing on the wheel of that plane, there is a very clear moment where you realise something important: there is no halfway option.
You can’t partially jump out of a plane.
Well, you can try. I did.
The plan was simple. When the giant rugby player tapped my shoulder, I was supposed to let go with both hands and fall backwards into the sky. But that’s not quite what happened.
When he tapped my shoulder the first time, I let go with my left hand. Unfortunately, at exactly the same moment I gripped even tighter with my right. The giant tapped my shoulder again. This time I let go with my right hand and clung on harder with my left.
It probably only lasted a few seconds, but standing on the wheel of a plane thousands of feet in the air, those seconds felt like forever. Eventually I found the courage to let go with both hands and fall backwards down to earth.
Starting and sustaining an open source project feels much the same. At some point, you move from talking about ideas to actually doing something. Once you do that, you’re in freefall. The project is live, people are using it, people are contributing to it, and there is no neat way to climb back into the plane.
Trust
In a tandem skydive you put an enormous amount of trust in someone you met about ten minutes earlier. You trust that they packed the parachute correctly. You trust that they know when to pull the cord. You trust that they have done this before and will do it again successfully.
And remember, you don’t even have your own parachute. The straps that would normally attach you to one are connected to them instead. If they get it wrong, you both discover that at exactly the same moment.
Open source runs on exactly the same kind of trust.
You trust that contributors are acting in good faith. You trust that maintainers review code carefully. You trust that someone else will spot the mistake you missed. You trust that when things go wrong, the community will respond and fix them.
Without that trust, nothing works.
The Freefall
The moment you leave the plane is chaos. Wind. Noise. Sensory overload. Your brain tries to process what is happening while gravity enthusiastically takes over.
In our case, the chaos didn’t stop after we left the plane.
The idea in a tandem skydive is that once you jump, both of you lean forward and settle into a stable position with your bodies parallel to the ground while you freefall until it’s time to pull the parachute.
Unfortunately, physics had other ideas.
Because of the height and weight difference between me and the rugby player strapped behind me, we didn’t settle into that nice textbook position. Instead we started tumbling through the air like a pair of socks in a washing machine.
Eventually we managed to stabilise ourselves into the proper freefall position — but by that point we were already well past the height where the parachute was supposed to open.
After just a few seconds of steady freefall he pulled the chute much later than planned. Thankfully it opened, we regained control, and we landed safely.
Open source projects have their own version of that tumbling freefall. In the early days everything feels chaotic. Decisions are fast, resources are limited, and the future is uncertain. You’re not gliding smoothly — you’re spinning and hoping someone remembers when to pull the cord. And much like trusting the rugby player with the parachute, you’re trusting your community to guide the project safely to the ground.
The Parachute
Eventually, in a skydive, the parachute opens and the violent rush of air turns into a quiet glide.
You’re still in the air, but now you have time to look around and appreciate where you are.
In open source, that moment comes when a project reaches maturity. It’s no longer just an experiment. It’s a platform people rely on, a community people belong to, and a piece of infrastructure that quietly supports thousands or millions of websites.
After twenty years with Joomla, that’s the stage we’re in now. The project isn’t falling anymore. It’s gliding.
Landing
Every skydive ends the same way: with a landing and a slightly shaky walk across a field while your brain catches up with what just happened.
Looking back, the jump itself only lasted a few minutes. But the memory has lasted 26 years.
Working on Joomla has been a much longer fall — twenty years and counting — but the feeling is surprisingly similar. You start with a risky decision, trust the people around you, survive a fair amount of chaos, and eventually realise that you’ve been part of something rather extraordinary.
Was it a mad rush of adrenaline? Absolutely.
Was it okay to trust the giant rugby player strapped to my back? Thankfully, yes.
Would I do it again?
No.
You can be lucky once. I’m not brave enough to test my luck a second time.
Fortunately, working on Joomla doesn’t require jumping out of another plane.
And if you think I’ve embellished a little over the past 26 years, fear not — there’s video on YouTube. Like Joomla itself, it’s sometimes chaotic, occasionally terrifying, but always a memorable experience.
