How do I set up a slotting and scheduling platform for tight grocery delivery windows and capacity control?

To set up a slotting and scheduling platform for tight grocery delivery windows with capacity control, design it around demand forecasting, inventory/fulfillment constraints, routing capacity, and real-time booking rules.

1) Define the operating constraints

Start by modeling the things that limit capacity:

• Delivery windows: e.g. 30-, 60-, or 120-minute slots
• Zone/geography: by postcode, radius, or route area
• Fleet capacity: number of drivers, vehicle types, temperature control limits
• Store/pick capacity: picker labor, dock capacity, staging space
• Order size rules: weight, volume, item count, refrigerated/frozen handling
• Cutoff times: same-day / next-day ordering deadlines
• Service levels: promised on-time %, max substitutions, freshness constraints

Treat each slot as having a capacity vector, not just one number.

---

2) Build a slot inventory system

Create a “slot inventory” service that exposes available delivery slots to the checkout and customer app.

Each slot should store:

• date
• start/end time
• delivery zone
• remaining capacity
• capacity type(s): van, bike, refrigerated van, etc.
• order limit and/or utilization %
• cutoff time
• eligibility rules
• price/surcharge if applicable
• status: open, constrained, closed, waitlist only

Example:

{
  "slot_id": "2026-07-23_Z3_18:00-19:00",
  "zone": "Z3",
  "start": "18:00",
  "end": "19:00",
  "remaining_orders": 12,
  "remaining_volume_m3": 4.8,
  "remaining_driver_minutes": 180,
  "cutoff": "16:30",
  "status": "open"
}

---

3) Forecast demand by slot

You need forecasted demand before booking opens.

Use historical data to predict:

• order count by time/day/zone
• basket size distribution
• lead time from booking to delivery
• cancellation/no-show rates
• seasonality, promotions, holidays, weather, local events

Then pre-allocate capacity per slot:

• baseline allocation
• reserve capacity for late orders / priority customers
• adjust for expected pick and route inefficiencies

A practical approach:

• forecast expected demand
• apply a safety buffer
• set slot opening capacity accordingly

---

4) Model capacity using multiple resources

A slot is feasible only if all required resources are available.

Typical resource model:

• Picking: labor minutes
• Delivery: route minutes, vehicle count
• Load/staging: bay capacity, cooler space
• Inventory freshness: some items may be unavailable for later slots
• Customer promise rules: premium customers may get priority access

Capacity should be updated using formulas like:

• remaining_order_capacity = min(by_driver, by_picker, by_zone, by_temp_chain)
• each new order consumes resources based on basket attributes

---

5) Add booking and reservation logic

When a customer selects a slot:

1. Validate serviceability (zone, postcode, basket constraints)
2. Lock capacity temporarily
3. Re-check inventory and capacity at commit
4. Confirm booking
5. Release lock if payment/checkout fails

Use optimistic concurrency or distributed locking so two users don’t claim the same last slot.

Important:

• hold slot for a short TTL during checkout
• reprice or re-offer if capacity changes during the session
• maintain audit logs for all reservation changes

---

6) Use dynamic slot throttling

Don’t keep all slots static. Adjust them in real time based on system load.

Examples:

• reduce availability when picker queues grow
• close slots if driver utilization exceeds target
• open extra capacity when routes are underfilled
• shift capacity between adjacent zones
• increase fees for peak slots to smooth demand

Rules can be:

• hard constraints: never exceed vehicle capacity
• soft constraints: target 85–90% utilization, but allow limited overbooking if cancellations are expected

---

7) Integrate route optimization

Scheduling must be aligned with routing.

For each slot or route wave:

• cluster deliveries geographically
• estimate stop duration
• calculate travel time
• assign vehicles/drivers to waves
• ensure promised delivery windows are realistic

If using tight windows, the routing engine should output:

• route ID
• assigned stops
• expected arrival times
• slack/variance
• capacity consumed per route

You can feed this back into slot inventory.

---

8) Introduce booking rules and prioritization

To make capacity control work well, define policies such as:

• priority for loyalty/subscription customers
• lower minimum basket for off-peak slots
• larger baskets only in wider windows
• cutoff times varying by zone
• limits on same-day orders
• reserve a % of slots for urgent or high-value customers

You can also implement:

• waitlist
• suggested alternatives
• auto-upgrade/downgrade to nearby slots

---

9) Handle substitutions and packing constraints

Grocery delivery isn’t just slotting time; product mix matters.

Examples:

• frozen-heavy baskets require cold-chain capacity
• large/heavy baskets require more driver time
• fragile items reduce packing density
• alcohol or age-restricted items may increase stop duration

So estimate order “cost” using a score:

• pick time
• pack time
• load volume
• delivery time
• special handling time

Then slot acceptance becomes a resource fit problem:

• accept order if score <= remaining slot capacity

---

10) Provide admin controls and simulations

Your ops team needs tools to:

• manually open/close slots
• override capacity
• set minimum service levels
• inspect route fill rate
• simulate demand spikes
• test holiday plans

Useful dashboards:

• slot occupancy heatmap
• forecast vs actual by zone
• over/under-capacity alerts
• late delivery risk
• picker/driver utilization
• cancellation impact

---

11) Build core services

A common architecture:

Services

• Demand Forecasting
• Slot Inventory
• Capacity Engine
• Booking Service
• Routing Service
• Rules/Eligibility Engine
• Admin Console
• Event/Audit Log

Data store

• transactional DB for slot reservations
• time-series/analytics DB for demand and utilization
• cache for fast availability lookup

Events

• order placed
• slot held
• slot confirmed
• order canceled
• route recalculated
• capacity adjusted

---

12) Define the key algorithms

You’ll likely need these:

• slot demand forecasting
• order-to-slot assignment
• capacity consumption scoring
• dynamic repricing
• route-based feasibility checking
• overbooking optimization
• cancellation recovery

A simple allocation rule:

1. forecast demand per slot
2. allocate base capacity
3. reserve a buffer
4. accept orders until remaining capacity < order cost
5. rebalance when actual route plans differ

---

13) Start with a practical MVP

For a first version:

• slot granularity: 60 minutes
• capacity per slot: max orders + max volume
• zone-based eligibility
• static cutoff times
• checkout reservation with 10-minute hold
• admin dashboard to open/close slots
• daily batch forecasting to prefill capacities

Then add:

• dynamic capacity updates
• route optimization
• predictive overbooking
• pricing controls
• real-time reallocation

---

14) Measure success with KPIs

Track:

• slot fill rate
• on-time delivery %
• rejected checkout rate
• utilization by slot
• average basket size per slot
• route efficiency
• cancellation rate
• customer conversion
• substitutions / failed fulfillment
• dispatch delay

---

15) Recommended implementation pattern

A solid pattern is:

• Forecast nightly
• Publish slot capacity daily
• Reserve capacity during checkout
• Recompute routes frequently
• Adjust slots as load changes
• Close/discount crowded slots
• Protect service levels with buffers

---

If you want, I can also provide:

1. a system architecture diagram,
2. a database schema for slot inventory, or
3. a sample capacity algorithm / pseudocode for grocery delivery slotting.