The Early Years

When I started my career in software, I was a manual tester. I’d write test specs and test cases to manually walk through the user flows of a product or feature. It was black-box testing. No coding required.

Eventually, I became a Program Manager. I loved gathering requirements, working closely with Product Managers to understand user needs and business goals. I partnered with designers to bring visuals to life that developers could accurately reference. I wrote technical specs and worked closely with both developers and testers to implement what we had envisioned. I loved being involved end-to-end. But still...no coding.

At every step of my career, I actually avoided learning to code. I figured it wasn’t a strength of mine and would be difficult to learn. Instead, I leaned hard into what I knew I was good at: communication, organization, prioritization, identifying risks, and seeing around corners.

I thought I understood the technology well enough to speak effectively with engineers. I thought I could accurately translate their challenges to business stakeholders and vice versa. And for the most part, I could - adequately enough.

But at some point, it started to feel like not enough. I kept hitting a wall in my career where I just didn’t come across as technical enough for the next level.

Learning

In 2018, I started learning to code, mainly out of necessity. I was between jobs and wanted to build a website to showcase my skills and experience.

I found learning the ins and outs of some web-building tools were just as complex as learning to code itself and often too bloated with a bunch of sh*t I didn't need. Then I discovered Jamstack architecture and something clicked. It felt like something I could really sink my teeth into.

So I took a few courses. And I knew (from many conversations with devs over the years) that the best way to learn was to actually build something yourself. So I did.

I built my first website using React.js and JavaScript.

And damn. That changed everything.

As I learned to code, and eventually found myself coding on teams with developers, I realized something huge: I had ZERO idea what devs really go through every day. Sure, I had understood the tech at a high level. But I didn’t have real empathy for the experience. I couldn’t truly advocate for my engineers when they pushed back, because I didn’t fully understand their pain points.

Growing Empathy

Learning to code is hard.

Now add the fact that you're working on a team where everyone's pushing code constantly. You spend a huge chunk of your day just pulling the latest branch, merging with your local work, fixing conflicts, running automated tests, fixing broken tests... and only then do you actually get to start your real work.

When I was coding on a team, this alone could eat up most of my day.

And honestly? I found it maddening. Necessary, but maddening.

And that’s just the baseline.

Now layer in broken dependencies, flaky systems, weird legacy bugs, tech debt, and blocked environments (all things your code might rely on just to run) and now you're stuck. Frustrated. Maybe yelling at the screen (definitely yelling at the screen).

Then the day finally comes, you've finished your feature work / bug fix/ small tweak, and the thing is done! You push your PR, and bam - a dozen comments from a senior dev flood in.

Face in palm, hand on head, you read through them and realize they’ve basically re-architected your whole approach. Or maybe you end up in a back-and-forth debate about your implementation versus theirs (because yes, coding is wildly creative).

That's if your team even has the bandwidth and process for regular code reviews. If not? Welcome to code purgatory where you wait...and wait..for someone to have time to review your work - which, by the way, is a blessing in disguise, because code reviews are where you really grow.

Finally, FINALLY, you get the green light. You merge. Your work goes live. You feel that fleeting rush of accomplishment.

And then it starts all over again.

Why do people enjoy this?! I have no idea. But some very smart, very talented individuals do - and sincerely, God bless them.

I Got You

I have been in the trenches now. And while I'm glad I have the background, my heart lies in program management.

So when my team tells me they’re blocked by a dependency? I get it. I understand the frustration at a gut level.

If a process is adding even more overhead? I’ll do everything I can to streamline it so they can just do the damn work.

If a stakeholder or business leader needs to understand why a deliverable is suddenly taking longer? I can explain it clearly - in a way that makes sense. Because I really get both sides now.

And most importantly, I celebrate every win.

Because coding isn’t just technically challenging — it’s emotionally draining, wildly unpredictable, and can be frustrating as hell.

So here’s to my dev buddies: I see you. And I’ve got your back.