Ouvert à de nouveaux projets · Équipe composée uniquement de seniors · Télétravail privilégié PWN-ALL · Studio de développement de logiciels sur mesure

Logiciels en qui survit l'équipe qui l'a livré.

Nous sommes un studio composé uniquement de seniors qui développe des logiciels sur mesure dans deux langages, et ce, de manière délibérée : Rust, où se tromper coûte cher, et Python, où prendre du retard dans la livraison coûte cher.

Lancer un projet Découvrez la pile
Amélioration moyenne p99 0× sur 40 migrations
Réduction de la mémoire 0 par rapport aux valeurs de référence JVM / Node
Services en production 0 depuis 2024
Incidents de sécurité résolus 0 depuis nos débuts
Les équipes qui font confiance à notre code
01 Deux langages. Pas cinq.

Une pile, choisie à dessein.

Les agences polyglottes font bonne impression dans un pitch. En production, cela signifie trois systèmes de build, quatre variantes de null et un cimetière de services à moitié maintenus. Nous avons choisi deux langages qui couvrent 95 % des charges de travail réelles — et nous sommes devenus très, très bons dans les deux.

Chemin critique · systèmes · sécurité

Rust

9,6 score d'ajustement interne

Sécurité mémoire sans ramasse-miettes. Absence de conflits d'accès aux données dès la compilation. Le réviseur de code le plus exigeant que vous ayez jamais eu — et une fois qu'il vous a donné son feu vert, votre service ne vous réveillera plus le dimanche.

Quand on s'y intéresse

  • Systèmes de paiement et tout ce qui touche à l'argent ou aux données personnelles
  • Passerelles API à haut débit avec des SLA à 99,999 % de disponibilité
  • Moteurs de correspondance à faible latence, trading, en temps réel
  • Modules WebAssembly déployés sur le navigateur
  • Outils CLI et démons devant démarrer en quelques millisecondes

Des compromis que nous n'ignorons pas

  • Mise en route des nouvelles recrues : environ 2 à 4 semaines avant d'être opérationnelles
  • Temps de compilation sur des espaces de travail volumineux (nous y remédions avec sccache)
  • Écosystème plus récent que Java — mature là où cela compte
Ciment · données · ML · vélocité

Python

9,3 score d'ajustement interne

Le chemin le plus rapide du tableau blanc au système opérationnel. L'écosystème le plus riche au monde pour les données, le ML et l'automatisation. Le Python moderne — 3.12, uv, ruff, pydantic, FastAPI — est un langage précis, typé et suffisamment rapide pour la plupart de vos besoins.

Quand on s'y met

  • Outils internes, tableaux de bord, panneaux d'administration
  • ETL, pipelines de données, Airflow / Dagster / Prefect
  • ML — formation, mise en service, évaluation
  • Automatisations et intégrations avec les API des fournisseurs
  • MVP livrés ce trimestre, pas l'année prochaine

Des compromis que nous n'ignorons pas

  • Le débit sur un seul cœur est 20 à 50 fois plus lent qu'avec Rust
  • Consommation de mémoire plus élevée par requête — fatale pour certaines charges de travail
  • Le typage dynamique pose problème sans mypy / pydantic strict
Rust, où l'erreur coûte cher. Python, où la lenteur de la livraison coûte cher. Une équipe. Aucun dogme.
02 Les chiffres, pas l'ambiance

Rust & Python face aux habituels suspects.

Appuyez sur un indicateur pour voir où se situe chaque langage. Les scores vont de 0 à 10 et sont calculés à partir de nos propres benchmarks ainsi que de sources publiques (Techempower R22, CLBG, migrations réelles que nous avons réalisées).

Criterion Rust Python Go C++ Java Node.js
Performances brutes (p99, un seul cœur) 10 3 7 10 7 5
Sécurité de la mémoire et conflits d'accès aux données 10 9 8 2 8 7
Délai de réalisation du prototype fonctionnel 5 10 7 3 6 8
Étendue de l'écosystème 8 10 7 9 10 9
La concurrence sans larmes 10 6 9 4 6 7
Coût opérationnel par requête 10 5 8 9 5 6
Disponibilité des talents seniors 6 10 7 8 10 9
Maintenabilité sur 10 ans 10 8 8 5 8 5
03 De → Vers

Ce qui change lorsque vous migrez.

Choisissez un langage de départ. Observez l'impact du passage à Rust ou Python. Les chiffres correspondent à des médianes issues de nos 40 derniers projets de migration, et non à des promesses marketing.

Actuellement sur

C / C++

Rapide, oui. Mais chaque pointeur nul est un CVE potentiel, chaque thread est une course aux données potentielle, et votre système de compilation est le travail à plein temps de quelqu’un.

Problèmes courants
  • CVE liés à la sécurité de la mémoire
  • Comportement indéfini
  • Prolifération du système de compilation
Aller à

Rust

Débit ×6,4
Empreinte mémoire −78 %
Plantages en exécution −99 %
Facture mensuelle de calcul −65 %

Idéal si vous êtes actuellement confronté à des bogues de pointeur nul, des conflits d'accès aux données ou une mémoire qui augmente sans limite. Rust conserve la vitesse et élimine les pièges.

Passer à

Python

Vitesse de développement ×3,1
Lignes de code −55 %
Délai de mise en production −60 %
Surcoût d'exécution +40 %

Idéal lorsque le véritable coût réside dans le temps d'ingénierie, et non dans le CPU. Échangez le débit brut contre une boucle de rétroaction plus courte, des bibliothèques plus riches et un code que les humains peuvent réellement lire.

Comment nous mesurons ces chiffres

Médianes calculées sur 40 migrations menées à bien entre 2023 et 2026. Débit mesuré au niveau de la couche applicative (p50 de bout en bout sous une charge réaliste, pas de micro-benchmarks). La mémoire correspond au RSS en régime permanent. Le coût correspond à la facturation mensuelle à la demande sur AWS/GCP, toutes choses égales par ailleurs. Les résultats individuels varient — nous publions également ceux qui ne se sont pas déroulés comme prévu, sur demande.

04 Chiffres sans astérisque

Requêtes par seconde sous charge réelle.

Charge de travail identique — validation JSON → requête Postgres → rendu — mesurée sur une seule machine AMD Ryzen 7. Il ne s'agit pas de micro-benchmarks. Source et méthodologie ↓

  1. 1 Rust · Axum
    21 030 requêtes/s
  2. 2 C# .NET · ASP.NET Core
    14 707 requêtes/s
  3. 3 Node.js · Fastify
    9 340 requêtes/s
  4. 4 C++ · Drogon
    7 200 requêtes/s
  5. 5 Go · Gin
    3 546 requêtes/s
  6. 6 Python · FastAPI (Uvicorn)
    1 185 requêtes/s
  7. 7 PHP · Laravel
    299 requêtes/s

Comprenez bien ceci : Python se trouve vers le bas de ce graphique, et c'est très bien ainsi. Nous n'utilisons pas FastAPI sur le chemin le plus sollicité. Nous l'utilisons là où 1 185 requêtes par seconde représentent déjà environ 10 fois plus que ce dont la charge de travail a besoin, et où les heures de travail des ingénieurs ont plus de valeur que les cycles CPU. Méthodologie : AMD Ryzen 7, Linux, Docker, instance unique, un framework populaire par langage. Les chiffres correspondent à des moyennes calculées sur plusieurs exécutions.

05 Le coût réel d'un code défectueux

Ce qu’une panne vous coûte réellement.

« Cinq neuf » n'est pas un argument marketing. Vous trouverez ci-dessous le coût d'une heure d'indisponibilité imprévue, par secteur d'activité — avec sources. Nous développons Rust là où ces chiffres prennent vie.

Coût accumulé depuis que vous avez ouvert cette section
Finance / santé 0 ~83 000 $/min · 5 millions de dollars/h
Automobile 0 ~38 000 $/min · 2,3 millions de dollars/h
Grandes entreprises 0 23 750 $/min · 1,4 million de dollars/h
Entreprise de taille moyenne 0 ~5 000 $/min · 300 000 $/h
Finance et santé Plus de 5 millions de dollars par heure

Les secteurs les plus exposés. Les plateformes de trading, les systèmes de règlement et les systèmes cliniques peuvent dépasser 5 millions de dollars par heure en cas de panne grave — avant même de compter les coûts liés à la réglementation ou aux litiges.

Source : Étude Gartner 2024 sur le Fortune 500 ; ITIC 2024, Coût horaire des temps d'arrêt.
Construction automobile 2,3 millions de dollars / heure

Une chaîne de production à l'arrêt coûte environ 640 dollars par seconde. La panne de CrowdStrike en juillet 2024 a coûté à elle seule 380 millions de dollars à Delta Air Lines en cinq jours.

Source : Répartition sectorielle 2025 du groupe Erwood ; analyse rétrospective d'Antithesis sur CrowdStrike.
Grande entreprise (moyenne) 1,4 million de dollars / heure

Chiffre de BigPanda pour les grandes entreprises en 2024 : 23 750 $ par minute. L'ITIC indique que 41 % des grandes entreprises perdent entre 1 et 5 millions de dollars par heure d'interruption.

Source : Étude BigPanda 2024 ; 11e rapport annuel de l'ITIC sur le coût horaire des temps d'arrêt.
Global 2000 (Oxford Economics) 400 milliards de dollars par an

Coût total caché des temps d'arrêt imprévus dans les 2 000 plus grandes entreprises mondiales, selon l'étude 2024 d'Oxford Economics — soit un impact moyen de 200 millions de dollars par entreprise lorsque l'on additionne les pertes de chiffre d'affaires, de productivité et les coûts de remise en état.

Source : Oxford Economics 2024, « The Hidden Costs of Downtime ».
Moyennes et grandes entreprises (heure type) Plus de 300 000 $ / heure

Enquête ITIC 2024 : plus de 90 % des moyennes et grandes entreprises estiment désormais qu’une seule heure d’indisponibilité imprévue dépasse ce seuil — sans compter les sanctions juridiques, civiles ou réglementaires.

Source : Rapport 2024 de l'ITIC sur le coût horaire des temps d'arrêt.
Petites et moyennes entreprises (PME) 25 000 $ à 150 000 $ / heure

L'étude conjointe ITIC / Calyptix de 2025 révèle que de nombreuses PME perdent ce montant par heure ; Siemens indique que les PME touchées par des pannes peuvent enregistrer jusqu'à 150 000 $/h. La durée moyenne d'une panne est de 87 minutes.

Source : ITIC + Calyptix 2025 ; Siemens, « True Cost of Downtime » 2024.
06 Sélection de travaux

Trois projets. Trois défis différents.

Anonymisés lorsque l'accord de confidentialité l'exige, précis lorsque les résultats le justifient. Voici les missions que nous présenterions en premier lieu à un acheteur technique.

  1. Cas n° 1 Python Base de données Cryptographie RGPD

    Volets de données Fintech : 4 fois plus petits, 5,5 fois plus rapides, conformes aux normes internationales.

    Le client disposait d’un cluster Postgres de 1,8 To encombré de colonnes héritées, d’index obsolètes et de BLOB chiffrés en ligne qui s’étaient accumulés au fil de sept années. Le chiffrement fonctionnait sur une bibliothèque obsolète signalée lors de trois audits distincts. Le risque réglementaire était réel ; les auditeurs rôdaient.

    Ce que nous avons fait

    • Audit complet du schéma et de l'utilisation, suppression des colonnes et index inutilisés, mise en place d'un partitionnement approprié.
    • Migrer le pipeline de chiffrement d'une bibliothèque héritée vers une pile AEAD moderne et auditée avec rotation des clés.
    • Convertir le chiffrement BLOB en ligne en chiffrement par enveloppe référencée + KMS dédié.
    • Aligner les flux de conservation des données et d'accès des personnes concernées sur le RGPD, le CCPA et l'APPI.
    Résultat

    Mêmes données, un quart de la facture de stockage, un débit 5,5 fois supérieur et un bilan de santé impeccable pour le prochain régulateur qui viendrait frapper à la porte.

  2. Cas n° 2 Rust C++ → Rust Sécurité Stockage

    Service C++ réécrit en Rust : plus de 100 bogues de type CVE corrigés en 9 semaines.

    Service de traitement de fichiers en C++ destiné aux utilisateurs, plantant tous les 4 à 5 jours et corrigé à la volée à chaque fois. Notre audit a mis au jour plus de 100 bugs réels : voies de déni de service, débordements de tampon, gestion illimitée des requêtes. Les erreurs 503 aux heures de pointe étaient un rituel hebdomadaire. Côté stockage, les téléchargements des utilisateurs s'étaient accumulés en un marécage de fichiers en double qui grignotaient l'espace du compartiment.

    Ce que nous avons fait

    • Réécriture complète en Rust (axum + tokio) avec validation stricte des entrées et limites de ressources bien définies.
    • Tests basés sur les propriétés + cargo-fuzz sur chaque analyseur et chaque limite de format de transmission.
    • Couche de stockage adressée par contenu avec déduplication au moment de l'écriture.
    • Déploiement bleu-vert dans une fenêtre d'intégration de 4 heures, sans temps d'arrêt.
    Résultat

    Le service est passé de « fragile et corrigé chaque semaine » à « nous ne regardons plus le pager ». Les coûts de stockage ont baissé grâce à la déduplication, les tickets d'assistance concernant les erreurs et les 503 se sont taris, et la refonte s'est rentabilisée en moins d'un trimestre.

  3. Cas n° 3 Rust Python eBPF / XDP CRM · 4 000 utilisateurs

    CRM d'entreprise, refait à neuf : 18 serveurs → 5, réduction des coûts de plus de 60 %.

    CRM interne desservant plus de 4 000 utilisateurs à travers IAM, SOC, journalisation centralisée, chat, partage de fichiers, VoIP et données chiffrées de bout en bout. Dix-huit serveurs, Cloudflare en plus, et une facture cloud qui ne cessait d’augmenter indépendamment des effectifs. Nous avons reconstruit le chemin principal en Rust, conservé Python pour la couche d'intégration et de reporting, et placé un filtre eBPF/XDP directement en amont de l'entrée.

    Ce que nous avons fait

    • Services Rust pour l'authentification (IAM), la messagerie en temps réel, la signalisation VoIP et le transfert de fichiers.
    • Python pour les interfaces d'administration, le reporting, la corrélation des événements SOC et l'intégration avec les API des fournisseurs.
    • Filtrage des bots et des abus via eBPF/XDP au niveau du noyau — Cloudflare a été remplacé pour cette charge de travail.
    • Pipeline de journalisation structuré réécrit autour d'un schéma sans copie.
    Résultat

    Treize serveurs en moins, plus de ligne budgétaire Cloudflare, l’équipe SOC dispose d’un signal plus clair via le pipeline de journalisation, et le directeur financier a cessé de poser des questions gênantes sur le budget infrastructure.

07 Comment nous travaillons concrètement

Ajustez les paramètres. Observez le plan évoluer.

Chaque projet trouve le juste équilibre entre rapidité, coût et fiabilité. L'estimation en cinq étapes ci-dessous est calibrée par rapport aux médianes du secteur (découverte 2 à 6 semaines, architecture 1 à 4 semaines, mise en œuvre 4 à 20 semaines, renforcement 2 à 8 semaines, transfert 1 à 2 semaines — selon les rapports 2024–2026 de NIX United, Agilie, SOLTECH, OTG Lab). Déplacez les curseurs ; le plan se recalibre en temps réel.

01

Découverte

3 semaines

Lisez votre code, interrogez vos équipes opérationnelles, dressez la liste des inconnues, choisissez le langage par composant.

  • Entretiens avec les experts du domaine et audit du code
  • Registre des risques et objectifs SLA
  • Choix du langage par service
02

Architecture

2 semaines

Les contrats avant le code. OpenAPI / protobuf, modèles de données, topologie de déploiement, squelettes de runbook.

  • Appels à propositions pour chaque marché public
  • Modèle de données + plan de migration
  • Référentiel « Infra-as-code »
03

Mise en œuvre

8 semaines

Petites PR, CI verte dès le premier jour, déploiements à chaque fusion, révision par un deuxième senior.

  • Rust : axum · tonic · sqlx
  • Python : FastAPI · Pydantic · SQLAlchemy
  • Démonstrations hebdomadaires + journal des modifications
04

Renforcement

3 semaines

Fuzzing, tests basés sur les propriétés, tests de charge sur un trafic réaliste, modèle de menace.

  • cargo-fuzz · proptest · hypothesis
  • Tests de charge k6 liés aux SLO
  • Revue de sécurité et audit des dépendances
05

Remise

1 semaine

Runbooks, rotation des permanences, ADR et une équipe qui a déjà livré ce projet une fois.

  • Guides d'intervention + grille de permanence
  • Journal ADR et schémas d'architecture
  • Assistance pendant 30 jours après le lancement
08 Même problème, deux langages

À quoi ressemble le même point de terminaison dans chacune d'elles.

Récupérer un utilisateur, valider l'entrée, enregistrer dans Postgres, renvoyer un JSON. Basculez entre les langages — les deux sont du code réel que nous livrerions réellement. 

SQL_CREATE_USER = "insert into users(email,name) values(lower($1),$2) returning id,email,name"
Name = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=120)]

class UserIn(BaseModel):
    email: EmailStr
    name: Name

class UserOut(UserIn):
    id: int

@router.post("/users", response_model=UserOut, status_code=201)
async def create_user(u: UserIn) -> UserOut:
    try:
        row = await pool.fetchrow(SQL_CREATE_USER, str(u.email), u.name)
   except UniqueViolationError as exc:
        raise HTTPException(status_code=409, detail="l'adresse e-mail existe déjà") from exc
    if row is None:
        raise HTTPException(status_code=500, detail="échec de l'insertion")
    return UserOut.model_validate(dict(row))
#[derive(Deserialize, Validate)]
#[serde(deny_unknown_fields)]
pub struct UserIn {
    #[validate(email)]
    pub email: String,
    #[validate(custom(function = "valid_name"))]
    pub name: String,
}

pub async fn create_user(
    State(pool): State<PgPool>,
    ValidatedJson(u): ValidatedJson<UserIn>,
) -> Result<(StatusCode, Json<UserOut>), ApiError> {
   let user = sqlx::query_as!(UserOut,
        "insert into users(email,name) values(lower($1),$2) returning id,email,name",
        u.email.as_str(),
        u.name.trim(),
    )
    .fetch_one(&pool)
    .await
    .map_err(ApiError::from_db)?;

    Ok((StatusCode::CREATED, Json(user)))
}
Lignes de code
16 22
Débit
1 185 requêtes/s 21 030 requêtes/s
Latence p50
21,0 ms 1,6 ms
Mémoire vive en veille
41,2 Mo 8,5 Mo
Nous répondons dans un délai d'un jour ouvré. Sans blague.

Vous avez lu toute la page.
Allons-y, construisons ça.

Dites-nous ce qui ne va pas avec votre pile technologique, ou ce que vous souhaitez créer de A à Z. Vous obtiendrez un véritable avis d'ingénieur — pas un argumentaire commercial.

hello@pwn-all.com Retour en haut
  • Pas d'ingénieurs juniors. Pas de délocalisation.
  • Options à prix fixe pour les missions ciblées.
  • Signature d'un accord de confidentialité avant toute demande de votre part.