Skip to main content

Code Review at Orus

· 29 min read
Samuel Rossille
Samuel Rossille
Chief Technology Officer
Cover

Everybody who writes software with AI agents sees the same thing: code review became the bottleneck. Writing code got cheap. Reading it did not.

We saw it in our own numbers. Comparing the months after July 2026 with the quarter before, the average number of lines of code produced per person went up by 72%. The median pull request grew from 72 to 129 lines. Merged PRs per person went up too. And the median time to merge a PR went up sharply, because the people who review are the same people who now produce twice as much code.

The usual framing is a trade-off. Keep reviewing everything the way you used to, and let the team spend its days waiting for each other. Or lower the bar, and slowly lose what review was protecting: security, architecture, coding standards, and the shared understanding of the codebase.

That framing treats review as one job. It is several:

  • catching bugs before production
  • holding the code to our standards
  • guarding security and architecture
  • spreading knowledge across the team
  • on some PRs, a real design discussion between people who know the domain

Those jobs don't need the same reviewer. Checking a change against almost two hundred coding rules, or hunting for the retry that charges a customer twice, takes patience and context more than seniority. Deciding whether a design is right, or signing off on a pricing change, takes a person who owns the consequences. So we split them. Orusaurus, an AI reviewer we built in-house, does the first kind of work on any PR you ask it to review, in about four minutes. Our approval rules decide which PRs still need a human, and that is where human attention goes.

This post describes how it works, the decisions behind it, what we measured, and what it does not do. It is also the reference for our own team on what to expect from it.

How to build AI agents that actually work in prod

· 19 min read
Samuel Rossille
Samuel Rossille
Chief Technology Officer
Cover

At Orus, we built an AI agent to handle the termination of a customer's previous insurance contract after they subscribe to a new one. The process covers roughly 500 cases a month. Internal estimates put the previous handling time at 15 to 20 minutes of human work per case.

On paper, it looked like a great fit for an agent. Read a contract, collect missing information, prepare a mandate for signature, send a registered letter, and keep the customer informed. The process was documented and repetitive. Very little of it seemed to require judgment.

Then we replayed real conversations. The documented process and what our operations team actually did diverged in roughly 30% of cases. Documents were incomplete. Customers replied out of order. Humans added attachments without explaining what they meant. Third-party APIs failed after an action had been approved. The same conversation could be picked up by several executions. Some cases waited for a signature for days.

The model was not the hard part. Building a system that could survive all of this was.

In its first six weeks of production, which happened to span the summer slowdown when volumes run well below the yearly average, reviewers made 659 validation decisions on the agent's proposals. They accepted 60% unchanged, corrected 35%, and rejected 5%. We review every customer-facing action, which gave us a safe rollout path and a dense feedback loop. As evidence accumulates, execution can become automatic, backed by deterministic checks, for actions where the risk justifies it.

From 0 to 50k Customers: What I Learned Building Orus's Product

· 6 min read
Axel Kalonji
Axel Kalonji
Squad Lead
Cover

May 2022. I've been at Orus for about two weeks, and it's the day after we signed our first customer. We run into our first real business problem: our customer made a mistake on one of the details, and we need to process an endorsement to their contract.

The catch: at that point, nothing had been built for it. No screen, no data model, no business logic. Just a customer who needed to change what they'd just subscribed to, and a small team improvising the feature in real time. Years later, it's one of the core features of our product, and one I still own with my squad today.

That story sums up what this whole journey has been like for me: every new customer brought its own use case, and we built the product day after day, client after client. The company's growth didn't follow the product. It drove it, and I was lucky enough to have a front-row seat.

Props, Composers, and Providers: the composition pattern we're converging on

· 12 min read
Maxime Grébauval
Maxime Grébauval
Senior Front-end Software Engineer
Cover

Our frontend has grown fast. Along the way we accumulated props drilled several layers deep to reach one leaf, components that fetch data, hold state, and render markup at once, and rows steered by a growing pile of props.

None of this is a disaster. It is just friction, and it compounds. So we made a deliberate call: converge on composition, and treat it as a ladder. You start on the cheapest rung, and you only climb when a concrete pain pushes you up.

This article is about that ladder: how we compose React components, and when each step is worth its cost. The wider story, where the Orus frontend is heading, is for another article.

How we run software projects with AI at Orus

· 14 min read
Pierre Coimbra
Pierre Coimbra
Software Engineer
Cover

On our last project, the way we planned, built and reviewed the work changed more than the code itself. AI agents were part of the project from day one, no longer a tool we used from time to time. This post is about that method.

The project was a rebuild of our organizations module, one of the oldest and most central parts of the codebase. It models partners, brokers and their members, and it sits upstream of most of what the platform does. Replacing it had been on the backlog for a while. It was the kind of project that stays "not yet" because the risk surface is high: everything touches it, and touching it wrong has cascading consequences.

We shipped it. We sized it at around 30 working days, shipped in about 20, and every milestone landed ahead of its ETA. But the schedule is not the point. The method is, and it is one we want to apply to all our next projects, not just this one.

Generating insurance documents at scale using AI

· 12 min read
Hafida Maaraf
Hafida Maaraf
Senior Fullstack Developer
Cover

Every Orus insurance contract ships with a stack of legal documents: the contract terms, the insurance certificate, invoices, fiscal attestations for tax-deductible contracts. Their format is regulated, their content reviewed by legal counsel, and they're rendered dynamically from subscription data: customer name, company SIREN, coverages, premium, any clauses negotiated for that specific deal.

We add new products every few weeks. At the time of writing this, we render 60 distinct customer-facing document templates across our French and Spanish products. The whole thing is 218 React components.

Adding a new template used to take a couple of days. We've brought it down to a few hours by building a Claude Code skill that handles the tedious parts, with a human still in the loop on every non-trivial decision. This article walks through what the skill does, what we deliberately keep human, and the gotchas baked into it.

Reacting to events at Orus

· 14 min read
Samuel Rossille
Samuel Rossille
Chief Technology Officer
Cover

In our previous article, we introduced how event sourcing works at Orus. Instead of mutating rows in a database, we append immutable events to an event store. We then derive the current state of any entity (a contract, an invoice, a user, or whatever...) by replaying those events through a reducer.

That covers writing data and reading it. But there's a third thing every real application needs to do: react to what happened.

When a contract is signed, an invoice needs to be generated. When a payment fails, a broker needs to be notified. When a user uploads a document, an AI analysis should kick off. None of that happens by itself just because you appended an event.

This calls for additional infrastructure.

Event sourcing at Orus

· 7 min read
Samuel Rossille
Samuel Rossille
Chief Technology Officer
Cover

Event sourcing is rarely used as the foundation of the whole system, but at Orus, we had the chance to start from scratch, and think things through before writing the first line of code.

Insurance is complicated, and we need to know exactly what happened at any given time.

When a claim is filed, a contract renewed, or a coverage added, the "current state" of a database row isn't enough. We need to answer: Who changed this? When? Why? And what did the contract look like exactly before that change?

In a standard CRUD application, you might add an audit log table. But audit logs rot. They get out of sync with the actual data. In event sourcing, the audit log is the data.

We decided early on to build our backend (TypeScript/Node.js) on a 100% event sourced architecture. It wasn’t the easiest path, but it was the right one for our domain.

Hiring the right people at Orus

· 6 min read
Samuel Rossille
Samuel Rossille
Chief Technology Officer
Cover

At Orus, we pay a lot of attention to recruiting the right people, and it's been my main priority since the beginning.

To give a bit of transparency to anyone interested in how we work, here are the fundamental guidelines that I follow as a CTO when hiring people.

Hiring a trajectory, not a perfect CV​

Years ago, at Kapten (back when it was still called Chauffeur Privé), I was hired in a way that didn't make a lot of sense on paper. My background wasn't the obvious fit. There were shinier CVs. More traditional paths. Safer bets.

And yet, someone looked at me and thought: this guy can grow into the role. He's curious, fast, hungry. He'll figure it out.

They took the bet. I ran with it. And it shaped how I see hiring forever: the best people are often the ones you can't perfectly describe in a job ad.

So when I'm on the hiring side now, I remind myself: don't just scan for the checklist. Scan for the energy, the capacity to stretch. Because that's where the real leverage is.

Understanding and using MongoDB indexes effectively

· 6 min read
Thomas Bodin
Thomas Bodin
Squad Lead
Cover

At Orus, MongoDB is a cornerstone of our technical stack. Its flexibility, thanks to its document‑oriented model, makes it an excellent choice for quickly modeling complex data. But, as with any powerful tool, that flexibility can become a pitfall if not handled correctly.

Index management, in particular, is still underestimated.

We've all, at some point early in our careers, added an index "just in case," copy‑pasted configuration from a neighboring repository, or assumed MongoDB would "choose the right index" for us. The result: useless indexes, performance regressions, and sometimes even counterproductive setups.

In this article, we share our experience on:

  • How MongoDB indexes really work (beyond the documentation)
  • Indexing patterns to avoid, even if they seem "safe"
  • A clear method to decide when and why to add an index