Why I Focused on Open Source Technologies

If you’re learning on a student budget, the wall isn’t “which stack is best.” It’s whether you can install anything on the machine you actually have. That’s where I was before I knew what a “stack” was - and I’m glad open tools were what I could actually run.

I learned ASP from someone, then went looking for real software built with it - sites I could study, tools I could run locally, something that wasn’t just tutorial code in a book.

I couldn’t find much. Not because ASP was useless. Because so much of that world was proprietary. The examples lived behind licenses, closed demos, or setups I couldn’t replicate on a student budget.

PHP kept showing up instead. Open tutorials. Actual CMS installs you could download. That pushed me toward XAMPP - Apache, MySQL, PHP in one folder.

What’s great about XAMPP, especially back then: they ship a portable version. On locked-down PCs that block installers - school labs, internet cafes, borrowed office machines - you unzip and run. No admin prompt. No IT ticket.

That wasn’t a XAMPP quirk. Open source stacks often ship a portable build, or at least a zip you can drop in a folder without touching the registry. The place it really landed for me was my office desktop. Corporate image. No installer rights. I could still run Apache, MySQL, and PHP from a directory I owned. I’d break a CMS install on my lunch break while the rest of the floor stayed on the standard Windows image. That mattered as much as “free.”

Once I had a local PHP stack, installing a CMS was the obvious next step. Drop files in htdocs, run the installer, break something, fix it, break it again. XAMPP plus a CMS gave me more exposure to open source than any manifesto could have. I wasn’t reading about freedom. I was clicking through it.

The first CMS I actually liked was XOOPS. WordPress and Joomla had louder crowds. XOOPS gave me something I cared about more: control of the theme. Templates made sense in my hands. I could bend the layout without feeling like I was hacking around someone else’s guardrails.

That wasn’t just weekend tinkering. Knowing XOOPS well enough to ship real sites helped me land a job - the kind that moved me from teacher toward web developer for real. Open source didn’t only let me practice without a license. It gave the market something concrete to hire.

Every new stack after that had the same permission feeling. Download a zip. No serial number. No “request a trial key.” No corporate card. Just files.

When I got serious about web work, “open source” wasn’t a brand I wore on a conference lanyard. It was the shelf I could afford.

Free Got Me in the Door. Freedom Kept Me.

Proprietary CMS licenses, boxed design software, monthly platform fees - fine if someone else is paying. When you’re learning, freelancing, or teaching students who are scraping together a borrowed laptop, no license fee is the difference between trying the thing this week or putting it off for a year.

That part is easy to misunderstand from the outside. People hear “open source” and think “free stuff.” Sometimes it is. More often the real win is permission.

Install without asking. Break things on your own machine where nobody’s paying customers will see. Read the source when the docs lie. Hand a client something they actually own instead of a login to your proprietary dashboard.

Freedom still costs time. WordPress took me months before I trusted myself on a live site. Hugo took another stretch before the build pipeline felt natural. Open source lets you learn on your own schedule. It doesn’t skip the learning.

Small and medium businesses hit the same wall from the other side. They couldn’t afford proprietary stacks - the license ate the margin. Open source gave them room to customize instead, but the software still had to match how the shop actually ran. Inventory, bookings, a theme that didn’t look like a template from 2014. Someone paid in expertise - a freelancer to wire it up, or the owner’s weekends learning plugins. Freedom to adapt, not a finished product out of the box.

I still use that split in my head: free is what gets you past the gate. Freedom is what you’re buying with the evenings.

Teaching Stacks Students Could Actually Install

I taught seminars on open-source technology and web careers in the Philippines. Not because I wanted everyone to wave a FOSS flag. Because the job market already ran on WordPress, Linux hosting, and PHP stacks you could start without a corporate card.

The classroom test was blunt. If a student couldn’t install the tool on the laptop they brought from home - borrowed, old, maybe shared with a sibling - we were wasting the afternoon. Teaching Dreamweaver or some closed CMS with a trial that expires in fourteen days felt pointless. By the time their trial ran out, they’d only just figured out where the publish button lived.

Open stacks passed the test. XAMPP portable on a machine that won’t let you run installers. Download tonight. Break it tomorrow. Show up next week with questions that came from real friction, not from a slide deck.

The career advice was equally practical. Learn tools employers actually hire for. In web work around here, a huge slice of that table is open source whether or not you care about the label. WordPress listings were everywhere. “Drupal developer” was a niche inside a niche. I wasn’t going to send students hunting for jobs that didn’t exist in our market just because the architecture diagram looked cleaner.

That bias stuck. Not as ideology. As default.

Friedman Is Why I Focused on It

I’d already stumbled into PHP and XAMPP by accident - student budget, locked-down PCs, no license fees. The World Is Flat is what made me focus on open source on purpose.

Thomas Friedman’s book landed in the mid-2000s, right when I was teaching seminars and burning Linux CDs. I wasn’t looking for a manifesto. I was looking for a frame.

Friedman listed ten flatteners: forces he argued were leveling the global playing field. The Cold War ending. Netscape putting a browser on every desk. Workflow software forcing different apps to talk to each other. Then, fourth on the list: open-sourcing - communities shipping code anyone could download, read, fork, and improve.

That was the sentence that stuck. Not “free software is morally pure.” This is where the world is going. If open source was flattening the field - letting talent compete from anywhere because the tools weren’t locked behind a product key - then learning proprietary stacks was learning yesterday’s gate.

Look at what came after on Friedman’s list. Outsourcing. Offshoring. Walmart-scale supply chains. Companies “insourcing” logistics they used to buy from vendors. Informing - basically Google making the world’s reference shelf searchable. Wireless and VoIP as steroids on all of the above. Impressive if you ran a multinational. Abstract if you were trying to land your first freelance gig from a province outside Manila.

Open source was the outlier. The flatteners before it mostly built the pipes - politics, browsers, standards. The flatteners after it mostly described how big companies moved work around the planet. Number four was the one a student could ride this semester. That’s the flattener I decided to bet my career on.

And the timing backed the bet. Mid-2000s open source wasn’t a hobbyist museum anymore. Apache ran half the web. Firefox was finally giving Internet Explorer a fight. Ubuntu made Linux installs feel almost normal. WordPress was turning “I need a site” into a Saturday project instead of a capital expense. MySQL and PHP came preinstalled on cheap shared hosting. Friedman gave me the theory. The stack gave me proof.

The book got roasted for sounding like an airport-business-magazine TED talk. Bangalore call centers. Flat-world PowerPoints. Fair. I didn’t take every line at face value.

But flattener number four gave me language for what I’d felt in the classroom. A student in UPLB wasn’t learning on different software than a student in UCLA. Same WordPress zip. Same Apache license. Same Stack Overflow thread at three in the morning Manila time. Permission scaled globally. You didn’t need to be in Silicon Valley to ship a CMS theme. You needed a decent internet connection, a zip file, and the willingness to break an install twice before it worked.

After Friedman, “open source” stopped being the path I fell into because I was broke. It became the path I chose because it was a flattener - the one force on that list an ordinary developer could actually use without a boardroom.

I Was the Linux Evangelist at an IT Training Company

Seminars were one thing. My day job at an IT training company was another - and there I had a title I wore proudly and probably too loudly: the Linux guy.

They let me run Linux on my work desktop. Not a VM tucked in the corner for demos. My actual machine. That freedom was rare then. Most shops wanted one standard image on every desk, and that image was Windows.

I burned a lot of CDs of Linux installers. Handed them out in class. Talked students through booting from optical drive like it was a normal Tuesday. MEPIS, Ubuntu, Red Hat back before the Fedora split - I’d cycle through whatever I was testing that month. I spent embarrassing hours on DistroWatch comparing releases like other people compared phone specs. The distro mattered less than the idea that you could own your operating system without a product key.

My evangelism was way ahead of its time. Back then “just use Linux” sounded like a hobby, not career advice. Drivers fought you. Photoshop didn’t run. Client software expected Windows. You weren’t wrong to pick the path of least resistance.

Now Linux is a viable option in a way I couldn’t always defend out loud. My home desktop runs Linux Mint today. Servers already did. Dev containers and WSL blurred the old either-or fight. I don’t bring it up to say I called it. I bring it up because the bet was the same one I made with PHP and XAMPP: learn on tools you can inspect, even when the room isn’t ready yet.

I Went Hunting for the Best Open-Source CMS

At some point I stopped picking a CMS on guesswork and actually compared the open options side by side. Joomla, WordPress, Drupal, a few smaller names I don’t remember now - after XOOPS had already shown me what theme control could feel like. Same small site, three different installs, see which one I’d want to live in for years.

I wrote the longer version in Why I Switched from Drupal to WordPress. The short version: Drupal’s architecture made sense to me - content types, fields, views, structure before theme code. WordPress felt like the popular kid getting by on charm.

Then reality showed up. Drupal’s community was thin. Upgrades ate weekends. I couldn’t find paid work with it in my market. WordPress had the plugin shelf, the job listings, and eventually WordCamp Asia in Manila with fourteen hundred people in the same room.

Both are open source. The lesson wasn’t “Drupal good, WordPress bad.” It was open source gives you choice, and choice only helps if you pick for your actual life - market, clients, tolerance for upgrade pain - not for the cleanest architecture diagram.

I still respect Drupal. I don’t run my income on it.

When Paid Hosting Wasn’t Viable, Open Files Saved the Work

The stack shift that really locked this in wasn’t a CMS debate. It was losing my old PHP hosting and a chunk of my work with it.

For years I’d shared a modest hosting bill with a client. When that client moved on, suddenly I was paying the whole thing for what was effectively my personal blog. Shared hosting. A database I didn’t control. Content trapped in formats that only exported cleanly if you paid extra or prayed the backup plugin still worked.

I’d lived through the old workflow too - cPanel, FTP, editing PHP on the box real visitors were hitting. header.php with a typo could take down a contact form while the client was in a meeting. “I’ll sync my laptop later” is how two copies of the same theme stop agreeing on which file is real. Open source didn’t fix that habit by itself. It just meant the files on my machine were the same files the world ran on, not a mystery locked on someone else’s server.

Moving to Hugo + GitHub + Cloudflare Pages wasn’t “I love Go.” It was: my posts are markdown files in a repo. The theme is open source. The build tool is one binary. Push, and ninety seconds later it’s live. If Cloudflare changes terms tomorrow, the content still lives in Git. I can point the repo somewhere else.

I learned the boring parts the embarrassing way - Hugo version mismatches, a theme folder spelled HugoPlate when Linux wanted hugoplate, Node version drift on the build server. Annoying. Fixable in ten minutes because the whole stack is files I can read, not a black box dashboard.

That’s the open-source win I care about day to day - not stickers on a laptop. Freedom to move. Boring formats. Tools I can open when something breaks at ten at night. I paid for that freedom in evenings, not subscriptions.

Git Is the Part Nobody Puts on the Homepage

People argue about which CMS or static generator is “most open.” Fair. The tool that actually changed my daily risk tolerance was Git.

First time it saved me, I was halfway through a client WordPress theme tweak and realized I’d fallen back into the old habit: editing like it was still 2009. git checkout -- . and I was back to the last commit. No phone call to the host. No digging through cPanel backups that might be from Tuesday.

Every clone is a full copy of the project - history, branches, the whole attic. You commit on a plane. You branch while the coffee shop Wi-Fi is lying to you. You push when you’re ready. That sounds like a nerd detail until you’ve watched two people edit the same PHP file on the server and staging at once.

Philippines dev communities run on this whether we say “open source” out loud or not. WordPress meetups, student GitHub accounts, client repos on free tiers, agencies passing child themes around - all of it sits on Git. The license says you may use the code. Git is how you actually touch it without breaking everyone else.

Open formats plus version control is how “I own my work” stops being a slogan. Git didn’t invent backups or branching. It packaged them for a distributed world - and gave the rest of us a rewind button that actually works.

What Open Source Actually Buys Me

After years of building and teaching on this stuff, the benefits aren’t abstract. Last month a Hugo partial threw a blank page on one note route. I opened the theme file, found a nil check someone forgot, fixed it in ten minutes. No ticket queue. No waiting to learn whether the bug was mine or theirs.

When a WordPress plugin throws a fatal error on a client site, the code is right there too. Sometimes the fix is commenting out one bad line until you find a maintained fork. Sometimes it’s admitting the plugin was abandonware and swapping it. Either way I’m not stuck guessing from a support form.

Leaving matters as much as fixing. Markdown in Git outlives any one host. That’s the whole sustainable publishing argument in one sentence. Open tools tend to use open formats. Closed tools tend to trap exports until you need them.

Community depth is part of the product, not a nice extra. WordPress plugins, Hugo themes, Stack Overflow threads from last month - open projects accumulate fixes in public. Thin communities cost you hours. Thick ones save weeks. I chose WordPress partly because the bench was deeper, not because the logo was prettier.

Free tiers stack in a way that matters when you’re building on the side. Hugo is free. Hugoplate is MIT licensed. Cloudflare Pages has a generous free tier for static sites. My personal publishing stack doesn’t need a monthly hosting bill to stay online. Domains still cost money. I’m not pretending otherwise. But the software layer doesn’t nickel-and-dime me for existing.

Clients can own it. When I hand off a static site, they’re not renting my proprietary theme on my proprietary platform. They get a repo. That’s a cleaner conversation than “call me when the license renews.” For WordPress builds, about eighty percent of what I ship repeats the same patterns anyway - blocks, cards, forms - so the reusable layer is worth documenting before I pass it off, not hoarding.

What It Doesn’t Mean

I don’t treat open source as a purity test.

There’s a gallery-slider plugin still sitting in one client install that hasn’t seen a commit since 2019, and “view source” has never once helped me with it. Open doesn’t mean maintained, and it definitely doesn’t mean good. In freelance markets you still see tempted shortcuts - nulled premium plugins, cracked themes, “free” installs that phone home. I’ve had clients ask. I say no. The license fee you skip becomes a security bill you didn’t budget for.

I evaluate open tools the same way as anything else: does it solve the job, is somebody still fixing it, will the client still own it after I pass it off?

No license fee also isn’t no cost. I paid in evenings - tutorials, broken staging sites, plugin configs that almost worked. I took that trade because the skills stuck and because I wasn’t renting permission to touch my own stack. Domains still cost money. Bitwarden’s paid family plan is one I hand over money for happily - open core, hosted convenience that earned the invoice. Same with anything where self-hosting would eat a weekend I’d rather spend with my kid.

I also don’t build from scratch to prove anything. I’d rather start from Hugoplate than hand-roll a theme for ego, since the whole point is standing on work other people already tested. And using this stuff doesn’t put me in debt to it - I’m not obligated to ship patches or talk at meetups. Gratitude is fine. Guilt isn’t part of the license.

The filter is practical: can I inspect it, move it, and find help when I’m stuck? If yes, it gets a serious look.

How That Shows Up in My Stack Now

jorap.com runs on Hugo, an open-source theme forked in-repo, markdown in Git, deployed through Cloudflare Pages. JoRap Notes lives on the same build - flashcards, graph, export - not a separate wiki host I can’t migrate. Private captures stay in the garage until they’re ready for the garden. Same repo shape. Same freedom to move.

My Linux Mint desktop is open source end to end. The MacBook runs the same Hugo folder. The Windows laptop still shows up for client WordPress work when a plugin only behaves on that stack. Different machines, same files in Git. That’s the workflow open tooling makes possible without me becoming a sysadmin.

Client work still goes WordPress when the job needs logins, carts, or five non-technical editors - also open source, also chosen for fit, not fanboyism. I use Cursor with a short rules doc so AI output on those builds stops drifting file to file. The editor is commercial. The stack underneath is still inspectable PHP and theme files the client can keep.

That last part isn’t accidental. AI coding tools lean hard on open source because that’s what they learned from. Public repos on GitHub. Stack Overflow answers. Theme files and plugins with real patterns to copy. A model can’t study what was never published. When I ask for a WordPress helper or a Hugo partial fix, the answer it reaches for is usually an open-source-shaped solution - the same libraries and file layouts already sitting in millions of repos. Closed black boxes don’t train the bench.

I’m not saying AI only recommends good software. It recommends familiar software - and familiar, in 2026, means open source a depressing amount of the time. That’s another reason I keep my own stack inspectable. The assistant and I are reading from the same shelf.

Password managers, RSS readers, static generators - I lean open when the category has mature options, because auditability and export matter for tools that hold my data. Inoreader for feeds. Bitwarden for secrets. Hugo for publishing. Not because closed tools are evil. Because data about my life deserves the same “can I leave?” test as my blog posts.

Teaching hasn’t changed either. I still point students at stacks they can install tonight without a trial expiring. The career advice is the same: learn what employers hire for, build something real on your own machine, and don’t let a license server decide whether you’re allowed to practice.

What I’d Tell Someone Starting Out

I wouldn’t start with a manifesto. I’d start with the problem in front of me.

Need a site you can afford to keep running? Look at static generators and markdown in Git. Hugo isn’t the only option. It’s the one I know cold. The pattern matters more than the logo: boring files, version control, a host that rebuilds when you push.

Need client work next quarter? Go where the job posts are. In my market that meant WordPress for a long time. Learn the plugin shelf. Learn when to say no to a plugin. Learn how to hand off something the client owns.

Need to trust a tool with secrets? Want open source plus a real security track record, not marketing copy. Audits, bug bounty history, a export path that works on purpose - not buried in settings.

I pick for freedom, ownership, and community depth, not just “is it free.” I skip tools that only let me work inside their garden, unless the garden is genuinely worth the rent. And I budget time to learn, because there’s no shortcut past that part.

This week: install one open stack on the machine you actually have and break something on purpose. Follow the job posts where you live, not the cleanest architecture diagram. Budget the evenings. That’s still the trade I’d make again - thankful the open path was there when I needed it.