Maintainable

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.

Rewrites are seductive. Clean slates promise clarity, speed, and “doing it right this time.” In practice, they’re often late, over budget, and quietly demoralizing.
In this episode of Maintainable, Robby sits down with Brittany Ellich, a Senior Software Engineer at GitHub, to talk about a different path. One rooted in stewardship, readability, and resisting the urge to start over.
Brittany’s career began with a long string of rebuild projects. Over time, she noticed a pattern. The estimates were wrong. Feature development stalled. Teams burned energy reaching parity with systems they’d already had. That experience pushed her toward a strong belief: if software is in production and serving users, it’s usually worth maintaining.
[00:00:57] What well-maintained software actually looks like
For Brittany, readability is the first signal. If code can’t be understood, it can’t be changed safely. Maintenance begins with making systems approachable for the next person.
[00:01:42] Rethinking technical debt
She explains how her understanding of technical debt has evolved. Rather than a fixed category of work, it’s often anything that doesn’t map directly to new features. Bugs, reliability issues, and long-term risks frequently get lumped together, making prioritization harder than it needs to be.
[00:05:49] Why AI changes the maintenance equation
Brittany describes how coding agents have made it easier to tackle small, previously ignored maintenance tasks. Instead of waiting for debt to accumulate into massive projects, teams can chip away incrementally. (Related: GitHub Copilot and the Copilot coding agent workflow she’s explored.)
[00:07:16] Context from GitHub’s billing systems
Working on metered billing at GitHub means correctness and reliability matter more than flash. Billing should be boring. When it’s not, customers notice quickly.
[00:11:43] Navigating a multi-era codebase
GitHub’s original Rails codebase is still in active use. Brittany relies heavily on Git blame and old pull requests to understand why decisions were made, treating them as a form of living documentation.
[00:25:27] Treating coding agents like teammates
Rather than delegating massive changes, Brittany assigns agents small, well-scoped tasks. She approaches them the same way she would a new engineer: clear instructions, limited scope, and careful review.
[00:36:00] Structuring the day to avoid cognitive overload
She breaks agent interaction into focused windows, checking in a few times a day instead of constantly monitoring progress. This keeps deep work intact while still moving maintenance forward.
[00:40:24] Low-risk ways to experiment
Improving test coverage and generating repository instructions are safe entry points. These changes add value without risking production behavior.
[00:54:10] Navigating team resistance and ethics
Brittany acknowledges skepticism around AI and encourages teams to start with existing backlog problems rather than selling AI as a feature factory.
[00:57:57] Books, habits, and staying balanced
Outside of software, Brittany recommends Atomic Habits by James Clear, sharing how small routines help her stay focused.
The takeaway is clear. AI doesn’t replace engineering judgment. Used thoughtfully, it can support the unglamorous work that keeps software alive.
Good software doesn’t need a rewrite.
It needs caretakers.
References Mentioned
GitHub – Brittany’s current role and the primary environment discussed
GitHub Universe – Where Brittany presented her coding agent workflow
Atomic Habits by James Clear – Brittany’s recommended book outside of tech
Overcommitted - Podcast Brittany co-hosts
The Balanced Engineer Newsletter – Brittany’s monthly newsletter on engineering, leadership, and balance
Brittany Ellich’s website – Central hub for her writing and links
GitHub Copilot – The AI tooling discussed throughout the episode
How the GitHub billing team uses the coding agent in GitHub Copilot to continuously burn down technical debt – GitHub blog post referenced
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.

Kent Beck: You’re Ignoring Optionality… and Paying for It
In this episode of Maintainable, Robby speaks with Kent Beck, a foundational voice in modern software development and author of Tidy First?. Kent joins from California to explore why optionality is a central, often underestimated dimension of maintainable software.
Kent begins by describing the tension between features and future flexibility. Shipping new capabilities is easy to measure. Creating options for what comes next is not. That imbalance is where maintainability either flourishes or collapses. Senior developers in particular must learn to navigate this tension because they have lived through the consequences when no one does.
They reflect on how cost models have shifted across the last five decades. Early in Kent’s career, computers were expensive and programmers were cheap. Today the balance often flips depending on scale. At massive scale, electricity and compute time become meaningful costs again. That variability shapes whether teams optimize for hardware efficiency or developer efficiency.
Episode Highlights
[00:00:46] The Two Forms of Software Value
Kent explains why software value comes from both current features and the options you preserve for future work. He describes optionality as the invisible half of maintainability.
[00:03:35] When Computers Become “Expensive” Again
Robby and Kent revisit the shift from hardware-optimized development to developer-optimized development and how large-scale systems have reintroduced compute cost pressures.
[00:07:25] Why the Question Mark in Tidy First?
Kent shares why tidying is always a judgment call and why he put a question mark in the title.
[00:10:14] The Real Cost of Speculative Flexibility
They discuss why adding configurability too early creates waste and why waiting until just before you need it increases value.
[00:13:46] Making Hard Changes Easy
Kent outlines his guiding idea. When you face a difficult change, make the change easy first, then make the easy change.
[00:17:08] The Feature Saw
Kent explains his features versus options graph and how teams repeatedly burn optionality until they hit zero. At that point, forward movement becomes painful.
[00:19:37] Why 100 Percent Utilization Is a Trap
Kent discusses how queuing theory shows that full utilization pushes wait times toward infinity. Overcommitted teams have no room for design work.
[00:22:44] Split Teams Do Not Solve the Problem
Robby talks about consulting scenarios where “tidy teams” and “feature teams” are separated. Kent argues that this splits incentives and prevents optionality from being sustained.
[00:26:15] Structure and Behavior Should Not Ship Together
Kent describes why feature changes are irreversible, structure changes are reversible, and why combining them increases risk for everyone.
[00:30:37] Tidying Reveals Intent
While cleaning up structure, developers often uncover logic flaws or misunderstandings that were previously hidden.
[00:32:00] When Teams Discourage Testing
Kent shares stories about environments where developers were punished for refactoring or writing tests. He explains why building career options is essential in those situations.
[00:37:57] Why Tidying Is an Ethical Obligation
Kent reframes optionality as a moral responsibility. No one should make work harder for the next person who touches the code.
[00:41:33] Succession and Slicing
Kent describes how nearly every structural change can be broken into small, safe steps, even when the change first appears atomic.
[00:47:00] A Small Habit to Start Today
Kent suggests adding a blank line to separate conceptual chunks in long functions. It is a small step that improves clarity immediately.
Resources Mentioned
Tidy First? by Kent Beck
Kent Beck on Substack
The Timeless Way of Building by Christopher Alexander
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.

Episode Highlights
[00:00:48] What Makes Software Maintainable
Don explains why unnecessary complexity is the biggest barrier to maintainability, drawing on themes from A Philosophy of Software Design.
[00:03:14] The Cost of Clever Abstractions
A real story from a Node.js API shows how an unused abstraction layer around MongoDB made everything harder without delivering value.
[00:04:00] Shaping Teams and Developer Tools
Don describes the structure of the Searchcraft engineering team and how the product grew out of recurring pain points in client projects.
[00:06:36] Reducing Complexity Through SDK and Infra Design
Why Searchcraft intentionally limits configuration to keep setup fast and predictable.
[00:08:33] Lessons From Consulting
Robby and Don compare consulting and product work, including how each environment shapes developers differently.
[00:15:34] Inherited Software and Abandoned Dependencies
Don shares the problems that crop up when community packages fall behind, especially in ecosystems like React Native.
[00:18:00] Evaluating Third-Party Libraries
Signals Don looks for before adopting a dependency: adoption, update cadence, issue activity, and whether the library is “done.”
[00:19:40] Designing Code That Remains Understandable
Why clear project structure and idiomatic naming matter more than cleverness.
[00:20:29] RFCs as a Cultural Anchor
How Don’s team uses RFCs to align on significant changes and avoid decision churn.
[00:23:00] Documentation That Adds Context
Documentation should explain why, not echo code. Don walks through how his team approaches this.
[00:24:11] Type Systems and Maintainability
How Don’s journey from PHP and JavaScript to TypeScript and Rust changed his approach to structure and communication.
[00:27:05] Testing With Types
Stable type contracts make tests cleaner and less ambiguous.
[00:27:45] Building Trust in AI Systems
Don discusses repeatability, hallucinations, and why tools like MCP matter for grounding LLM behavior.
[00:29:28] AI in Developer Tools
Search Craft’s MCP server lets developers talk to the platform conversationally instead of hunting through docs.
[00:33:21] Improving Legacy Systems Slowly
The Strangler pattern is a practical way to replace old systems one endpoint at a time.
[00:34:11] Deep Work and Reducing Reactive Noise
Don encourages developers to carve out time for uninterrupted thinking rather than bouncing between notifications.
[00:36:09] Measuring Progress
Build times, test speeds, and coverage provide signals teams can use to track actual improvement.
[00:38:24] Changing Opinions Over a Career
Why Don eventually embraced TypeScript after initially writing it off.
[00:39:15] Industry Trends and Repeating Cycles
SPAs, server rendering, and the familiar pendulum swing in web architecture.
[00:41:26] Experimentation and Team Autonomy
How POCs and side projects surface organically within Don’s team.
[00:44:42] Growing Skills Through Intentional Goals
Setting learning targets in 1:1s to support long-term developer growth.
[00:47:19] Where to Find Don
LinkedIn, Blue Sky, and his site: donmackinnon.dev.
Resources Mentioned
A Philosophy of Software Design by John Ousterhout
John Ousterhout’s Maintainable.fm Interview (Episode 131)
Searchcraft
Elastic
Algolia
WordPress Plugin Directory
Request for Comments (RFC)
Strangler Fig Pattern
C2 Wiki
Model Context Protocol (MCP)
Glam AI
Aubrey/Maturin Series by Patrick O’Brian
Master and Commander
donmackinnon.dev
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.