B2B ordering portal
OngoingMoving orders out of an internal Excel file and opening their entry to clients.
- orders per season
- 1 000+
- users
- ~100
- to v1.0
- 5 mois

Context
- The internal team alone handles seasonal commitments, orders and delivery planning, in Excel.
- Its commercial data already lives in an ERP. The project keeps that ERP.
- The portal opens entry to over a hundred clients. Each client sees only their own data.
My mission
- Stack selection and Azure infrastructure design.
- Writing the technical architecture document.
- Implementing the entire backend.
- Delivery pipeline on Azure DevOps. Deployment requires a green build, the SonarQube quality gate and zero critical vulnerability.
- Supervising the frontend developer and defining the conventions shared by both applications.
- Technical contact for the client, on specifications and estimates for changes.
Decisions and trade-offs
01
Delivering in increments instead of one release
ProblemThe client expects a finished product and keeps changing its requests. Meanwhile, the ERP sync falls behind.
SolutionRe-cutting the backlog to ship the features already done.
Why this choiceThe client's requests settle only once the product is in use.
02
Building the synchronisation ahead of the API
ProblemThe ERP team's API arrives two months late. The synchronisation depends on it, along with its transaction and conflict-resolution logic.
SolutionBuilding and testing against the interface contract, on datasets made for the purpose. The feature stays off in production until the API ships.
Why this choiceThe contract is available and frozen. Waiting stalls the most complex part of the backend on an external dependency.
03
Recovery driven by hand rather than automatically
ProblemThe sync fails in two ways: on fetching data from the ERP, and on sending to the ERP, with timeouts on slow responses.
SolutionInbound, no automatic retry. The administrator sees the status per category and reruns only the failed category. Outbound, an icon flags the failure and an internal queue replays each timed-out send once.
Why this choiceThe administrator picks the moment to rerun. A blind retry would resync unasked. On sends, a single replay absorbs about 90 % of errors.
04
Ruling out Next.js in favour of a standalone backend
ProblemThe team maintains Go, C# and JavaScript, and has to sustain the choice over time. A proposal pushes Next.js to cover front and back in one piece.
SolutionA separate React frontend, a standalone NestJS backend.
Why this choiceThe application runs the ERP sync cron, and a planned change needs websockets in the same instance. Next.js follows a one-off request model, a poor fit for continuous processing. A standalone backend makes that lifecycle explicit, free of hosting-platform constraints.
05
One architecture across both applications
ProblemTwo applications for one product, with a different developer on each.
SolutionThe same split into feature slices on both sides. On the front, logic moves out of components into hooks, and React Query handles server state.
Why this choiceThe folder tree shows the business scope, and a developer moves between the two applications without reorienting. In exchange, the frontend developer upskills on common React practices.
What this project taught me
- Technically supervising a developer on a client project, after several internal ones.
- Moving from a waterfall plan to short, incremental releases, against a vague need and shifting requirements.
- Handling a blocking external dependency, with a late ERP API and a shifted schedule.
- Taking over a third party's estimate, with the gap between that estimate and the real need.
- Producing architecture documentation at a level above the code.
- Estimating changes, with each request's impact on the whole project.
In hindsight
- Set up a deployment pipeline and a minimal feature slice from day one, to test the product against its real environment early.
- Capture the need in an interactive mock-up session with the client before scoping, rather than from a specification.