Skip to Content
Meubles Morinière

The project26 min read

Case study: Meubles Morinière

A furniture workshop and store, two applications in production on one shared database, and a project I led on my own. I go through the context, the problem, the constraints, the decisions, the implementation and the results, and every claim links to its evidence.

Meubles Morinière has built furniture in its workshop in Cholet, France, and sold it in its own store since 1971. Every sale there is a small project: a quote, a deposit, weeks of fabrication, an order with a supplier, a date promised to the customer, and an invoice the law forbids anyone to alter. Here I describe the software I built for that trade with AI coding agents (an ERP for the team, an online store for customers, an AI assistant, one database) and what it guarantees today, with the evidence.

In one minute, read At a glance. In three, add My role. In twenty minutes, the story goes from context to results, then to what the project demonstrates. In an hour, move on to the technical case studies, the architecture decisions and the skills and evidence, extracted from the repository at every build.

The skills pages and the technical case studies are in English. The ADRs and the reference pages behind them are in French, marked FR in the menu. Code excerpts, tests and figures read the same in either language.

At a glance

  • It is a cabinetmaking workshop and a furniture store, where a small team sells, builds, buys, delivers and keeps the books, at the counter and online.
  • The software is an ERP for the team, an online store for customers and Fisher, an AI assistant inside the ERP: two Next.js applications on one Postgres database, plus this documentation.
  • I’m Adrien Poirier, and I led the project on my own, from analysing the store’s needs to running it in production. I build AI (Claude Code) into my development process to explore, design and build more effectively, while keeping control of the technical choices, the consistency of the product and the quality delivered: I frame the needs with the store’s manager, make the calls, set the rules the AI follows, run the tests and check the result on screen (My role).
  • I have six years of industry experience, four of them in software development. Since 2022 I have been building a Next.js traceability application as part of a team. I detail that background further down.
  • I am looking for a role in a product team, in Nantes or Montréal, from March 2027. My contact details are at the end of the page (contact me).
  • On the technical side: strict TypeScript, Next.js 16 and React 19, Postgres (Neon) and Prisma, Stripe, Better Auth, Tailwind CSS 4, Vercel, Anthropic models.
  • Both applications are in production on Vercel, in the Paris region. I started the project on August 23, 2026, and the storefront has been open to the public since November 2, 2026: meublesmoriniere.fr.
Postgres tables
54
schema migrations
169
business modules
40
test files
1,789
Counted in the repository at each build of this documentation.

What the software guarantees today, verified by a test or by the database itself:

  1. A one-of-a-kind piece sells only once, even when it leaves from the counter while another customer is paying for it online.
  2. A breach of the public storefront cannot mark an order as paid, because the database refuses it to the storefront’s role.
  3. If someone edits a recorded payment, the morning check sees it, even with full privileges and the triggers disabled. Hiding it would mean rewriting the whole chain after it (the limits).
  4. The AI assistant can’t pull a number out of thin air without it showing: every number it writes is looked up in what the ERP gave it.

My role

AI as leverage. Engineering as the standard. From the first idea to the implementation, Claude Code lets me go further: the code, the tests, the migrations and this documentation go through it. The choices, the consistency of the product and the quality of what ships remain mine.

StageWhat I doWhere to verify
FramingI gather the needs from the store’s manager and the team, and hand them to the sessions as the frame: a family-run small business, a single warehouse, consumers and business customers, VAT at 10% and 20%. The rules that commit the store are submitted to the manager in the ERP, and after two rounds of triage, their list went from 302 to 8.Design
CallsI decide on budget, scope and ways of working: the trade-offs table lists seven of them, dated, such as leaving refunds out of the first version, running the production migration by hand or forbidding the AI to run the tests. The structural choices (monorepo, two applications, shared database, unalterable money) came out of exchanges with the AI: it proposed, I chose.Trade-offs, What is mine in these decisions (in French)
Directing the agentsI set the rules the sessions follow (AGENTS.md), and hooks enforce part of them. I run several sessions in parallel, each in its own worktree, and integrate their work on main. From October 22 to November 13, that came to 462 sessions and 818 typed messages.Development
ValidationI have run the tests myself since October 12, I check the result on screen and I ask for the source of what the AI claims.Validation, Understanding and questioning
ProductionI am the only person responsible for releases, database migrations and outages. The ERP went to production 126 times between August 23 and November 16, 2026, according to the deployments GitHub recorded for the repository.Quality and delivery, Deployment (in French)

I detail this method, with the records behind it, in My contribution and AI. And I offer to defend any decision in this project in an interview, without AI (the questions I suggest).

Outside this project

This repository shows a project led solo, with AI as leverage. My work in a team is in my job.

Since September 2022

Full-stack developer, Oui-Connect then Cometi (Saint-Herblain, France)

Oui-Connect was the digital subsidiary of Cometi, an industrial group that builds thermal equipment, which absorbed it in 2026. Working in a pair with another developer, I build the interfaces and the server layer of a Next.js application for QR-code traceability and asset management, now in production. I have authored about half of its commits since July 2024. I wrote its frontend architecture plan and its testing strategy, kept the team’s record of technical decisions and set up continuous integration (GitHub Actions). I was there on a work-study (co-op) contract until 2025, and my current contract ends in March 2027.

2020 – 2022

Customer support and development, 7Opteam (Nantes, France)

7Opteam publishes SaaS software for managing field service operations. I handled its customers’ requests, visited them on site to gather their requirements and delivered changes to the product in Angular.

My employer’s repository is private, like this one. The figures come from its git history, and I am happy to talk about it in an interview.

1. Context

The company’s cabinetmakers build solid wood and steel furniture on site, made to measure or from their own designs. The store shows it next to furniture, lighting and decor chosen from Italian, Spanish and French makers.

The same small team sells, writes quotes, orders from suppliers, builds, delivers and keeps the books, and nobody on it works in IT. They wanted to sell online without the website turning into a second store to manage. A piece can leave from the counter or through the website, so each side has to see right away what the other did.

Storefront · /
The storefront’s home page: a workshop piece on the front page, with its dimensions, price and availability.
ERP · /tableau-de-bord
The ERP dashboard: orders to prepare, storefront and store status, incidents, workshop progress, quotes and stock.
The storefront’s home page on a phone.
The live storefront and the ERP dashboard, on desktop and on a phone. Screenshots from the team’s manual, on the demo database. The people, emails and amounts are fictitious, and the numbered markers guide the reader.

The trade, its users and its screens are described in detail in the Overview.

2. The problem

An ordinary order

A customer walks into the store for a made-to-measure solid oak table and a sofa from an Italian maker. The team writes the quote: dimensions, wood, finish, deposit. She accepts it, pays the deposit by card at the counter and will pay the balance on delivery.

The date she is given depends on the workshop’s lead time (six to eight weeks, counted in working days), on store closures and on the Italian maker. The maker’s acknowledgement arrives three days later, with a fabric in a different colour from the one she chose. Six weeks on, the table is ready, but the sofa is two weeks late. The promised date will not be met, and she has to hear it from the store before she finds out for herself. That same afternoon, the showroom’s last display chair is sold at the counter while another customer is paying for it on the website. On delivery, the balance is collected and the invoice issued. It can never be changed after that.

The real problem lies between the tools

Each of these moments can be handled with an ordinary tool: a till, an online shop, a tracking spreadsheet. But nothing that matters happens inside just one of them. The date shown on the website depends on the workshop and the supplier. A piece paid for online has to disappear from the counter. A supplier delivery has to serve the customer waiting for it, and each payment has to find its invoice. Computerising each step was therefore not enough: the links between them had to be kept.

TensionWhat happens when the software gets it wrong
Timea promised date that slips, discovered by the customer the day the furniture fails to arrive
Money in instalmentsa deposit, balance, refund or credit note that no longer finds its invoice
Two channels, one stocktwo customers charged for a single piece
Purchasingan unchecked acknowledgement, and a sofa in the wrong colour delivered two months later
The lawan altered invoice, a till where an edit leaves no trace, personal data kept too long

Code audits found two of these failures. The one on September 1, 2026 showed that two buyers could pay for the same piece ten minutes apart, and the one on November 7 that the delivery date was computed differently from one screen to the next. I tell both stories, with their fixes, in Holding a piece during payment and A promised date you can keep.

3. Constraints

The business said what to build, and the constraints decided how.

  • I am the only one who builds, runs and repairs it. Every component therefore has to cost less to maintain than it brings, and anything that relies on human vigilance ends up forgotten.
  • I build fast, with AI as leverage, and that speed must cost nothing in reliability (An ERP too heavy to maintain). So no guarantee rests on review alone: the database, the type system, the linter or a test provides it.
  • Money and French law come with their own rules: point-of-sale software under article 286 of France’s General Tax Code (CGI), whose records must be unalterable, invoices numbered without gaps, VAT, the right of withdrawal for distance sales, the GDPR and timber traceability (EUDR). A mistake here cannot be erased by shipping a fix.
  • The storefront is open to the whole Internet and connected to the accounting database. A breach of the storefront must not be able to reach the money, the invoices or customer data.
  • Third parties run on their own clock. Stripe confirms a payment minutes or hours later and redelivers its events for three days. A supplier delivers late, and a delivery note arrives as a photo.
  • The team has no IT staff. The ERP has to flag problems on its own, work on a phone and forgive a wrong click.
  • The budget is a small business’s: managed services, no servers to administer and a monthly cap on AI spending.

4. Decisions

Six decisions give the software its shape. Each one comes with its cost and a written record: an ADR, a case study or both.

The constraints on budget, scope and ways of working come from me. Many of the technical choices came from Claude Code’s proposals within that frame, and I chose to keep them. The split, ADR by ADR, is in What is mine in these decisions (in French).

Two applications, one database, two roles

The ERP and the public storefront are two Next.js applications that share one Postgres database, but not the same rights. The storefront connects with a role that holds only what its code needs, table by table and column by column. It can create an order awaiting payment, but it can never mark it paid. Only the ERP does that, when Stripe’s webhook arrives.

An online sale and a counter sale therefore become the same order, with no synchronisation and no double entry, and the part exposed to the Internet does not hold the keys to the money.

In return, the storefront depends on the schema, and its rights are maintained by hand. A test lists every query the storefront makes and fails on any that lacks its grant.

ADR 0002 · ADR 0003 · The storefront only has the rights it needs

The guarantees live in the database

Postgres guarantees what money, the law and stock depend on. Amounts are integers in cents. The database refuses to update or delete an issued invoice, a till closure, a stock movement or a payment. Stock never goes below zero. And each payment carries a SHA-256 hash, computed by the database, that chains it to the previous one.

A guarantee written in application code breaks with a bug, a script or a moment of inattention, whereas a database constraint does not. The hash chain exposes an edit made with full privileges, unless the whole chain after it is rewritten.

It costs heavier migrations, and tests that need a real Postgres database rather than mocks, since every CHECK constraint has a test proving it refuses bad data.

ADR 0008 · Payments that cannot be edited · Data

A business rule is written once

VAT, prices, discounts, shipping, lead times and the promised date live in a single package that both applications call, packages/domain. It opens no connection and reads neither the network nor environment variables. The storefront, born as a fork of the ERP, can no longer drift from it: a pre-push check rejects a rule fixed on one side only.

As a result, the price, availability and date the customer sees are the ones the workshop applies, and customers pay what they saw.

What remains is a set of one-line relay files between the applications and the packages, kept so the code could be extracted without rewriting the tests, and recorded as debt.

ADR 0005 · Two applications born from a fork · A promised date you can keep

Derive rather than store

Holding a piece while a payment is in progress is not written anywhere. It is read from the storefront orders that are still pending and still payable.

A reservations table needs an expiry sweep and a release path for every case, and each one that gets missed either locks a piece or frees it too early. Here, an abandoned order stops holding anything, even if no code ever touches it again.

In exchange, every read recomputes the holds. At a store’s volume that means a handful of rows, but a large retailer would need a dedicated index.

Holding a piece during payment

Fisher’s facts come from the ERP

Fisher reads documents, drafts and answers, but the model supplies no facts. Names and addresses are placeholders the ERP fills in afterwards. Reading a quote request has no price field. Every number in an answer is cross-checked against what the ERP provided during the exchange. Every write waits for a person to confirm it.

In an ERP, a plausible but wrong number commits money or a promise to a customer. And asking the model not to make things up is something nobody can verify.

The check is lexical, so it also flags a correct calculation made by the model. That is intended, because calculations belong to the code.

ADR 0012 · An assistant that does not bring the facts

Build as little as possible

The project has no durable queue, no API in front of the database, no hosted CI, no staff roles and no feature flags. The gate before production is a pre-push hook that checks every commit in a detached worktree.

At the scale of one store and one person, each of these would cost more to maintain than it would bring.

The cost moves without disappearing: reliability rests on local checks and alerts. Each missing piece has its trigger written down. A second person pushing code would bring CI back, and a third client of the database would bring an API. With no queue, a send whose outcome is unknown stays a visible state of the line, and every retry carries the idempotency key of the first attempt.

ADR 0010 · Technical debt, risks and next steps · A request that may or may not have gone out

In the code

Here are four of these decisions, read from the repository when this page is built. Identifiers are in English, while comments and test names are in French.

  • Derived hold: an order holds its pieces as long as it was sold on the storefront, is awaiting payment, has not been cancelled and is recent enough to still be payable. It already carries those four facts.
  • Storefront role: on a real database and with the storefront’s role, Postgres refuses to let it mark an order as paid.
  • Chained payments: each payment carries the hash of the previous one. An edited row therefore breaks the chain, and the daily check verifies it every morning.
  • Fisher’s figures: at the end of each exchange, numbers in the answer that are missing from what the ERP supplied are flagged to the person.
pendingReservationWherepackages/domain/src/stock-reservation.ts · lines 25–51
/**
 * Les commandes du site qui tiennent encore leurs pièces : impayées, et ouvertes depuis moins
 * longtemps que leur session de paiement (et le délai de reprise des événements Stripe, quand une
 * session est partie). Une commande que l'atelier a annulée avant son paiement n'en tient plus :
 * payée quand même, elle ne prend rien au stock (`settleCanceledOrder`). Une pièce réservée n'est pas
 * libre pour le paiement du site, son panier et sa page de commande (`withFreeStock`), ni pour les
 * gestes de l'ERP qui servent une commande déjà payée (changement de variante, rupture servie). La
 * vente au magasin (vente hors site, devis accepté au comptoir), elle, la prend sur le stock brut :
 * le client est là, la pièce en main ; le paiement en ligne qui la tenait se ferme ensuite
 * (`releaseSoldReservations`). Les soldes AFFICHÉS de la fiche et le « Disponible » de
 * la console restent le stock brut : la caisse dit au client que la pièce est en cours de paiement
 * (`StockShortage.isInPayment`).
 */
export function pendingReservationWhere(nowMs: number): Prisma.OrderWhereInput {
	return {
		channel: SaleChannel.WEB,
		paymentStatus: PaymentStatus.PENDING,
		fulfillmentStatus: { not: FulfillmentStatus.CANCELED },
		OR: [
			{ createdAt: { gt: new Date(nowMs - CHECKOUT_RESERVATION_WINDOW_MS) } },
			{
				stripeSessionId: { not: null },
				createdAt: { gt: new Date(nowMs - CHECKOUT_PAYABLE_RESERVATION_WINDOW_MS) },
			},
		],
	};
}

5. Implementation

The product

  • The ERP covers the whole trade: counter sales and quotes, orders that show the state of the money and the state of preparation side by side, workshop deadlines, purchases tied to customer order lines, stock at weighted average cost, catalogue, invoices, credit notes, VAT and accounting export, after-sales.
  • The storefront sells the catalogue with the availability and delivery date each product page can promise. It can take payment through Stripe Checkout and let customers accept and pay quotes, but online payment and quote sending stay closed in production until the terms of sale are final (isCheckoutOpen). It already tracks orders without requiring an account and receives withdrawal requests online.
  • Fisher reads a delivery note, a supplier acknowledgement or a quote request, on paper, as a photo or by voice. It drafts from the ERP’s facts and answers the team’s questions, within the rights of the person using it.

Architecture

A pnpm monorepo brings together the three applications (apps/erp, apps/site, apps/docs) and the packages they share: the schema and migrations (db), the business rules (domain), authentication (auth), the contract for their exchanges (contracts), the UI kit (ui), the technical building blocks (infra) and withdrawals (orders). ESLint guards the boundaries between layers, and dependencies only go one way.

Postgres · Neon

the shared database

  • ERP → DATABASE_URL · owner role
  • Storefront → DATABASE_URL · moriniere_site role

Stripe

payments

  • ERP → STRIPE_SECRET_KEY · secret key
  • ERP ← STRIPE_WEBHOOK_SECRET · webhook
  • Storefront → STRIPE_SECRET_KEY · restricted key

Vercel Blob

photos, accounting documents

  • ERP → BLOB_READ_WRITE_TOKEN · photos, write
  • ERP → INVOICE_BLOB_READ_WRITE_TOKEN · invoices and quotes, write
  • Storefront → BLOB_PUBLIC_HOST · photos, read only

Resend

email

  • ERP → RESEND_API_KEY · sending
  • Storefront → RESEND_API_KEY · sending

Upstash Redis

rate limits

  • ERP → KV_REST_API_URL · rate, idempotency
  • Storefront → KV_REST_API_URL · rate

Vercel AI Gateway

Fisher, Anthropic models

  • ERP → AI_GATEWAY_API_KEY · calls

Web Push

staff notifications

  • ERP → VAPID_PRIVATE_KEY · signing

La Poste

parcel tracking

  • ERP → LA_POSTE_OKAPI_KEY · tracking API

Vercel Cron

scheduled task

  • ERP ← /api/veille · “0 6 * * *”, UTC

Between the two applications

  • ERP → Storefront /api/revalidate · REVALIDATE_SECRET · expire page caches
  • Storefront → ERP /api/evenements-site · SITE_EVENTS_SECRET · announce a withdrawal or an account deletion
  • Storefront → ERP /api/devis-site · QUOTE_PDF_SECRET · fetch a quote PDF
  • Storefront → ERP /api/factures-site · QUOTE_PDF_SECRET · fetch an invoice PDF
A link is drawn only if the application’s code reads the environment variable that opens it; channel paths come from packages/contracts, the scheduled task from vercel.json. Re-read from the repository at every build of this documentation.
  • Rendering goes through the Next.js App Router, with Cache Components and React Compiler. An ERP page never waits for its slowest query: each secondary block streams in under its own Suspense boundary, with a skeleton that matches the final layout.
  • On the caching side, publishing in the ERP immediately expires the affected storefront pages, by tag.
  • The events the storefront sends the ERP (withdrawals, account deletions) are signed (HMAC-SHA256) and timestamped, and rejected after five minutes. Other calls between the applications use a shared secret, compared in constant time. The storefront holds only a restricted Stripe key and no file-storage write token.

Architecture · Next.js and React · Exchanges between the applications

Security and privacy

  • In the database, least privilege comes from the storefront’s role, column-level grants and guard triggers. The storefront refuses to start if it connects with any other role.
  • Every ERP server action opens with its guard, and a test reads every action to check it. Refunding, erasing or exporting data requires a recent sign-in.
  • Customers have no password. The account is optional, and they sign in with a one-time code sent by email.
  • An erasure survives a restore: when a copy of the database is restored, a register of hashes that holds no addresses is replayed (An erasure that survives a restore).
  • In the data the ERP supplies to the model, customer contact details are masked. A document uploaded by the team goes as is. And the provider does not train on the data.

Security · Personal data

Quality

  • Every Postgres guarantee has its tests on a real database: constraints, triggers, concurrent sales of the last unit, and the number of queries per page, to catch N+1 queries.
  • Other tests read the code and reject any departure from a rule: every write expires its cache, every action has its guard, and locks are always taken in the same order (Tests that read the code in place of the reviewer).
  • Before production, the pre-push hook re-runs, in a detached worktree, the lint, the type checks, the affected tests and, when the change calls for it, the Postgres suite and the weight of the storefront’s JavaScript.
  • The documentation cannot stay wrong for long: every code excerpt on these pages is read from the repository at build time, and a missing symbol breaks the build.

Quality and delivery · Tests

Operations

  • Every morning, a daily check looks for what is wrong in production (money received by Stripe that the ERP has not recorded, an order paid without an invoice, a gap in invoice numbering, stock that no longer matches its history) and sends it to the team by email and to their phones (A morning check that says what it could not read).
  • Migrations are scripted: a dry run, then the real run, with the Neon restore point noted beforehand. A destructive migration requires an explicit flag.
  • A restore replays the erasures, so an erased person does not come back with an old copy.
  • Production measurements are dated and reproducible: function response times, the share of requests served from cache (Metrics).

Ways of working

  • I set written rules, for humans and AI coding agents alike (AGENTS.md): how a page loads, when a toast appears, what a test must check, when to split a file. The mechanical guardrails (types, lint, constraints and tests that read the code) apply to everyone.
  • Decisions are recorded as ADRs, with what the sources confirm, what remains an assumption, the residual risks and the signal that would change the decision.
  • I measure before I fix. When the ERP was adding 2.5 lines for every line removed (October 18 to November 9), I answered with a writing rule rather than a big clean-up (An ERP too heavy to maintain).
  • The documentation lives in the repository and reads the code at build time. It is written in French, and the entry pages, the skills pages and the technical case studies also exist in English.

6. Results

What the database and tests guarantee

test suites run against a real Postgres database
111
apps/*/test/db/*.db.test.ts
regression tests, most of which read the source code and reject any departure from a rule
92
apps/*/test/*.regression.test.ts
hand-written CHECK constraints, re-read on the database after every applied migration
169
apps/erp/scripts/constants/db-invariants.ts#EXPECTED_CHECKS
tables, out of the 54 in the schema, the public storefront can write to
6
apps/site/scripts/lib/database-grants.ts#SITE_TABLE_GRANTS
code files still copied from one application to the other, a list that can only shrink
28
scripts/twins.manifest.json
anomalies the ERP’s morning watch looks for in production
28
apps/erp/modules/monitoring/constants/anomaly-readings.ts#ANOMALY_READINGS
Measured in the repository at each build of this documentation.

Before and after

The problemWhat changedThe evidence
Two buyers could pay for the same one-of-a-kind piecethe second buyer is refused before paying, with nothing to expire or clean upPostgres test: only one order is created for a single piece
Each screen computed the delivery date its own wayone rule, a promise frozen at payment, a notice to the customer when the workshop deadline overruns ittest sweeping every day around public holidays
A disabled trigger left no traceany edit to a payment breaks the chain, verified every morning and after every migrationSHA-256 hash chain computed by the database
A restored copy brought erased customers backthe erasure register is replayed on restore, without keeping any addressreplay tests on a real database
A storefront breach would have exposed the whole databasefor writes, at worst orders awaiting payment and customer-account datatest run with the storefront’s role
A language model writes plausible numbersthe model supplies no facts, and every number it writes is cross-checkedcheck on every exchange, draft refused on any mismatch
Two copies of a pricing rule drifted silentlya fix made on one side only is rejected at pushpnpm check:twins, a list of copies that can only shrink
The ERP added 2.5 lines per line removed, from October 18 to November 91.35 per line over the next four days (measured November 13, 2026)git log, with the counting method in the case study

What is not proven yet

A case study that only lists its successes cannot be checked, so here is what the repository does not show yet.

  • I have no usage figures to show: no order counts, no time saved for the team. The project started on August 23, 2026, the storefront has been open since November 2 and the team has only recently started using the ERP. These pages show what the software guarantees, and not yet what it has changed for the store.
  • Neither test coverage nor Core Web Vitals measured on real visitors are recorded, and the browser tests that walk through whole user flows are run by hand. The protocol to obtain them is written down (Metrics).
  • One person writes, reviews, migrates and restores. The procedures are scripted, but no full restore has left a trace in the repository.
  • Whether the software qualifies as point-of-sale software under article 286 of the CGI is waiting for the accountant’s answer. It is the one risk no line of code can reduce.
  • Size has not gone down yet. The pace of additions has slowed, but some components still exceed the 600-line ceiling, and mocked tests still duplicate the suite that runs against the database.

Technical debt, risks and next steps · What is not covered

7. What this project demonstrates

Depending on the role you are hiring for, here is where to look. The table says what the software does and where to verify it. What comes from me in each row is in My role.

RoleWhat the project showsWhere to verify
Full-stack (TypeScript, React, Next.js)two Next.js 16 and React 19 applications in production, streamed server rendering, a cache invalidated by the ERP, customers pay what they sawFull-stack, Next.js and React
Back-end and dataa rich domain model, with Postgres as the guardian: constraints, triggers, ordered locks, hash chain, scripted migrationsData, Quality
Software architecturea monorepo with checked boundaries, decisions recorded with their trade-offs, reasoned decisions not to buildArchitecture, Decisions
Application security (AppSec)least privilege in the database, signed messages, secrets that change without downtime, privacy designed in from the startSecurity
Applied AI (LLM integration)an assistant in production whose guarantees the code checks, an evaluation set built from real errors, capped spendingFisher, An assistant that does not bring the facts
Product and UXan ERP for a small team: progressive loading, undoable actions, nothing lost on a dropped connection, checked accessibilityUX
AI-assisted developmentwritten rules, mechanical guardrails, a maintenance rate measured then correctedAn ERP too heavy to maintain
Requirements analysis and working with the businessa trade modelled from quote to invoice, rules submitted to the manager in the ERP, a built-in manual for the teamBusiness logic (in French), Design
Delivery and operationsa gate before production, scripted migrations with their rollback, backups, a morning check that looks for anomalies every dayQuality and delivery, A morning check that says what it could not read

What carries over to Quebec and Canada

The project answers to French law, for a French business, but its practices carry over directly.

  • Collect as little as possible, keep it only as long as needed (retention periods written once in the code and applied every morning) and prove erasure: these are the privacy principles the project applies under the GDPR, and they are also those of PIPEDA and Quebec’s Law 25, which requires personal information to be destroyed or anonymised once the purposes of its collection have been achieved. Law 25 also requires a privacy impact assessment before personal information leaves Quebec. The documentation already states where the applications and the database are hosted (Vercel in Paris, Neon in Virginia), which is where that assessment starts.
  • For sales taxes, rates and rounding live in a single pure, tested package that every sales channel calls. That is the right shape for GST, HST and QST, whose rates and combinations vary from one province to another.
  • On languages, the product is designed French-first, as Quebec’s Charter of the French Language expects of commercial software and websites. The code uses English names. This documentation is written in French, and its entry pages, skills pages and technical case studies are translated into English.

Further reading

Contact

If this project looks like the role you are hiring for, I’d be glad to walk you through the code in an interview.

Adrien Poirier

Full-stack software developer

I am looking for a role in a product team, in Nantes or Montréal, from March 2027. I have six years of industry experience, four of them in software development. Since 2022 I have been building a Next.js traceability application as part of a team.

Education
French professional certification at master’s level (RNCP, level 7)
Location
Nantes, France. Relocating to Montréal upon hiring.
Status in Canada
Application planned for the 2027 IEC Working Holiday program (open work permit)
Languages
French, native. English, intermediate.

On this page