Coordination, Leadership & Org Dependencies in Projects

TAKEAWAYS:

• Coordination bridges gaps between project teams and external stakeholders using tools like RACI matrices and communication plans.
• Leadership styles (autocratic, democratic, laissez-faire) impact team performance—choose based on project urgency and team expertise.
• Organizational dependencies (internal vs. external) require clear contracts, SLAs, and buffer management to avoid delays.
• Conflict resolution techniques (collaborating, compromising, forcing) depend on the situation’s urgency and importance.
• Agile coordination relies on daily standups, sprint planning, and cross-functional teams to adapt to changing dependencies.
• Case studies (eSewa’s API integrations, Daraz’s vendor coordination) show how real projects handle dependencies in practice.

Core Concepts: Coordination in Projects

Coordination ensures that all project activities, teams, and stakeholders work harmoniously to meet deadlines and quality standards. Poor coordination leads to:

• Delays (e.g., a bank’s loan processing system failing due to misaligned IT and finance teams).
• Budget overruns (e.g., NTC’s fiber-optic project delays costing millions in penalties).
• Quality issues (e.g., Pathao’s driver-app mismatch causing customer complaints).

Types of Coordination Dependencies

Dependencies are relationships where one task or team cannot proceed without another. They are classified into:

mindmap
  root((Coordination Dependencies))
    Internal
      Task Dependencies
        Finish-to-Start (FS)
        Start-to-Start (SS)
        Finish-to-Finish (FF)
        Start-to-Finish (SF)
      Resource Dependencies
        Shared Resources (e.g., developers, servers)
        Limited Resources (e.g., testers, budget)
    External
      Organizational Dependencies
        Vendor Dependencies (e.g., Daraz relying on third-party logistics)
        Stakeholder Dependencies (e.g., NEPSE requiring regulatory approvals)
      Inter-Project Dependencies
        Shared Teams (e.g., IT team working on multiple bank projects)
        Shared Infrastructure (e.g., cloud services like AWS)

Key Definitions:

How Coordination Works: Tools and Techniques

1. RACI Matrix

   • Assigns roles to team members for each task:
     • Responsible (does the work)
     • Accountable (owns the outcome)
     • Consulted (provides input)
     • Informed (kept updated)
   • Example: In a Khalti payment integration project, the RACI might look like this:

     Task: API Integration
     Developer (R), Project Manager (A), Security Team (C), Finance (I)
     

2. Communication Plans

   • Defines who communicates what, when, and how (meetings, emails, tools like Slack/Teams).
   • Example: NTC’s fiber-optic project uses weekly syncs between civil engineers and IT teams to avoid misalignment.

3. Dependency Mapping

   • Visualizes dependencies using Gantt charts or precedence diagrams.
   • Example: For eSewa’s new feature rollout, dependencies might include:
     • Backend development → API testing → Frontend integration → UAT.

A Gantt chart showing task dependencies in a software project (e.g., coding → testing → deployment). (Image: Dbsheajr at English Wikipedia, CC BY-SA 3.0, via Wikimedia Commons)

Leadership Styles in Project Management

Leadership directly impacts team motivation, decision-making speed, and project success. Three primary styles:

classDiagram
  class LeadershipStyle {
    +Name: String
    +Description: String
    +BestFor: String[]
    +Risks: String[]
  }
  LeadershipStyle <|-- Autocratic
  LeadershipStyle <|-- Democratic
  LeadershipStyle <|-- LaissezFaire
  Autocratic : +Name = "Autocratic" +Description = "Leader makes decisions alone" +BestFor = ["Crises", "Tight deadlines"] +Risks = ["Low team morale", "High turnover"]
  Democratic : +Name = "Democratic" +Description = "Team input in decisions" +BestFor = ["Creative projects", "Long-term teams"] +Risks = ["Slower decisions", "Conflict if unmanaged"]
  LaissezFaire : +Name = "Laissez-Faire" +Description = "Hands-off approach" +BestFor = ["Experienced teams", "Innovative work"] +Risks = ["Lack of direction", "Poor accountability"]

When to Use Which Style?

Worked Example: Scenario: A bank is launching a new mobile loan approval system with a 3-month deadline.

• Autocratic: The PM makes all decisions quickly but risks developer burnout.
• Democratic: The team suggests a two-week sprint cycle, improving buy-in but slowing initial progress.
• Laissez-Faire: Developers work independently but miss deadlines due to unclear priorities.

Best Choice: Democratic with autocratic phases (e.g., democratic for design, autocratic for final approval).

Organizational Dependencies: Managing External Factors

External dependencies involve third parties, regulations, or other projects. Common types:

1. Vendor Dependencies

   • Example: Pathao relies on Google Maps API for real-time traffic updates.
   • Risk: API changes or downtime disrupts the app.
   • Mitigation: Use Service Level Agreements (SLAs) and backup APIs.

2. Regulatory Dependencies

   • Example: Nepal Rastra Bank (NRB) approvals for a new fintech product.
   • Risk: Delays in compliance can halt the project.
   • Mitigation: Start regulatory discussions early and assign a compliance officer.

3. Inter-Project Dependencies

   • Example: NTC’s fiber project depends on the Ministry of Communications for land permits.
   • Risk: Permit delays cause cost overruns.
   • Mitigation: Include buffer time in the schedule.

Conflict Resolution in Projects

Conflicts arise due to miscommunication, resource clashes, or differing priorities. Use the Thomas-Kilmann Conflict Mode Instrument to choose a strategy:

stateDiagram-v2
  [*] --> ChoosingStrategy
  ChoosingStrategy --> Collaborating : High assertiveness, high cooperation
  ChoosingStrategy --> Compromising : Moderate assertiveness, moderate cooperation
  ChoosingStrategy --> Forcing : High assertiveness, low cooperation
  ChoosingStrategy --> Avoiding : Low assertiveness, low cooperation
  ChoosingStrategy --> Accommodating : Low assertiveness, high cooperation
  Collaborating --> Resolved : Best for win-win situations
  Compromising --> Resolved : Quick but may not satisfy all
  Forcing --> Resolved : Fast but risks resentment
  Avoiding --> Unresolved : Temporary fix, may worsen
  Accommodating --> Resolved : Good for maintaining relationships

Example: Scenario: Two teams in a banking software project are competing for the same QA tester.

• Collaborating: Both teams agree to share the tester for critical phases.
• Compromising: One team gets the tester for first two weeks, the other for the next two.
• Forcing: The PM assigns the tester to the higher-priority team, risking resentment.

Best Approach: Collaborating (if time allows) or compromising (for urgent projects).

In the Real World

1. eSewa’s API Integrations

   • Dependency: eSewa relies on Khalti, IME Pay, and Nabil Bank APIs for payments.
   • Coordination: Uses RACI matrices to assign roles (e.g., Khalti team is Consulted on payment failures).
   • Risk Mitigation: Maintains backup payment gateways to avoid downtime.

2. Daraz’s Vendor Coordination

   • Dependency: Daraz’s third-party logistics (3PL) partners (e.g., DHL, GDS) handle deliveries.
   • Conflict: A vendor delays shipments due to traffic in Kathmandu.
   • Solution: Daraz uses real-time tracking tools and penalty clauses in contracts.

3. NTC’s Fiber-Optic Project

   • Dependency: Civil engineers and IT teams must sync cable laying with network configuration.
   • Tool Used: Gantt charts to show sequential dependencies (e.g., "Cable laid → Network tested").
   • Challenge: Monsoon rains delay fieldwork → buffer time added in the schedule.

4. Nepal Rastra Bank (NRB) Compliance

   • Dependency: Any fintech project (e.g., a new digital wallet) must get NRB approval.
   • Coordination: Projects start regulatory discussions 6 months early to avoid delays.
   • Tool Used: Dependency mapping in project plans to track approval timelines.

5. Pathao’s Driver-App Sync

   • Dependency: Driver availability affects app performance.
   • Conflict: Drivers go offline during peak hours, causing customer complaints.
   • Solution: Pathao uses real-time dashboards to monitor driver status and incentivizes online drivers.

Exam Tip

1. For "Explain leadership styles":

   • Must include: Definitions, pros/cons, and real-world examples (e.g., autocratic for NTC emergencies, democratic for Daraz’s product teams).
   • Avoid: Generic descriptions without project scenarios.

2. For "Classification of coordination dependencies":

   • Structure your answer using a table (like above) with examples from Nepalese companies (e.g., eSewa’s APIs, NTC’s vendors).
   • Key points to cover:
     • Internal vs. external dependencies.
     • Task vs. resource vs. organizational dependencies.
     • Tools used (RACI, Gantt charts, SLAs).

3. Worked Examples:

   • Always tie to a real scenario (e.g., "How would you handle a delay in Khalti’s API for eSewa?").
   • Use visuals (e.g., draw a dependency map for a bank’s loan system).

4. Common Pitfalls:

   • Don’t confuse "coordination" with "communication." Coordination is action-oriented (e.g., assigning tasks via RACI).
   • Don’t forget external dependencies—examiners love questions on vendor/regulatory risks.

Final Checklist Before Exam: ✅ Can you draw a RACI matrix for a given project? ✅ Can you classify dependencies in a real-world example (e.g., Daraz’s logistics)? ✅ Can you match leadership styles to project scenarios (e.g., autocratic for crises)? ✅ Can you resolve a conflict using the Thomas-Kilmann model?