Maintainable

Sally Lait joins Robby Russell on Maintainable to explore software maintainability through a different lens… not just code quality, but how teams work together over time.

Sally is a fractional technology leader and advisor with more than two decades in the industry. You can follow her on LinkedIn or Mastodon.

They start with a familiar question: what makes software well maintained? Structure and standards matter, but Sally shifts the focus to signals around the edges… documentation, onboarding speed, knowledge sharing, and especially how confident people feel making changes.

That confidence becomes the thread throughout the conversation.

Teams with high confidence move faster and adapt more easily. Teams with low confidence hesitate, avoid parts of the system, and struggle to make progress… regardless of what the code looks like.

Robby and Sally also dig into why maintenance work often struggles to get traction. It rarely speaks for itself. Leaders need to connect it to outcomes the business already cares about… risk, hiring, delivery speed, and long-term sustainability.

Sally references a LeadDev panel she moderated on why maintenance still feels “stuck in 2015”: Why Software Maintenance Is Stuck in 2015.

They also discuss modernizing legacy systems and moving away from long-standing in-house software… work that is rarely just technical. It requires trust, clear communication, and navigating the emotional attachment teams have to what they’ve built.

The episode closes with advice for engineers joining older codebases: stay curious, build relationships early, and use onboarding gaps as opportunities to improve things for the next person.

Episode Highlights

[00:01:02] What Makes Software Maintainable: Technical quality matters, but cultural signals often tell the deeper story.

[00:05:45] Why Progress Still Feels Slow: Even with improvements, teams can feel stuck due to perception gaps.

[00:07:30] Communicating Small Wins: Lack of visibility into incremental progress impacts morale and confidence.

[00:12:40] Influencing Without Manipulating: Maintenance work needs to be framed in business terms.

[00:16:00] Technical Debt as a Hiring Problem: Outdated systems affect recruiting and retention.

[00:20:22] Modernizing a Siloed System: Unlocking legacy data required both technical and organizational change.

[00:26:55] Building Trust for Change: Surprise proposals fail… alignment takes time.

[00:32:39] Letting Go of “Our Baby”: Replacing systems involves emotional and cultural dynamics.

[00:46:25] Joining an Older Codebase: Practical advice for onboarding and building confidence quickly.

Resources Mentioned

Sally Lait

Sally Lait on LinkedIn

Sally Lait on Mastodon

Why Software Maintenance Is Stuck in 2015 (LeadDev Panel)

Lara Hogan

The Murderbot Diaries by Martha Wells

Death of the Author by Nnedi Okorafor

Sally’s Reading & Reviews Site

Thanks to Our Sponsors!

Your test coverage says 90%, but that might be misleading. Undercover CI looks at your Ruby pull requests and shows you which parts of your changes weren't tested- not just overall coverage, but what changed and what got missed, down to the method level. Visit undercover-ci.com and use code MAINTAINABLE for 15% off your first billing cycle. Free for public repos. Private repos with unlimited users also available.

Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks. It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications. Keep your coding cool and error-free, one line at a time! Use the code maintainable to get a 10% discount for your first year. Check them out!

Subscribe to Maintainable on:
Apple Podcasts
Spotify
Or search "Maintainable" wherever you stream your podcasts.
Keep up to date with the Maintainable Podcast by joining the newsletter.

Software maintenance is often framed as a technical problem. Refactoring code, fixing bugs, or upgrading dependencies. In this conversation, Robby Russell talks with Rein Henrichs about a different lens, one centered on understanding.

Rein is a Principal Software Engineer at Procore, where he works within a large, long-lived system used across the construction industry. Rather than focusing on tooling, Rein emphasizes that well-maintained software is software that makes sense to the people maintaining it.

To explain this, Rein introduces the idea of the line of representation, drawing on the work of Richard Cook. Engineers do not interact directly with systems. They rely on representations such as logs, dashboards, and code. These are approximations, not reality, echoing ideas from Plato’s Allegory of the Cave.

When those representations break down, teams lose shared understanding, what Rein describes as “common ground.” This often shows up as weak signals. Subtle indicators that something is not quite right. They are easy to ignore, but over time they lead to confusion and slower decision-making.

Incidents make this especially visible. Rein explains how teams build alignment under pressure, highlighting that the role of an incident commander is coordination, not control. Clear communication matters as much as technical correctness.

The conversation also explores how large systems behave in practice. They rarely fail completely. Instead, they degrade in multiple ways at once. While SLOs can help teams respond to customer-facing issues, they do not capture internal clarity or alignment.

Rein references W. Edwards Deming to highlight a common trap. Not everything that matters can be measured. High-performing teams often rely on judgment, experience, and shared context.

Toward the end, Rein connects these ideas to The Field Guide to Understanding Human Error by Sidney Dekker, challenging the idea that incidents are simply caused by mistakes. Instead, they emerge from the same behaviors that usually lead to success, just under different conditions.

For teams working in complex systems, the takeaway is straightforward. Maintaining software depends on maintaining understanding.

Links & Resources

Procore

Rein Henrichs on LinkedIn

Concepts & References

How Complex Systems Fail – Richard Cook

The Field Guide to Understanding Human Error – Sidney Dekker

W. Edwards Deming

Gerald Weinberg – Secrets of Consulting

Referenced in this Conversation

Kent Beck: You’re Ignoring Optionality and Paying for It

Charity Majors: Deploys Are Just the Beginning

Heidi Helfand: The Art and Wisdom of Changing Teams

Thanks to Our Sponsor!

Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks.

It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications.

Keep your coding cool and error-free, one line at a time! 

Use the code maintainable to get a 10% discount for your first year. Check them out!

Subscribe to Maintainable on:
Apple Podcasts
Spotify
Or search "Maintainable" wherever you stream your podcasts.
Keep up to date with the Maintainable Podcast by joining the newsletter.

Software doesn’t become hard to maintain only because the code is messy. It often becomes hard to maintain because the reasoning behind it disappears.

In this episode of Maintainable, Robby Russell talks with Russ Olsen about trade-offs, legacy systems, and why maintainability depends on context more than dogma. Russ brings decades of experience across very different kinds of systems, each with its own definition of what “maintainable” actually means.

A central theme is that software must be understandable to the people maintaining it. Teams tend to document implementation details well, but often fail to capture system-level intent and the trade-offs behind major decisions. Russ makes the case for preserving that thinking, including the alternatives that were rejected, so future maintainers don’t have to rediscover it the hard way.

The conversation also touches on Russ’s book Eloquent Ruby, Second Edition. Rather than teaching syntax, the book focuses on how Ruby is actually used in practice and why common patterns exist. That leads into a discussion about where elegance improves maintainability, and where it turns into unnecessary cleverness.

From there, the episode shifts into the realities of working in legacy systems. Russ explains how teams develop pessimism over time, often accepting flawed assumptions about how their systems behave. In some cases, major issues turn out to be far simpler than expected. The challenge is that teams stop looking.

Robby and Russ also discuss the value of fresh perspective. New engineers or outside contributors can surface assumptions that longtime maintainers overlook. Russ suggests finding “pinch points” in a system as a practical way to understand behavior without needing to fully untangle everything at once.

Later, the conversation explores developer quality of life. Long build and deploy cycles create daily friction that teams often underestimate. These slow feedback loops quietly degrade productivity and morale over time.

The episode also tackles rewrites. Russ warns that teams frequently underestimate how much knowledge is embedded in existing systems. Code that looks questionable may reflect constraints no one documented. In practice, most successful rewrites happen incrementally, not all at once.

The conversation wraps with a reminder that software development is fundamentally a social process. Russ argues that engineers undervalue storytelling, even though it’s one of the most effective ways to connect technical work to real human outcomes.

Episode Highlights

[00:00:40] Defining maintainability: Why context matters more than a universal standard

[00:02:01] Beyond code comments: Documenting system intent and trade-offs

[00:08:14] Who Eloquent Ruby is for: Understanding how Ruby is used in practice

[00:16:21] Elegance vs. cleverness: Where maintainability starts to erode

[00:23:18] Legacy pessimism: Why teams stop questioning assumptions

[00:29:25] Pinch points: A practical way to understand complex systems

[00:32:05] Developer experience: The hidden cost of slow feedback loops

[00:38:26] Rewrites: Why they fail and what teams overlook

[00:44:00] Storytelling: Connecting technical work to real-world impact

Resources Mentioned

Russ Olsen on LinkedIn

Eloquent Ruby, Second Edition

Getting Clojure

Zen and the Art of Motorcycle Maintenance

A History of Western Philosophy

Thanks to Our Sponsor!

Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks.

It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications.

Keep your coding cool and error-free, one line at a time! 

Use the code maintainable to get a 10% discount for your first year. Check them out!

Subscribe to Maintainable on:
Apple Podcasts
Spotify
Or search "Maintainable" wherever you stream your podcasts.
Keep up to date with the Maintainable Podcast by joining the newsletter.

Long-lived software systems rarely stay tidy. Over time they accumulate decisions, workarounds, and layers of history that can make even simple changes feel risky. For engineers responsible for maintaining those systems, the challenge often becomes less about writing new code and more about understanding what already exists.

In this episode of Maintainable, Robby Russell speaks with Joel Oliveira, Engineering Manager at ezCater, about what helps software remain understandable and adaptable as it evolves.

Joel starts with a principle that often gets overlooked: predictability. When patterns are consistent and code is organized in familiar ways, engineers can navigate a codebase with confidence. Frameworks like Ruby on Rails reinforce this by encouraging shared conventions, making it easier for developers to orient themselves when working in a new application.

The conversation also explores how common metrics can be misleading. Test coverage is often treated as a proxy for quality, but Joel explains that it can create a false sense of confidence. Instead, he values testing most as a thinking tool. Practices like test-driven development can help engineers clarify interfaces and better understand the problem before committing to an implementation.

Joel also shares a story from ezCater about replacing an aging image-cropping service that had become difficult to maintain and required frequent restarts due to a memory leak. Rather than patch the system again, the team introduced ImageProxy, an open source image processing tool created by Evil Martians.

Because the image URLs flowed through a single object in their GraphQL layer, the team could introduce an adapter and gradually route traffic to the new service using feature flags. This allowed them to migrate safely and incrementally instead of relying on a risky “big bang” change.

Robby and Joel also discuss how engineers’ perspectives shift over time. Early in a career it is easy to look at legacy code and label it as bad. Joel now sees older systems as layers of decisions shaped by real constraints. Approaching them with empathy makes it easier to improve them thoughtfully.

The episode closes with advice for engineers maintaining complex systems: frame problems as opportunities. By documenting impact and proposing incremental improvements, teams can steadily move their software toward a healthier future.

Maintainable software rarely comes from one heroic refactor. More often, it’s the result of many small improvements made by teams who understand their systems and care about how they evolve.

Episode Highlights

00:02:18 – Predictability as a Maintainability Feature

Joel explains why predictable patterns and conventions make large codebases easier to navigate.

00:07:41 – When Test Coverage Misleads

Why high coverage can give a false sense of quality.

00:12:05 – Consulting vs. Product Engineering

How switching environments shaped Joel’s approach to code.

00:16:32 – Replacing a Legacy Image Service

ezCater’s migration away from a failing Node-based image service.

00:21:14 – Migrating with Adapters and Feature Flags

How the team gradually moved traffic to ImageProxy.

00:26:03 – Developing Empathy for Legacy Code

Why older systems deserve understanding, not blame.

00:30:47 – The Shift to Engineering Management

Joel reflects on moving from IC work to leading teams.

00:34:52 – Advice for Improving Complex Systems

Small, consistent improvements matter more than big rewrites.

Thanks to Our Sponsor!

Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks.

It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications.

Keep your coding cool and error-free, one line at a time! 

Use the code maintainable to get a 10% discount for your first year. Check them out!

Links / References

Joel Oliveira — LinkedIn

Joel Oliveira — Website

Joel Oliveira — Mastodon (@jayroh)

ezCater

ImageProxy

Subscribe to Maintainable on:
Apple Podcasts
Spotify
Or search "Maintainable" wherever you stream your podcasts.
Keep up to date with the Maintainable Podcast by joining the newsletter.

Maintaining software over time rarely fails because of one bad decision. It fails because teams stop getting clear signals… and start guessing.
In this episode, Robby talks with Lucas Roesler, Managing Partner and CTO at Contiamo. Lucas joins from Berlin to unpack what maintainability looks like in practice when you are dealing with real constraints… limited context, missing documentation, and systems that resist understanding.
A big through-line is feedback. Lucas argues that long-lived systems become easier to change when they provide fast, trustworthy signals about what they are doing. That can look like tests that validate assumptions, tooling that makes runtime behavior visible, and a habit of designing for observability instead of treating it as a bolt-on.
The conversation also gets concrete. Lucas shares a modernization effort built on a decade-old tangle of database logic… views, triggers, stored procedures, and materializations… created by a single engineer who was no longer around. With little documentation to lean on, the team had to build their own approach to “reading” the system and mapping dependencies before they could safely change anything.
If you maintain software that has outlived its original authors, this is a grounded look at what helps teams move from uncertainty to confidence… without heroics, and without rewriting for sport.
Episode Highlights
[00:00:46] What well-maintained software has in common: Robby asks Lucas what traits show up in systems that hold together over time.
[00:03:25] Readability at runtime: Lucas connects maintainability to observability and understanding what a system actually did.
[00:16:08] Writing the system down as code: Infrastructure, CI/CD, and processes as code to reduce guesswork and improve reproducibility.
[00:17:42] How client engagements work in practice: How Lucas’ team collaborates with internal engineering teams and hands work off.
[00:25:21] The “rat’s nest” modernization story: Untangling a legacy data system with years of database logic and missing context.
[00:29:40] Making data work testable: Why testability matters even when the “code” is SQL and pipelines.
[00:34:59] Pivot back to feedback loops: Robby steers into why logs, metrics, and tracing shape better decision-making.
[00:35:20] Why teams avoid metrics and tracing: The organizational friction of adding “one more component.”
[00:42:59] Local observability with Grafana: Using visual feedback to spot waterfalls, sequential work, and hidden coupling.
[00:50:00] Non-technical book recommendations: What Lucas reads and recommends outside of software.
Links & References
Guest and Company
Lucas Roesler: https://lucasroesler.com/
Contiamo: https://contiamo.com/
Social
Mastodon: https://floss.social/@theaxer
Bluesky: https://bsky.app/profile/theaxer.bsky.social
Books Mentioned
The Wheel of Time (Robert Jordan): https://en.wikipedia.org/wiki/The_Wheel_of_Time
Accelerando (Charles Stross): https://en.wikipedia.org/wiki/Accelerando
Charles Stross: https://en.wikipedia.org/wiki/Charles_Stross
Thanks to Our Sponsor!
Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks.
It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications.
Keep your coding cool and error-free, one line at a time! 
Use the code maintainable to get a 10% discount for your first year. Check them out!

Subscribe to Maintainable on:
Apple Podcasts
Spotify
Or search "Maintainable" wherever you stream your podcasts.
Keep up to date with the Maintainable Podcast by joining the newsletter.