Skip to content

When Underperformance Is Just Invisible Work in Disguise

You look at the sprint board and see, that one of the developers has two tickets carried over from last sprint. Three more are parked stubbornly in In Progress. Looks like he isn't delivering.

It is tempting to treat a red sprint board as an individual character flaw. It gives management an easy target and a tidy narrative.

But jumping to conclusions without digging into the systemic reality is how good leaders destroy great engineers.


The "Ghost" on the Sprint Board

A few years ago, I found myself facing this exact scenario. A senior engineer on my team - someone historically dependable, sharp, and deeply knowledgeable - had been slowly flatlining on the board. Week after week, his sprint commitments dissolved into carryovers. I had to react.

But, when our scheduled 1-on-1 came around, I didn't open Jira. I didn't wave charts or ask why ticket PROJ-412 was running three days late. Instead, I asked one simple diagnostic question:

"Walk me through your week. What is eating your mental bandwidth right now?"

The reaction wasn't defensiveness or excuses. It was a heavy sigh of sheer exhaustion.

The developer wasn't slacking. He was drowning.

He was working 9-hour days, completely drained by 6:00 PM, yet having virtually nothing to show for it on our sprint board. Why? Because his week was dominated by invisible work - a toxic mixture of unlogged side-channel demands and paralyzing ambiguity debt.

He wasn't underperforming. The system was failing him.


The Two Silent Productivity Killers

When delivery collapses despite high effort, it almost always traces back to two systemic killers lurking just outside the view of your issue tracker.

graph LR
    subgraph Visible Delivery
        JIRA[Sprint Board / Tickets] --> SHIPPED[Shipped Features]
    end
    subgraph Invisible Drain
        DM[Drive-by DMs & Side Doors] -.-> DRAIN[Exhaustion & Context Switching]
        AMB[Cryptic, Ambiguous Tickets] -.-> DRAIN
    end
    DRAIN ==>|Cannibalizes| JIRA

Killer 1: The "Side Door" Trap (Drive-by Requests)

When an engineer has deep domain expertise, they become a high-value target for other teams.

Downstream service teams, data pipelines, product managers from adjacent squads - whenever they hit an edge case touching our team's domain, they don't submit a ticket to our backlog. Filing a ticket feels slow, formal, and bureaucratic.

Instead, they slide quietly into the engineer's Slack or Teams DMs:

"Hey, quick question! You know this auth flow inside and out - can you just take a look at why this token validation is failing for our service? Should only take five minutes."

Except it never takes five minutes. It takes thirty minutes of investigation, fifteen minutes of explaining, and an hour to regain deep focus.

Why does the engineer say yes?
Because they care. They want to be helpful, they care about the overall product, and saying "no" feels combative, uncooperative, or obstructionist.

The systemic damage:
Legitimate, company-critical architectural firefighting is being conducted - completely off the books. It is 100% invisible to capacity planning. The engineer burns their mental energy rescuing neighboring teams, and at the end of the sprint, the board brands them an "underperformer" for missing their own assigned commitments.


Killer 2: Ambiguity Debt (The One-Line Jira Ticket)

The second killer is the dreaded stub ticket:

  • PROJ-891: Update auth token validation
  • PROJ-904: Fix data sync discrepancy

Description: empty.
Acceptance criteria: none.
Reproduction steps: none.

How developers respond to ambiguity exposes fundamental differences in cognitive and engineering styles:

  1. The "Cowboy" Coder: Makes quick assumptions, writes twenty lines of code, pushes to staging, and moves the ticket to Done. If it breaks an edge case, they'll fix it later. Their velocity looks phenomenal on the board.
  2. The Meticulous Engineer: Understands the downstream architecture. Knows that changing token validation could inadvertently lock out 5,000 legacy mobile clients. Refuses to push unverified guesses into production.

When handed an ambiguous ticket, the meticulous engineer freezes. They spend three days playing forensic detective: digging through three-year-old Git blame logs, deciphering legacy PR comments, and scheduling alignment calls to discover what product actually intended.

The Management Failure

Mistaking an engineer's requirement for clear specifications as a defect in "seniority" or "autonomy" is lazy leadership. Asking for clarity before modifying high-stakes systems is not a lack of independence; it is engineering maturity.


The Diagnostic Framework: Check the System First

Before questioning an engineer's competence or commitment, audit the operational system they are forced to navigate.

Here is the triage hierarchy every engineering manager should run through when observing stalled work:

graph TD
    A[Observed: Low Delivery / Stalled Tickets] --> B{1. Visibility Audit<br/>Is all work on the board?}
    B -- No: Unlogged DM requests / fires --> B1[Fix: Shield Perimeter & Log Work]
    B -- Yes --> C{2. Clarity Audit<br/>Are requirements & DoD explicit?}
    C -- No: Ambiguous tickets / moving targets --> C1[Fix: Enforce Definition of Ready]
    C -- Yes --> D{3. Environmental Audit<br/>Tooling, CI/CD, Dependencies?}
    D -- Blocked --> D1[Fix: Clear Roadblocks]
    D -- Clear --> E[4. Skill / Will Evaluation<br/>Coaching or Capability Intervention]

To translate this hierarchy into your 1-on-1s, swap your assumptions for systemic questions:

The Diagnostic Matrix

What Shows on the Board The Lazy Manager's Assumption The Systemic Question to Ask
Low story point velocity "They're slow or disengaged." Where is their time actually going? Are other teams using them as an unlogged, private helpdesk?
Stalled tickets / churn in 'In Progress' "They lack technical capability." Are the acceptance criteria clear? Or is the ticket a vague riddle requiring days of guesswork?
Missed sprint commitments "They have poor estimation skills." Did we protect their focus? Or did drive-by emergencies blow up their calendar mid-sprint?
Reluctance to merge / ship "They lack confidence or are perfectionist." Is the Definition of Done crisp? Or do they fear breaking fragile, untested downstream dependencies?

The Tactical Playbook: Debugging the Team's Environment

If your audit reveals invisible work and ambiguity debt, your job isn't to lecture the developer. Your job is to debug the environment.

Action 1: Erect the Perimeter Shield

Enforce one non-negotiable golden rule: If it's not in the backlog, it doesn't exist.

Engineers often hesitate to push back on colleagues because they don't want to look unhelpful. Take that social burden off their shoulders:

  1. Provide a ready-to-use deflection script:
    Give your team an official, polite response template to paste into Slack or Teams:

    "I'd love to help you with this! Since it touches our core domain and impacts ongoing commitments, please pop a quick ticket into our team intake queue so our EM can prioritize it against our sprint capacity."

  2. Act as the social heat shield:
    When external leads complain that your engineer isn't answering their DMs immediately, the manager must step in: "Our team is committed to this sprint's delivery. If your request is urgent, let's look at the priority together and decide what on our board gets dropped to make room." Watch how quickly "urgent" five-minute requests evaporate when a trade-off is required.

  3. Budget for cross-team reality:
    If your team owns a shared core domain that inevitably generates cross-team questions, stop pretending your sprint has 100% feature bandwidth. Allocate an explicit on-call rotation or dedicated support buffer (e.g., 20% capacity) specifically for triaging external inquiries.


Action 2: Eradicate Ambiguity Debt

Never allow a half-baked thought to become an active sprint commitment.

Before a ticket enters a sprint, enforce a strict Definition of Ready (DoR):

  • Context (The Why): What business problem or customer friction does this solve?
  • Acceptance Criteria (The What): Exactly what conditions must be true for this ticket to be marked Done? What are the verifiable inputs and outputs?
  • Explicit Non-Goals (What NOT to touch): What is intentionally out of scope? Defining boundaries prevents meticulous engineers from rabbit-holing into adjacent refactoring.

Precision is not micromanagement. Providing clear constraints gives engineers the psychological safety and clarity they need to move with speed and confidence.


The Resolution & The Takeaway

Returning to that "underperforming" senior engineer from our story:

Once we put the perimeter shield in place, redirected external drive-by requests through a structured queue, and refused to pull tickets into sprints without clear acceptance criteria, something remarkable happened.

Within two sprints, his delivery metrics completely reversed. Stalled tickets vanished. Velocity surged. He was shipping high-impact code calmly and consistently.

We didn't need a performance improvement plan. We didn't need technical remedial coaching. We didn't need disciplinary lectures.

We simply stopped making him fight an invisible war.

The Leadership Test

A mediocre manager looks at missed deliverables and asks:
"Why isn't this person working hard enough?"

A great engineering leader looks at the board and asks:
"What in our system is preventing this talented person from succeeding?"

Before you grade an engineer on their output, make sure you haven't forced them to take an invisible exam.


Share on Share on Share on