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

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:

Or search "Maintainable" wherever you stream your podcasts.

Keep up to date with the Maintainable Podcast by joining the newsletter.

Lucas Roesler: The Fast Feedback Loop Advantage

Maintainable