Runtime Regret Podcast

Runtime Regret

We explore what happens when technology decisions meet reality. We focus on incentives, silos, leadership behavior, and organizational politics—why plans succeed in meetings but fail at scale, and why accountability disappears at runtime. runtimeregret.substack.com

  1. 5d ago

    How Can Engineering Push Back on Unrealistic Timelines Without Being Seen as Blockers?

    “It’ll take longer than that.” If you work in engineering, you’ve said it, and you’ve probably watched the room decide you’re the problem. That’s the question Stephanie sent in for this episode of Runtime Regret: how can engineering teams push back on unrealistic timelines without sounding defensive or uncooperative? Joe Kennedy, who has spent decades running technology and operations teams, says the answer comes down to one word: transparency. Why stakeholders think engineering is slow When the business brings you a list of requirements and a deadline, they usually don’t understand why it takes so long because they can’t see the complexity behind it. To them, it’s “build the feature.” To you, it’s standing up a development environment, getting the right data, validating that data, securing approvals, moving through development and user acceptance testing (UAT), running quality checks and code scans in your CI/CD pipeline, and promoting the release through pre-production into production. Most of that work is invisible. And invisible work looks like stalling. Draw the picture: turn your delivery process into a timeline Joe’s first move is simple. When someone hands you requirements, say “That’s fine,” and then come back with the date it will actually take, along with a schedule that shows why. * Map every step: data, environments, approvals, development, UAT, pipeline checks, pre-prod and production. * Put it on a timeline so stakeholders can see that the coding is only one part of the effort. * Walk them through each callout so the date stops feeling arbitrary. Once people see all the steps laid out, they understand it’s not just the development effort that takes time. It’s everything around it. Show the real cost of a change request The second lesson: when stakeholders change the requirements, use the same picture to show what that change triggers. The change itself might be four hours of work. Orchestrating it might take two or three days, because it has to be re-developed, retested, re-approved and possibly pushed into the next release cycle. When you make that latency visible, people ask fewer questions and stop treating engineering as the blocker. You don’t need to be a diagramming expert Joe recommends PlantUML for building these timeline diagrams, but you don’t even need to learn it. Ask an AI tool like ChatGPT to turn your list of delivery steps into a PlantUML timeline diagram, drop the result into your presentation, and use it to tell the story of what it really takes to ship. Do that consistently, and you’ll have a much easier time explaining deadlines, managing expectations and building trust with your business counterparts. Watch the full episode above. Got a question about engineering leadership, delivery or working with the business? Leave it in the comments or send it in the chat, and Joe may answer it on a future episode of Runtime Regret. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit runtimeregret.substack.com

    How Can Engineering Push Back on Unrealistic Timelines Without Being Seen as Blockers?
  2. Oct 15

    Accountable for Uptime, But Not the Architecture? How to Manage the Risk

    You’re on the hook for uptime. When the system goes down, people look at you. But you don’t get a vote on the architecture. Sound familiar? That’s the question Ahmed sent in for this episode of Runtime Regret: how do you manage risk when you’re responsible for the outcomes, but not the choices? Joe Kennedy, who has spent 35 years running operating systems, operations and telecommunications, walks through how he thinks about it. First, let go of the idea that you could have prevented everything Systems go down for a lot of reasons: hardware configuration, network problems, power issues, and everything from the hypervisor up through the software stack. Joe’s point is simple. Nobody on the planet understands every part of today’s systems. If you’re telling yourself outages happen because you weren’t in the room, that’s probably not true. It’s a big reason so many teams moved to the cloud in the first place: controlling every lever that can cause an outage is hard. Your real job: find the single points of failure If you own resiliency, you don’t need to design every component. A single application can rely on 60 or 70 pieces: databases, application servers, open source libraries, reporting tools. Your leverage comes from mapping those pieces and calling out the single points of failure. Think about how we treat physical infrastructure. You want two telecom lines coming into a facility and two power grids feeding it. Apply the same thinking to software: * Where are your data centers or cloud regions, and do they have real fault tolerance? * What are the single points of failure between them? * How are they kept in sync, and what happens when that sync breaks? Accountability without authority is a visibility problem You can’t force an architecture decision, but you can make the risk impossible to ignore. Document the single points of failure, explain the business impact of each one, and put it in front of the people who do make the call. That’s how you turn responsibility without control into influence. Watch or listen to the full episode above. Got a question about infrastructure, reliability or tech leadership? Leave it in the comments and we may answer it on a future episode of Runtime Regret. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit runtimeregret.substack.com

    Accountable for Uptime, But Not the Architecture? How to Manage the Risk
  3. Oct 4

    They Told Me to Build AI Agents. Now I Can’t Find the Off Switch.

    Six months ago the instruction was simple: build AI agents. Automate the busywork. Move faster. So you did. One agent to summarize meetings. One to triage the inbox. One to write the status report, and another to check the first one’s status report. Now there are agents everywhere. They ping you, they ping each other, and somewhere in the pile is a task a human used to do in ten minutes. This is agent sprawl, and almost nobody warned you about it. How it happens Nobody decides to build forty agents. You build one, it works, and the reward is a request for three more. Each one is reasonable on its own. Together they become a second job: watching, fixing, and explaining what the agents did. The signs you’re there * You spend more time reviewing agent output than doing the original work. * Nobody can say who owns which agent, or what it’s allowed to touch. * Two agents do the same thing, slightly differently, and both are “in production.” * Something breaks and the first question is “which one did that?” What helps * Inventory everything. Name, owner, business function, project and cost for every agent. Yes, you can build an agent to do it. * Sort by risk. Flag the agents that could do real damage and watch those first. * Watch them in one place. Is it running, how often, what triggers it, and which agents depend on which. * Evaluate and cut. Does it do its job? Does another agent do it better? Delete the duplicates. * Take back control. Set an approval process, decommission what you can, and quarantine or retire anything rogue. * Keep rationalizing. Every new agent gets checked against what already exists. It’s ongoing, not a one-time cleanup. AI agents aren’t the problem. Building them without a plan for living with them is. In this episode, a friend in tech stops me at a New York street festival with exactly this question, and Joe answers it step by step: how to rein in agents that are already running amok. If this sounds like your week, subscribe. You’re not the only one. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit runtimeregret.substack.com

    They Told Me to Build AI Agents. Now I Can’t Find the Off Switch.
  4. Mar 8

    When They Hire A Chief Information Officer Who has Never Actually Coded

    In the Runtime Regret episode, Joe talks about something that genuinely confounds him: the recurring pattern of companies hiring a Chief Information Officer who has never actually run engineering or technology systems in the trenches. To Joe, this is one of those organizational decisions that sounds reasonable on paper but breaks down immediately when you look at how technology work really happens. Companies will recruit someone with a polished executive résumé—someone who has managed budgets, sat in board meetings, or overseen “IT strategy”—but who has never personally lived through the chaos of running real systems. They’ve never been responsible for a failing deployment at 2 a.m., never had to debug a cascading outage, and never had to balance reliability, developer velocity, and operational risk at the same time. What bothers Joe most is the disconnect between the expectations placed on the role and the experience the person actually brings. A CIO is often expected to guide architecture decisions, shape infrastructure strategy, and evaluate the tradeoffs between new platforms and legacy systems. But if the person has never operated production systems themselves—never been “in the weeds,” as Joe puts it—they lack the intuition that comes from experience. They may understand the vocabulary of technology leadership, but they don’t always understand the consequences of the decisions they’re making. That gap shows up in subtle but important ways: unrealistic timelines, overconfidence in vendor promises, or strategic initiatives that ignore the operational complexity engineers deal with every day. Joe frames this as part of a broader cultural problem in how organizations think about technology leadership. In many companies, engineering experience is treated as something you grow out of rather than something foundational to leadership. The result is that executives sometimes come from backgrounds closer to finance, consulting, or general management than to software or infrastructure. From Joe’s perspective, that’s like hiring a hospital administrator to run surgery who has never stepped inside an operating room. The leadership might be excellent in terms of communication and organization, but without firsthand exposure to the work itself, it’s difficult to make grounded decisions. Ultimately, Joe isn’t arguing that every CIO needs to be the best engineer in the room. Leadership, after all, involves far more than technical skill alone. What he is pushing back against is the idea that deep operational experience is optional. The most effective technology leaders tend to be people who have spent real time in the systems they’re now responsible for guiding. They understand the constraints engineers face because they’ve faced them themselves. That perspective builds trust with teams and leads to decisions that respect the messy, complicated reality of running modern software systems. Without that grounding, Joe suggests, organizations risk creating a leadership layer that talks about technology but doesn’t truly understand it. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit runtimeregret.substack.com

    When They Hire A Chief Information Officer Who has Never Actually Coded

About

We explore what happens when technology decisions meet reality. We focus on incentives, silos, leadership behavior, and organizational politics—why plans succeed in meetings but fail at scale, and why accountability disappears at runtime. runtimeregret.substack.com