Scalabilité

Par  Jason Pindat · Mis à jour le

En résumé

La scalabilité (ou passage à l'échelle) est la capacité d'un système à absorber une charge croissante, plus d'utilisateurs, plus de données, plus de requêtes, sans dégradation de performance. Elle se construit par paliers, en fonction de la croissance mesurée plutôt que de la croissance espérée.

La scalabilité (passage à l’échelle ou montée en charge, scalability en anglais) est la capacité d’un système à absorber une charge croissante, plus d’utilisateurs, plus de données, plus de requêtes, sans que ses performances se dégradent de façon perceptible. Un système scalable répond aussi vite à dix mille utilisateurs qu’à cent. Il n’est pas forcément rapide : il reste stable quand on le pousse, et l’ajout de ressources lui permet d’encaisser le palier suivant.

Le mot est plus ancien que le cloud. En 1990, Mark Hill ouvrait un article intitulé « What is scalability? » en constatant qu’aucune définition rigoureuse n’existait. En 2000, André Bondi en a proposé un découpage encore utilisé : scalabilité de charge (le système tient quand le trafic monte), d’espace (la mémoire ne croît pas plus vite que les données) et structurelle (on peut ajouter des composants sans refondre l’architecture). Pour un produit SaaS, c’est la première qui compte, et c’est elle qu’on désigne au quotidien.

Un point mérite d’être posé tout de suite, parce que la scalabilité est aussi le mot qu’on nous sert le plus souvent pour justifier des choix techniques qui ne servent à rien tant que le marché n’est pas validé. Avant mille utilisateurs simultanés, la question se règle avec un serveur correctement dimensionné et une base de données bien indexée.

Scalabilité verticale ou horizontale

La scalabilité verticale (scale up) consiste à renforcer la machine existante : plus de processeurs, plus de mémoire, un disque plus rapide. C’est la solution la plus simple, puisque le code ne change pas. Son plafond est plus haut qu’on ne le croit : AWS loue depuis décembre 2024 des instances de 1 920 vCPU et 32 To de mémoire vive, prévues pour des bases en mémoire comme SAP HANA. Mais le prix grimpe plus vite que la puissance, et une seule machine reste un point de défaillance unique.

La scalabilité horizontale (scale out) consiste à ajouter des machines et à répartir la charge entre elles. Dix serveurs modestes derrière un répartiteur de charge remplacent un gros serveur. Il n’y a pas de plafond théorique et la panne d’une machine passe inaperçue. En contrepartie, l’application doit être conçue pour tourner en plusieurs exemplaires : aucune donnée de session en mémoire locale, aucun fichier écrit sur le disque du serveur.

CritèreVerticale (scale up)Horizontale (scale out)
PrincipeUne machine plus puissantePlusieurs machines en parallèle
Modification du codeAucuneApplication sans état requise
PlafondPhysique et tarifaireThéoriquement illimité
Tolérance aux pannesPoint de défaillance uniqueLes autres instances prennent le relais
Coût marginalCroissantÀ peu près linéaire
Cas typiqueBase de données principaleServeurs d’application, workers

En pratique, les deux se combinent. On scale verticalement ce qui est difficile à distribuer, la base de données relationnelle en premier lieu, et horizontalement tout ce qui est sans état : serveurs d’API, traitements en arrière-plan.

Scalabilité technique et scalabilité économique

Pour un entrepreneur, le mot recouvre une seconde idée : un modèle est scalable quand le coût de servir un client supplémentaire tend vers zéro. C’est ce qui donne au SaaS ses marges brutes de 70 à 80 %, et ce que les investisseurs vérifient avant de parler de scale-up.

Les deux notions se rejoignent sur la facture d’infrastructure. Si chaque nouveau client coûte autant de serveurs que le précédent, la marge fond à mesure que le produit grandit. L’architecture multi-locataire du SaaS, où une même instance sert des centaines de clients, existe précisément pour casser cette proportionnalité. À l’inverse, un prototype monté sur une plateforme no-code rencontre souvent un mur au premier succès : la licence est facturée au volume, et la facture mensuelle dépasse vite le prix d’un serveur dédié, comme nous le détaillons dans notre guide sur le coût de développement d’un SaaS.

Les paliers du passage à l’échelle

Un produit n’a pas besoin d’une architecture distribuée le premier jour. La scalabilité se construit par paliers, chacun déclenché par une mesure réelle et non par une croissance imaginée.

Palier 1 : un monolithe modulaire et un monitoring

Au départ, un monolithe bien découpé est le bon choix : une application, un déploiement, un débogage simple. Correctement structuré, il sert des dizaines de milliers d’utilisateurs. Shopify fait tourner l’une des plus grosses plateformes e-commerce du monde sur un monolithe Ruby on Rails modulaire ; au pic du Black Friday 2025, sa plateforme a reçu 489 millions de requêtes par minute. Stack Overflow a servi ses millions d’utilisateurs pendant seize ans depuis quelques dizaines de serveurs dans un centre de données du New Jersey, avant de migrer vers Google Cloud en 2025.

Ce qu’il faut poser dès ce palier, c’est la mesure : temps de réponse par endpoint, requêtes SQL les plus lentes, taux d’erreur. Sans ces chiffres, chaque décision suivante sera une supposition.

Palier 2 : optimiser avant de multiplier

Aux premiers signes de lenteur, optimiser ce qui existe rapporte plus que d’ajouter des serveurs. Un index manquant, une requête qui charge mille lignes pour en afficher dix, un appel externe répété : ces corrections multiplient souvent les performances par dix sans toucher à l’architecture.

Le cache est le levier le moins cher. Un catalogue, les préférences d’un utilisateur ou le résultat d’un calcul lourd changent rarement. Les servir depuis Redis plutôt que depuis la base évite la requête la plus coûteuse à chaque affichage.

Palier 3 : répartir et désynchroniser

Quand l’optimisation ne suffit plus, on répartit. Les lectures partent vers des répliques de la base, le contenu statique est servi par un CDN proche de l’utilisateur, un répartiteur de charge distribue le trafic entre plusieurs instances de l’application. Les traitements longs (e-mails, exports, rapports, génération de PDF) quittent la requête utilisateur pour une file d’attente traitée en arrière-plan, éventuellement en serverless.

C’est le palier que la plupart des SaaS n’atteignent jamais, et c’est celui où Figma s’est retrouvé en 2020 avec une seule base PostgreSQL sur la plus grosse instance d’AWS. Fin 2022, l’équipe avait ajouté du cache, des répliques en lecture et une douzaine de bases séparées par domaine. Il a ensuite fallu neuf mois pour répartir horizontalement une première table, et Figma décrit le chantier complet comme un effort de plusieurs années.

Palier 4 : découper ce qui a des besoins différents

À très grande échelle, certains modules reçoivent cent fois plus de trafic que d’autres. Extraire la recherche ou la génération de rapports en microservices permet de les dimensionner séparément. Le prix est connu : réseau, déploiements multiples, observabilité, débogage réparti. Ce palier se justifie par la charge et par la taille de l’équipe, rarement avant quinze à vingt développeurs.

Auto-scaling et facturation à l’usage

L’auto-scaling est la capacité d’une infrastructure à ajouter des instances quand le trafic monte et à les retirer quand il redescend, sans intervention humaine. Les trois grands clouds le proposent, Kubernetes l’orchestre pour les conteneurs, et le serverless le pousse jusqu’à zéro instance quand plus personne n’appelle. Le modèle est devenu la norme : dans l’enquête annuelle 2025 de la CNCF, 82 % des organisations qui utilisent des conteneurs font tourner Kubernetes en production, contre 66 % deux ans plus tôt.

L’auto-scaling ne dispense pas d’optimiser. Un système mal conçu qui scale automatiquement produit surtout une facture cloud qui scale automatiquement. Le réflexe inverse existe aussi : 37signals, l’éditeur de Basecamp, a rapatrié ses applications sur ses propres serveurs en 2023, puis a entrepris de sortir son stockage d’AWS en 2025, et chiffre l’économie attendue à plus de dix millions de dollars sur cinq ans. Sa charge est stable et prévisible ; l’élasticité du cloud ne lui servait à rien.

Les goulots d’étranglement courants

Les lenteurs ne viennent pas toujours d’où on les attend, et multiplier les serveurs n’y change rien si le goulot est ailleurs.

La base de données vient en tête. Une requête qui prend 10 millisecondes sur mille lignes peut en prendre dix mille sur un million, parce qu’un index manque ou qu’une jointure ramène trop de données. Viennent ensuite les appels externes : un backend qui enchaîne une API de paiement, un service d’e-mail et un CRM accumule les latences de chacun. Le traitement synchrone est le troisième piège. Créer un compte, envoyer l’e-mail de bienvenue, notifier l’administrateur et mettre à jour les statistiques dans la même requête fait exploser le temps de réponse, alors que seule la création du compte est urgente.

Le dernier goulot est le navigateur. Un client web qui charge plusieurs mégaoctets de JavaScript et lance trente appels API à l’ouverture paraît lent quel que soit le serveur. La scalabilité que perçoit l’utilisateur se joue autant sur le frontend que sur l’infrastructure.

Les erreurs classiques

La première est de construire pour dix millions d’utilisateurs quand on en a cinquante. Kubernetes, microservices, cache distribué et files d’attente pour un produit qui n’a pas encore validé son marché, c’est résoudre un problème qui n’existe pas, au prix de semaines de travail et d’une complexité qui ralentira chaque évolution. Il faut l’infrastructure de ses clients, pas celle de ses ambitions.

La deuxième est d’optimiser sans mesurer. Décréter que « la base est lente » sans profil de requêtes conduit à des semaines d’optimisation sans effet. Un test de charge avant le lancement, avec un outil comme k6, révèle en une après-midi le premier composant qui cède.

La troisième est d’attendre la crise. Ne rien surveiller et découvrir le problème quand les clients se plaignent. Les problèmes de performance s’accumulent lentement et se résolvent très mal sous pression, quand la base sature un lundi matin et que les ventes sont bloquées.

La dernière est de laisser la dette technique s’accumuler. Sans tests, on n’ose plus toucher à la requête qui fait tout ralentir. Un code que personne n’ose modifier ne passera jamais à l’échelle, quelle que soit l’infrastructure dessous.

FAQ scalabilité

Scalabilité et performance, quelle différence ?

La performance mesure la vitesse à un instant donné : une page qui s’affiche en 300 millisecondes est performante. La scalabilité mesure ce qui arrive à cette vitesse quand la charge est multipliée par dix ou par cent. Un système peut être rapide et non scalable, c’est le cas de la plupart des prototypes, ou scalable et lent, si chaque requête traverse dix services.

À partir de combien d’utilisateurs faut-il s’en préoccuper ?

La question utile porte sur les utilisateurs simultanés plutôt que sur les comptes créés. Un SaaS B2B avec dix mille comptes en voit rarement plus de quelques centaines actifs au même moment, et un serveur correctement dimensionné avec une base indexée tient cette charge sans architecture particulière. Les paliers suivants se décident sur des mesures : temps de réponse qui dérive, base de données saturée, facture qui grimpe.

Un monolithe peut-il être scalable ?

Oui, et c’est même le cas général. Un monolithe sans état se duplique derrière un répartiteur de charge comme n’importe quelle application. Ce qui limite, c’est la base de données partagée et le couplage interne du code. Avoir un seul déployable n’est pas le problème. Shopify, Stack Overflow et Basecamp le montrent à des échelles que peu de produits atteindront.

Comment Polara Studio aborde la scalabilité

Chez Polara Studio, Jason Pindat, Tech Advisor, intervient sur ces arbitrages avant qu’ils ne deviennent coûteux à inverser. Son constat après des dizaines de revues d’architecture : neuf projets sur dix gagneraient à démarrer en monolithe modulaire, et le dixième sait déjà pourquoi il fait autrement.

Nos SaaS démarrent donc sur une architecture monolithique découpée en modules, en TypeScript avec NestJS côté API et Next.js côté front, en conteneurs Docker sur AWS avec une base PostgreSQL managée. Le monitoring et les alertes de coût sont posés au premier déploiement, dans un budget d’infrastructure qui démarre autour de 200 € par mois. Les paliers suivants, cache, répliques, traitements asynchrones, se décident ensuite en regardant les courbes de monitoring. C’est aussi ce que nous faisons pour les fondateurs qui arrivent avec un prototype qui a validé son marché mais ne tient pas la charge, un cas de plus en plus fréquent que nous décrivons dans notre article sur le vibe coding.

Prêt à transformer votre idéeen produit ?

Programmez un entretien découverte avec nos experts pour définir ensemble vos priorités et identifier la meilleure approche pour votre projet.

Discutons de votre projet