MK
All case studies
Case study

Medical Device Manufacturer: Supply Chain Allocation MVP

MVP validated with the team · Product delivery & engineering

Medical device manufacturing / supply chain

Made complex supply-chain decisions easier to inspect, challenge and validate, combining product judgement with hands-on delivery of an allocation engine and AI-assisted process tools.

Concept illustration of an allocation network connecting factories and distribution centres

Concept illustration

Key Performance Indicators

Allocation MVP Validated With the Team
1
Distribution Centres Covered by Allocation Planning
2

MVP delivery and scope measures. The MVP was validated with the team; realised savings and operational adoption are not claimed.

Context

Through Future Works, I worked on supply-chain decision support for a medical device manufacturer. The work spanned how planners allocate inventory and how subject-matter experts capture and investigate business processes. In both, the useful product was a decision people could understand and review.

Challenge

A medical device manufacturer needed supply-chain recommendations that planners could understand and validate. Demand, safety stock, inventory limits and freight costs had to become explicit allocation rules, with shortages and exceptions visible. Consulting through Future Works, I also needed to make AI-assisted process maps reviewable and correctable by subject-matter experts.

Solution

  • Translated planning priorities into product behaviour

    Mapped demand, safety stock, stock limits and freight costs into tunable allocation rules. Defined how shortages and exceptions should surface so planners could assess a recommendation and decide whether to approve it or rerun the scenario.

  • Made business validation part of the product

    Built Excel validation workbooks with plain-English explanations, editable scenarios, input provenance and expected-versus-actual checks. Added CSV cross-checks against the live solver so stakeholders could test the logic using familiar tools.

  • Built the allocation engine and service

    Implemented the Python optimisation service using Pyomo and HiGHS, with FastAPI and PostgreSQL. Separated the solver from the API and persistence layers so the allocation logic could be tested and extended as requirements changed.

  • Contributed the workflows for AI-assisted process discovery

    Built streaming chat and view-aware tools in the process-map explorer, alongside inline subject-matter-expert editing, change history, revert and saved map layouts. These contributions connected AI assistance with reviewable business knowledge.

  • Bound reporting access to the person making the request

    Built a reporting API with verified caller identity, reader and writer permissions, and guarded read-only queries. Added per-caller agent access so AI-assisted investigation followed the requesting user's permissions.

Trade-offs I'd defend

Explainability before model complexity

Used a transparent optimisation model with explicit priorities. This gave planners a basis for challenging an answer and adjusting assumptions before relying on it.

Planner review before operational execution

Kept recommendations reviewable, with approval and rerun workflows. Validation against existing spreadsheets was a delivery requirement, not an activity deferred until after the engine was built.

Impact

Delivered an allocation MVP validated with the team, translating planning priorities into reviewable recommendations across two distribution centres, with scenario comparisons for stock, shortages and freight costs.

My process-map contributions added expert editing, change history and revert, so AI-assisted discovery could be corrected and reviewed. The reporting service, supported by 67 automated tests, bound reporting and agent queries to the caller's permissions. Together, these contributions made recommendations and process knowledge easier to inspect, validate and govern. The central product decision was to build explainability and user control into the workflow.

Live cross-checks
Stakeholders can compare spreadsheet scenarios with the running solver
Reviewable decisions
Allocation recommendations expose constraints and exceptions
Editable knowledge
Process-map changes have history and a way to revert
Caller-aware access
Reporting and agent queries follow user permissions
Python
FastAPI
Pyomo / HiGHS
PostgreSQL
Next.js
React Flow
Where this goes next

Work of this shape starts with Phase Zero: three weeks, a fixed fee, and a paper written for your steering group — with a proof on your own data where there is something to prove.

Specialist engineering for larger companies
Weighing a similar problem for your team?

A build you can't evaluate, a demo that has to ship, or a certificate a contract is waiting on.

Book a 30-minute discovery call. If we're not a fit, I'll tell you on the call — and point you toward someone who is.

WhatsApp me