#EngineeringLeadership | Bhavin Gandhi's Blog

Dependency Management with AI: From Tracking to Forecasting

A few years ago, I was in a Roadmap Planning Onsite in a room full of incredibly smart, driven people, the kind of team any company would be proud of. Product leaders, engineers, designers, program managers, everyone aligned, everyone motivated. The roadmap looked solid, the timelines felt achievable, and there was real excitement in the air. If you had walked in at that moment, you would have confidently predicted a couple of successful launches. And yet… these launches slipped.

It didn’t happen all at once. First, a small delay in a review. Then a meeting got pushed out. A dependency that seemed “almost ready” turned out not to be ready at all. One team was waiting on another, and that team, in turn, was waiting on someone else. Before long, what had started as well planned initiatives turned into a series of urgent follow-ups, escalations, and frustration.

What struck me most was this: no one lacked talent, and no one wasn’t working hard. The failure wasn’t about capability. It was about something much quieter and far more dangerous…….unmanaged dependencies.

In smaller companies, this problem is easier to avoid. Decisions happen quickly, often made by a single founder or a small group of leaders. Teams are lean, and the same people who define the problem often see it through to completion. Dependencies still exist, but they are visible, human, and manageable. If something is blocked, everyone knows about it almost immediately, and adjustments happen quickly. The feedback loop is tight, and the risk is contained.

But as organizations grow, so does complexity. What used to be a simple flow, from idea to execution, turns into a chain of handoffs. Product defines the “what,” design shapes the experience, engineering builds it, QA tests it, DevOps deploys it, and along the way, legal, finance, content, and other teams may also get involved. No single person owns the entire journey anymore. Instead, execution depends on how well these teams coordinate with each other. And that’s where things start to break down.

Without a clear operating model and a strong way to track and manage dependencies, teams begin to work in silos. Each team focuses on its own deliverables, assuming that everything else will fall into place. Progress is reported optimistically, but risks remain hidden until it’s too late. Eventually, you start hearing the same familiar line: “We have done everything on our end, but we are blocked by another team.”

On the surface, that sounds reasonable. But when every team is saying it, it points to a deeper issue. It means the system itself is not working.

One of the most challenging aspects of dependencies is that they rarely fail loudly. They fail quietly, almost politely. A review gets postponed. A requirement remains unclear. A deliverable is “in progress” just a little longer than expected. Nothing feels urgent in the moment, so it doesn’t get escalated. But over time, these small slips compound. By the time the impact becomes visible, the situation is already critical. Deadlines are missed, launch dates shift, and trust between teams begins to erode.

I have seen this play out in both small and large organizations. In smaller teams, you might lose a few weeks before the issue becomes visible. In larger enterprises, the problem becomes even harder to detect. Dependencies spread across teams, tools, systems, and time zones. They get buried in JIRA, Asana or Trello tickets, scattered across calendars, and diluted across layers of communication. They don’t become less severe, they just become harder to see.

Take a simple example. Your team is ready to launch an A/B test. Everything is built, tested, and ready to go. You assumed that the experimentation platform team would support your test when you needed it. But it turns out that team is already running multiple experiments and doesn’t have the capacity to take yours on. No one flagged it early, no one anticipated it, and now your launch is blocked. What seemed like a minor assumption quietly becomes a major delay, impacting not just one feature, but potentially a significant portion of your roadmap.

This is why, in my experience, unmanaged dependencies are the single most consistent reason why even the best companies struggle to execute. It’s not technical difficulty. It’s not lack of talent. It’s the invisible gaps between teams.

What is encouraging, though, is that this is starting to change. One of the most powerful shifts I have seen with GenAI is the move from simply tracking dependencies to actively forecasting them. Instead of asking AI, “What are our dependencies?” teams are beginning to ask better questions like “Which dependency is most likely to surprise us?” “Which team is likely to become a bottleneck based on past data?” “What should we be watching closely in the next few weeks?”

This shift changes the entire tone of planning. Conversations move away from debating optimistic timelines and toward understanding risk and building resilience.

This is where AI plays a transformative role. AI is uniquely good at something humans struggle with at scale, it can reason across both time and structure. It can look at historical patterns and identify where delays typically occur. It can spot patterns in scheduling mismatches, highlight recurring bottlenecks, and even identify situations where one team consistently absorbs the impact of another team’s delays. Traditional tools (like JIRA, Asana, Planview PPM) show you connections between Features, Epics, and their relevant User Stories/Tasks. However, AI takes this further and it helps you understand the consequences of those connections.

And when teams start working this way, something interesting happens. Conversations become calmer and happen earlier. Risks feel less like surprises. Escalations decrease. Instead of reacting to problems at the last minute, teams begin to anticipate them and adjust ahead of time. The culture shifts from blame to problem-solving, from urgency to clarity.

In the end, execution doesn’t fail because people aren’t capable or committed. It fails because the space between teams is left unmanaged. When that space is made visible, when dependencies are not just tracked but understood and anticipated, everything changes. Teams move faster, with more confidence, and with far less friction. And that’s the real unlock: not just building great things, but building the systems that allow great teams to deliver them, consistently and predictably.

AI is Breaking the Illusion of Engineering Velocity

18 Jun

For most of my career, I have been deeply involved in guiding product, engineering, design, and program teams to accelerate their growth through a data driven approach. If I look back, a big part of my role was helping teams understand how fast they were moving and where they were getting stuck. I worked with multiple teams and workstreams, tracking their velocity, reviewing pull request timelines, and connecting code check-ins to actual feature releases. The goal was always the same, to figure out where things were slowing down and what was getting in the way.

Over time, I built frameworks around common product and engineering operational metrics from story points, sprint burndowns, capacity charts, to PR cycle times, and more. These frameworks weren’t just about tracking numbers; they were used to drive conversations and actions. At the leadership level, especially with Executive Leadership Teams (XLT) and the C-suite, these metrics helped tell a story that progress was happening and that teams were moving in the right direction. I have seen this play out repeatedly across large organizations like Amazon, Facebook, GE, Schneider, etc. The scale varied, the tools were different, but the pattern remained the same.

Then AI entered the picture, and it started changing this dynamic in a very profound way. For the first time, the gaps between what teams reported and what was actually happening became much harder to ignore. Earlier, it was possible for teams to highlight improvements in velocity while delivery timelines kept slipping in the background. Dependencies would quietly pile up, and engineers would feel the pressure, but those signals often stayed hidden beneath layers of reporting. Now, with AI, these patterns don’t need someone to escalate them, they become visible on their own.

To put this into perspective, think about smaller, leaner organizations. In a team of 5 within a company of 50, if something slows down, everyone feels it immediately. There is no insulation, no layers to absorb the problem. The impact is direct and visible. But in large enterprises, those same problems are often diffused across multiple layers, making them harder to detect. AI removes that insulation. It surfaces patterns in a way that makes them almost impossible to overlook.

At its core, this change forces us to rethink what “flow” really means.Flow is not about how fast a team completes tasks. It’s about how smoothly work moves from an idea to actual impact. When you start looking closely, most flow problems are not caused by individuals. They come from the system itself. For example, there could be too many handoffs, too many approvals, too many hidden queues, etc. These issues build up slowly and are spread across teams and processes, which makes them very hard for humans to detect. We tend to focus on what is visible in front of us, but these problems live in the connections between steps.

This is where AI becomes incredibly powerful. AI is exceptionally good at spotting patterns that are distributed and slow-moving. Even at a tech giant like Amazon, I have seen AI uncover insights that would have taken months to identify manually. For example, it could highlight that a certain type of work consistently spends more time waiting than actually being built. Or that specific dependencies only create delays when they interact with quarterly planning cycles. These are not patterns that a single program manager could reliably detect on their own, especially at scale. But once AI is fed historical data, like cycle times, it can surface these insights almost instantly.

The real breakthrough, however, happens when teams change how they use AI. Thus, instead of using AI to simply track performance metrics like velocity or PR turnaround time, you should shift your focus on understanding behavior. Instead of asking, “How fast are we going?” or “What is our average velocity?”, leaders should start asking, “Why does work slow down?”, “Where exactly is it slowing down?”, and “What are the real bottlenecks in our system?”

When these answers are connected back to the data from tools like JIRA, Asana, Trello, or Monday.com, something interesting happens. Conversations change. I have seen this firsthand at Amazon. Within a single quarter, meetings evolved from being about defending estimates to being about removing friction. The tone changed from justification to problem-solving.

To make this more practical, I built an AI agent to bring this idea to life. My AI agent pulled in team data like JIRA movements, PR merges, review times, etc., and translated it into simple, plain-language insights about what was slowing teams down. Instead of showing a chart, it told a story. For example, it could say, “Work slowed because reviews were clustered toward the end of the sprint.” That single sentence made the problem feel real and actionable.

And the response from teams was immediate. Engineers started breaking their work into smaller pieces. They updated JIRA more consistently. They distributed reviews more evenly instead of letting them pile up at the end of the sprint. As a result, more work was completed within the sprint itself. What is important here is that the underlying data was not new, it was always there. But presenting it as a clear explanation, rather than a metric, drove faster behavioral change. A velocity chart alone would not have created that shift in such a short time.

This is why I strongly believe that AI accelerates speed in a very different way than traditional tools. It doesn’t just help teams move faster, it helps them see the truth earlier. And in engineering systems, that matters a lot. These systems rarely fail in obvious ways. They don’t break loudly. Instead, they degrade slowly and quietly over time.

AI brings that quiet degradation to the surface before it turns into a major problem. And that, more than anything else, is where its real power lies.

How AI Transforms Program Management: From Reporting to Strategic Partnership

20 May

Early in my career at a couple of Fortune 500s, program management excellence often meant one thing: being able to produce a clean, defensible status report. Green boxes built credibility. Red ones triggered escalation. The irony was that by the time something turned red, everyone already felt the pain, the report simply made it official.

Fast forward to today, use of AI often exposes an uncomfortable truth: much of what we call program management has been information movement, not decision support. Startups figured this out long ago. They don’t have the luxury of formal status cycles; they rely on shared situational awareness. AI finally allows large organizations to do the same without collapsing under scale.

What changes is not visibility, but interpretation. AI is extremely good at synthesizing fragmented signals into a coherent story. That’s something PMOs have historically tried to do manually, often under time pressure and political constraints.

In most of these big tech giants, I have often seen programs where risk doesn’t emerge explosively, it creeps. A dependency slips a sprint. A scope assumption quietly changes. A team compensates heroically. None of this is “red,” but all of it matters. AI excels at spotting these slow burn patterns precisely because it doesn’t get tired, defensive, or distracted by hierarchy.

Thus, I have been extensively using AI into my day-to-day activities by replacing weekly status decks with weekly sense‑making narratives. Instead of asking teams to explain why something is red or green, I have been using Rovo and Cursor to ask questions like: What’s drifting from plan but not yet obvious? What commitments are most vulnerable if nothing changes? These questions provoke far better conversations, provide helpful insights to the leadership team, and help the core project team to maneuver challenges.

The practical change required to implement this workflow is surprisingly small. You just need to enable Rovo agent in JIRA, work with your teams to fix JIRA hygiene challenges, and connect Cursor with your Atlassian suite. Once you do the groundwork, you can then feed AI your existing artifacts like Jira updates, roadmap changes, sprint notes, and ask it to generate insights rather than summaries. You can then review these insights and share it with your teams. This workflow and its visibility will fundamentally change how your teams operate. Over time, teams will stop optimizing for optics and start optimizing for coherence.

So, I strongly believe that AI won’t make program managers irrelevant, but it will make them more like strategists and less like couriers. The PMO of the future won’t be judged by how accurate its reports are, but by how early it helps leaders see reality and help them win through data driven decision making.