En résumé
Un monolithe est une application dont tout le code vit dans un seul programme, déployé d'un bloc et relié à une seule base de données. C'est le point de départ de presque tous les produits, et un monolithe modulaire bien tenu reste le bon choix pour la grande majorité des SaaS.
Un monolithe (ou architecture monolithique) est une application dont tout le code, de l’authentification à la facturation en passant par les notifications, vit dans un seul programme, déployé d’un bloc et relié à une seule base de données. Quand un utilisateur clique sur « payer », la vérification de son compte, le calcul du prix et l’envoi du reçu sont trois fonctions du même processus qui s’appellent directement en mémoire, sans passer par le réseau. C’est l’architecture logicielle la plus naturelle, celle par laquelle presque tous les produits commencent.
Le mot a pris une connotation négative : il évoque un bloc inerte, impossible à faire évoluer. Cette réputation vient de monolithes mal tenus, pas de l’architecture elle-même. Shopify et Basecamp tournent encore sur des monolithes en 2026, à des échelles que la plupart des SaaS n’atteindront jamais. La différence entre un monolithe sain et un monolithe ingérable tient au couplage entre ses parties, bien plus qu’à sa taille.
Monolithe ou microservices : ce qui change vraiment
Dans une architecture microservices, chaque fonction métier devient un programme autonome, avec son propre déploiement et souvent sa propre base. Les services se parlent par le réseau, via des API ou des files de messages.
| Monolithe | Microservices | |
|---|---|---|
| Déploiement | Un seul artefact, un seul pipeline | Un pipeline par service, déploiements à coordonner |
| Communication interne | Appel de fonction en mémoire | Appel réseau : latence, pannes partielles, versions d’API |
| Données | Une base partagée, transactions garanties | Une base par service, cohérence à reconstruire |
| Débogage | Une trace, un journal | Trace distribuée entre plusieurs services |
| Montée en charge | On duplique toute l’application | On duplique seulement le service qui sature |
| Équipe | Confortable jusqu’à une quinzaine de développeurs | Utile quand plusieurs équipes se bloquent |
| Compétences requises | Un framework, un serveur | Conteneurs, orchestration, observabilité, réseau |
Martin Fowler a posé l’arbitrage dès mai 2015 dans « Microservice Premium » : les microservices ajoutent un surcoût de complexité, et il ne faut même pas les envisager tant que le système n’est pas trop complexe pour être géré comme un monolithe. Un mois plus tard, dans « MonolithFirst », il observait que presque toutes les réussites en microservices avaient commencé par un monolithe devenu trop gros pour rester en un morceau, et que les projets lancés directement en microservices finissaient souvent en difficulté.
Pourquoi le monolithe reste le bon point de départ
Le premier avantage est la vitesse de développement. Un développeur passe d’une fonctionnalité à l’autre dans le même projet, avec le même langage et les mêmes outils. Ajouter un champ à une commande et l’afficher sur la facture tient dans une seule modification, testable en local, sans négocier un contrat d’API avec une autre équipe.
Le deuxième est la cohérence des données. Créer une commande, décrémenter le stock et débiter le client sont trois écritures dans la même base de données : si l’une échoue, la transaction annule les autres. Obtenir la même garantie entre plusieurs services indépendants demande des mécanismes de compensation que peu d’équipes de cinq personnes ont intérêt à maintenir.
Le troisième est le coût d’exploitation. Un monolithe tourne sur un ou deux serveurs, avec un seul monitoring. Quand un bug apparaît, la pile d’appels raconte toute l’histoire, là où une architecture distribuée oblige à suivre la requête de service en service.
Pour une startup qui cherche encore son marché, ces trois avantages se résument à une seule chose : pouvoir changer d’avis vite. Un MVP monolithique se réorganise en quelques jours quand une hypothèse tombe. Un découpage en services fige des frontières qu’on ne connaît pas encore.
Ce qui fait vieillir un monolithe
Les reproches faits au monolithe sont réels, mais ils ont une cause précise. Avec le temps, le code des paiements se met à lire directement les tables des utilisateurs, le module de facturation importe des fonctions du module de notifications, et plus personne ne sait quelle modification va casser quoi. Les anglophones parlent de « big ball of mud » : une boule de code où tout dépend de tout. C’est la forme la plus coûteuse de dette technique, parce qu’elle ne se rembourse pas fichier par fichier.
Les symptômes suivent. Les déploiements deviennent des moments de tension parce qu’une correction dans un domaine fait régresser un autre. La suite de tests dure quarante minutes et les développeurs cessent de la lancer. Deux équipes sur des sujets différents passent leurs journées à résoudre des conflits de fusion. Et quand une seule fonction sature, c’est toute l’application qu’il faut dimensionner, y compris les parties qui n’en ont pas besoin. Aucun de ces problèmes ne vient du fait d’avoir un seul déployable. Tous viennent de l’absence de frontières à l’intérieur.
Le monolithe modulaire : la discipline plutôt que le découpage
Un monolithe modulaire est un monolithe dont le code est organisé en modules alignés sur des domaines métier (commandes, facturation, utilisateurs, notifications) plutôt que sur des couches techniques (contrôleurs, modèles, services). Chaque module possède ses tables, expose une interface publique restreinte et n’a pas le droit d’aller lire dans les entrailles d’un autre. Cette organisation reprend les idées du Domain-Driven Design sans imposer de réseau entre les domaines.
La règle ne vaut que si une machine la vérifie. Shopify a documenté l’exercice en février 2019 : plus de mille développeurs sur un seul code Ruby on Rails vieux de dix ans, le code des frais de port posé à côté de celui du checkout, et un couplage tel que chaque changement cassait des tests sans rapport. Plutôt que de passer aux microservices, l’équipe a classé quelque 6 000 classes Ruby par concept métier, les a déplacées en une seule pull request, puis a construit un outil qui repère les appels entre composants contournant les interfaces publiques. Packwerk, publié ensuite, applique ces règles à chaque intégration. Au Black Friday 2025, ce monolithe a encaissé 489 millions de requêtes par minute en bordure de réseau.
Chaque écosystème a ses équivalents : Spring Modulith côté Java, les modules NestJS et des règles de lint sur les imports côté TypeScript. L’outil compte moins que l’habitude. Une frontière de module qui n’est pas contrôlée en intégration continue disparaît en six mois, et la remettre en place est un travail de refactoring long, à faire sans arrêter les livraisons.
Le gain se voit le jour où un module doit vraiment partir. Si ses frontières sont nettes, l’extraire en service séparé est un projet de quelques semaines. Si elles n’existent pas, c’est une réécriture.
Ceux qui sont revenus au monolithe
Le mouvement inverse est moins médiatisé mais bien documenté. En juillet 2018, Segment a raconté comment ses 140 microservices de destination, chacun dans son dépôt, étaient devenus impossibles à faire évoluer : une correction dans une librairie partagée exigeait 140 déploiements et les versions des dépendances divergeaient. Après le retour à un seul service dans un dépôt unique, l’équipe a livré 46 améliorations de librairies en un an, contre 32 sur toute la période microservices.
En mars 2023, l’équipe Prime Video d’Amazon a expliqué comment son service d’analyse de qualité audio et vidéo, découpé en fonctions Lambda orchestrées par Step Functions, avait été regroupé en un seul processus. Le coût d’infrastructure a baissé de plus de 90 %. Il ne s’agit pas de tout Prime Video, mais d’un service parmi d’autres, et c’est justement la leçon : le bon découpage se décide service par service, pas par principe.
Basecamp n’en est jamais parti. Dans « The Majestic Monolith » (février 2016), David Heinemeier Hansson explique qu’une douzaine de programmeurs servant six plateformes n’ont rien à gagner à transformer leur application en système distribué. Google a tenté une troisième voie avec Service Weaver, annoncé en mars 2023 : écrire l’application comme un monolithe modulaire et laisser l’outil la déployer en microservices. Le projet est passé en maintenance en décembre 2024 et son dépôt a été archivé en mars 2026. Avoir les deux mondes à la fois reste, pour l’instant, une discipline d’équipe plutôt qu’un framework.
Quand sortir du monolithe
Le bon moment se reconnaît à la convergence de plusieurs signaux concrets, plus qu’à une date ou à un nombre d’utilisateurs. L’équipe dépasse une quinzaine de développeurs et les groupes se bloquent dans le même code. Un module a des besoins de scalabilité sans rapport avec le reste, par exemple un moteur de calcul qui consomme dix fois plus de processeur que l’interface. Le temps de build et de test freine les livraisons. Ou une contrainte externe, souvent réglementaire, impose d’isoler un périmètre.
Même alors, la sortie se fait par morceaux. On extrait d’abord le module qui gagnerait le plus à son indépendance, on l’observe en production, et on décide de la suite avec des chiffres. C’est le « strangler fig » décrit par Fowler en 2004 : la nouvelle structure pousse autour de l’ancienne jusqu’à la remplacer, sans jamais interrompre le service.
Nous l’avons appliqué sur une plateforme SaaS de gestion RH vieille de trois ans : un backend où tout était mélangé, des requêtes qui chargeaient toutes les données de l’entreprise à chaque clic, aucun test sur le moteur de calcul des congés, et trois semaines pour ajouter une règle de calcul. Le moteur est sorti en premier, dans un service testé à 100 %, avec une chaîne d’intégration continue pour bloquer les régressions. Quatre mois plus tard, sans arrêt de production, les bugs critiques avaient baissé de 80 % et les pages se chargeaient trois fois plus vite. Le reste de l’application est resté en place. Le diagnostic complet est dans notre article sur la dette technique.
FAQ monolithe
Un monolithe peut-il tenir la charge ?
Oui, et c’est le cas général. Un monolithe sans état se duplique derrière un répartiteur de charge comme n’importe quelle application. La limite arrive sur la base de données partagée et sur le couplage interne du code, pas sur le fait d’avoir un seul déployable. Shopify en est la démonstration la plus visible, et la plupart des SaaS B2B n’approcheront jamais un centième de son trafic.
Quelle différence entre monolithe modulaire et monolithe distribué ?
Le monolithe modulaire est un seul programme avec des frontières internes strictes. Le monolithe distribué est son contraire : des services séparés par le réseau mais sans vraies frontières, qui partagent une base, se déploient ensemble et tombent ensemble. C’est le résultat le plus fréquent d’un passage prématuré aux microservices, et il cumule les coûts de la distribution sans aucun de ses avantages.
Faut-il partir sur un monolithe pour un MVP ?
Presque toujours. L’objectif d’un MVP est de vérifier qu’un marché existe, et cette vérification demande de pouvoir modifier le produit chaque semaine. Un monolithe modulaire, dans un seul langage, avec des tests automatisés sur la logique critique, se livre en six à dix semaines et se réorganise sans réécriture quand les hypothèses changent. Un prestataire ou un futur CTO qui propose Kubernetes et dix services pour une première version répond à une autre question que la vôtre.
Comment Polara Studio conçoit ses monolithes
Chez Polara Studio, Jason Pindat, Tech Advisor, intervient sur ces arbitrages en revue d’architecture et en tech due diligence, quand un client envisage de reprendre une base de code existante. Son constat après des dizaines de revues : 90 % des projets sur lesquels on l’appelle gagneraient à commencer en monolithe modulaire, et les 10 % restants savent déjà pourquoi ils font autrement. Le vrai sujet est rarement l’architecture en soi, c’est la discipline qu’on met dedans.
Nos SaaS démarrent donc sur un monolithe découpé en modules métier, en TypeScript de bout en bout avec NestJS côté API et Next.js côté front, en conteneurs Docker sur AWS avec une base PostgreSQL managée. NestJS impose ce découpage par construction : chaque module déclare son périmètre et ses dépendances. Le monitoring est posé au premier déploiement, dans un budget d’infrastructure qui démarre autour de 200 € par mois. Ce choix de stack, et la raison pour laquelle nous déconseillons les microservices avant les premiers millions d’ARR, sont détaillés dans notre article sur les technologies à utiliser pour son SaaS. Quand un module doit sortir, parce qu’il sature ou parce qu’une équipe dédiée veut son propre rythme de livraison, l’extraction est un projet cadré de quelques semaines, parce que les frontières existent déjà.
Termes associés
Articles qui pourraient vous plaire

Agents IA en entreprise : chiffres 2026 et PME françaises
Projets abandonnés, ROI introuvable, mais des PME françaises qui accélèrent : les vrais chiffres de l'adoption des agents IA en entreprise en 2026.
Lire
Spec-driven development : pourquoi l'avenir du développement logiciel est déclaratif
Le spec-driven development fait de la spec la source de vérité et du code un artefact généré. Concept, avantages, pièges et mise en place concrète en équipe.
Lire
Top 5 des sociétés d'infogérance Cloud en France en 2026
Notre classement 2026 des meilleures sociétés d'infogérance Cloud qu'on recommande à nos clients : Log'in Line, Enix, Claranet, Cyllene, Iguane Solutions.
Lire

