There's a certain kind of stubbornness that comes with being self-taught. You built everything yourself, from the ground up and there's a quiet pride in that. Every feature on your website, you coded it. Every database query, you wrote it. Every layout, you designed it by hand. It's CMS era!
And then someone shows you a Content Management System, and in about forty-five minutes you've got a fully functioning website with navigation, user registration, a blog, and a contact form — and you sit there feeling equal parts amazed and slightly insulted.
That was me, discovering CMS platforms for the first time.
What Even Is a CMS?
Before I get into the story, let me explain what a CMS actually is — because not everyone reading this comes from a technical background, and that's perfectly fine.
A Content Management System is essentially a pre-built web application framework. Someone else has already written the core code — the user authentication, the database structure, the admin panel, the templating engine — and you get to build on top of it rather than starting from scratch every single time.
Think of it like this. Building a website from raw PHP and MySQL is like constructing a house by first going to the forest to chop down your own timber. A CMS is like arriving at a construction site where the foundation is already poured, the walls are framed, and you just need to fit out the interior.
You're still building. You're still making meaningful decisions. But you're not spending half your time on problems that have already been solved a thousand times before.
Joomla: My First CMS Love
My first serious encounter with a CMS was Joomla.
Joomla was — and still is, honestly — a powerful, flexible platform. When I first got into it, somewhere in the mid-2000s, it was one of the most widely used CMS platforms on the internet. It had an active community, a large extension marketplace, and a level of customisation that kept someone like me genuinely engaged.
The learning curve was steep. Joomla had its own way of thinking about content — articles, categories, menus, modules, components — and until you understood how those pieces connected, the whole thing felt like a puzzle with no picture on the box. But I've never been the type to give up on a puzzle.
I went deep. I learned the templating system. I learned how to install, configure, and customise extensions. I learned how to override the default output with custom code, which meant understanding how Joomla structured its own PHP files underneath. I built complete websites for people — proper, functional, professional-looking sites — and they had no idea how much was happening behind the scenes.
Joomla taught me something important: understanding a complex system from the inside out is a skill in itself. It's not just about knowing how to use a tool. It's about understanding why the tool was designed the way it was, what problems it was solving, and where its limits are. That kind of understanding is what separates someone who can follow a tutorial from someone who can actually troubleshoot when things go sideways.
And things always go sideways eventually.
Then WordPress Walked In
At some point, I made the move to WordPress.
I'll be honest — my first impression of WordPress was that it was simpler than Joomla. Less flexible, more opinionated, built primarily for blogs. And for a while I kept that slightly snobbish attitude, the way someone who learned to drive on a manual car looks at people who only drive automatics.
Then I actually learned WordPress properly. Not just "install it and pick a theme" learned it, but actually learned it — the template hierarchy, the hook and filter system, custom post types, the Loop, theme development from scratch, plugin architecture, the REST API.
And I had to retire the snobbery pretty quickly.
WordPress is deceptively deep. The surface is simple by design — that's intentional, and it's a feature, not a flaw. But underneath that simple surface is an incredibly well-thought-out system that can be extended and customised into almost anything. At its peak, WordPress was powering somewhere around 40% of all websites on the internet. That's not an accident. That's a product that genuinely understood what its users needed.
I eventually learned WordPress from A to Z. Installation, configuration, theme development, plugin development, performance optimisation, security hardening, multisite setup, migration, the works. If something could be done in WordPress, I wanted to know how it was done.
Freelance Work Starts to Take Shape
It was around this CMS era that I started doing more structured freelance work.
Before, I had built things for fun, for practice, for the satisfaction of making something work. Now people were actually coming to me with real requirements and real budgets — small budgets, admittedly, because this was the Malaysian freelance web market in the mid-2000s, but real money nonetheless.
I built company profile websites. I built simple e-commerce setups. I built school and community organisation sites. Clients would tell me what they needed, I'd figure out how to build it, and then I'd figure out how to explain to them how to update it themselves afterward — which, in the CMS era, was actually possible for the first time.
That last part was quietly revolutionary. Before CMS platforms, handing a website over to a non-technical client was basically handing them a problem. They'd call you every time they needed to change a word on the homepage. With Joomla or WordPress, you could train them to manage their own content in an afternoon, and then get out of the way.
That's good engineering. Building something and then making yourself unnecessary. Not everyone understands that instinct, but I've always believed the best systems are the ones that empower the people using them, not the ones that create dependency on the person who built them.
The Thing CMS Platforms Actually Taught Me
Here's what I think is the underappreciated lesson from this entire era.
A lot of developers dismiss CMS platforms as "not real coding." I've heard it many times. The attitude that if you're using WordPress or Joomla, you're not a real developer — you're just clicking buttons and installing plugins.
That attitude misses the point entirely.
Working deeply with mature, large-scale codebases — which is what Joomla and WordPress are — teaches you things that building small personal projects never will. You see how serious engineers structure code for scale. You see how they handle backwards compatibility. You see how they design APIs for other developers to extend. You see how they think about security, performance, and long-term maintainability.
Every hour I spent reading WordPress's source code, tracing how a hook propagated through the system, understanding why a particular function was written the way it was — that was free education from some of the best engineers in the open-source world.
You just had to be curious enough to look.
Closing: Part 4
By the time I had properly mastered both Joomla and WordPress, I had a genuinely well-rounded skill set. I could build from scratch when needed, and I could build on top of established platforms when that made more sense. I understood databases, server-side scripting, front-end design, and the full lifecycle of a web project from brief to launch.
But all of this had been happening in parallel with something else entirely — a completely separate path that was quietly running alongside the coding journey the whole time.
Because while I was teaching myself to build things on the internet, life was also steering me toward a door I hadn't expected. A door that said Government Service.
And once I walked through it, everything I had built quietly on my own would suddenly have a very different kind of stage.
Wahyudin Aziz | Career Journey Series
#TechJourney #WebDevelopment #CMS #WordPress #Joomla #Malaysia #PersonalBranding
