Optimizing Conference Budget Allocation with Integer Programming in Python

Overview

Conference attendnce planning is a natural optimization problem. We may have a fixed travel and expense (T&E) budget, a separate registration budget, a set of flagship conferences, and several competing objectives: technical learning, brand presence, recruiting, and broad associate participation.

In this post, we will model a conference attendance strategy as a linear and integer programming problem. The setup is inspired by a conference strategy proposal I recently presented that evaluates five anonymized flagship conferences:

• Flagship conference A
• Flagship conference B
• Flagship conference C
• Flagship conference D
• Flagship conference E

My proposal compares three intuitive attendance strategies:

• Strong presence: send 7 associates to every flagship conference
• SME efficiency: send 3 subject matter experts to every flagship conference
• Balanced reach: send 5 associates to every flagship conference

These strategies are useful starting points. However, they force the same headcount at every flagship conference regardless of location, cost, and associate demand. Optimization gives us a more flexible way to answer the same planning question: if we have a balanced-reach target of 25 flagship seats, how should those seats be distributed across conferences?

Tools From The Python Ecosystem

We will be using the following libraries and packages:

[project]
name = "conference-budget-optimization"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "numpy>=2.4.5",
    "polars>=1.40.1",
    "pulp>=3.3.1",
    "scipy>=1.17.1",
]

[tool.uv]
package = false

[dependency-groups]
notebook = [
    "ipykernel>=6.29.5",
    "ipywidgets>=8.1.5",
    "nbformat>=5.10.4",
]
lint-fmt = [
    "ruff>=0.15.13",
]

The core optimization work is handled by two packages:

• scipy.optimize.linprog for the continuous linear programming relaxation, which relaxes the integer constraints to allow for continuous solutions
• PuLP for the integer programming formulation, see documentation

from typing import Dict, List, Optional

import numpy as np
import polars as pl
import pulp
from scipy.optimize import linprog

---

Data Inputs

Let us generate some data. In practice, I find it cleaner to keep the planning assumptions in separate tables before joining them into the modeling dataset. This mirrors how the information often arrives in real planning work: the conference list may come from the committee, flight assumptions may come from a travel policy, and hotel/food estimates may come from a finance planning template.

The first input table contains the conference-level planning information: region, number of days, registration fee, and a simulated demand score. The demand score can be interpreted as expected associate demand, e.g., the number of associates likely to attend the conference.

conference_inputs = pl.DataFrame(
    {
        "conference": conference_names,
        "region": conference_regions,
        "days": conference_days,
        "registration_fee": conference_registration_fees,
        "demand_score": conference_demand_scores,
    }
)

conference_inputs

shape: (5, 5)

conference	region	days	registration_fee	demand_score
str	str	i64	i64	i64
"Flagship A"	"South America"	5	850	75
"Flagship B"	"Asia"	7	1100	153
"Flagship C"	"Asia"	5	975	97
"Flagship D"	"Non-flagship"	6	725	23
"Flagship E"	"Oceania"	7	1250	78

The second input table stores the estimated flight cost by region.

flight_cost_inputs = pl.DataFrame(
    {
        "region": flight_regions,
        "flight_cost": flight_costs,
    }
)

flight_cost_inputs

shape: (4, 2)

region	flight_cost
str	i64
"Non-flagship"	600
"South America"	1500
"Asia"	3000
"Oceania"	4000

The third input table stores the hotel and food cost estimate per attendee per day. In this simplified example, we use one cost profile for all conferences. However, we can easily extend this to allow for cost profiles based on the conference location.

daily_cost_inputs = pl.DataFrame(
    {
        "hotel_food_per_day": [daily_hotel_food_cost],
    }
)

daily_cost_inputs

shape: (1, 1)

hotel_food_per_day
i64
400

Finally, we join the input tables and calculate per-attendee cost estimates, including T&E (travel and expenses) and total cost per person.

conference_data = (
    conference_inputs
        .join(flight_cost_inputs, on="region", how="left")
        .join(daily_cost_inputs, how="cross")
        .with_columns(
            (
                pl.col("flight_cost") + pl.col("days") * pl.col("hotel_food_per_day")
            ).alias("te_cost_per_person")
        )
        .with_columns(
            (
                pl.col("te_cost_per_person") + pl.col("registration_fee")
            ).alias("total_cost_per_person")
        )
)

conference_cost_table = (
    conference_data
    .select(
        [
            "conference",
            "region",
            "days",
            "flight_cost",
            "te_cost_per_person",
            "registration_fee",
            "total_cost_per_person",
        ]
    )
    .to_dicts()
)

Flagship Conference Cost Assumptions

conference	region	days	flight_cost	te_cost_per_person	registration_fee	total_cost_per_person
Flagship A	South America	5	$1,500	$3,500	$850	$4,350
Flagship B	Asia	7	$3,000	$5,800	$1,100	$6,900
Flagship C	Asia	5	$3,000	$5,000	$975	$5,975
Flagship D	Non-flagship	6	$600	$3,000	$725	$3,725
Flagship E	Oceania	7	$4,000	$6,800	$1,250	$8,050

The T&E estimate follows the same simple formula for each attendee:

$$\text{T\&E Cost}=\text{Flight Cost}+\text{Days}\times (\text{Hotel}+\text{Food})$$

Using $400 per day for hotel and food:

• Flagship A: $1,500 + 5 $\times$ $400 = $3,500
• Flagship B: $3,000 + 7 $\times$ $400 = $5,800
• Flagship C: $3,000 + 5 $\times$ $400 = $5,000
• Flagship D: $600 + 6 $\times$ $400 = $3,000
• Flagship E: $4,000 + 7 $\times$ $400 = $6,800

average_flagship_te = (
    conference_data
    .select(pl.col("te_cost_per_person").mean())
    .item()
)

The average flagship T&E cost is therefore $4,820.

---

Baseline Scenarios

Before moving into optimization, it is useful to reproduce the three fixed-headcount scenarios. These scenarios send the same number of attendees to each flagship conference. We use one shared budget set throughout the post, so the fixed strategies are intentionally sized to stay feasible under the same caps used by the optimization model:

• T&E budget: $170,000
• Registration budget: $35,000
• Total T&E cost per person:
  • Flagship: $4,820
  • Non-flagship: $2,200
• Planning flagship seat target: 25

scenarios = pl.DataFrame(
    {
        "scenario": ["Strong Presence", "SME Efficiency", "Balanced Reach"],
        "attendees_per_flagship": [strong_presence, sme_efficiency, balanced_reach],
    }
)

one_each_te = conference_data["te_cost_per_person"].sum()
one_each_registration = conference_data["registration_fee"].sum()

scenarios = (
    scenarios
    .with_columns(
        [
            (pl.col("attendees_per_flagship") * len(conference_data)).alias(
                "flagship_attendees"
            ),
            (pl.col("attendees_per_flagship") * one_each_te).alias("te_spend"),
            (pl.col("attendees_per_flagship") * one_each_registration).alias(
                "registration_spend"
            ),
        ]
    )
    .with_columns(
        [
            (te_budget - pl.col("te_spend")).alias("remaining_te"),
            (registration_budget - pl.col("registration_spend")).alias(
                "remaining_registration"
            ),
        ]
    )
    .with_columns(
        (
            (pl.col("remaining_te") >= 0)
            & (pl.col("remaining_registration") >= 0)
        ).alias("is_budget_feasible")
    )
    .with_columns(
        (
            pl.col("remaining_te") / non_flagship_event_te_cost
        )
        .floor()
        .clip(lower_bound=0)
        .cast(pl.Int64)
        .alias("additional_non_flagship_event_seats")
    )
    .with_columns(
        (
            pl.col("flagship_attendees")
            + pl.col("additional_non_flagship_event_seats")
        ).alias("total_estimated_seats")
    )
)

scenarios_table = (
    scenarios
    .to_dicts()
)

Fixed-Headcount Strategy Scenarios

scenario	attendees_per_flagship	flagship_attendees	te_spend	registration_spend	remaining_te	remaining_registration	is_budget_feasible	additional_non_flagship_event_seats	total_estimated_seats
Strong Presence	7	35	$168,700	$34,300	$1,300	$700	Yes	0	35
SME Efficiency	3	15	$72,300	$14,700	$97,700	$20,300	Yes	44	59
Balanced Reach	5	25	$120,500	$24,500	$49,500	$10,500	Yes	22	47

The fixed scenarios are easy to explain, and under the shared budget caps all three are feasible:

• Strong presence sends 7 associates to every flagship.
• SME efficiency sends 3 associates to every flagship. This preserves the most remaining T&E budget, which can be redeployed into many smaller non-flagship events.
• Balanced reach sends 5 associates to every flagship and sits between the two extremes.

These scenarios are intentionally simple. They are useful for communicating the trade-off between flagship depth and broader participation before introducing an optimization model.

However, the fixed-headcount approach has one important limitation: it assumes every conference should receive the same number of attendees. If one flagship has much higher associate demand but is also more expensive, while another is less expensive but has lower demand, we should allow the model to trade off cost and demand directly.

For the optimization model, we will use the same shared budget caps and target the balanced-reach 25-seat flagship footprint. The key difference is that optimization can vary the allocation by conference instead of requiring the same headcount everywhere. This creates a cleaner comparison: the optimized strategy keeps the same total footprint as the balanced fixed strategy while using the budget more flexibly across cost and demand.

---

Optimization Problem

Let:

$$x_i=\text{number of attendees assigned to flagship conference }i$$

We want to choose the vector $x$ that maximizes associate demand while respecting T&E and registration budgets.

Objective

We will optimize directly against expected demand. Let $s_i$ be the demand score for flagship conference $i$:

$$\begin{array}{rl}{s}_i& ={\text{DemandScore}}_i\end{array}$$

The objective is then:

$$\begin{array}{rl}\underset{x}{max}& \sum _i{s}_i{x}_i\end{array}$$

---

Constraints

The model includes the following constraints:

$$\begin{array}{rlrl}\sum _i{\text{T\&E Cost}}_i{x}_i& \le \mathrm{170,000}& & \text{T\&E budget}\\ \sum _i{\text{Registration}}_i{x}_i& \le \mathrm{35,000}& & \text{Registration budget}\\ \sum _i{x}_i& =25& & \text{Planning flagship seat target}\\ x_i& \ge 3& & \mathrm{\forall }i\text{Minimum flagship coverage}\\ x_i& \le 7& & \mathrm{\forall }i\text{Maximum practical delegation size}\\ x_i& \in {\mathbb{Z}}_{\ge 0}& & \mathrm{\forall }i\text{Integer attendance}\end{array}$$

The LP version relaxes the final integer constraint; the ILP version enforces it fully.

---

Solve LP Relaxation with SciPy

First, we define the decision vector:

$$\begin{array}{rl}x& ={\left[\begin{array}{cccc}{x}_1& x_2& \cdots & x_n\end{array}\right]}^{\mathrm{\top }}\end{array}$$

conference_names = conference_data["conference"].to_list()
n = len(conference_names)

Since our original objective maximizes associate demand, we negate the demand score vector to turn the maximization problem into a minimization problem:

$$\begin{array}{r}\underset{x}{max}{s}^{\mathrm{\top }}x⟺\underset{x}{min}{c}^{\mathrm{\top }}x,c=-s\end{array}$$

c = -conference_data["demand_score"].to_numpy()

The two upper-bound budget constraints can be written in matrix form:

$$\begin{array}{rl}{A}_{\text{ub}}x& \le b_{\text{ub}}\\ \underset{2\times n}{\underbrace{\left[\begin{array}{cccc}{\text{TECost}}_1& {\text{TECost}}_2& \cdots & {\text{TECost}}_n\\ {\text{Registration}}_1& {\text{Registration}}_2& \cdots & {\text{Registration}}_n\end{array}\right]}}\underset{n\times 1}{\underbrace{\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]}}& \le \underset{2\times 1}{\underbrace{\left[\begin{array}{c}\mathrm{170,000}\\ \mathrm{35,000}\end{array}\right]}}\end{array}$$

A_ub = np.vstack(
    [
        conference_data["te_cost_per_person"].to_numpy(),
        conference_data["registration_fee"].to_numpy(),
    ]
)
b_ub = np.array([te_budget, registration_budget])

The planning flagship seat target is an equality constraint:

$$\begin{array}{rl}{A}_{\text{eq}}x& =b_{\text{eq}}\\ \underset{1\times n}{\underbrace{\left[\begin{array}{cccc}1& 1& \cdots & 1\end{array}\right]}}\underset{n\times 1}{\underbrace{\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]}}& =25\end{array}$$

A_eq = np.ones((1, n))
b_eq = np.array([planning_flagship_seat_target])

Finally, each relaxed decision variable is bounded between the minimum and maximum practical delegation sizes. In this example, the lower bound matches the SME-efficiency strategy, while the upper bound allows one seat above the strong-presence strategy:

$$\begin{array}{r}3\le x_i\le 7,i=1,2,\dots ,n\end{array}$$

bounds = [
    (min_flagship_attendees, max_flagship_attendees)
    for _ in conference_names
]

Putting these pieces together, the formulation passed to linprog is:

$$\begin{array}{rl}\underset{x}{min}& c^{\mathrm{\top }}x\\ \text{subject to}& A_{\text{ub}}x\le b_{\text{ub}}\\ & A_{\text{eq}}x=b_{\text{eq}}\\ & 3\le x_i\le 7\end{array}$$

lp_result = linprog(
    c=c,
    A_ub=A_ub,
    b_ub=b_ub,
    A_eq=A_eq,
    b_eq=b_eq,
    bounds=bounds,
    method="highs", # https://ergo-code.github.io/HiGHS/dev/
)

lp_result.status, lp_result.message

(0, 'Optimization terminated successfully. (HiGHS Status 7: Optimal)')

lp_solution = (
    conference_data
    .select(
        [
            "conference",
            "te_cost_per_person",
            "registration_fee",
            "demand_score",
        ]
    )
    .with_columns(
        pl.Series("attendees", lp_result.x)
    )
    .with_columns(
        [
            (pl.col("attendees") * pl.col("te_cost_per_person")).alias("te_spend"),
            (pl.col("attendees") * pl.col("registration_fee")).alias(
                "registration_spend"
            ),
            (pl.col("attendees") * pl.col("demand_score")).alias("demand_contribution"),
        ]
    )
)

lp_solution_table = (
    lp_solution
    .to_dicts()
)

LP Relaxation Solution

conference	te_cost_per_person	registration_fee	demand_score	attendees	te_spend	registration_spend	demand_contribution
Flagship A	$3,500.00	$850.00	75.00	3.00	$10,500.00	$2,550.00	225.00
Flagship B	$5,800.00	$1,100.00	153.00	7.00	$40,600.00	$7,700.00	1,071.00
Flagship C	$5,000.00	$975.00	97.00	7.00	$35,000.00	$6,825.00	679.00
Flagship D	$3,000.00	$725.00	23.00	3.00	$9,000.00	$2,175.00	69.00
Flagship E	$6,800.00	$1,250.00	78.00	5.00	$34,000.00	$6,250.00	390.00

The LP relaxation is useful for understanding the shape of the optimization problem. However, conference attendance seats cannot be fractional (even though sometimes the optional solution does not contain any fractional values). This is where integer programming becomes the more appropriate formulation.

---

Solve the ILP with PuLP

For the integer programming formulation, each decision variable represents a whole number of attendees. The optimization model is initialized as a maximization problem:

model = pulp.LpProblem("conference_attendance_allocation", pulp.LpMaximize)

Before building PuLP expressions, we export the columns needed by the solver into plain Python dictionaries. This keeps avoids row-wise iteration over polars DataFrame, which is columnar.

demand_score_by_conference = dict(
    zip(
        conference_names,
        conference_data["demand_score"].to_list(),
    )
)

te_cost_by_conference = dict(
    zip(
        conference_names,
        conference_data["te_cost_per_person"].to_list(),
    )
)

registration_fee_by_conference = dict(
    zip(
        conference_names,
        conference_data["registration_fee"].to_list(),
    )
)

The PuLP decision variables correspond to the same attendance vector as the LP relaxation, but now each element is explicitly integer-valued:

$$\begin{array}{r}{x}_i\in \mathbb{Z},3\le x_i\le 7,i=1,2,\dots ,n\end{array}$$

x = {
    conference: pulp.LpVariable(
        f"attendees_{conference}",
        lowBound=min_flagship_attendees,
        upBound=max_flagship_attendees,
        cat="Integer",
    )
    for conference in conference_names
}

The objective maximizes total demand:

$$\begin{array}{rl}\underset{x}{max}& \sum _i{s}_i{x}_i\end{array}$$

model += pulp.lpSum(
    demand_score_by_conference[conference] * x[conference]
    for conference in conference_names
)

The first budget constraint keeps total T&E spend within the planning cap:

$$\begin{array}{r}\sum _i{\text{TECost}}_i{x}_i\le \mathrm{170,000}\end{array}$$

model += pulp.lpSum(
    te_cost_by_conference[conference] * x[conference]
    for conference in conference_names
) <= te_budget

The second budget constraint keeps registration spend within the registration cap:

$$\begin{array}{r}\sum _i{\text{Registration}}_i{x}_i\le \mathrm{35,000}\end{array}$$

model += pulp.lpSum(
    registration_fee_by_conference[conference] * x[conference]
    for conference in conference_names
) <= registration_budget

The flagship seat target keeps the ILP focused on a fixed planning footprint:

$$\begin{array}{r}\sum _i{x}_i=25\end{array}$$

model += pulp.lpSum(x[conference] for conference in conference_names) == planning_flagship_seat_target

Putting the pieces together, PuLP solves the integer program:

$$\begin{array}{rl}\underset{x}{max}& \sum _i{s}_i{x}_i\\ \text{subject to}& \sum _i{\text{T\&ECost}}_i{x}_i\le \mathrm{170,000}\\ & \sum _i{\text{Registration}}_i{x}_i\le \mathrm{35,000}\\ & \sum _i{x}_i=25\\ & 3\le x_i\le 7\\ & x_i\in \mathbb{Z}\end{array}$$

model.solve(pulp.PULP_CBC_CMD(msg=False))

1

ilp_status = pulp.LpStatus[model.status]
ilp_status

'Optimal'

ilp_solution = (
    conference_data
    .select(
        [
            "conference",
            "region",
            "te_cost_per_person",
            "registration_fee",
            "demand_score",
        ]
    )
    .with_columns(
        pl.Series(
            "attendees",
            [int(x[conference].value()) for conference in conference_names],
        )
    )
    .with_columns(
        [
            (pl.col("attendees") * pl.col("te_cost_per_person")).alias("te_spend"),
            (pl.col("attendees") * pl.col("registration_fee")).alias(
                "registration_spend"
            ),
            (pl.col("attendees") * pl.col("demand_score")).alias(
                "demand_contribution"
            ),
        ]
    )
)

ilp_solution_table = (
    ilp_solution
    .to_dicts()
)

ilp_summary = {
    "total_attendees": ilp_solution["attendees"].sum(),
    "te_spend": ilp_solution["te_spend"].sum(),
    "registration_spend": ilp_solution["registration_spend"].sum(),
    "remaining_te": te_budget - ilp_solution["te_spend"].sum(),
    "remaining_registration": registration_budget - ilp_solution["registration_spend"].sum(),
    "objective_value": ilp_solution["demand_contribution"].sum(),
}

Integer Programming Solution

conference	region	te_cost_per_person	registration_fee	demand_score	attendees	te_spend	registration_spend	demand_contribution
Flagship A	South America	$3,500	$850	75.00	3	$10,500	$2,550	225.00
Flagship B	Asia	$5,800	$1,100	153.00	7	$40,600	$7,700	1,071.00
Flagship C	Asia	$5,000	$975	97.00	7	$35,000	$6,825	679.00
Flagship D	Non-flagship	$3,000	$725	23.00	3	$9,000	$2,175	69.00
Flagship E	Oceania	$6,800	$1,250	78.00	5	$34,000	$6,250	390.00

The optimized solution does not need to pick the same number of attendees for every conference. Instead, it allocates the 25 flagship seats toward conferences with stronger demand, while still maintaining a minimum level of participation at every flagship.

---

Compare Fixed Scenarios with Optimized Allocation

To compare fixed scenarios and the optimized plan, we can compute their objective values using the same demand score and the same budget caps.

def evaluate_fixed_strategy(attendees_per_flagship: int) -> Dict[str, object]:
    """
    Evaluate a fixed-headcount conference allocation strategy.

    Parameters
    ----------
    attendees_per_flagship : int
        Number of attendees assigned to every flagship conference.

    Returns
    -------
    Dict[str, object]
        Summary statistics for the fixed strategy, including total
        attendees, budget spend, remaining budget, feasibility, and
        objective value.
    """
    attendees = np.repeat(attendees_per_flagship, len(conference_data))
    te_spend = float(
        (attendees * conference_data["te_cost_per_person"].to_numpy()).sum()
    )
    registration_spend = float(
        (attendees * conference_data["registration_fee"].to_numpy()).sum()
    )
    objective_value = float(
        (attendees * conference_data["demand_score"].to_numpy()).sum()
    )

    return {
        "model_type": "Fixed",
        "strategy": f"{attendees_per_flagship} per flagship",
        "flagship_attendees": int(attendees.sum()),
        "te_spend": te_spend,
        "registration_spend": registration_spend,
        "remaining_te": te_budget - te_spend,
        "remaining_registration": registration_budget - registration_spend,
        "is_budget_feasible": (te_spend <= te_budget)
        and (registration_spend <= registration_budget),
        "objective_value": objective_value,
    }

strategy_comparison = pl.DataFrame(
    [
        evaluate_fixed_strategy(strong_presence),
        evaluate_fixed_strategy(sme_efficiency),
        evaluate_fixed_strategy(balanced_reach),
        {
            "model_type": "Optimized",
            "strategy": "optimized integer allocation",
            "flagship_attendees": int(ilp_solution["attendees"].sum()),
            "te_spend": float(ilp_solution["te_spend"].sum()),
            "registration_spend": float(ilp_solution["registration_spend"].sum()),
            "remaining_te": te_budget - float(ilp_solution["te_spend"].sum()),
            "remaining_registration": registration_budget
            - float(ilp_solution["registration_spend"].sum()),
            "is_budget_feasible": True,
            "objective_value": float(ilp_solution["demand_contribution"].sum()),
        },
    ]
)

strategy_comparison_table = (
    strategy_comparison
    .to_dicts()
)

Fixed Strategies vs Optimized Allocation

model_type	strategy	flagship_attendees	te_spend	registration_spend	remaining_te	remaining_registration	is_budget_feasible	objective_value
Fixed	7 per flagship	35	$168,700	$34,300	$1,300	$700	Yes	2,982.00
Fixed	3 per flagship	15	$72,300	$14,700	$97,700	$20,300	Yes	1,278.00
Fixed	5 per flagship	25	$120,500	$24,500	$49,500	$10,500	Yes	2,130.00
Optimized	optimized integer allocation	25	$129,100	$25,500	$40,900	$9,500	Yes	2,434.00

This comparison highlights the practical value of optimization. The fixed strategies are clear and communicable, while the optimized allocation keeps the planned 25-seat footprint without requiring a rigid equal-headcount rule.

---

Add Additional Non-Flagship Conference Seats

The original scenario framing also considers how many additional non-flagship event seats could be funded after flagship commitments. We can add this as a second-stage calculation.

Let $B_{\text{TE}}$ be the total T&E budget, ${\text{TE}}_{\text{flagship}}$ be the optimized flagship T&E spend, and $c_{\text{nonflagship}}$ be the estimated T&E cost for one additional non-flagship event seat. The remaining budget and additional seats are:

$$\begin{array}{rl}{B}_{\text{remaining}}& =B_{\text{TE}}-{\text{TE}}_{\text{flagship}}\\ n_{\text{nonflagship}}& =\lfloor \frac{B_{\text{remaining}}}{c_{\text{nonflagship}}}\rfloor \\ n_{\text{total}}& =n_{\text{flagship}}+n_{\text{nonflagship}}\end{array}$$

remaining_te = ilp_summary["remaining_te"]
additional_non_flagship_seats = int(remaining_te // non_flagship_event_te_cost)

total_estimated_participation = int(
    ilp_summary["total_attendees"] + additional_non_flagship_seats
)

non_flagship_participation_summary = pl.DataFrame(
    {
        "flagship_attendees": [ilp_summary["total_attendees"]],
        "remaining_te": [remaining_te],
        "non_flagship_te_cost_per_seat": [non_flagship_event_te_cost],
        "additional_non_flagship_event_seats": [additional_non_flagship_seats],
        "total_estimated_participation": [total_estimated_participation],
    }
)

non_flagship_participation_summary_table = (
    non_flagship_participation_summary
    .to_dicts()
)

Estimated Participation After Non-Flagship Seats

flagship_attendees	remaining_te	non_flagship_te_cost_per_seat	additional_non_flagship_event_seats	total_estimated_participation
25	$40,900	$2,200	18	43

This is a pragmatic way to combine flagship planning with broader participation goals. The first-stage model determines the flagship footprint. The remaining budget can then be used for smaller non-flagship, affinity, or niche conferences.

---

Scenario Analysis

The biggest benefit of formulating the planning problem as code is that scenario analysis becomes straightforward. We can define a function that solves the ILP for a given set of demand adjustments, minimum attendees, maximum attendees, and flagship seat target.

def solve_conference_ilp(
    conference_data: pl.DataFrame,
    demand_adjustments: Optional[Dict[str, int]] = None,
    min_attendees: int = min_flagship_attendees,
    max_attendees: int = max_flagship_attendees,
    flagship_seat_target: int = planning_flagship_seat_target,
) -> pl.DataFrame:
    """ 
    Solve the conference attendance allocation problem with integer programming.

    Parameters
    ----------
    conference_data: pl.DataFrame
        A DataFrame with the conference names, demand scores, te costs, registration fees, and attendees.
    demand_adjustments: Optional[Dict[str, int]]
        A dictionary of conference names and demand adjustments.
    min_attendees: int
        The minimum number of attendees for each conference.
    max_attendees: int
        The maximum number of attendees for each conference.
    flagship_seat_target: int
        The target number of flagship seats.

    Returns
    -------
    pl.DataFrame
        A DataFrame with the conference names, demand scores, te costs, registration fees, and attendees.
    """
    if demand_adjustments:
        demand_adjustment_data = pl.DataFrame(
            {
                "conference": list(demand_adjustments.keys()),
                "demand_adjustment": list(demand_adjustments.values()),
            }
        )

        scenario_data = (
            conference_data
                .join(demand_adjustment_data, on="conference", how="left")
                .with_columns(
                    (
                        pl.col("demand_score")
                        + pl.col("demand_adjustment").fill_null(0)
                    ).alias("demand_score")
                )
                .drop("demand_adjustment")
        )
    else:
        scenario_data = conference_data

    scenario_names = scenario_data["conference"].to_list()
    scenario_demand_score = dict(
        zip(
            scenario_names,
            scenario_data["demand_score"].to_list(),
        )
    )
    scenario_te_cost = dict(
        zip(
            scenario_names,
            scenario_data["te_cost_per_person"].to_list(),
        )
    )
    scenario_registration_fee = dict(
        zip(
            scenario_names,
            scenario_data["registration_fee"].to_list(),
        )
    )

    scenario_model = pulp.LpProblem("conference_attendance_scenario", pulp.LpMaximize)

    x_scenario = {
        conference: pulp.LpVariable(
            f"attendees_{conference}",
            lowBound=min_attendees,
            upBound=max_attendees,
            cat="Integer",
        )
        for conference in scenario_names
    }

    scenario_model += pulp.lpSum(
        scenario_demand_score[conference] * x_scenario[conference]
        for conference in scenario_names
    )

    scenario_model += pulp.lpSum(
        scenario_te_cost[conference] * x_scenario[conference]
        for conference in scenario_names
    ) <= te_budget

    scenario_model += pulp.lpSum(
        scenario_registration_fee[conference] * x_scenario[conference]
        for conference in scenario_names
    ) <= registration_budget

    scenario_model += pulp.lpSum(
        x_scenario[conference] for conference in scenario_names
    ) == flagship_seat_target

    scenario_model.solve(pulp.PULP_CBC_CMD(msg=False))

    solution = (
        scenario_data
        .select(
            [
                "conference",
                "demand_score",
                "te_cost_per_person",
                "registration_fee",
            ]
        )
        .with_columns(
            pl.Series(
                "attendees",
                [
                    int(x_scenario[conference].value())
                    for conference in scenario_names
                ],
            )
        )
        .with_columns(
            [
                (pl.col("attendees") * pl.col("te_cost_per_person")).alias(
                    "te_spend"
                ),
                (pl.col("attendees") * pl.col("registration_fee")).alias(
                    "registration_spend"
                ),
                (pl.col("attendees") * pl.col("demand_score")).alias(
                    "objective_value"
                ),
            ]
        )
    )

    return solution

Scenario A: Updated Demand

Suppose updated planning data comes in after the initial planning pass. Demand for Flagship A, Flagship D, and Flagship E increases sharply, while demand for Flagship B and Flagship C softens. This is intentionally a meaningful demand shock so the scenario produces a visibly different allocation rather than a cosmetic score change.

updated_demand_solution = solve_conference_ilp(
    conference_data=conference_data,
    demand_adjustments={
        "Flagship A": 120,
        "Flagship B": -80,
        "Flagship C": -60,
        "Flagship D": 80,
        "Flagship E": 40,
    }
)
updated_demand_solution

shape: (5, 8)

conference	demand_score	te_cost_per_person	registration_fee	attendees	te_spend	registration_spend	objective_value
str	i64	i64	i64	i64	i64	i64	i64
"Flagship A"	195	3500	850	7	24500	5950	1365
"Flagship B"	73	5800	1100	3	17400	3300	219
"Flagship C"	37	5000	975	3	15000	2925	111
"Flagship D"	103	3000	725	5	15000	3625	515
"Flagship E"	118	6800	1250	7	47600	8750	826

Scenario B: Smaller Flagship Footprint

If the committee wants to reserve more budget for non-flagship events, we can reduce the flagship seat target from 25 to 20 while keeping the same budget caps.

smaller_footprint_solution = solve_conference_ilp(
    conference_data=conference_data,
    flagship_seat_target=smaller_flagship_seat_target,
)
smaller_footprint_solution

shape: (5, 8)

conference	demand_score	te_cost_per_person	registration_fee	attendees	te_spend	registration_spend	objective_value
str	i64	i64	i64	i64	i64	i64	i64
"Flagship A"	75	3500	850	3	10500	2550	225
"Flagship B"	153	5800	1100	7	40600	7700	1071
"Flagship C"	97	5000	975	4	20000	3900	388
"Flagship D"	23	3000	725	3	9000	2175	69
"Flagship E"	78	6800	1250	3	20400	3750	234

scenario_attendance_compare = (
    ilp_solution
    .select(
        [
            "conference",
            pl.col("attendees").alias("base_optimized"),
        ]
    )
    .join(
        (
            updated_demand_solution
            .select(
                [
                    "conference",
                    pl.col("attendees").alias("updated_demand"),
                ]
            )
        ),
        on="conference",
    )
    .join(
        (
            smaller_footprint_solution
            .select(
                [
                    "conference",
                    pl.col("attendees").alias("smaller_footprint"),
                ]
            )
        ),
        on="conference",
    )
)

scenario_attendance_compare_table = (
    scenario_attendance_compare
    .to_dicts()
)

final_strategy_comparison = pl.concat(
    [
        strategy_comparison,
        pl.DataFrame(
            [
                {
                    "model_type": "Optimized",
                    "strategy": "updated demand allocation",
                    "flagship_attendees": int(updated_demand_solution["attendees"].sum()),
                    "te_spend": float(updated_demand_solution["te_spend"].sum()),
                    "registration_spend": float(
                        updated_demand_solution["registration_spend"].sum()
                    ),
                    "remaining_te": te_budget
                    - float(updated_demand_solution["te_spend"].sum()),
                    "remaining_registration": registration_budget
                    - float(updated_demand_solution["registration_spend"].sum()),
                    "is_budget_feasible": True,
                    "objective_value": float(
                        updated_demand_solution["objective_value"].sum()
                    ),
                },
                {
                    "model_type": "Optimized",
                    "strategy": "smaller footprint allocation",
                    "flagship_attendees": int(smaller_footprint_solution["attendees"].sum()),
                    "te_spend": float(smaller_footprint_solution["te_spend"].sum()),
                    "registration_spend": float(
                        smaller_footprint_solution["registration_spend"].sum()
                    ),
                    "remaining_te": te_budget
                    - float(smaller_footprint_solution["te_spend"].sum()),
                    "remaining_registration": registration_budget
                    - float(smaller_footprint_solution["registration_spend"].sum()),
                    "is_budget_feasible": True,
                    "objective_value": float(
                        smaller_footprint_solution["objective_value"].sum()
                    ),
                },
            ]
        ),
    ]
)

final_strategy_comparison_table = (
    final_strategy_comparison
    .to_dicts()
)

Optimized Attendance Across Scenarios

conference	base_optimized	updated_demand	smaller_footprint
Flagship A	3	7	3
Flagship B	7	3	7
Flagship C	7	3	4
Flagship D	3	5	3
Flagship E	5	7	3

Final Fixed and Optimized Strategy Comparison

model_type	strategy	flagship_attendees	te_spend	registration_spend	remaining_te	remaining_registration	is_budget_feasible	objective_value
Fixed	7 per flagship	35	$168,700	$34,300	$1,300	$700	Yes	2,982.00
Fixed	3 per flagship	15	$72,300	$14,700	$97,700	$20,300	Yes	1,278.00
Fixed	5 per flagship	25	$120,500	$24,500	$49,500	$10,500	Yes	2,130.00
Optimized	optimized integer allocation	25	$129,100	$25,500	$40,900	$9,500	Yes	2,434.00
Optimized	updated demand allocation	25	$119,500	$24,550	$50,500	$10,450	Yes	3,036.00
Optimized	smaller footprint allocation	20	$100,500	$20,075	$69,500	$14,925	Yes	1,987.00

The objective values here represent the total demand score for the allocation.Scenario analysis helps move the discussion away from a single answer. Instead, the committee can ask how sensitive the allocation is to new demand, minimum coverage requirements, or changes in travel assumptions.

Wrapping Up

The fixed scenario approach is a good executive communication tool: 3x, 5x, and 7x flagship attendance levels are easy to understand. Integer programming adds another layer by letting the attendance plan vary by conference while still respecting budget, demand, and operational constraints.

The general workflow is:

1. Translate the planning proposal into structured data.
2. Define the objective function explicitly.
3. Add budget and operational constraints.
4. Solve the ILP to produce an executable attendance plan.
5. Run scenarios to test how assumptions change the recommendation.

One final modeling note is worth emphasizing: in this example, $s_i$ represents expected associate demand. In other settings, $s_i$ could be a recruiting value, learning value, leadership priority score, or another single value signal.

By combining domain judgment with optimization in Python, we can make conference planning decisions that are more transparent, reproducible, and aligned with planning priorities.