Theme:

Safety Nets: What Cycling Taught Me About Umbraco Development

A story about bikes, brakes, and better development: how unlearning an old "rule" helped me understand Umbraco's evolution and how safety nets like monitoring, tests, and community make us braver developers.

The Lesson I Half Remembered

Before we dive into Umbraco's safety nets, let me share a cycling lesson.

Some of my earliest weekends were spent cycling with my dad and siblings, taking short local routes. He taught us the basics and, after a crash that left us with scraped knees and nettles, gave us advice on braking. I don't recall the specific lesson, but I remember using the rear brake first, which on my childhood bike meant using the right-hand brake lever.

Later, he signed us up for Cycling Proficiency. We learned hand signals and how to share the road. By my teens, I was cycling 24 miles round-trip to my Saturday job. Then a car, a career, and years off the bike followed.

My partner is a dedicated cyclist who believes the correct number of bikes to own is n + 1. When we met, he promised to help me rediscover my love for cycling. Following a back injury, the physio suggested cycling as gentle rehabilitation, so my partner set up his spare bike as a turbo trainer (because, of course, he had a spare). But I found static exercise incredibly boring, so we started cycling outdoors instead.

His spare bike was too big, the routes were hilly, and my confidence was low. Eventually, I bought an e-bike, which let me cycle the steep hills without hindering my recovery.

Something still felt wrong. Every time I needed to stop, my instinct was to use the right-hand brake lever first, but it no longer matched what the bike or the moment needed.

Eventually, I realised why: I was following a childhood rule I'd half-remembered. 

That forgotten principle had survived in muscle memory long after its meaning had faded. Twenty years later, it had quietly become risky because braking is not a fixed rule; it depends on the bike, the surface, and the situation.

Stuck on the Same Routes

Despite my partner's experience, we continued to ride the same 15-mile loops. We'd developed a comfortable routine, but we weren't pushing beyond it.

Early on, I'd say, "I need a drink," and he'd keep cycling, not realising I meant "stop now." Over time, he learned to check in regularly: "Need water?" He even started adding electrolytes to my water bottle. These tiny changes mattered, but they weren't enough to break our pattern.

What finally changed things was technology. My partner kept mentioning his cycle radar, a device that detects cars approaching from behind and alerts the rider and drivers. He described it as a total game-changer. I was sceptical until I got one myself.

The effect was immediate, but not in the way I expected. He relaxed.

"It's not about your skill," he admitted, "it's about knowing you're safe."

I added cycle insurance next. Then we started using my cycle computer to track our routes. Each addition built confidence, until we were exploring routes I never would have attempted a year earlier.

The cycle computer revealed something else, too: those hills I'd been struggling with were genuinely steep. One of them had even featured as a "Queen of the Mountain" segment during the Women's Tour of Britain. The data validated my experience. I wasn't failing at easy routes. 

When Familiar Approaches Stop Fitting

If you're still following along, you might be wondering how this relates to Umbraco development.

Remember my dad's "rear brake first" advice? I remembered how, but forgot the why. I learned an implementation, not a principle.

In any long-lived platform, patterns can outlive the context in which they were created. Umbraco is no different. With each major release, we have reassessed inherited approaches and reaffirmed the principles behind good development practice.

Umbraco 14 marked a fundamental shift. Extensions are no longer clever back-office hacks, but first-class citizens that the CMS actively supports. We're no longer building around the system; we're building with it.

And the good news from Umbraco HQ is that Umbraco 17 represents the last major architectural change for the foreseeable future. The foundation is now stable, modern, and consistent.

The Safety Nets That Let You Go Further

Cycling taught me this: even experienced people need safety nets when exploring new areas. My partner is a skilled cyclist, but he rides more confidently with a radar. This isn't because his ability changes; it is because it gives visibility before potential crises. Development is no different.

Across the Umbraco ecosystem, there are nine categories of safety nets you can draw on. You don't need all of them from day one; start with what's accessible and build from there.

1. Monitoring & Observability (The Radar)

My radar is connected to the rear light on my bike. As a car approaches, the light flashes faster and brighter; not to warn me, but to make drivers more aware that I'm there. Good observability serves the same purpose: it doesn't just alert you when something goes wrong. It alerts you when something goes wrong and helps everyone see what's happening before it becomes a problem.

Monitoring tools reveal what's happening behind the scenes and what you can't see from your current position. These range from free options, such as Serilog configured to write to files, to solutions like Application Insights or OpenTelemetry. Start with what you can access, even if it's just structured logging you can search through.

Umbraco uses Serilog for structured logging, helping you identify issues that occur only in production.

Umbraco integrates with .NET logging providers through the Microsoft.Extensions.Logging abstraction that lets you connect production logs to your observability platform of choice.

Observability transforms reactive firefighting into proactive problem-solving, and you don’t need expensive tools to start.

2. Metrics & Data (The Cycle Computer)

Cycling taught me that feelings aren't always reliable, but data is. The same is true in development.

Metrics do the same in development. Performance tests, accessibility scans, and sustainability checks make invisible problems measurable and actionable. Without data, you can only guess; with it, you gain knowledge.

Many measurement tools are free. Browser developer tools, Lighthouse for accessibility and performance, and basic load testing with tools like JMeter cost nothing but time to learn.

In the Umbraco ecosystem, these metrics can guide decisions on caching, media handling, content structure, and the editor experience, long before issues reach production.

3. Automated Testing (The Insurance)

Cycle insurance isn't about avoiding crashes; it's about recovering quickly when they happen. Automated testing is your development insurance: unit, integration, UI, and accessibility tests all let you refactor and upgrade with confidence.

In Umbraco:

  • Umbraco's move to ASP.NET Core (from version 9 onwards) introduced more precise separation of concerns, DI-based services, and more testable abstractions. This makes it easier to write unit tests around your own code, though some Umbraco internals still require mocks or wrappers.
  • AI-assisted tooling can help scaffold test boilerplate, allowing developers to focus on intent and behaviour rather than setup.
  • For UI and editor testing, Playwright test helpers make it practical to run repeatable tests against real Umbraco backoffice workflows. The test helpers have been used in packages like CSP Manager and the Sustainability Package.

4. CI/CD Pipelines (The Regular Check-ins)

Remember my partner's regular "Need a drink?" check-ins? CI/CD pipelines provide ongoing care in a similar way.

In Umbraco development, CI/CD pipelines are usually set up by the development team/ DevOps specialists. They may include static analysis tools, automated tests, accessibility checks, and sustainability scans that run on every pull request or as part of the build pipeline. Small, consistent feedback keeps a project healthy and safe. These early checks stop problems from reaching production.

5. Umbraco Cloud Safety Nets

Umbraco Cloud, Umbraco's SaaS offering, provides users with isolated environments (typically Dev, Staging, and ProdNote 1), WAF protection, and CDN caching. According to Umbraco's internal monitoring, roughly 20%Note 2 of Cloud sites that could have CDN caching enabled have it disabled—it's like skipping electrolytes in your water: small, but it matters.

If you're self-hosting, you'll need to set those infrastructure safety nets yourself. It's like maintaining your own bike instead of using a serviced hire scheme.

Both approaches are valid. Umbraco Cloud reduces infrastructure overhead; self-hosting offers more control but requires more expertise.

6. Community Safety Nets (The Support System)

The Umbraco community is widely recognised for being welcoming:

Most of these spaces are managed by the community rather than by Umbraco HQ, which is part of what makes the ecosystem unique and resilient.

No one rides alone here; there's even a weekly newsletter, umb.fyi, that provides signposts to all the great articles. The more you share, the more safety nets you build for others.

7. Packages as Safety Nets

Packages are reusable solutions that turn individual effort into community-wide safety nets.

Before building custom functionality, always check the Umbraco Marketplace for existing solutions. It's the central hub for discovering and sharing packages that solve everyday problems, often maintained by community members who've faced the same challenges.

Many packages are entirely free and open source:

  • uSync, a widely-used open-source tool for synchronising schema and settings between environments, is often used as an alternative approach to Umbraco Deploy, depending on team preference and hosting mode
  • Accessibility Reporter, to audit your website against WCAG guidelines directly in Umbraco
  • SEO packages with proven approaches to meta tags, redirects, and sitemaps

There are also commercial options, such as Umbraco Forms, that enable you to create accessible forms, validate submissions, ensure GDPR compliance, and include built-in workflows.

Browse the Marketplace before reinventing a wheel that's already perfectly round.

8. Training & Certification (The Proficiency Course)

Remember how Dad signed me up for Cycling Proficiency? Umbraco offers similar safety nets for developers:

If formal training isn't an option, the documentation and community-created content on 24 Days, Skrift, and YouTube provide excellent free alternatives.

9. The MVP Program and Umbraco Community Teams (Safety Net Builders)

The Umbraco Community Teams act like the support crew that rides alongside. They create spaces where contributors can collaborate, learn, and share their expertise. Each team works closely with Umbraco HQ in its own area, helping refine ideas, shape approaches, and represent community perspectives. They strengthen the ecosystem by making it easier for people to contribute confidently and consistently.

The MVP Program recognises those who make sustained, significant contributions across the community — through packages, documentation, events, accessibility work, meetups, and the countless acts of support that help others succeed.

As an Umbraco and Microsoft MVP, I've found that contributing to the community isn't just about giving back. It's about shaping the ecosystem we all depend on. The safety nets we build for others often end up catching us as well.

Prioritising Your Safety Nets

Not every organisation can adopt every safety net at once, and that’s completely normal. Many of the nine categories I’ve outlined require time, budget, or organisational support.

Instead of trying to implement everything from the start, you can make real progress by focusing on just three:

  • Community: Join the forum, Discord, and attend a local meetup if possible. When you're stuck, having people to ask is invaluable.
  • Version control + basic CI: Git and GitHub ActionsNote 4 cost nothing and catch problems before they reach production.
  • One testing approach: Choose one. Even testing your most important feature is better than testing nothing at all.

Add others as you grow, as your projects require them, or as your organisation evolves.

Permission to Go at Your Own Pace

I'll never be a dedicated cyclist. I won't ride in heavy rain or compete, and that's fine.

Safety nets don't just protect you from failure. They create room for experimentation. They give you the confidence to try new things at your own pace, deliver value, and support your team without taking unnecessary risks.

So Here's My Challenge to You

What's your radar? What safety net would let you go further?

Maybe it's joining the forum and asking your first question. Maybe it's writing one test for your most important feature. Maybe it's just reading the documentation for something you've been avoiding.

Start where you are. The Umbraco community gives you support, momentum, and a place to grow.

And remember: you don't have to be a dedicated cyclist. You just need to enjoy the ride.

Note

Cycling Proficiency Test

The Cycling Proficiency Test was a test administered by the Royal Society for the Prevention of Accidents, serving as a minimum recommended standard for cycling on British roads. The National Standards for Cycle Training superseded Bikeability in England in 2007.

Notes

Note 1 - The exact Umbraco Cloud Environments available depend on the plan selected.

Note 2 - 20% source: Umbraco Product Update - Q1 2025

Note 3 - better IDE Integration Umbraco 17: Ready, Reliable, and Less Scary than It Sounds

Note 4- GitHub Actions provides free CI/CD for public repositories and generous free tiers for private ones (2,000 minutes/month on the free plan). GitHubAction Pricing