Classroom Activity: Build a Simple Transportation Management Simulation

Hook: Teach logistics, APIs and optimization with a hands-on simulation that mirrors today's industry

Students and instructors often struggle to find classroom projects that are both technically rigorous and directly relevant to industry. Building a simple transportation management simulation that models tendering and dispatch for autonomous trucks solves that problem: it teaches APIs, basic optimization, and logistics fundamentals in a tangible, multidisciplinary project aligned with 2026 industry trends.

Why this project matters in 2026

By late 2025 and into 2026, the logistics industry moved from isolated autonomous truck pilots to practical integrations between autonomy providers and Transportation Management Systems (TMS). Industry-first links have shown how a TMS can tender, dispatch and track driverless capacity via APIs. That shift means students who learn to model tendering, API-driven dispatch and routing optimization are acquiring skills employers want now.

This classroom project mirrors those real-world changes and gives students the chance to:

• Understand how a TMS interacts with carriers and autonomy platforms through REST/WebSocket APIs.
• Implement allocation and routing algorithms used in dispatch — from greedy heuristics to integer programming and OR-Tools.
• Design business rules for tendering, rate negotiation and SLAs, useful in business or supply-chain classes.
• Build simulated telemetry and dashboards that mimic live operations.

Project overview: Build a tender-and-dispatch simulation

At a high level students will implement a mock TMS and an autonomous fleet provider that exchange messages to tender and accept loads. The project fits a 3–6 week module and scales from a simple API exercise to an advanced optimization lab.

Core learning objectives

• Design and implement a set of RESTful APIs for tendering and dispatch.
• Model essential logistics entities: orders, equipment, lanes, time windows, capacity and telemetry.
• Implement dispatch logic: acceptance rules, bidding or auto-accept, and routing.
• Use optimization libraries (e.g., OR-Tools or PuLP) to solve assignment or routing variants.
• Measure KPIs: service rate, cost per mile, on-time performance, tender acceptance rate.
• Communicate trade-offs between operational rules and business outcomes.

What you’ll need (tools and datasets)

This project is inexpensive and can run on student laptops or low-cost cloud instances.

• Language: Python (recommended) or Node.js/Java
• Web framework: Flask / FastAPI or Express
• Database: SQLite for small classes or Postgres for larger datasets
• Optimization: OR-Tools (Google), PuLP, or SciPy for heuristics
• Mapping/visualization: Leaflet with OpenStreetMap tiles or Mapbox
• Message broker (optional): MQTT or RabbitMQ for telemetry streams
• Testing tools: Postman or curl for API testing
• Datasets: OpenStreetMap for roads, synthetic load manifests, or simple CSVs

Design: Entities, API schema and flow

Start by defining the minimal domain model and a concise API. Keep the first iteration small — then iterate.

Essential entities

• Load: id, origin, destination, pickup window, delivery window, weight, commodity type.
• Truck: id, location, capacity, battery/charge (if electric), current assignment.
• Tender: a request from shipper/TMS to carrier/autonomy provider that includes load details and price.
• Bid/Response: carrier acceptance, rejection, or counter-offer.
• Telemetry/Event: timestamped GPS, status updates (en route, loading, delivered).

Minimal API endpoints (example)

Define clear, RESTful endpoints for each role. Here’s a compact example for the TMS side:

POST /tenders        # create a tender (load) 
GET  /tenders/{id}   # check tender status
POST /carriers/{id}/bids  # carrier submits bid or acceptance
POST /dispatch/{truck_id}/assign # assign load to truck
GET  /telemetry/{truck_id}     # stream or fetch latest telemetry

For the autonomous carrier service, serve endpoints or WebSocket events that accept tenders and return acceptance or rejection quickly.

Typical message flow

1. TMS creates a tender with pickup/delivery windows and rate.
2. TMS sends tender to one or more carriers via API.
3. Carriers evaluate and respond with bids or acceptances.
4. TMS accepts a bid, assigns the load, and dispatches a truck.
5. Truck streams telemetry; TMS updates ETAs and KPIs.

Keep the first pass synchronous: tender → accept/decline → assign. Add auctions, counter-offers, and multi-stop routing later.

Teaching the optimization: from greedy to OR-Tools

Optimization is the core technical learning outcome. Structure labs so students start with simple heuristics and graduate to formal optimization.

Step 1 — Heuristics (Week 1)

• Nearest-truck-first: pick the truck closest to the pickup (Euclidean or Manhattan distance on small maps).
• First-available: assign the truck with earliest availability that meets time windows.
• Cost-based: choose truck minimizing a cost function (deadhead distance + fuel).

These heuristics are fast and help students understand trade-offs and complexity.

Step 2 — Assignment problem (Week 2)

Formulate tendering as a bipartite assignment: loads on one side, trucks on the other. Solve with the Hungarian algorithm or OR-Tools’ linear solver to minimize total cost.

Step 3 — VRP and constraints (Week 3–4)

Extend to a Vehicle Routing Problem (VRP) with time windows and capacity constraints. Use OR-Tools’ routing solver. If computing resources are limited, run small scenarios or allow students to test only subproblems.

Practical notes on optimization

• Teach students to encode costs clearly: distance, time, penalties for late delivery.
• Provide baseline scenarios with known optimal or near-optimal solutions for grading.
• Discuss runtime complexity and why heuristics matter in real-time dispatch.

Business-class angle: tender economics and KPIs

This project also maps perfectly to business or supply-chain courses. Students can model tender economics and run what-if analyses to see how operational choices affect profit and service.

Assignments for business students

• Model tender cost components: linehaul rate, accessorials, detention, fuel surcharge, and risk premium for autonomous service.
• Simulate different pricing models: fixed rate tenders vs. auctioned loads vs. dynamic pricing.
• Analyze KPIs: on-time delivery percentage, average cost per mile, tender acceptance rate, and utilization.
• Debate strategic questions: when to prefer autonomous carriers versus human-driven carriers? What operational changes reduce total cost?

Classroom timeline and milestones (4-week module)

Below is a practical schedule you can tailor for your class size and length.

1. Week 1 — Project kickoff: domain model, API design, simple heuristic dispatch. Deliverable: working tender API and nearest-truck dispatch.
2. Week 2 — Optimization lab: assignment solver and basic cost model. Deliverable: solver that assigns multiple loads to trucks.
3. Week 3 — Telemetry and visualization: simulate GPS updates and build a live dashboard. Deliverable: map-based dashboard showing truck locations and statuses.
4. Week 4 — Business scenario and evaluation: run experiments, analyze KPIs and present findings. Deliverable: final report and demo with performance metrics.

Sample starter code (conceptual)

Provide students with a minimal starter repo containing:

• API scaffold (Flask/FastAPI) with /tenders and /truck endpoints
• Small SQLite dataset with synthetic loads and trucks
• Simple greedy dispatch function
• Front-end HTML + Leaflet map to visualize trucks

from fastapi import FastAPI
app = FastAPI()

@app.post("/tenders")
def create_tender(tender: dict):
    # store tender and return id
    pass

@app.post("/dispatch/{truck_id}/assign")
def assign(truck_id: int, tender_id: int):
    # assign load to truck if feasible
    pass

Keep the code documented and include test cases so students can verify behavior quickly.

Evaluation: rubrics and experiments

A good rubric blends technical correctness, code quality and business insight.

• Functionality (40%): APIs work, dispatch flows complete, telemetry updates.
• Optimization correctness (25%): solver returns valid assignments and improves objective vs. baseline.
• Analysis and reporting (20%): KPIs, graphs, sensitivity analysis.
• Code quality and testing (15%): clear structure, unit tests, documentation.

Extensions & advanced ideas for CS or research students

Once the core project is complete, several advanced directions fit capstone or research projects:

• Integrate an auction mechanism where carriers bid and simulated negotiation or multi-round tenders occur.
• Build a digital twin by coupling the simulation to traffic models or SUMO for realistic routing and congestion effects.
• Apply reinforcement learning for dynamic dispatch and compare RL policies to heuristics and OR-Tools across metrics.
• Model energy constraints for electric autonomous trucks with charging station scheduling.
• Implement event-driven microservices architecture with Kafka or MQTT to emulate production-grade systems.

Data, ethics and safety considerations

Students must learn real-world constraints beyond optimization. Cover these important topics:

• Privacy: avoid using real carrier or driver data without consent. Use synthetic datasets.
• Safety: autonomous systems have safety-critical implications. Discuss risk management and regulatory oversight.
• Bias and fairness: ensure routing decisions don’t systematically disadvantage certain regions or carriers.
• Explainability: teach students to make dispatch decisions auditable and explainable for stakeholders.

2026 trends and how they inform the project

Several trends seen in late 2025 and early 2026 should shape classroom conversations and project design:

• API-first TMS integration: Leading TMS platforms are exposing APIs that allow automated tendering and dispatch. Your mock TMS should be API-driven to reflect this reality.
• Rise of service-level contracts for autonomy: Carriers are increasingly defining SLAs for autonomous loads (uptime, minimum miles). Add SLA fields in tenders and penalties for missed SLAs.
• Data-driven dispatch: Digital telemetry and predictive ETAs are standard. Simulate telemetry and show how predictive models affect routing decisions.
• Interoperability pressure: Expect industry moves toward standardized event schemas and payloads; encourage students to use OpenAPI specs and well-documented JSON schemas.

Common pitfalls and how to avoid them

• Scope creep: start small. A working heuristic-first system is better than an incomplete OR-Tools monster.
• Complex mapping dependencies: keep the map/simple routing logic lightweight initially — avoid external API quotas by using offline or synthetic distances.
• Unclear grading: provide clear test scenarios and expected KPIs so students know what success looks like.

Classroom-tested example: results & case study

In a recent semester-style implementation (adapted from industry workflows that integrated driverless fleets into TMS platforms), student teams built a mock TMS and simulated tenders across 50 loads and 12 autonomous trucks. Key outcomes included:

• Median assignment latency under the greedy heuristic: < 200ms
• Switching to OR-Tools improved total simulated deadhead miles by ~18% at the cost of increased compute time
• Business teams showed that raising the tender acceptance probability (via slightly higher rates) reduced average detention costs by 10% — a direct operational insight

These results demonstrate how an interdisciplinary project yields both technical and managerial learning.

Assessment ideas and presentation

Ask students to present:

• Demo of API flows and dashboard
• Comparative results: heuristic vs. optimized strategy
• Business analysis with KPIs and cost trade-offs
• Reflections on limitations and real-world applicability, including safety and regulatory considerations

Teacher resources and starter checklist

Use this quick checklist to get started:

• Prepare a minimal API scaffold and sample dataset.
• Create 3 baseline scenarios (small, medium, large) with ground-truth outcomes.
• Provide step-by-step lab guides for heuristics and then OR-Tools.
• Offer a grading rubric and deliverable templates (README, report, slides).

Final takeaways: what students will gain

By completing this project, students will:

• Gain hands-on experience building and documenting APIs and microservices used in modern TMS workflows.
• Understand the trade-offs between heuristics and exact optimization under real-time constraints.
• Learn to interpret logistics KPIs and link technical decisions to business outcomes.
• Prepare for careers in software engineering, logistics, operations research, and product roles where multidisciplinary skills are essential.

Call to action

Ready to bring this module into your classroom? Assemble your starter repo, pick one scenario, and run the first tender-to-dispatch demo in a single lab session. If you’d like a ready-made starter kit, sample datasets and rubrics for instructors and students, download the teacher resources and starter code from the learns.site classroom resources page or contact your department to adapt this curriculum for your course. Start small, iterate, and let industry trends from 2026 inform richer extensions as your students’ skills grow.

Related Reading

• LEGO Zelda: Ocarina of Time — The Final Battle Set Deep Dive for Gamers and Collectors
• Monetizing Sensitive Topics on YouTube: A Creator’s Checklist After Policy Changes
• FedRAMP and Quantum Clouds: What BigBear.ai’s Acquisition Means for QubitShared Sandboxes
• BTS’ Comeback Title Explained: The Meaning of the Folk Song and What It Signals Musically
• The Ethical Side of Cozy: Sustainable Fillings for Microwavable Heat Packs