Redesign the Work, Then Invest in Your People

You’ve got a slow, buggy codebase. Your team is burned out. The usual fix? Throw more people at the problem, or hire a consultant to “inject agility.” But here’s the uncomfortable truth: investing in your people before redesigning their work is like buying faster horses before realizing the cart has square wheels. In this article, you’ll learn a surprisingly effective two-step approach: first redesign the work itself to eliminate waste and frustration, then invest in your people to make them more effective. We’ll demystify concepts like process mapping, flow efficiency, and automation—showing you exactly how to apply them with concrete code and real-world analogies.

Start by Mapping the Mess

You can’t fix what you can’t see. Process mapping is the practice of drawing out every step a piece of work takes—from idea to deployment. Think of it like a food delivery app’s delivery route: if you don’t map the driver’s stops, you won’t spot the ten-minute detour to pick up a missing order.

Under the hood, process mapping reveals bottlenecks, handoffs, and waiting times. Here’s a raw example:

# A simple process map as a list of steps
steps = [
    "Design received from UX",
    "Code implementation",
    "Code review (3-day average wait)",
    "QA testing",
    "Deployment"
]
# The bottleneck is 'Code review'—waiting eats time

Notice how Code review appears as a waiting step, not actual work. That’s the insight: most teams invest in working harder at the implementation step, but it’s the waiting that kills productivity.

The analogy: Imagine a restaurant kitchen where the chef waits for the waiter to bring dirty plates before cooking the next course. Would you train the chef to chop faster? No—you’d redesign the work so plates arrive before the chef needs them.

Non-obvious insight: Process mapping often reveals that 60-80% of time is waiting, not working. Fixing that waiting costs nothing but thought.

Measure Flow Efficiency

Flow efficiency measures how much time work actually gets worked on versus how much it’s waiting. If a task takes 5 days from start to finish but only 2 hours of active work, your flow efficiency is (2 hours / 120 hours) = 1.67%. That’s terrible.

Now, a code example: let’s track a feature request through your system:

def flow_efficiency(active_work_time, total_cycle_time):
    # active_work_time is the sum of all working hours
    # total_cycle_time is days * 8 hours
    return (active_work_time / total_cycle_time) * 100

# Example: 2 hours work, 5-day cycle = 40 total hours
efficiency = flow_efficiency(2, 40)
print(f"Flow efficiency: {efficiency:.1f}%")
# Output: Flow efficiency: 5.0%

The analogy: Imagine you’re paid to fold laundry, but you spend 95% of your shift waiting for the dryer to finish. Would you invest in ironing training? No—redesign the work so you have a continuous flow of dry laundry.

Non-obvious insight: Improving flow efficiency often means reducing the number of people involved. Fewer handoffs = less waiting. Counterintuitive, but true.

Automate the Boring Stuff

Automation isn’t about writing scripts for fun. It’s about replacing predictable, error-prone human steps with machines. Think of it like a checkout lane in a grocery store: scanning a barcode is faster and less error-prone than typing prices by hand.

Here’s a concrete example: instead of manually deploying code, you can automate the test run and deployment:

# Before automation: manual steps
# 1. Run tests locally (forget? broken build)
# 2. Zip files (wrong ones? deploy old code)
# 3. Upload to server (typo in path? crash)

# After automation (pseudocode for a CI/CD pipeline)
pipeline:
  trigger: git push
  steps:
    - run: pytest tests/    # fail early if tests break
    - build: docker build -t app .
    - deploy: kubectl apply -f deployment.yaml

The analogy: You wouldn’t wash each dish by hand when you have a dishwasher available. Automation is your dishwasher for software tasks—less effort, fewer mistakes.

Non-obvious insight: Automation shouldn’t replace humans in every step. The value is in removing repetitive, predictable tasks so people can focus on unpredictable, judgment-heavy ones (like designing features or handling customer edge cases).

Invest in Your People (Wisely)

Only after you’ve redesigned the work should you invest in your people. This means training them in new workflows, tools, and skills—not just doing the same old things faster.

Define: Investment in people is any activity that increases their capacity to produce quality work: training, mentoring, tooling, time for experimentation. But invest after you’ve removed wasteful friction.

The mechanism: Without redesigning first, training is like teaching a race car driver to shift gears faster while the car still has a flat tire. You’re solving the wrong problem.

Code example:

# Before redesign: people spend 80% time on manual steps
# After redesign: same people now spend 80% on creative work

# Scenario: deploying a microservice
# Redesign (automation) + investment (learn Docker, CI/CD)
# Result: deploy time drops from 2 hours to 5 minutes
# Team morale improves because they're solving real problems

The analogy: Imagine you’re a gardener. You can spend money on better seeds and fertilizer (investing in people), but if the soil is full of rocks (bad processes), the plants won’t grow. First remove the rocks. Then invest.

Non-obvious insight: Many “good” teams fail because they invest in people but ignore process. The best teams do both—but process first.

Comparison Table: Three Key Concepts

How they relate: Process mapping shows where waste is. Flow efficiency measures how bad the waste is. Automation removes the waste. Then, and only then, do you invest in people to shine in the streamlined system.

Key Takeaways

• Redesign first: Map your work’s actual path, measure flow efficiency, and remove waiting.
• Automate wisely: Replace predictable, error-prone steps with machines—but keep judgment-heavy steps for humans.
• Invest second: After the system is efficient, train people in new workflows and tools.
• Measure relentlessly: Use flow efficiency as a dashboard for process health.
• Avoid the trap: Don’t invest in people when the problem is a broken process. Fix the process first.