Europe/Paris
Projets

Krown by Favikon – App iOS B2C pour créateurs de contenu (lead technique)

Krown by Favikon – App iOS B2C pour créateurs de contenu (lead technique)
19 octobre 2026
Krown est le produit B2C de Favikon : là où la plateforme Favikon sert les marques et les agences, Krown s'adresse directement aux créateurs de contenu (Instagram, TikTok, YouTube, X, LinkedIn). Son principe : faire de la croissance d'un créateur un jeu qu'on peut gagner. Chaque jour, l'app calcule un score d'autorité, place le créateur dans de vrais classements (mondial, par niche, par pays), suit ses streaks de publication et décortique ce que fait son contenu. Elle ne lit que des données publiques et ne publie jamais à la place du créateur. L'app a été validée par l'App Store (« Krown - Become a Top Creator ») et sa sortie publique est à venir ; elle sera proposée en freemium avec un abonnement Krown Pro. J'ai porté le lead technique du produit de A à Z, du premier commit sur un repo vide (avril 2026) à la validation par l'App Store (octobre 2026) :
  • Architecte : j'ai conçu toute l'architecture dès le premier commit (monorepo, API, app iOS, web, design system, contrats partagés) et rédigé les guides qui la décrivent
  • Lead d'équipe : pilotage technique de 4 développeurs (iOS et API, Android, web), avec les standards de code, les règles de branches et le process de release que j'ai mis en place
  • IA : conception et développement de Koach, l'agent IA de l'app
  • Mise en production : soumission App Store, conformité aux guidelines Apple et billing StoreKit 2
Architecture de Krown : sources uniques, clients générés, API hexagonale et services
J'ai réuni l'app iOS, l'API, le web et l'app Android dans un seul monorepo (pnpm + Turborepo). Un changement de contrat, de design token ou de traduction se fait en un seul commit et atteint toutes les plateformes en même temps.
krown/
├── apps/
│   ├── ios/            # SwiftUI (iOS 17+), widgets
│   ├── api/            # NestJS 11, hexagonal
│   ├── web/            # Next.js 16
│   └── android/        # Jetpack Compose (en cours)
└── packages/
    ├── types/          # 149 JSON Schemas → TS, Swift, Kotlin
    ├── design-tokens/  # 211 tokens → iOS, web, Android
    ├── ui-ios/         # Design system SwiftUI
    ├── ui-web/         # Design system web
    ├── ui-android/     # Design system Compose
    ├── i18n/           # ~3 000 clés × 4 langues
    ├── content/        # Textes légaux → iOS + web
    └── brand-assets/   # Logos, badges, illustrations
J'ai fait de JSON Schema la source unique des types d'API : 149 schémas, générés en TypeScript, Swift et Kotlin avec quicktype. Quand un client et l'API divergent, on corrige le schéma, jamais le client. J'ai appliqué la même règle aux design tokens (Style Dictionary), aux traductions (xcstrings, strings.xml, next-intl) et aux textes légaux, ce qui supprime toute une classe de bugs de dérive entre client et serveur. Un hook pre-commit vérifie en plus que les enums métier n'ont pas dérivé des schémas. J'ai posé dès le premier commit une API NestJS en monolithe modulaire hexagonal : 34 modules, tous découpés de la même façon.
modules/<module>/
├── domain/          # entités et value objects, sans framework
├── application/
│   ├── ports/       # interfaces vers l'extérieur
│   └── use-cases/   # logique applicative, ne connaît que les ports
├── infrastructure/  # adapters : données, recherche, paiement, LLM
└── presentation/    # controllers REST et DTO
  • Les dépendances pointent vers le domaine. Le domaine n'importe ni NestJS, ni l'ORM, ni le moteur de recherche. Les use-cases ne connaissent que des ports, et NestJS ne leur sert qu'à l'injection de dépendances.
  • Tout ce qui est externe est un adapter : base de données, moteur de recherche, App Store, analytics, notifications et modèle de langage. Changer de fournisseur revient à écrire un nouvel adapter, sans toucher aux use-cases.
  • Deux adapters d'entrée, une seule logique. Les controllers REST de l'app et le serveur MCP de l'agent IA appellent les mêmes use-cases : l'agent réutilise la logique métier au lieu de la dupliquer.
  • Testable sans infrastructure. 227 des 234 fichiers de tests de use-cases tournent sur des fakes en mémoire des ports (188 fakes, modèle de langage compris), sans base de données ni réseau.
  • Les données partagées de Favikon ne sont accessibles que depuis la couche infrastructure, une règle posée dès le premier commit et documentée dans le guide de l'API.
C'est aussi le sujet de la première machine de Nightprint, mon side-project qui dessine l'architecture hexagonale en machine 3D.
  • Les droits d'accès sont calculés côté serveur : l'app ne décide jamais seule, elle affiche ce que l'API calcule.
  • Version gating et feature flags pilotés à distance : activer une fonctionnalité ou exiger une mise à jour ne demande pas de nouveau build.
  • Une version par livrable, et un numéro de build iOS qui ne fait que monter, pour que l'API sache toujours à quelle version de l'app elle répond.
  • Côté iOS, un cache hybride en stale-while-revalidate entre les repositories et le réseau garde l'app utilisable hors ligne.
Le même découpage Atomic Design (atoms, molecules, organisms, templates) est appliqué sur iOS, web et Android. Sur iOS, le design system compte 119 atoms, 131 molecules, 56 organisms et 7 templates, couverts par 1 561 snapshots de référence. J'ai mis en place les règles qui permettent à 4 développeurs d'avancer vite sans casser les autres plateformes :
  • 13 guides d'architecture (flux de données, design system, workflow git, intégrations Apple…), écrits pour l'équipe et pour ses agents de code
  • Des règles imposées par les outils plutôt que par la relecture : hooks git sur les branches (trunk, release, production), Conventional Commits, lint sur les trois langages
  • Un process de release : master part en preprod, production n'avance que par promotion fast-forward d'un commit validé, taggée à chaque mise en production ; l'API et le web sortent toujours ensemble
  • Côté iOS : une branche de release par version, correctifs en cherry-pick et un tag par build envoyé à Apple
  • Une CI sur chaque pull request qui protège les contrats partagés entre plateformes
  • Score d'autorité quotidien, décomposé en Reach, Engagement, Audience et Consistency, avec un objectif du jour
  • Classements mondial, par niche et par pays, et streaks de publication de Bronze à Challenger
  • Score par post, médailles élite et « Krowns » pour le meilleur post de chaque arène
  • Content DNA et Explore & Compare pour se situer face aux autres créateurs
  • Widgets, Live Activity et Control Center sur l'écran d'accueil et l'écran verrouillé
  • Vérification de compte par OAuth officiel (Instagram, TikTok, YouTube) et abonnement StoreKit 2
Écrans de Krown : connexion, choix de la niche, points du jour, accueil
J'ai conçu et développé Koach, un agent LLM qui répond aux questions du créateur à partir de ses propres données. Ses outils passent par un serveur MCP qui réutilise les use-cases de l'API. Le modèle a été choisi après une évaluation de 13 modèles, l'agent a été soumis à un red-teaming, ses limites de coût et de temps sont imposées dans le code et ses réponses sont streamées en SSE jusqu'à l'app. Koach arrive avec la version 1.1.0.
  • Swift 5.9, SwiftUI, iOS 17+, projet généré par XcodeGen
  • MVVM avec @Observable, navigation typée (NavigationStack)
  • WidgetKit, ActivityKit (Live Activities), AppIntents (Control Center), StoreKit 2, Sign in with Apple, RealityKit (badges 3D)
  • NestJS 11, Node 20, TypeScript : architecture hexagonale (ports & adapters), 34 modules
  • MongoDB (Mongoose), Elasticsearch 8, stockage S3
  • App Store Server Library, APNs, Swagger, zod
  • Agent LLM outillé par un serveur MCP (@modelcontextprotocol/sdk), embeddings pour la recherche de posts, streaming SSE
  • Next.js 16, React 19, Tailwind CSS 4, next-intl
  • Kotlin 2, Jetpack Compose, Material 3 (en cours)
  • Monorepo : pnpm workspaces + Turborepo
  • Qualité : ESLint, Prettier, SwiftLint, SwiftFormat, ktlint, commitlint, husky
  • Tests : Jest côté API, XCTest et snapshot tests côté iOS
  • Environnements : preprod et prod séparés
  • Du repo vide à la validation App Store en cinq mois et demi, sur un produit polyglotte dont les contrats sont partagés entre quatre plateformes.
  • Faire grandir l'équipe sans perdre la cohérence : des guides d'architecture, des règles imposées par les outils et une CI qui protège les contrats ont permis d'intégrer de nouveaux développeurs sans dérive.
  • Mise en conformité App Store : j'ai mené la mise en conformité avant la soumission (Sign in with Apple, suppression de compte, consentement IA, privacy manifest, textes légaux), découpée en 16 chantiers priorisés.
  • Un billing solide : droits calculés côté serveur, notifications App Store idempotentes, sandbox et production vérifiées côte à côte.
  • Validations tierces : applications OAuth approuvées par Google (YouTube), Meta (Instagram) et TikTok.
  • 5 mois et demi du premier commit à la validation par l'App Store
  • 4 plateformes dans un seul monorepo et 34 modules d'API hexagonale
  • ~10 000 tests automatisés : ~6 300 côté API, ~3 700 côté iOS
  • 149 schémas partagés, 211 design tokens, ~3 000 clés de traduction en 4 langues
  • 13 guides d'architecture
Krown a été validée par l'App Store et sa sortie publique est à venir ; l'app est présentée sur krown.me. La version 1.1.0 est en préparation, et une app Android est en cours de développement.