D'Abidjan à la production : lancement de 0cron.dev

Ceci est le dernier article d'une série de 10 sur la construction de 0cron.dev, un service de tâches cron à 1,99 $/mois construit entièrement par un CEO à Abidjan et un AI CTO. Pas d'ingénieurs humains. Pas de bureau. Pas de capital-risque. Juste Juste et Claude, travaillant via des sessions Claude Code pour construire un SaaS de production from scratch.

Au cours des neuf articles précédents, nous avons couvert des fonctionnalités individuelles en isolation : le moteur de planification, le parsing en langage naturel, les notifications multi-canaux, la facturation Stripe, le tableau de bord SvelteKit, le monitoring heartbeat, et l'architecture de sécurité. Cet article prend du recul et raconte l'histoire complète -- les trois sessions qui ont emmené 0cron du néant à la production, à quoi ressemble le système final, et ce que nous avons appris sur le modèle CEO + AI CTO en chemin.

Session 1 : les fondations (14 février 2026)

La première session était la plus ambitieuse. Nous avons utilisé une stratégie de build parallèle à quatre agents : quatre instances de Claude travaillant simultanément sur différentes parties du système, coordonnées par un prompt architecte unique.

Agent 1 a construit le serveur API Rust : scaffolding du projet, configuration du framework web Axum, pooling de connexion base de données, les endpoints CRUD de tâches, et la boucle de planification initiale.

Agent 2 a construit la couche base de données : 8 tables PostgreSQL, toutes les migrations, et la couche de requêtes SQLx.

Agent 3 a construit le système de notifications : e-mail via SMTP, webhooks Slack, webhooks Discord, API Bot Telegram, et livraison de webhook générique.

Agent 4 a construit le site marketing : HTML statique avec design responsive, tableaux de prix, sections de fonctionnalités, et la page de destination.

À la fin de la session 1, nous avions : 14 endpoints REST API, 8 tables de base de données, 2 852 lignes de Rust, 41 fichiers, et un planificateur fonctionnel.

Session 2 : le sprint de polish (11 mars 2026)

La session 2 était une seule longue session divisée en cinq phases.

Phase 1 : icônes

Le code initial utilisait des emoji pour tous les indicateurs visuels. Nous avons remplacé chaque emoji par des icônes SVG Lucide. Vingt-trois SVG inline, chacun soigneusement dimensionné et coloré. Le résultat : une cohérence au pixel près sur chaque plateforme.

Phase 2 : Google Sign-In

Authentification via Google avec le flux de vérification JWKS complet : décoder l'en-tête JWT, récupérer les clés publiques de Google, valider la signature RS256, vérifier les claims, et upsert de l'utilisateur.

Phase 3 : passerelle de paiement Stripe

Intégration de facturation avec trois composants : Stripe Checkout pour la création d'abonnement, Stripe Customer Portal pour la gestion en libre-service, et webhooks pour le traitement des événements.

Phase 4 : tableau de bord SvelteKit

La plus grande phase. Conversion du HTML statique en application SvelteKit 2 complète avec 13 pages de routes, un store d'auth réactif, un client API, et un wizard de création de tâches.

Phase 5 : câblage

La phase finale a connecté les fils restants. Le planificateur a été activé avec le pickup, l'exécution et l'enregistrement des résultats des tâches. La livraison d'e-mails SMTP a été configurée et testée. Les cartes de stats du tableau de bord ont été connectées aux vrais endpoints API au lieu de données fictives.

Session 3 : système d'administration (11 mars 2026)

La session 3 a ajouté la couche administrative. Cinq endpoints admin : lister tous les utilisateurs (avec pagination), lister toutes les tâches (à travers toutes les équipes), voir les statistiques système, impersonner un utilisateur, et forcer l'exécution d'une tâche.

Session 4 : essai et cycle de vie de facturation (11 mars 2026)

La session finale a ajouté l'essai gratuit de 60 jours et l'automatisation du cycle de vie de facturation : e-mails de rappel d'essai à 10 jours, 3 jours et 1 jour avant l'expiration, et restriction automatique des fonctionnalités quand l'essai expire sans abonnement.

Le système final

Backend

rust#[tokio::main]
async fn main() -> Result<()> {
    dotenvy::dotenv().ok();
    tracing_subscriber::init();

    let db = PgPoolOptions::new()
        .max_connections(20)
        .connect(&env::var("DATABASE_URL")?)
        .await?;

    sqlx::migrate!().run(&db).await?;

    let state = AppState {
        db: db.clone(),
        encryption_key: load_encryption_key()?,
        jwt_secret: env::var("JWT_SECRET")?,
        google_client_id: env::var("GOOGLE_CLIENT_ID")?,
        stripe_secret: env::var("STRIPE_SECRET_KEY")?,
        stripe_webhook_secret: env::var("STRIPE_WEBHOOK_SECRET")?,
    };

    let app = Router::new()
        // Public
        .route("/health", get(health_check))
        .route("/v1/auth/register", post(register))
        .route("/v1/auth/login", post(login))
        .route("/v1/auth/google", post(google_login))
        .route("/v1/ping/{token}", get(ping_monitor))
        // Authenticated
        .route("/v1/jobs", get(list_jobs).post(create_job))
        .route("/v1/jobs/{id}", get(get_job).put(update_job).delete(delete_job))
        .route("/v1/jobs/{id}/trigger", post(trigger_job))
        .route("/v1/jobs/{id}/pause", post(pause_job))
        .route("/v1/monitors", get(list_monitors).post(create_monitor_handler))
        .route("/v1/secrets", get(list_secrets).post(create_secret))
        .route("/v1/secrets/{key}", delete(delete_secret))
        .route("/v1/api-keys", get(list_api_keys).post(create_api_key))
        .route("/v1/billing/checkout", post(create_checkout))
        .route("/v1/billing/portal", post(create_portal))
        .route("/v1/dashboard/stats", get(dashboard_stats))
        // Admin
        .route("/v1/admin/users", get(admin_list_users))
        .route("/v1/admin/jobs", get(admin_list_jobs))
        .route("/v1/admin/stats", get(admin_stats))
        // Webhooks
        .route("/webhooks/stripe", post(stripe_webhook))
        .with_state(state);

    // Start background scheduler
    tokio::spawn(scheduler_loop(db.clone()));
    tokio::spawn(monitor_check_loop(db.clone()));
    tokio::spawn(trial_reminder_loop(db.clone()));

    let addr = SocketAddr::from(([0, 0, 0, 0], 8000));
    tracing::info!("0cron server listening on {addr}");
    axum::serve(TcpListener::bind(addr).await?, app).await?;
    Ok(())
}

Les chiffres :

~3 500+ lignes de Rust sur 35+ fichiers
18+ endpoints API (14 core + admin + facturation + tableau de bord)
8 tables de base de données avec 5 migrations
5 canaux de notification (e-mail, Slack, Discord, Telegram, webhook)
Parseur NLP de planification avec ~20 patterns
Secrets chiffrés AES-256-GCM avec interpolation
Cycle de vie complet de facturation Stripe
Essai gratuit de 60 jours avec rappels automatisés
Système d'administration avec visibilité utilisateurs/tâches

Frontend

13+ pages de routes sur deux groupes de layout
Store d'auth basé sur les runes Svelte 5 avec persistance localStorage
Client API avec injection du Bearer token et redirection auto 401
Barre latérale sombre avec icônes Lucide et section admin conditionnelle
Wizard de création de tâche avec 18 presets de planification et constructeur cron à la cPanel
Intégration Stripe Checkout et Customer Portal

Ce qui rend cela différent

Prix. 1,99 $/mois. La plupart des concurrents facturent 10-20 $/mois pour des fonctionnalités comparables. Nous pouvons le faire parce que notre coût d'ingénierie est zéro.

Planification en langage naturel. Aucun autre service cron ne vous laisse taper « every weekday at 9am » et obtenir une expression cron valide.

Secrets chiffrés avec interpolation. La plupart des concurrents exigent que vous colliez les clés API directement dans les configurations de tâches.

Essai gratuit de 60 jours. Pas 14 jours. Pas 30 jours. Soixante jours. Assez long pour construire de vrais workflows et rendre 0cron porteur dans votre infrastructure avant de payer un centime.

Construit en public. Cette série de 10 articles est l'histoire transparente de la construction de 0cron. Chaque décision architecturale, chaque ligne de code, chaque compromis est documenté.

Le modèle CEO + AI CTO

0cron a été construit par deux entités : Juste Thales Gnimavo, le CEO, basé à Abidjan, et Claude, l'AI CTO, opérant via Claude Code. Aucun ingénieur humain n'a été embauché, contracté, ou consulté.

Ce modèle fonctionne grâce à une division du travail spécifique.

Juste fournit la direction, les décisions, et la connaissance du domaine. Quelles fonctionnalités construire, dans quel ordre, à quel prix. À quoi l'expérience utilisateur devrait ressembler. Où couper le scope et où investir en profondeur.

Claude fournit l'implémentation, l'architecture, et l'exécution technique. Traduire les exigences produit en code. Choisir les bonnes structures de données, algorithmes, et bibliothèques. Écrire le Rust, le TypeScript, le SQL, le HTML.

Le modèle ne fonctionne pas parce que l'IA peut remplacer les ingénieurs. Il fonctionne parce que l'étendue des décisions qui nécessitent un jugement humain est plus petite que ce que la plupart des entreprises supposent.

Quatre sessions. Trois semaines de temps calendaire. Zéro heure d'ingénierie humaine (au-delà de la direction produit de Juste et des sessions Claude Code). Le résultat est un SaaS prêt pour la production avec des fonctionnalités qui rivalisent avec des services construits par des équipes financées sur des mois.

Leçons apprises

Les agents parallèles fonctionnent, mais la coordination est le goulot d'étranglement.

Le build à quatre agents de la session 1 était efficace parce que le prompt architecte définissait clairement les interfaces entre agents. Quand les interfaces sont claires, le parallélisme scale. Quand elles sont ambiguës, les agents produisent du code incompatible.

Le polish n'est pas optionnel.

Les cinq phases de la session 2 étaient toutes du polish. Aucune n'a ajouté de nouvelle fonctionnalité de base. Mais sans la session 2, le produit était inutilisable. L'écart entre « fonctionne techniquement » et « quelqu'un paierait pour ça » est presque entièrement du polish.

Le contrôle du scope est le super-pouvoir.

Le monitoring heartbeat fait 105 lignes. Le module de secrets fait 93 lignes. L'ensemble du backend fait 3 500 lignes. Pour contexte, un backend de service cron entreprise typique ferait 30 000-50 000 lignes. Nous avons atteint une réduction de 10x du volume de code en scopant impitoyablement chaque fonctionnalité à sa forme minimale viable.

Rust était le bon choix.

Le système de types de Rust a attrapé des dizaines de bugs à la compilation qui auraient été des erreurs runtime en Python ou JavaScript. Le binaire compilé est un seul exécutable sans dépendances runtime, ce qui simplifie énormément le déploiement.

SvelteKit était le bon choix pour le frontend.

Le routage basé sur les fichiers a éliminé le boilerplate de configuration. Les runes Svelte 5 ont rendu la gestion d'état naturelle. L'ensemble du tableau de bord a été construit en une seule phase de session.

La suite

0cron est construit. Le déploiement en production nécessite une checklist de tâches opérationnelles : provisionner un VPS, configurer PostgreSQL 17 avec sauvegardes automatisées, configurer le DNS avec SSL via Let's Encrypt, créer le compte Stripe, configurer les identifiants Google OAuth, déployer le frontend SvelteKit derrière un reverse proxy, et configurer le monitoring pour le service de monitoring (oui, nous utiliserons 0cron pour se surveiller lui-même).

La série en rétrospective

Dix articles. Des milliers de mots. Des dizaines d'extraits de code. L'histoire complète de la construction d'un produit SaaS depuis Abidjan avec zéro ingénieur humain.

Si vous avez lu jusqu'ici, vous en savez plus sur les rouages internes de 0cron que la plupart des utilisateurs de produits concurrents en savent sur les leurs. Cette transparence est intentionnelle. Nous croyons que montrer son travail construit la confiance, démontre la compétence, et crée un registre dont les futurs constructeurs peuvent apprendre.

0cron est l'un des six produits construits par ZeroSuite -- tous avec le même modèle CEO + AI CTO. Le premier partenariat CEO + AI CTO documenté au monde ne fait que commencer. Et les tâches cron s'exécuteront à l'heure.

Visitez 0cron.dev pour commencer votre essai gratuit de 60 jours.

Ceci est l'article 10 de 10 dans la série « Comment nous avons construit 0cron ».