Six histoires concrètes — situation, action, résultat.

À 19 ans, je voulais comprendre comment un serveur temps réel tient 250+ connexions en simultané. Personne autour de moi ne savait l'expliquer. Le marché en 2016 était cadenassé par des middlewares propriétaires payants. Aucune base ouverte pour bâtir un framework C# avec un protocole réseau optimisé.

Concevoir from scratch un framework réseau temps réel C# / C++ open-source capable d'encaisser 30 000+ comptes, 250 connexions concurrentes en continu, avec déploiement live sans interruption. Puis, en tant que CTO d'IdentityRP / SARP (2019-2021), maintenir le serveur communautaire en production avec une équipe de 15 personnes.

• Conçu une architecture client-serveur autoritaire avec sérialisation binaire propriétaire (protobuf-net + UDP custom via Lidgren) — réduction de la bande passante d'un facteur 4 vs JSON sur TCP
• Bâti la stack CI/CD complète (build, test, deploy, rollback) — mises à jour live sans interruption pour 250 connexions actives, opérées toutes les semaines pendant deux ans de CTO
• Implémenté le monitoring proactif (CPU, RAM, sockets, taux de perte) avec autoscaling automatique sur les pics d'affluence
• Recruté, formé et dirigé une équipe de 15 personnes (devs, designers, QA, modérateurs) sans diplôme de management — la discipline a été imposée par la livraison hebdomadaire devant des utilisateurs réels
• Documenté l'architecture pour que le système puisse survivre à mon départ — ce qui s'est avéré décisif lors de la vente du serveur communautaire à des investisseurs allemands en 2021

• 30 000+ comptes créés, 250 connexions persistantes concurrentes sans panne critique sur les années de production
• Mon départ en 2021 a été sans impact opérationnel — le serveur communautaire a été vendu à un groupe d'investisseurs allemands la même année et a continué d'opérer
• V-Multi a fusionné avec un projet concurrent (GTA Network) ; cette lignée technologique a ensuite été reprise dans l'écosystème Rockstar Games (Rockstar a intégré la filière Cfx.re/FiveM en août 2023).
• Sans diplôme d'ingénieur, sans investisseur initial, sans agence — juste plusieurs années de production continue

Gecko Alliance est leader mondial des systèmes de contrôle pour spas connectés — 30-40 % du marché global, 100+ OEM clients. En 2023, ils lançaient leur plateforme IoT cloud-native. Aucune équipe existante ne couvrait l'ensemble de la chaîne firmware → cloud → mobile, ce qui obligeait les sprints à se coordonner entre 3 équipes séparées et à perdre du temps sur les contrats d'interface.

Intervenir comme dev full-stack IoT capable de prendre des décisions sur l'ensemble de la chaîne. Spécification, firmware embarqué C / FreeRTOS sur microcontrôleurs contraints (< 256 KB RAM), pipeline cloud AWS IoT Core / Lambda / DynamoDB, et applications mobiles de contrôle. Cible : 150 000+ systèmes produits/an déployés en production.

• Co-conçu le firmware embarqué en C / FreeRTOS avec optimisation stricte de l'empreinte mémoire (heap profiling, suppression des malloc dynamiques sur les hot paths, watchdog hardware)
• Architecturé les pipelines de télémétrie haute fréquence MQTT → AWS IoT Core → Lambda → DynamoDB — ingestion sans perte de paquets sur des bursts d'usage en heure de pointe
• Implémenté les mises à jour OTA des firmwares avec rollback automatique sur signature corrompue ou checksum invalide
• Développé l'app mobile de contrôle qui parle au backend cloud et au spa local en Bluetooth Low Energy (fallback si pas de Wi-Fi)
• Imposé une discipline d'observabilité (Serilog → CloudWatch) qui a permis de diagnostiquer les failures de production à distance plutôt que d'envoyer un technicien chez le client

• Firmware déployé sur 150 000+ systèmes IoT produits par an, en chaîne de production 24/7
• Ingestion télémétrie sans perte de paquets validée sur 6 mois de prod
• Time-to-diagnose des incidents firmware divisé par 3 grâce à l'observabilité distribuée
• Onboarding d'un nouveau dev sur la chaîne IoT réduit de 4 semaines à 1 grâce à la doc d'archi unifiée

EXFO est la référence mondiale du test télécoms — 2 000+ clients, présent dans 100 pays. Leurs techniciens fibre / 5G travaillent sur le terrain, souvent sans réseau, et doivent communiquer en Bluetooth Low Energy avec des appareils de mesure propriétaires. Tolérance zéro à la perte de données terrain — un test raté = un déplacement à refaire à 200 € la visite.

Rejoindre l'équipe mobile pour développer / maintenir les apps Flutter / C# utilisées par 250 000+ techniciens. Intégrer les nouveaux protocoles BLE bas niveau pour la prochaine génération d'appareils de mesure. Garantir l'intégrité offline et la sync bidirectionnelle au retour réseau.

• Intégré les protocoles Bluetooth Low Energy + Wi-Fi bas niveau pour la communication directe avec les appareils de mesure propriétaires — reverse engineering partiel du protocole legacy
• Contribué à l'architecture offline-first avec sync bidirectionnelle au retour réseau, sans perte de mesure même sur 8 h en zone blanche
• Renforcé les tests d'intégration BLE en simulation (mock du firmware côté Dart) — pas besoin du matériel physique pour la CI
• Documenté les patterns de comm BLE pour que les futures features ne réinventent pas la roue à chaque nouveau modèle d'appareil

• Apps déployées dans 100 pays, utilisées par 250 000+ techniciens en quotidien
• Aucune régression sur les patterns BLE existants pendant l'intégration de la nouvelle génération d'appareils
• Couverture des tests d'intégration BLE passée de manuelle à automatisée sur la CI

Les frameworks RP classiques empilent les API REST entre serveur, UI et admin. Au-delà d'un certain volume d'évènements concurrents, la latence cumulée tue l'UX. Le brief : un framework positionné comme une plateforme SaaS multi-tenant, capable d'héberger plusieurs instances en parallèle, sur une archi Event-Driven pure (zéro REST entre domaines) qui survive aux contraintes brutales d'un runtime in-game Mono 5.16.

Concevoir une plateforme RP multi-tenant Event-Driven en .NET 9/10. La même archi doit servir le serveur cloud, l'admin Blazor .NET 10 (MudBlazor 8), les DLLs in-game Mono 5.16 et 48 mini-applications React 19.

• Fusion RPC bout-en-bout (NUI ↔ serveur via WebSocket dédié /rpc/ws, MessagePack) — auto-invalidation des computed values, zéro endpoint REST entre domaines
• Multi-tenant imposé par InstanceId + Global Query Filters EF Core + TenantMiddleware — isolation par construction, impossible de fuiter une donnée entre instances
• Pattern dual-path MutateAsync vs MutateSerializableAsync pour les read-then-write monétaires (transactions atomiques)
• Analyzers Roslyn custom (codes ONERP00x) qui bloquent les anti-patterns à la compilation — la convention devient un check de build
• Wrapper SafeTriggerAsync pour contourner le bug Mono 5.16 où ScriptContext [ThreadStatic] est perdu après await (47 règles de contrainte Mono documentées dans CLAUDE.md)
• Dev harness NUI offline avec 68 callbacks mockés : tester les 48 UIs dans Chrome sans lancer le client lourd
• Type generation C# → TypeScript automatique : aucune divergence backend ↔ NUI

• 2 048 connexions concurrentes ciblées sur le même monde virtuel — 4× ce que tient la concurrence directe (~500 connexions avant écroulement)
• 1 150+ tests cumulés (842 xUnit unit + 9 integration + 303 Vitest NUI)
• Pattern Fusion + multi-tenant query filter réutilisé sur SaleCast, PromptVault, Racine — sur des contextes business très différents
• Stack obs Docker prête : Prometheus + Grafana + Seq + OpenTelemetry + Serilog

Dans la plupart des boîtes, les prompts ChatGPT / Claude qui marchent finissent collés dans des notes Notion ou Docs perso. Pas de capitalisation, les non-tech ne peuvent pas exécuter un prompt complexe sans en comprendre la mécanique, et quand un membre part la connaissance part avec.

Bâtir un SaaS B2B qui prend ces prompts ad-hoc et les transforme en outils internes : variables `{{champ}}` détectées automatiquement → formulaire généré pour les non-tech, chaînes multi-étapes, ContextPacks (ton/glossaire entreprise), Privacy Shield pour masquer les PII avant envoi LLM, workspaces multi-sièges avec billing Stripe, extensions Chrome MV3 + VS Code pour injecter les prompts dans les outils existants.

• Architecture Feature Slices : chaque feature = I{Name}ComputeService Fusion (cache + invalidation cascade) + {Name}ApiEndpoints + composants Blazor dédiés — 34 slices au total
• Blazor Web App SSR pour le SEO landing + Interactive Server pour l'app (WASM écarté à cause du download initial de 5-10 MB)
• Deux extensions natives co-développées avec le backend : Chrome (Manifest V3, TypeScript, Vite) + VS Code (TypeScript, esbuild) — même API contract
• Privacy Shield isolé en couche transverse (plan dédié de 26 KB de specs) — PII masquées avant envoi LLM côté navigateur
• Observabilité OpenTelemetry + Seq + Hangfire jobs Postgres

• Privacy Shield PII en couche transverse : les données personnelles sont masquées AVANT d'arriver chez OpenAI / Claude — l'un des rares moyens d'utiliser ChatGPT en boîte tout en respectant le RGPD
• 3 surfaces parallèles consommant la même API : Blazor Web + Chrome MV3 + VS Code
• Auth multi-providers (ASP.NET Identity + JWT + OAuth Google/GitHub/Microsoft) + workspaces multi-sièges
• Pas encore de prod publique — projet en dev actif, objectif documenté 500 users payants à 12 mois

Tout le monde dit que "le web est lent pour les simulations". Avec WebGPU stabilisé en 2024, c'est devenu faux — mais quasiment personne ne le sait. Je voulais publier une preuve open source : 100 000 agents autonomes simulés à 60 FPS dans un onglet Chrome, sans appel serveur, sans WASM, juste du WebGPU pur.

Construire un moteur de simulation WebGPU + WGSL, publier en package npm réutilisable, supporter la dégradation gracieuse (WebGPU → WebGL → Canvas2D) pour la compatibilité, viser 100 000 entités à 60 FPS sur un MacBook récent.

• Pipeline GPU en 8 passes séquentielles dans un seul batch — zero allocation pendant la simulation
• Recherche de voisins par partitionnement spatial parallèle à 3 niveaux (algorithme académique adapté pour compute shader)
• 5 niveaux de détail (LOD) selon la distance — rendu précis au premier plan, densité agrégée en arrière-plan
• Détection automatique du matériel : bascule WebGPU → WebGL → Canvas2D selon ce qui est dispo
• Génétique optionnelle : chaque entité a un génome (vitesse, perception, taille), évolution par sélection naturelle — tout sur GPU

• 100 000 entités à 60 FPS constants validé sur MacBook M3 Pro
• 60× plus rapide que l'implémentation CPU équivalente
• 70 tests automatisés couvrant la correctness du partitionnement spatial (validation cross-renderer)
• Open-source MIT — démo live publique poisson.floriansola.fr (deep dives architecture + simulation + sandbox)