Multi-Project Resource Allocation

Organizations rarely run a single project. They run portfolios of projects competing for the same limited resources: people, budget, equipment, and time.

Why Resource Allocation Is Hard

Without systematic allocation:

• Critical projects lack resources
• Low-priority projects consume scarce talent
• Resource conflicts cause delays across all projects
• Overloaded employees burn out and quit

A 10% improvement in resource allocation efficiency can increase portfolio throughput by 25% or more.

What Is Multi-Project Resource Allocation?

The problem: given a set of projects with resource requirements and a pool of limited resources, assign resources to projects to maximize total value.

| Resource Type | Example | Typical Constraint | |---------------|---------|:------------------:| | People | Engineers, designers | Max 10 engineers available | | Budget | Capital, operational | $500K total budget | | Equipment | Servers, lab space | 20 server rack units | | Time | Project deadlines | All projects done in 6 months |

How to Model Resource Allocation

Problem Setup

A consulting firm has 3 projects and 4 types of consultants. Each project needs specific hours from each consultant type.

import pulp

# Projects
projects = ["WebApp", "MobileApp", "DataPlatform"]

# Consultant types
roles = ["Senior", "Mid", "Junior", "Designer"]

# Available hours per consultant type (per month)
available = {"Senior": 160, "Mid": 320, "Junior": 480, "Designer": 160}

# Hours needed per project per role
# (project, role): hours needed
hours_needed = {
    ("WebApp", "Senior"): 80,
    ("WebApp", "Mid"): 160,
    ("WebApp", "Junior"): 240,
    ("WebApp", "Designer"): 40,
    ("MobileApp", "Senior"): 120,
    ("MobileApp", "Mid"): 80,
    ("MobileApp", "Junior"): 160,
    ("MobileApp", "Designer"): 80,
    ("DataPlatform", "Senior"): 160,
    ("DataPlatform", "Mid"): 240,
    ("DataPlatform", "Junior"): 80,
    ("DataPlatform", "Designer"): 40,
}

# Revenue per project
revenue = {"WebApp": 200000, "MobileApp": 250000, "DataPlatform": 300000}

# Cost per hour per role
cost = {"Senior": 150, "Mid": 100, "Junior": 60, "Designer": 120}

# Create problem
prob = pulp.LpProblem("Resource_Allocation", pulp.LpMaximize)

# Decision variables: hours of each role assigned to each project
x = {}
for p in projects:
    for r in roles:
        x[(p, r)] = pulp.LpVariable(f"x_{p}_{r}", lowBound=0)

# Whether each project is selected (binary)
selected = {}
for p in projects:
    selected[p] = pulp.LpVariable(f"selected_{p}", cat="Binary")

# Objective: maximize profit (revenue - cost)
prob += pulp.lpSum(
    revenue[p] * selected[p] - pulp.lpSum(cost[r] * x[(p, r)] for r in roles)
    for p in projects
), "Maximize_Profit"

# Constraint 1: Resource availability
for r in roles:
    prob += pulp.lpSum(x[(p, r)] for p in projects) <= available[r], f"Resource_{r}"

# Constraint 2: Link selection to hours
M = 10000  # Large number
for p in projects:
    prob += pulp.lpSum(x[(p, r)] for r in roles) <= M * selected[p], f"Select_{p}"
    prob += pulp.lpSum(x[(p, r)] for r in roles) >= hours_needed[(p, r)] * selected[p], f"MinHours_{p}"

# Constraint 3: At most 2 projects selected
prob += pulp.lpSum(selected[p] for p in projects) <= 2, "Max_Projects"

# Solve
prob.solve()

print(f"Status: {pulp.LpStatus[prob.status]}")
print(f"Total Profit: ${pulp.value(prob.objective):,.0f}")
print()

for p in projects:
    if pulp.value(selected[p]) == 1:
        print(f"{p}: SELECTED")
        total_hours = sum(pulp.value(x[(p, r)]) for r in roles)
        total_cost = sum(pulp.value(x[(p, r)]) * cost[r] for r in roles)
        print(f"  Hours: {total_hours:.0f}, Cost: ${total_cost:.0f}")
        for r in roles:
            h = pulp.value(x[(p, r)])
            if h and h > 0:
                print(f"    {r}: {h:.0f} hrs")

Advanced Constraints

Minimum Resource Utilization

# Each selected project must use at least 50% of its requested hours
for p in projects:
    total_requested = sum(hours_needed[(p, r)] for r in roles)
    prob += pulp.lpSum(x[(p, r)] for r in roles) >= 0.5 * total_requested * selected[p]

Maximum Allocation per Role

# No single project gets more than 60% of any role
for r in roles:
    for p in projects:
        prob += x[(p, r)] <= 0.6 * available[r]

Phased Allocation

# Months 1-2: focus on WebApp, Months 3-4: focus on MobileApp
# Model with time-phased variables

Real-World Applications

| Industry | Resources | Projects | Typical Size | |----------|-----------|----------|:------------:| | Consulting | Consultants by skill level | Client engagements | 50-200 | | Software | Engineers by specialty | Product features | 20-100 | | Construction | Labor, equipment, materials | Building projects | 10-50 | | RD | Scientists, lab equipment | Research programs | 30-80 | | Marketing | Designers, copywriters, budget | Campaigns | 15-40 |

Compare: Manual vs ILP Allocation

| Aspect | Manual (Spreadsheet) | ILP Optimization | |--------|:-------------------:|:----------------:| | Time to schedule | 2-3 days | 30 seconds | | Optimality | ~70% | 95%+ | | Constraint handling | Prone to errors | 100% consistent | | What-if analysis | Hours per scenario | Seconds per scenario | | Scalability | Falls apart at 20 projects | Handles 1000+ |

The Vibe Coding Approach

"I have 3 projects with different resource needs across 4 consultant types. Each consultant type has limited hours per month. Maximize profit. At most 2 projects can be selected."

The AI will generate the complete PuLP resource allocation model.

Summary

Multi-project resource allocation is a critical business problem that ILP solves efficiently. The model balances resource constraints with project selection to maximize overall value.

Key takeaways:

• Resources include people, budget, equipment, and time
• Binary variables model project selection
• Continuous variables model resource allocation quantity
• Big-M constraints link selection to allocation
• Multiple constraint types model real business rules
• ILP finds optimal solutions in seconds vs days manually

What's Next: Supply Chain Optimization

The next chapter extends resource allocation to supply chain networks - optimizing inventory, production, and distribution across multiple locations.

Sensitivity Analysis

After finding the optimal allocation, ask "what-if" questions:

What if we hire another Senior consultant?

• Increase available["Senior"] by 160 hours
• Re-run the model
• Is the additional profit worth the hiring cost?

What if a project deadline is moved?

• Adjust the hours_needed or add time constraints
• See how resource allocation shifts

What if budget is cut by 20%?

• Reduce available hours proportionally
• Which projects get descoped or delayed?

Practical Tips

| Tip | Why | |-----|-----| | Start with a simplified model | Get a baseline before adding complexity | | Test with historical data | Validate the model against past decisions | | Run what-if scenarios | Understand sensitivity before committing | | Combine with human judgment | ILP is a decision support tool, not a replacement | | Update regularly | Re-run as project requirements change |

Summary

Multi-project resource allocation with ILP enables organizations to maximize portfolio value under real-world constraints.