STEM Project: Build a Simple Simulation of a TMS That Integrates Autonomous Freight Capacity

Build a Classroom TMS Simulation That Tenders to Autonomous Trucks — Fast

Struggling to fit hands-on logistics, coding, and systems thinking into one project? This applied STEM unit gives students a compact, scaffolded way to prototype a Transportation Management System (TMS) and simulate tendering to autonomous carriers — the kind of API-driven workflow driving real-world change in 2025–2026.

Why this project matters in 2026

By 2026 the logistics industry has moved from early pilots to operational integrations between TMS platforms and autonomous carriers. Partnerships like TMS vendors connecting via APIs to autonomous fleets (for example, pilot integrations announced in previous years) mean students can now study the exact workflow companies use to tender, dispatch, and track autonomous trucks. For classroom purposes we’ll emulate those APIs and focus on the decision-making and system-level tradeoffs — the skills teachers and employers want.

What students will learn (quick preview)

• Systems thinking: map the TMS lifecycle from tendering to execution and feedback loops for performance improvement.
• Coding & APIs: build a simple TMS backend and a mock autonomous-carrier API, exchange JSON payloads, and simulate tender acceptance.
• Logistics logic: create tender-selection rules, cost/time tradeoffs, and KPIs (on-time, cost per mile, utilization).
• Prototyping & UX: make a minimal UI or CLI for tendering and viewing simulated tracking updates.

Project overview: scope, timeline, and outcomes

Design this as a 3–4 week classroom module (adjustable) with these milestones:

1. Week 1 — Systems mapping & data model design.
2. Week 2 — Backend prototyping (TMS API and mock autonomous carrier API).
3. Week 3 — Tender logic, simulation runs, and KPI dashboards.
4. Week 4 — Presentation, reflection, and extensions (ML ranking, multi-agent sim).

Deliverables: working prototype (code repo), simulation report with KPIs and system diagrams, and short demo video or live demo.

Technology stack (teacher-friendly)

Pick tools that match your students’ experience. Two recommended options:

Option A — Python stack (best for STEM classes)

• Backend: Flask or FastAPI
• Database: SQLite for simplicity or PostgreSQL for realism
• Frontend: simple React app or a Flask Jinja template
• Testing & tooling: Postman / HTTPie, Docker for containerizing

Option B — JavaScript stack (best for web-focused classes)

• Backend: Express.js with Node
• Database: SQLite or MongoDB
• Frontend: React or plain HTML/CSS with fetch()

Pro tip: Use cloud-hosted free tiers (Replit, Glitch, Railway) if students can’t run Docker locally.

System design: components and data model

Keep the architecture simple but realistic. The simulation should include these core components:

• TMS Core: API endpoints to create loads, tender loads, and receive status updates.
• Carrier Marketplace: a registry of carriers (human-driven and autonomous) with attributes like cost-per-mile, start/end locations, available capacity, and acceptance probability.
• Autonomous Carrier Mock API: a simulated external API that accepts tenders and returns automated acceptance/decline decisions and tracking events.
• Decision Engine: tender selection logic that ranks carriers by cost, ETA, utilization, and preference for autonomous capacity.
• Simulator: advances simulated time, generates telematics updates, and logs KPIs.

Minimal data model (JSON examples)

Share these example schemas with students so they can start coding quickly.

Load (TMS)

{
  "loadId": "L1001",
  "origin": "Kansas City, MO",
  "destination": "Denver, CO",
  "weight": 18000,
  "pickupWindow": "2026-02-10T08:00:00Z",
  "deliveryWindow": "2026-02-11T18:00:00Z",
  "status": "created"
}

Carrier (marketplace)

{
  "carrierId": "AUR-DRVR-01",
  "type": "autonomous",
  "name": "Aurora-Sim",
  "costPerMile": 1.45,
  "availableFrom": "2026-02-10T00:00:00Z",
  "acceptanceRate": 0.95,
  "averageSpeedMph": 60
}

Build the mock autonomous carrier API — the classroom equivalent of Aurora’s link

One of the real-world changes by 2026 is the availability of carrier APIs that allow TMS platforms to tender directly to autonomous fleets. In class, students will build a simplified version that mimics that behavior.

Core endpoints to implement

• POST /tenders — receive a tender request; respond with accept/decline and ETA.
• GET /status/{tenderId} — return current status and simulated telematics.
• POST /webhooks — (optional) allow the mock carrier to push status updates to a TMS webhook URL.

Example tender request payload

{
  "tenderId": "T-9001",
  "loadId": "L1001",
  "origin": { "lat": 39.0997, "lon": -94.5786 },
  "destination": { "lat": 39.7392, "lon": -104.9903 },
  "pickupWindow": "2026-02-10T08:00:00Z",
  "weight": 18000
}

Your mock API will run a simple decision: if the carrier has capacity and the route matches, accept with probability equal to acceptanceRate. If accepted, return an ETA and an initial tracking state.

Tendering logic and decision heuristics

Teach students simple heuristics first, then encourage experimentation. Start with:

• Lowest cost-per-mile subject to meeting pickup/delivery windows
• Preference for autonomous carriers when they reduce cost or improve ETA
• Penalty for carriers with lower acceptance probability to avoid tender rejections

Score formula (classroom-safe):

score = (weightCost * normalizedCost) + (weightTime * normalizedETA) + (weightReliability * (1 - acceptanceRate))

Students can tune weights and run simulations to see how favoring autonomous carriers affects KPIs like total cost, average transit time, and tender rejection rate.

Simulation design: running experiments and collecting KPIs

Simulations let students explore policy outcomes at scale without needing hardware. Have them define experiments and collect these KPIs:

• On-time delivery rate
• Average cost per load
• Tender rejection rate
• Autonomous utilization (share of miles moved by autonomous carriers)

Example experiment

Run 1: Baseline — no preference for autonomous carriers. Run 2: Aggressive — favor autonomous carriers by lowering their effective cost in the scoring formula. Run 3: Conservative — prefer human carriers unless autonomous ETA is substantially better.

Collect results over 1,000 simulated loads. Use graphs (Matplotlib or Chart.js) to show tradeoffs. This is a perfect place to practice data visualization and storytelling in the classroom.

Systems thinking: map feedback loops and unintended consequences

Encourage students to go beyond code. Ask them to draw causal loops for decisions such as:

• Increased autonomous utilization → lower cost-per-mile → higher tendering to autonomous carriers → congestion on routes suited for autonomous trucks → potential delays
• High rejection rates → more re-tendering → longer lead times and increased cost

Prompt reflection questions:

• How does prioritizing cost affect reliability?
• Which metrics should a real company prioritize during the adoption phase of autonomous capacity?
• What safeguards should be built into a TMS to avoid oscillations (rapid switching between carriers) when acceptance rates change?

Assessment rubric and classroom roles

Divide students into roles to mirror real-world teams: TMS engineer, carrier manager, data analyst, product owner. Assess with this rubric:

• Prototype functionality (40%): endpoints work, tenders processed, and simulation runs.
• Systems artifacts (20%): diagrams, causal loops, and reasoning.
• Data analysis (20%): KPIs tracked, charts, and experiment comparisons.
• Communication (20%): demo, code documentation, and reflection on tradeoffs.

Classroom-ready code snippets & testing tips

Share these snippets as starter templates. Teachers can paste into classroom IDEs to accelerate setup.

Minimal FastAPI handler for /tenders (Python)

from fastapi import FastAPI
from pydantic import BaseModel
import random

app = FastAPI()

class Tender(BaseModel):
    tenderId: str
    loadId: str
    pickupWindow: str
    weight: int

@app.post("/tenders")
def receive_tender(tender: Tender):
    # simplistic acceptance: acceptanceRate 0.9
    accepted = random.random() < 0.9
    return {"tenderId": tender.tenderId, "accepted": accepted, "etaHours": 18 if accepted else None}

Testing with curl

curl -X POST http://localhost:8000/tenders -H "Content-Type: application/json" -d '{"tenderId":"T1","loadId":"L1","pickupWindow":"2026-02-10T08:00:00Z","weight":18000}'

Encourage students to instrument their endpoints with simple logs and to use Postman or HTTPie for exploratory testing. If your mock carrier supports webhooks, demonstrate receiving asynchronous updates in the TMS — a neat way to teach event-driven architecture.

Extensions & advanced challenges (for advanced students)

Once students have the base system, push them with optional improvements that echo industry practice in 2026:

• Rate-limited APIs & retries: simulate API throttling and implement exponential backoff.
• Multi-agent simulation: model traffic, weather, and road closures that change ETA and acceptance probabilities.
• Machine learning ranking: train a simple model to predict carrier acceptance or delay risk using historical simulation data.
• Security & compliance: discuss identity/auth for carrier APIs; add API keys or JWTs to endpoints.
• Real-time visualization: WebSockets to stream tracking updates to the dashboard.

Pedagogical notes: safety, ethics, and industry context

Always pair the technical build with a discussion on safety, labor impacts, and regulation. By 2026, autonomous freight has matured but remains regulated; students should consider:

• How automation affects drivers and dispatch staff
• Bias in optimization (e.g., favoring low-cost offers that undercut safety margins)
• Data privacy for telematics and location data
• Regulatory constraints such as regional route approvals and operational hours

Bringing in a guest speaker from logistics or a virtual tour of a TMS vendor can connect classroom work to 2026 industry realities.

Real-world tie-ins and recent trends (late 2025–2026)

Several trends make this classroom project timely:

• TMS–autonomy integrations: commercial TMS platforms increasingly offer API links to autonomous carriers, letting shippers tender directly from their TMS dashboards.
• Open APIs & standardization: industry groups pushed for more standardized freight APIs in 2025, lowering integration barriers for smaller carriers and classroom simulations.
• Simulations for certification: logistics training programs are using simulations as part of certification and hiring pipelines, creating a demand for students with applied TMS experience.
• Edge AI in routing: by 2026 many carriers use onboard AI to optimize routing and energy consumption — an advanced topic students can simulate as an extension.

Common pitfalls & how to avoid them

• Too much complexity: start simple; avoid full telematics networks. Get tendering right first.
• Lack of evaluation: always define KPIs before simulation. Otherwise, experiments are storytelling, not evidence.
• Ignoring edge cases: teach students to handle rejections, partial loads, and API failures — these are where real systems show weaknesses.
• Poor team roles: split tasks so students rotate through coding, analysis, and systems design.

Wrap-up: what success looks like

A successful project produces:

• A working TMS prototype that can send a tender to a mock autonomous carrier and receive a deterministic or probabilistic response
• A short experiment comparing policies (baseline vs. favor-autonomy vs. conservative) and a one-page KPI summary
• Diagrams connecting systems thinking to simulation outcomes and a clear reflection on tradeoffs and ethics

Ready-to-run starter checklist (for teachers)

• Repository template with backend scaffolding (FastAPI/Express), sample data, and README
• One-page assignment brief with roles and rubric
• Sample Postman collection or curl commands
• Notebook or script to run 1,000-load simulations and produce KPI charts
• Slide template for student demos

Next steps & classroom resources

To implement this module quickly:

1. Clone the starter repo and spin up the backend in a classroom cloud environment.
2. Walk students through the data model and run a live tender demo.
3. Assign teams to implement endpoints and run the first simulation by Week 2.

Teacher tip: use pair programming and daily standups — this mirrors industry workflow and keeps projects on track.

Final thoughts

This STEM project blends coding, logistics, and systems thinking into a compact, real-world-relevant unit for 2026 classrooms. Students get to prototype a TMS, interact with an autonomous carrier API, and explore the tradeoffs companies face when they adopt driverless freight capacity. That combination of technical skill, analytic reasoning, and ethical reflection prepares learners for careers in logistics, product engineering, and operations research.

Call to action

Want a ready-made starter repo, lesson slides, and assessment rubric tailored for your grade level? Download our classroom kit and get a step-by-step teacher guide to run this unit in 2–4 weeks. Try a demo simulation with your class this term and share results — we’ll feature standout projects and interview winning teams on Classroom.top.

Related Reading

• From Stove to Global: How Hands-On Product Development Inspires Better Spa Offerings
• 7 CES 2026 Smart-Home Upgrades That Actually Improve Resale Value
• Gentleman’s Bar Guide: Signature Drinks to Order with Your Winter Wardrobe
• How Diaspora Communities Can Safely Support Artists Abroad — A Guide to Transparent Fundraising
• Rapid QA Checklist for AI-Generated Email Copy