Europe/Paris
Projects

Krown by Favikon – B2C iOS App for Content Creators (Tech Lead)

Krown by Favikon – B2C iOS App for Content Creators (Tech Lead)
October 19, 2026
Krown is Favikon's B2C product: where the Favikon platform serves brands and agencies, Krown speaks directly to content creators (Instagram, TikTok, YouTube, X, LinkedIn). Its idea: turn a creator's growth into a game you can win. Every day, the app computes an Authority Score, places the creator in real rankings (global, by niche, by country), tracks posting streaks and breaks down what their content does. It reads public data only and never posts on the creator's behalf. The app has been approved by the App Store ("Krown - Become a Top Creator") and its public release is still to come; it will be a freemium download with a Krown Pro subscription. I was the tech lead of the product from start to finish, from the first commit on an empty repo (April 2026) to App Store approval (October 2026):
  • Architect: I designed the whole architecture from the first commit (monorepo, API, iOS app, web, design system, shared contracts) and wrote the guides that describe it
  • Team lead: technical leadership of 4 developers (iOS and API, Android, web), with the coding standards, branching rules and release process I put in place
  • AI: design and development of Koach, the app's AI agent
  • Release: App Store submission, Apple guideline compliance and StoreKit 2 billing
Krown architecture: single sources, generated clients, hexagonal API and services
I brought the iOS app, the API, the web app and the Android app into a single monorepo (pnpm + Turborepo). A change to a contract, a design token or a translation lands in one commit and reaches every platform at once.
krown/
├── apps/
│   ├── ios/            # SwiftUI (iOS 17+), widgets
│   ├── api/            # NestJS 11, hexagonal
│   ├── web/            # Next.js 16
│   └── android/        # Jetpack Compose (in progress)
└── packages/
    ├── types/          # 149 JSON Schemas → TS, Swift, Kotlin
    ├── design-tokens/  # 211 tokens → iOS, web, Android
    ├── ui-ios/         # SwiftUI design system
    ├── ui-web/         # Web design system
    ├── ui-android/     # Compose design system
    ├── i18n/           # ~3,000 keys × 4 languages
    ├── content/        # Legal texts → iOS + web
    └── brand-assets/   # Logos, badges, illustrations
I made JSON Schema the single source of API types: 149 schemas, generated into TypeScript, Swift and Kotlin with quicktype. When a client and the API disagree, the schema gets fixed, never the client. I applied the same rule to design tokens (Style Dictionary), translations (xcstrings, strings.xml, next-intl) and legal texts, which removes a whole class of client/server drift bugs. A pre-commit hook also checks that domain enums have not drifted from the schemas. From the first commit, I set up the NestJS API as a hexagonal modular monolith: 34 modules, all split the same way.
modules/<module>/
├── domain/          # entities and value objects, no framework
├── application/
│   ├── ports/       # interfaces to the outside world
│   └── use-cases/   # application logic, knows only the ports
├── infrastructure/  # adapters: data, search, payments, LLM
└── presentation/    # REST controllers and DTOs
  • Dependencies point to the domain. The domain imports neither NestJS, nor the ORM, nor the search engine. Use-cases only know ports, and NestJS only provides their dependency injection.
  • Everything external is an adapter: database, search engine, App Store, analytics, notifications and the language model. Switching provider means writing a new adapter, without touching the use-cases.
  • Two driving adapters, one logic. The app's REST controllers and the AI agent's MCP server call the same use-cases: the agent reuses the business logic instead of duplicating it.
  • Testable without infrastructure. 227 of the 234 use-case test files run on in-memory fakes of the ports (188 fakes, the language model included), with no database and no network.
  • Favikon's shared data can only be reached from the infrastructure layer, a rule set from the first commit and documented in the API guide.
It is also the subject of the first machine of Nightprint, my side project that draws hexagonal architecture as a 3D machine.
  • Access rights are computed on the server: the app never decides on its own, it shows what the API computes.
  • Remote version gating and feature flags: turning a feature on or requiring an update does not need a new build.
  • One version per deployable, and an iOS build number that only goes up, so the API always knows which app version it is answering.
  • On iOS, a stale-while-revalidate hybrid cache between the repositories and the network keeps the app usable offline.
The same Atomic Design split (atoms, molecules, organisms, templates) applies on iOS, web and Android. On iOS, the design system has 119 atoms, 131 molecules, 56 organisms and 7 templates, covered by 1,561 reference snapshots. I put in place the rules that let 4 developers move fast without breaking the other platforms:
  • 13 architecture guides (data flows, design system, git workflow, Apple integrations…), written for the team and for its coding agents
  • Rules enforced by tools rather than by review: git hooks on branches (trunk, release, production), Conventional Commits, linting across the three languages
  • A release process: master deploys to preprod, production only moves through a fast-forward promotion of a validated commit, tagged on every release; the API and the web always ship together
  • On iOS: one release branch per version, cherry-picked fixes and one tag per build uploaded to Apple
  • CI on every pull request to protect the contracts shared across platforms
  • Daily Authority Score, broken down into Reach, Engagement, Audience and Consistency, with a daily target
  • Rankings (global, by niche, by country) and posting streaks from Bronze to Challenger
  • Post score, elite medals and "Krowns" for the best post in each arena
  • Content DNA and Explore & Compare to see where you stand against other creators
  • Widgets, Live Activity and Control Center on the Home Screen and Lock Screen
  • Account verification through official OAuth (Instagram, TikTok, YouTube) and a StoreKit 2 subscription
Krown screens: sign-in, niche picker, daily points, home
I designed and built Koach, an LLM agent that answers the creator's questions from their own data. Its tools go through an MCP server that reuses the API's use-cases. The model was picked after an evaluation of 13 models, the agent went through a red-team pass, its cost and time limits are enforced in code, and its answers are streamed over SSE to the app. Koach ships with version 1.1.0.
  • Swift 5.9, SwiftUI, iOS 17+, project generated with XcodeGen
  • MVVM with @Observable, typed navigation (NavigationStack)
  • WidgetKit, ActivityKit (Live Activities), AppIntents (Control Center), StoreKit 2, Sign in with Apple, RealityKit (3D badges)
  • NestJS 11, Node 20, TypeScript: hexagonal architecture (ports & adapters), 34 modules
  • MongoDB (Mongoose), Elasticsearch 8, S3 storage
  • App Store Server Library, APNs, Swagger, zod
  • LLM agent powered by an MCP server (@modelcontextprotocol/sdk), embeddings for post search, SSE streaming
  • Next.js 16, React 19, Tailwind CSS 4, next-intl
  • Kotlin 2, Jetpack Compose, Material 3 (in progress)
  • Monorepo: pnpm workspaces + Turborepo
  • Quality: ESLint, Prettier, SwiftLint, SwiftFormat, ktlint, commitlint, husky
  • Tests: Jest on the API, XCTest and snapshot tests on iOS
  • Environments: separate preprod and prod
  • From an empty repo to App Store approval in five and a half months, on a polyglot product whose contracts are shared across four platforms.
  • Growing the team without losing consistency: architecture guides, rules enforced by tools and a CI that protects the contracts made it possible to onboard new developers without drift.
  • App Store compliance: I led the compliance work before submission (Sign in with Apple, account deletion, AI consent, privacy manifest, legal texts), split into 16 prioritized work items.
  • Solid billing: server-side entitlements, idempotent App Store notifications, sandbox and production verified side by side.
  • Third-party reviews: OAuth apps approved by Google (YouTube), Meta (Instagram) and TikTok.
  • Five and a half months from the first commit to App Store approval
  • 4 platforms in a single monorepo and 34 modules of hexagonal API
  • ~10,000 automated tests: ~6,300 on the API, ~3,700 on iOS
  • 149 shared schemas, 211 design tokens, ~3,000 translation keys in 4 languages
  • 13 architecture guides
Krown has been approved by the App Store and its public release is still to come; the app is presented on krown.me. Version 1.1.0 is in preparation, and an Android app is in development.