Introduction

Looking back on my time as a Senior Platform Engineer at Holland & Barrett, it’s been a period of significant growth and learning. Before this role, I spent eight years working with Symfony, a PHP framework I still hold in high regard. Most of my career was based in Scotland, balancing backend development and cloud engineering, though I’ve always leaned more toward the backend.

In my mid-20s, before stepping into platform engineering, I thought I had it figured out—building and managing solid applications that did the job. But moving from fast-paced startups to a structured corporate environment was a wake-up call. The challenges were bigger, and the stakes were higher. It forced me to rethink what it takes to build scalable, reliable tech.

This post explores that transition, the challenges I’ve faced, and how this journey has shaped me as an engineer.

What is Platform Engineering?

Platform engineering is about reducing complexity and building systems that empower developers to focus on delivering value without getting bogged down by the intricacies of infrastructure. It provides streamlined, scalable solutions that balance ease of use with the technical demands of modern software development.

The distinction between DevOps and platform engineering often comes down to scale and specialization. In smaller startups, a single DevOps engineer might handle the entire stack—writing code, managing deployments, and maintaining infrastructure. However, as companies grow and adopt more complex architectures like microservices, the sheer number of moving parts becomes overwhelming. This demands a more structured approach, with dedicated teams to manage different aspects of the platform.

Platform engineering typically brings together specialized teams such as:

PaaS (Platform as a Service) Teams: Provide developers with abstractions and tools to deploy and manage applications with minimal friction.
SRE (Site Reliability Engineering) Teams: Focus on reliability, ensuring systems remain operational and performant.
DX (Developer Experience) Teams: Optimize workflows, tooling, and processes to make developers’ lives easier.

The goal is to create a self-service ecosystem where developers can access everything they need without constantly relying on infrastructure specialists.

Unlike DevOps, which emphasizes collaboration between development and operations, platform engineering focuses on building reusable, scalable systems that support growth and reduce cognitive load. It’s not just about making things work—it’s about making them work at scale, efficiently, and reliably.

That said, the line between DevOps and platform engineering can be blurry, and definitions often vary depending on the organization. There’s no shortage of debate about these roles, especially in forums like Reddit and Twitter.

And as a fun example, I once had a frontend contractor dismiss DevOps as “not a real job,” only to ask me for help debugging a failing deployment shortly after. Irony at its finest.

The Initial Challenges

Moving into platform engineering came with a steep learning curve. Some of the biggest challenges were:

Stepping Out of My Comfort Zone: Years of Symfony expertise didn’t fully prepare me for the breadth of knowledge needed in platform engineering.
Scaling with Terragrunt: Managing infrastructure as code for large-scale, multi-environment deployments was a huge step up from hardcoded solutions.
Tackling Kubernetes: My introductory Kubernetes knowledge wasn’t enough when managing it at scale. It was a humbling experience coming from ECS (Elastic Container Service).
Understanding AWS IAM Policies: A surface-level understanding wasn’t enough. I had to dive deep into policy evaluation logic and best practices.
Navigating Datadog: Filtering out what mattered from a sea of metrics and logs was overwhelming initially.
Debugging Across the Stack: Issues often spanned infrastructure, applications, and user interfaces, requiring a broader understanding to troubleshoot effectively.
Learning Microsoft Entra ID: Managing user permissions and security at scale was far more complex than I was used to.
Supporting While Learning: Providing support in areas I was still mastering added to the pressure.

These challenges pushed me to learn quickly and adapt, teaching me resilience and patience along the way.

Growth & Self-Development

This role has challenged me to grow in ways I hadn’t anticipated:

Embracing Discomfort: Being out of my depth taught me to adapt and improve.
The Value of Questions: Overcoming imposter syndrome helped me ask the “dumb” questions that were key to learning.
Learning Through Reading: Books like System Design Interview and The Power of Now sharpened my technical and personal focus.
Commitment to Documentation: Keeping docs in Confluence up to date improved both team collaboration and my knowledge.

These experiences haven’t just made me a better engineer—they’ve improved my ability to problem-solve and adapt to new challenges.

Overcoming Obstacles

Some key strategies that have helped me include:

Breaking Down Tasks: Tackling problems in smaller chunks made them manageable and less overwhelming.
Being Open to Feedback: Learning to see criticism as a tool for improvement, rather than taking it personally, was a turning point.
Taking Breaks: Sometimes stepping away and returning with a fresh perspective was all it took to solve a problem.

Problems I’ve Observed

In my time on the job, I’ve bumped into some real headaches that show just how tricky platform engineering can be. Here’s the lowdown:

This Job’s a Fucking Beast: Straight up, platform engineering’s tough. It’s not just about keeping the lights on; it’s about figuring out how to grow without blowing your budget.
Shortcut Syndrome: The convenience of our platform tools sometimes leads to a reliance on easy solutions, with a few engineers skipping the deeper dive into how things really work. This habit can spell trouble when unexpected issues pop up and not everyone has the know-how to troubleshoot effectively.
Balancing Act: Trying to scale things up but keep costs down is like walking a tightrope. Every choice impacts performance or the budget, and striking the right balance is hard.
Teamwork Hurdles: Mixing different teams shows off the gaps in what we all know. Getting everyone aligned is easier said than done, but it’s crucial for moving forward together.
Monitoring Madness: Just when you think you’ve got it all sorted, something new pops up that needs watching. It’s an endless game, always finding new stuff to keep an eye on.
Update Overload: Keeping track of all the updates and making sure the team does too feels like a full-time gig.
Engaging Engineers: The real challenge lies in getting engineers to prioritize and adapt to platform changes amid their own packed schedules. It requires persistent outreach and reminders to ensure they’re aligned and responsive to these necessary shifts.
Juggling Act with Priorities: It’s a constant balancing act between ongoing maintenance and tackling items on the roadmap. Figuring out what needs immediate attention versus what can wait is like trying to keep too many balls in the air. Every day is about making tough calls on where to focus next.
Managing Dependencies: Handling dependencies on a large scale is complex. It demands that every project is equipped with robust testing pipelines to ensure that any version updates won’t cause major disruptions.
Handling Egos: You will definitely run into folks resistant to change or just plain hard to work with. We’re all trying to reach the same goal, but that doesn’t always mean it’s smooth sailing. Dealing with it involves a lot of talking, understanding, and sometimes just navigating around those big egos to keep everything on track.

Navigating these issues has been part of the gig, offering up as many lessons as challenges.

Advice For newcomers

Ease Into It: Jumping into platform engineering? Don’t try to conquer everything day one. It’s a marathon, not a sprint. Get your bearings, learn the ropes, and pace yourself.
Own Your Mistakes: You’re going to mess up, and that’s okay. What’s important
Prioritize Self-Care: Don’t let the job consume you. Make time for yourself, your hobbies, and your loved ones. Burnout helps no one.
Stay Open to Change: The only constant in platform engineering is change. Whether it’s a new tool, a process overhaul, or adapting to team dynamics, stay flexible and open.
Get Comfortable Being Uncomfortable: You’ll be out of your comfort zone a lot. That’s where the growth happens. When things get tough, remember it’s all adding to your skillset.

Conclusion

My first year in platform engineering has been intense, to say the least. It’s stretched me in ways I didn’t expect, forcing me to tackle new challenges and broaden my skill set. While I wouldn’t claim to be an expert in everything, I’ve definitely come a long way.

This journey has been as rewarding as it’s been demanding. The move from a PHP/LAMP stack to cloud engineering has not only boosted my confidence but also opened doors I didn’t think possible—remote opportunities, better work-life balance, and a significant leap in my market value. Staying in my PHP comfort zone might have felt easier, but it wouldn’t have gotten me here.

Conquering Kubernetes and managing it at scale was a big turning point. It showed me that even the most daunting topics can be mastered with persistence (and a fair amount of Googling). Honestly, it’s a bit like playing guitar for years without touching music theory—you don’t realize how much you’re missing until you dive in.

All in all, this experience has been a game-changer. It’s taught me that progress isn’t about massive leaps, but about persistence and consistently taking small steps forward. With curiosity, a willingness to fail (sometimes quite impressively), and an iterative approach, progress is inevitable. And if there’s one thing I’ve learned, it’s this: the tech world is full of challenges, but they’re often just cleverly disguised opportunities to grow—and maybe laugh a little along the way.