Meridian

Problem

The company covers the chain from producing medicinal products to distributing them to the people who use them. Each stage has its own needs and its own users, but the data has to be one thing: a batch produced on one side is the same batch that reaches a customer on the other. In a regulated field, "roughly in sync" is not good enough. They needed a backend three different apps could stand on without stepping on each other, and without anything getting lost in the handoffs between stages.

What I built

I owned the backend from the first schema to production.

• The data model for the whole ecosystem, designed so a record created at one stage carries through to the next without being copied, re-keyed or drifting out of sync.
• One REST API for three apps. Each app consumes the same backend through its own endpoints, with shared endpoints where the stages overlap, so there is one behaviour and one source of truth rather than three copies that slowly disagree.
• Consistency across stages. State changes propagate through the chain in a controlled way: when something moves or changes at one stage, the stages that depend on it see it, and nothing falls through the gaps between apps.
• Role and stage-based access on the data itself, so each type of user only ever sees and touches the slice of the chain that belongs to them, enforced in the backend rather than hidden in the interface.
• Background tasks, triggers and webhooks for everything that happens without a user in front of a screen: movements, status changes, notifications and syncs with outside services.
• Built to scale. The schema and the queries were designed to hold their shape as volume grows, so the cost of an extra stage or a spike in activity is predictable, not a rewrite.
• Documentation and a review process for the backend, so other people on the team could read it, extend it and trust it.

Results

The product was still in development when my contract ended, so there are no usage numbers to show. What there is: three apps with very different users share one backend and one source of truth, data stays consistent as it moves across the chain, access is controlled at the data layer as a regulated field requires, and the backend is documented well enough that the team could take it forward without me.