Accounting → Software Development?

"So you quit accounting to do programming?"

Nah. I didn't quit. I leveled up.

The Real Origin Story: I Refused to Use WordPress

Here's what really started all of this: I've wanted a blog since I was 15. I was reading personal finance and tax blogs obsessively. Loved the format, loved the community, wanted my own space on the internet.

But I really, really didn't want to use WordPress.

I can trace so much of my motivation for becoming a web developer to that single fact: I wanted a blog, but WordPress felt wrong. Too bloated, too constrained, too much fighting the admin panel to do what I wanted.

Plus, WordPress was expensive. Every single blog I followed had a "how to start a blog" article that basically said: buy managed WordPress hosting from these providers for $10-15/month. And I definitely wasn't considering Shopify at $25/month.

(And those were the introductory rates. WordPress hosting costs have a magical tendency to balloon over time.)

I'm cheap. I wanted to do it for free. So instead of paying for managed WordPress, I decided to learn to make a blog myself. Which somehow made sense at the time.

The math? Spend thousands of hours learning to make a blog myself to avoid $15/month. This felt entirely justified, even when it was definitely difficult in those early days. The return on investment makes no sense, but here we are.

I Actually Tried WordPress (And Hated It)

Full disclosure: I did buy WordPress hosting for a year or two. Gave it a real shot. Tried to make a blog the "normal" way.

Mostly hated it.

Here's what I realized: I didn't enjoy "posting just to post." What I actually wanted was the ability to publish random stuff myself out into the world - and own my data and opinions. Not be locked into a platform.

Paying $15/month to "post content" made no sense when what I really wanted was to just... have things available on the internet. On my terms. In my control.

I was arriving at the principles of web development without knowing how to code at all. I understood why owning your own platform mattered before I understood how to build one.

It was only after I actually learned to code that I could realize any of this. And very badly at first.

So instead of settling for WordPress, I spent years learning to code so I could make my own publishing platform. Which is either admirably stubborn or completely insane. Probably both.

That stubborn refusal to use inadequate tools? That became my whole programming journey.

The Setup: What I Actually Studied

My accounting curriculum wasn't just debits and credits. It was:

• Data analysis and visualization
• Statistical analysis and auditing techniques on large financial datasets
• Database design and normalization
• ERP systems and data and corporate controls
• Financial data technology and IT

That's not accounting. That's backend development with a CPA license.

The Awakening: Excel is a Terrible Database

By the time I graduated in accounting I was an Excel Grand Wizard. Pivot tables, XLOOKUP, array formulas, Power Query, Macros? I was learning features that would make even senior accountants weep. I could make Excel do things it was never meant to do.

We were doing proto-programming in school without calling it that: using CONCAT for string manipulation (the first thing you learn in actual programming!), data validation for dropdown menus, navigation elements across sheets. We were building programs in Excel.

I'd seen VBA too - recorded macros, read the generated code, even loaded someone else's macros at work to create templates. I understood VBA could do things, but never actually wrote it myself.

But eventually I hit a wall where I was building complex systems in a tool designed for simple calculations. I used one too many utility cells or helper columns before realizing maybe Excel isn't actually good at everything. Combining functions and utility cells into God's unholiest formulae broke the camel's back. There had to be a better way.

How I Learned to Code? Tool Upgrades

Once you realize you're fighting your tools, the path forward is obvious: get better tools.

Level 1: AutoHotkey

After graduating with my master's degree in accounting, I was supposed to be studying for the CPA exam. The CPA exam is particularly grueling - hundreds of hours of study across multiple sections. My only brief respite from the grind was how satisfying it was to play with the computer and work on automation. What started as a distraction became an obsession.

I became obsessed with launching applications faster. Windows Key + typing the app name for instant launching. Then I thought: what if I could do the same thing with my bookmarks? And what about text expansion to automate how I typed things on the computer? It felt like typing things in fast and precisely in search boxes was the best way to "get what I wanted/needed" from the computer rather than clicking around. (Little did I know, that's exactly what commands are.)

This exploration led me straight to AutoHotkey. And that's where everything started.

I started with a simple goal: open frequent websites with a hotkey instead of typing URLs. One hotkey, one website. Easy enough.

Then I realized: if I can open one website... I can open five. Or ten. Or a HUNDRED websites with a single hotkey press.

That's when it clicked. That's what it means to execute a program. You write instructions once, and the computer does them instantly, at scale, perfectly, every time.

Then I discovered AutoHotkey could create right-click context menus. These are just little UI elements that pop up and do things kind of like how you might right-click to copy and paste. And I realized: making UI isn't as hard as I thought. You don't need to understand how to render pixels on the screen all the way down to binary instructions on bare metal. You just... write some code that says "make a right-click menu." That's it.

First taste of application programming logic. Mind = blown.

Level 2: HTML & CSS

After discovering that little tidbit about how things get rendered, I immediately made the connection to HTML and CSS. HTML is a language where I tell the screen what to do. It's a rendering language. It's just instructions that tell the browser what to put on the screen. CSS just tells it how to make it look prettier.

To a layman, this seems like an inefficient way to make ugly web pages. But I could see: if you make it pretty, and scale it up and give it lots of instructions, it's more powerful than any Word doc or PDF could ever be. You can build actual interfaces.

I started playing around with HTML and CSS in earnest, making simple pages and learning how they worked.

Level 3: Python

Once I felt like I truly "got" it, I got very excited. I thought that maybe I really can do this after all. Even though I knew it was a long uphill battle of learning ahead. But I really was loving it so I moved forward. I completed Harvard's CS50P (Introduction to Programming with Python) and became literate in Python. Finally felt like a "real" programmer.

Level 4: The Python Web Problem

I started working on Harvard's CS50W (Web Programming with Python and JavaScript). Didn't finish it, but I did make some functional sites. I learned Django properly, picked up some JavaScript fundamentals, and started to understand how some programming on the web actually worked.

Here's where things got frustrating. I knew Python. I could build web backends with Flask or Django. But for any interactivity on the frontend, I needed JavaScript.

But it was not working that well. Two completely different languages. Two different ecosystems. Every feature meant fighting to connect Python backend logic to JavaScript frontend behavior. It felt like I was constantly translating between two languages that didn't want to talk to each other.

That's when I started looking at Node.js. I played around with it and realized: okay, Node actually works pretty similar to Python, I would just need to learn more JavaScript. This could work. But then Express came into the picture and Express was hard. So I hardly touched it.

Back to Flask and Django for a while. At least I knew Python.

Level 5: React + Vite (The Breakthrough)

By this point, I was tired of hearing about React everywhere. "React gets you jobs." "Everyone's using React." "You need to learn React." Fine. I'll learn React.

I started a Scrimba course on React. Did not finish it. But I did learn the fundamentals and was kinda liking it.

Then I didn't code for several months. Not sure why. Life happened.

When I came back to it, React clicked even more. And then I fell in love with it. The component model finally made JavaScript make sense to me: build small pieces, compose them together, data flows down, events flow up.

Since then? I've written as much React as possible.

And Vite made the development experience actually pleasant. Fast refresh, just write code and see it work.

This was it. I could finally do full JavaScript without fighting Express. Just build powerful frontends and worry about backends later when I really needed them.

The SSG Detour: Hugo, Jekyll, Eleventy

I also tried the static site generator route: Hugo, Jekyll, Eleventy. Hugo especially. I actually put it through its paces, used the conventions, and understood the structure.

But then I hit Hugo's templating language. And I realized: I don't want to code anything real in such a brittle and stunted language. The skeleton and conventions were great. The actual programming experience? Terrible.

So I took the good parts - the project structure from Hugo, the patterns I learned from Django - and brought them into Vite and Next.js. Real programming, real components, same clean conventions.

Level 6: Next.js (Full Stack Realized)

Next.js was the final piece. Server-side rendering, API routes, file-based routing, React Server Components. Now I could be a full-stack developer entirely in JavaScript (well, TypeScript).

No more Python backend + JavaScript frontend split. No more fighting Express. Just Next.js handling everything: server logic, client interactivity, routing, rendering.

Now I'm building full-stack applications. The Excel wizard became a software developer.

And I feel genuinely productive. Not fighting tools, not context-switching languages. Just building.

The Truth: I Never Left Accounting

Here's what people miss: I didn't abandon accounting. I integrated it.

Some developers can't:

• Take a creation and turn it into a real business
• Read financial statements or understand business performance metrics
• Navigate taxes, audits, bookkeeping, incorporation, compliance
• Design organizational controls, data controls, access controls

That accounting degree? It's my differentiator. I can build the product and the business model. I know how to validate whether something is worth building. I'm not just a dev who can ship features; I'm someone who can turn code into a business and ship products that make financial sense.

The Pattern: Solving Tool Limitations

This is the real lesson: I wasn't learning programming for programming's sake. I was solving problems at each level:

• Excel was too limited → learned Python
• Python scripts were too isolated → learned web development
• Static pages were too rigid → learned React
• JavaScript was too loose → learned TypeScript
• Client-only apps were too constrained → learned Next.js

Each step was a tool upgrade. Each upgrade unlocked new capabilities.

Five Years Later

It's been under 5 years since I wrote my first line of code. I'm self-taught. I have no CS degree. But I have a master's degree in accounting and a healthy dose of computer nerdiness.

And honestly? Software development feels like the highest use of my skills. I'm building systems, solving problems, and creating tools that actually matter, all while enjoying the process. This is what I was meant to do.