DEV Community

전규현 (Jeon gyuhyeon)
전규현 (Jeon gyuhyeon)

Posted on

Why Excel WBS Fails: The Limits of File-Based Collaboration

#projectmanagement #excelalternative #realtimecollaboration #wbs

If you're a software engineer, you know CAP theorem for distributed systems. Consistency, Availability, Partition tolerance - the principle that you can't satisfy all three simultaneously.

Surprisingly, the exact same problem occurs in Excel WBS management.

Conversations repeated every morning:

  • "Didn't you receive the file I sent yesterday?"
  • "The version I modified is the latest?"
  • "Oh, did you overwrite that?"

One day, in an important milestone meeting, we discovered that the PM, development team lead, and QA team lead were all looking at different versions of the WBS. That moment, I realized.

Excel is perfect when used alone, but a disaster when used as a team.

Fundamental Limits of File-Based Systems

Race Condition: Who's First?

If you've worked with databases, you know Race Condition. A problem that occurs when two processes try to modify the same data simultaneously. This happens daily in Excel.

A real incident:

09:00 - Team Lead Kim opens WBS.xlsx and starts modifying schedule
09:05 - Assistant Park also opens the same file and starts changing assignee
09:30 - Team Lead Kim saves (30 minutes of work)
09:35 - Assistant Park saves (Team Lead Kim's 30 minutes of work disappears)
09:40 - Team Lead Kim: "Huh? Why is my edit gone?"
Enter fullscreen mode Exit fullscreen mode

If it were a database, it would be solved with code like this:

-- Database transaction processing
BEGIN TRANSACTION;
SELECT * FROM tasks WHERE id = 1 FOR UPDATE;  -- Acquire lock
UPDATE tasks SET start_date = '2024-01-15' WHERE id = 1;
COMMIT;  -- Others can now modify
Enter fullscreen mode Exit fullscreen mode

But Excel? Last Writer Wins. The person who saves last wins. The previous person's work disappears without a trace.

The Version Control Nightmare

Developers using Git don't know how blessed they are. Let me show you the reality of Excel version control:

project_WBS.xlsx
project_WBS_v2.xlsx
project_WBS_v2_final.xlsx
project_WBS_v2_final_reallyfinal.xlsx
project_WBS_v2_final_reallyfinal_modified.xlsx
project_WBS_v2_final_reallyfinal_modified_TeamLeadKimReviewed.xlsx
project_WBS_v2_final_reallyfinal_modified_TeamLeadKimReviewed_AssistantParkModified.xlsx
Enter fullscreen mode Exit fullscreen mode

Think this is an exaggeration? Open your project folder right now.

If it were Git, it would have been this clean:

git log --oneline
f3d2a1b Assistant Park: Changed assignee
e4c5b6a Team Lead Kim: Adjusted schedule
a1b2c3d Manager Lee: Added new task
Enter fullscreen mode Exit fullscreen mode

The Scalability Wall: O(n²) Complexity

As teams grow, file sharing complexity increases exponentially. Why?

def calculate_communication_overhead(team_size):
    """Communication complexity by team size"""

    # Number of file sharing paths between all team members
    paths = team_size * (team_size - 1) / 2

    # Possible conflicts per path
    conflicts_per_path = 3  # On average

    total_complexity = paths * conflicts_per_path

    print(f"Team of {team_size}:")
    print(f"  - Communication paths: {paths}")
    print(f"  - Potential conflicts: {total_complexity} cases/day")

    return total_complexity

# Actual calculation
calculate_communication_overhead(5)   # Team of 5: 10 paths, 30 conflicts
calculate_communication_overhead(10)  # Team of 10: 45 paths, 135 conflicts
calculate_communication_overhead(20)  # Team of 20: 190 paths, 570 conflicts!
Enter fullscreen mode Exit fullscreen mode

More than 20 people? You'll spend the whole day just managing files.

7 Reasons Excel Makes Our Lives Hard

1. Impossible Simultaneous Editing

Monday morning, sprint planning meeting. 10 people gather to update WBS.

Excel way:

PM Kim: "I'll share my screen. If you have anything to modify, please tell me."
Developer Park: "Change task 3 assignee to me..."
PM Kim: (typing)
QA Lee: "Oh, task 5 date too..."
PM Kim: "Wait, one at a time please"
(1 hour later)
Team Lead Choi: "Please send this file later"
Enter fullscreen mode Exit fullscreen mode

Google Docs/Modern tool way:

(Everyone editing simultaneously)
PM Kim: "Everyone update your own tasks"
(10 minutes later)
PM Kim: "All done. Next agenda..."
Enter fullscreen mode Exit fullscreen mode

Feel the time difference? This repeats every week, every day.

2. Version Conflict Hell

A real terrible incident:

class ExcelVersionHell:
    """The actual horror of Excel version control"""

    def monday_morning_disaster(self):
        """Monday morning disaster"""

        # Friday evening
        friday_evening = {
            "Team Lead Kim": "Wrote WBS_final.xlsx and left",
            "Assistant Park": "Downloaded WBS_final.xlsx at home"
        }

        # Weekend
        weekend = {
            "Assistant Park": "Extensively modified WBS_final.xlsx over weekend",
            "Manager Lee": "Slightly modified WBS_final.xlsx received Saturday"
        }

        # Monday morning
        monday_morning = {
            "09:00": "Team Lead Kim: Opens WBS_final.xlsx",
            "09:05": "Assistant Park: Sends WBS_final_weekendmodified.xlsx email",
            "09:10": "Manager Lee: Sends WBS_final_reviewed.xlsx email",
            "09:15": "Team Lead Kim: ????? Which one is latest?",
            "09:30": "Full meeting: Starts manual merge of 3 versions",
            "11:00": "Finally merge complete... morning is gone"
        }

        return "Zero productivity morning"
Enter fullscreen mode Exit fullscreen mode

3. Formula Hell and #REF! Error Party

Excel formulas are powerful, but they're time bombs in collaboration:

=SUMIF(Sheet2!C:C,A2,Sheet2!D:D)
=VLOOKUP(B2,'Assignees'!A:F,3,FALSE)
=IF(D2="Done",E2-F2,IF(D2="In Progress",TODAY()-F2,""))

# When someone deletes a row...
#REF! #REF! #REF! #REF! #REF!
Enter fullscreen mode Exit fullscreen mode

Time to fix one broken formula: Average 30 minutes.
Formula errors per month: Average 12 cases.
Annual wasted time: 72 hours (9 days!)

4. Email Bomb

What my actual inbox looked like:

📧 [09:00] Latest WBS version
📧 [09:30] Re: Latest WBS version (modified)
📧 [10:00] Re: Re: Latest WBS version (additional modification)
📧 [10:30] Urgent: WBS modified version (important)
📧 [11:00] Re: Urgent: WBS modified version (error fix)
📧 [14:00] WBS afternoon version
📧 [15:00] WBS final (really)
📧 [16:00] WBS final_modified
📧 [17:00] WBS for tomorrow's meeting
📧 [17:30] Re: WBS for tomorrow's meeting (date changed)
Enter fullscreen mode Exit fullscreen mode

Average WBS-related emails per day: 15
Per week: 75
Per month: 300

Just finding emails takes 30 minutes per day.

5. Impossible History Tracking

When something goes wrong:

// If it were Git
git blame tasks.js
// "Oh, Developer Kim modified this part 3 days ago"
git diff HEAD~3
// "I see why it was changed"

// In Excel
"Who changed this?"
"Not sure..."
"When was it changed?"
"Don't know..."
"Why was it changed?"
"......"
Enter fullscreen mode Exit fullscreen mode

6. Automation? What's That?

Creating burndown chart every Friday:

def friday_burndown_ritual():
    """Friday ritual"""

    tasks = [
        "1. Open Excel (1 min)",
        "2. Select data range (2 min)",
        "3. Insert > Chart (1 min)",
        "4. Choose chart type (1 min)",
        "5. Modify axis labels (3 min)",
        "6. Adjust colors (5 min)",
        "7. Add title (1 min)",
        "8. Adjust legend (2 min)",
        "9. Copy to PowerPoint (2 min)",
        "10. Write email (5 min)"
    ]

    total_time = 23  # minutes
    weeks_per_year = 52

    yearly_waste = total_time * weeks_per_year / 60  # hours
    print(f"Spend {yearly_waste:.0f} hours per year on chart creation")
    print("Could have developed 3 new features in this time...")
Enter fullscreen mode Exit fullscreen mode

7. Mobile? Don't Even Dream About It

When you urgently need to check WBS while traveling:

Me: "Please send WBS file"
Colleague: "Check email"
Me: (Download xlsx file on phone)
Phone: "No app to open this file"
Me: (Download Excel app)
Phone: (Spreadsheet with ant-sized text on screen)
Me: "Can't see..."
Me: "Have to wait until I can turn on laptop"
Enter fullscreen mode Exit fullscreen mode

Transition to Modern Tools: The Magic of Real-Time Collaboration

The Future Google Docs Showed

Remember when you first used Google Docs? That moment when you saw multiple people's cursors moving simultaneously and exclaimed "Wow, this works?"

The core of that technology is CRDT (Conflict-free Replicated Data Types):

// Principle of CRDT-based real-time synchronization
class RealtimeWBS {
  constructor() {
    this.state = new YMap(); // Yjs CRDT implementation
    this.awareness = new Awareness(); // User state tracking
  }

  updateTask(taskId, changes) {
    // 1. Immediately reflect locally (0ms)
    this.state.get(taskId).set(changes);

    // 2. Automatically propagate to other users
    // 3. Auto-merge on conflict (algorithm handles)
    // 4. All clients guaranteed same state
  }

  onRemoteChange(event) {
    // Receive other users' changes in real-time
    const cursor = event.user.cursor;
    const changes = event.changes;

    // Immediately reflect in UI
    this.updateUI(changes);
    this.showUserCursor(event.user);
  }
}
Enter fullscreen mode Exit fullscreen mode

Now WBS management can work this way too.

Actual Collaboration Scenario

Monday morning sprint planning, now it's like this:

09:00 - Entire team accesses WBS via web browser
09:01 - Everyone starts updating their own tasks simultaneously
       - PM Kim: Adding new milestone
       - Developer Park: Modifying task hours
       - QA Lee: Adjusting test schedule
       - Designer Choi: Adding design tasks
09:05 - All modifications complete
09:06 - Check auto-generated Gantt chart
09:07 - "Looks good, let's proceed"
Enter fullscreen mode Exit fullscreen mode

5 minutes. What took 1 hour in Excel takes 5 minutes.

Changes in Numbers

Before/after comparison from actual Company A:

def roi_calculation():
    """Return on investment calculation"""

    # Before: Excel era
    excel_era = {
        "version_conflict_resolution": 10,  # hours/week
        "file_finding": 5,        # hours/week
        "manual_update": 8,    # hours/week
        "email_management": 3,      # hours/week
        "chart_creation": 2,        # hours/week
        "total_waste": 28          # hours/week
    }

    # After: Modern tool era
    modern_era = {
        "version_conflict_resolution": 0,   # Auto-merge
        "file_finding": 0,        # Cloud
        "manual_update": 0,    # Automation
        "email_management": 0.5,    # Mostly unnecessary
        "chart_creation": 0,        # Real-time generation
        "total_waste": 0.5         # hours/week
    }

    # Savings
    weekly_saving = excel_era["total_waste"] - modern_era["total_waste"]
    monthly_saving = weekly_saving * 4
    yearly_saving = weekly_saving * 52

    # Convert to money (assuming $50/hour)
    yearly_money = yearly_saving * 50

    print(f"Weekly savings: {weekly_saving} hours")
    print(f"Monthly savings: {monthly_saving} hours")
    print(f"Yearly savings: {yearly_saving} hours")
    print(f"Yearly savings: ${yearly_money:,}")

    return yearly_saving

# Result: 1,430 hours per year, $71,500 savings
Enter fullscreen mode Exit fullscreen mode

Today is the Time to Transition

You've heard this, right? "We've always done it this way..."

The moment this comes out, your team is already falling behind.

Excel is a great tool. But only when used alone. If you work as a team, you need tools for teams.

You can hammer a screw. But if you have a screwdriver, why would you?

Start Small

No need to be grand. Just start one next project with modern tools.

After 2 weeks, your team will say:
"We never want to go back to Excel."

Change is hard, but not changing is more dangerous.

Want to experience real-time collaborative WBS? Start at Plexo.

Top comments (0)