By Thales & Claude -- CEO & AI CTO, ZeroSuite, Inc.
On February 14, 2026, at a desk in Abidjan, Ivory Coast, the first git commit for Deblo.ai was pushed. It contained a SvelteKit frontend skeleton, a FastAPI backend with a single /api/chat endpoint, and a dream that was, by any conventional measure, absurd: build an AI education platform that could serve 250 million African students, from a team of two -- one human CEO and one AI CTO.
Six weeks later, Deblo.ai was live. Two products (K12 for students, Pro for professionals), 30+ database tables, 100+ API endpoints, 60+ frontend components, 24 AI tools, 101 specialized advisors, a native mobile app, voice calls, background document generation, and payment integration across 6 African countries. Built without a single human software engineer.
This is the story of how we built it, session by session, decision by decision.
---
Act 1: Foundation (February 14-15, 2026)
The first two days produced the skeleton. Sessions 1 through 6 established the core architecture:
Session 1-2: The Bootstrap. SvelteKit 2 with Svelte 5 runes for the frontend. FastAPI with async SQLAlchemy for the backend. PostgreSQL 17 for the database. Redis for caching and real-time features. The initial commit had 82 files -- not boilerplate, but a working full-stack application with routing, database models, and API endpoints.
Session 3-4: Chat and Authentication. The chat system was built SSE-first. No WebSocket debate, no polling fallback -- Server-Sent Events from day one. The authentication system was phone + WhatsApp OTP, because that is how Africa logs in. JWT tokens with 30-day expiry, stored in localStorage on web and SecureStore on mobile.
Session 5-6: Credits and Pro. The credit system was implemented on day two because monetization is not an afterthought -- it is a survival requirement. Deblo cannot run on advertising revenue in markets where the average user generates $0.02 per month in ad revenue. Credits, priced in USD cents and converted to local currency at display time, were the answer from the start.
By February 15, we had a working chat application where a user could authenticate via WhatsApp, start a conversation with an AI tutor, and pay for credits. It was ugly. It was minimal. But it worked end to end.
---
Act 2: Pro Features and the Tool Explosion (February 18 - March 2, 2026)
The next two weeks were the most intense. Sessions 7 through 75 built the features that differentiate Deblo from a ChatGPT wrapper.
The Agentic Loop. We implemented the tool system that gives Deblo its capabilities: file generation (PDF, Excel, PowerPoint, Word, HTML, Markdown), web search, URL browsing, bash execution, memory management, task creation, email drafting, SMS and WhatsApp messaging, quiz generation, bug reporting, and credit purchasing. Twenty-four tools in total, each with input validation, execution logic, result formatting, and error handling. The agentic loop -- where the LLM can call tools, inspect results, and call more tools -- matured across dozens of sessions.
Payment Integration. ZeroFee (our primary African payment gateway) was integrated first, supporting Orange Money, Wave, MTN Money, Moov Money, and Airtel Money across Ivory Coast, Senegal, Cameroon, Burkina Faso, Mali, and Benin. Then Stripe for international credit cards. Then in-chat purchasing via the buy_credits tool, so a user can buy credits without leaving the conversation.
Voice Notes and Voice Calls. Audio input via voice notes (record, transcribe with Whisper, send as text) came first. Then full voice calls with AI -- LiveKit for WebRTC transport, Ultravox for the voice agent. A student can call Deblo like a phone call and have a spoken conversation about their homework.
The System Prompt Architecture. The K12 system prompt grew to handle anti-cheating (Socratic method enforcement), grade-level adaptation (CP through Terminale, each with calibrated vocabulary and complexity), and African curriculum alignment (BEPC, BAC, SYSCOHADA for Pro). The Pro system prompt reached version 7.0 with XML-structured constraints for model compliance.
The Organization System. Companies, schools, and families can create organizations with shared credit pools. The organizations and org_memberships tables enable multi-user access with role-based permissions. A school can purchase a bulk credit package and distribute access to all its students.
---
Act 3: Mobile (March 3-9, 2026)
Seven days, twenty sessions, one React Native app. The mobile sprint ran in parallel with continued web development, which is why the session numbering overlaps.
The monorepo architecture -- four shared packages (@deblo/api, @deblo/stores, @deblo/streaming, @deblo/i18n) and the apps/k12 Expo application -- enabled the mobile app to share API logic, state management, and streaming with the web. Zustand replaced Svelte stores, Expo Router replaced SvelteKit routing, but the patterns were deliberately parallel.
The mobile app brought features that only make sense on a phone: biometric authentication, push notifications via Expo Push API, the drawing board canvas, camera-based photo analysis, and native voice calls through LiveKit's React Native SDK. The K12 app uses green (#22c55e) as its primary color, distinguishing it visually from the web platform's orange branding.
By March 9, the K12 app had 20+ screens, 5 authentication methods, streaming chat, voice calls, and file handling. Not shipped to the App Store yet -- that requires additional polish and review cycles -- but functionally complete.
---
Act 4: Advanced AI and Polish (March 9-23, 2026)
The final phase added the features that push Deblo from "functional" to "production-ready."
Background Jobs. The queue-bridged architecture for long-running AI tasks: GenerationJob model, detached asyncio.Task execution, Redis progress tracking, 3-second polling, cooperative cancellation. This unlocked the document generation use case that Pro users need most -- 50-page reports that take 5-30 minutes to generate.
LaTeX and Quiz Rendering. Mathematical expressions rendered properly in both chat and quizzes, using KaTeX on web and a hybrid SVG/WebView approach on mobile. The MathBlock component handles inline and block expressions with detection-based routing.
Email Drafting. The draft_email tool creates interactive email drafts that the user can edit and send to any recipient. Professional users compose client correspondence, audit letters, and tax advisory memos through the chat interface.
Stripe Integration. International payment support alongside the African mobile money gateways. Credit card payments for diaspora users and international organizations.
Notification Templates. Server-side notification system with configurable templates for daily exercise reminders, task deadlines, credit balance warnings, and family activity alerts.
The Curriculum Engine. Country-specific curriculum data for the 6 initial target countries, covering primary (CP-CM2), secondary (6eme-3eme), and high school (2nde-Terminale) with subject-specific content alignment.
---
The Final Count
As of March 23, 2026, Deblo.ai consists of:
Backend (Python FastAPI):
# main.py -- Application lifespan and router registration
@asynccontextmanager
async def lifespan(app: FastAPI):
await seed_and_load_templates()
start_poller()
start_task_scheduler()
from app.services.background_generation import mark_stale_jobs_failed
await mark_stale_jobs_failed()
yield
stop_task_scheduler()
stop_poller()app = FastAPI(title="Deblo API", version="1.0.0", lifespan=lifespan)
# 18 route modules registered: app.include_router(chat.router, prefix="/api", tags=["chat"]) app.include_router(auth.router, prefix="/api/auth", tags=["auth"]) app.include_router(credits.router, prefix="/api/credits", tags=["credits"]) app.include_router(curriculum.router, prefix="/api", tags=["curriculum"]) app.include_router(parent.router, prefix="/api/parent", tags=["parent"]) app.include_router(upload.router, prefix="/api/upload", tags=["upload"]) app.include_router(admin.router, prefix="/api/admin", tags=["admin"]) app.include_router(org.router, prefix="/api/org", tags=["org"]) app.include_router(projects.router, prefix="/api", tags=["projects"]) app.include_router(webhooks.router, prefix="/webhooks", tags=["webhooks"]) app.include_router(contact.router, prefix="/api", tags=["contact"]) app.include_router(voice.router, prefix="/api", tags=["voice"]) app.include_router(pay.router, prefix="/api/pay", tags=["pay"]) app.include_router(tasks.router, prefix="/api/tasks", tags=["tasks"]) app.include_router(referral.router, prefix="/api/referral", tags=["referral"]) app.include_router(notifications.router, prefix="/api/notifications") app.include_router(suggestions.router, prefix="/api/suggestions") app.include_router(stats.router, prefix="/api/stats", tags=["stats"]) ```
Database: 30 tables across 23 model files:
| Domain | Tables |
|---|---|
| Users & Auth | users, otp_codes |
| Conversations | conversations |
| Credits | credit_purchases, credit_usages, credit_ledger |
| Content | uploaded_files, file_folders, document_chunks |
| AI | ai_logs, ai_memories, generation_jobs |
| Tasks & Projects | goals, tasks, task_comments, task_notifications, projects |
| Organizations | organizations, org_memberships |
| Curriculum | curriculum, exercise_results |
| Engagement | daily_suggestions, user_notifications, notification_templates |
| Voice | voice_sessions |
| Referrals | referrals, referral_clicks |
| Credits (bonus) | bonus_credits, coupon_redemptions |
| System | system_settings |
Frontend: 60+ Svelte components, 1,865 lines of agent definitions, full dark/light theme.
Mobile: 20+ screens, 4 shared packages, monorepo with workspaces.
AI: 24 tools, 101 advisors, 14 categories, grade-level adaptation (CP to Terminale), anti-cheating Socratic method, background generation up to 30 minutes.
Payments: 3 gateways (ZeroFee, Stripe, in-chat), 6 countries, 13 currencies, mobile money + cards.
Infrastructure:
services:
frontend:
build:
context: ./frontend
dockerfile: Dockerfile
ports:
- "3000:3000"
depends_on:
- backendbackend: build: context: ./backend dockerfile: Dockerfile ports: - "8000:8000" environment: - DATABASE_URL=postgresql+asyncpg://deblo:deblo@postgres:5432/deblo - REDIS_URL=redis://redis:6379/0 depends_on: postgres: condition: service_healthy redis: condition: service_healthy
postgres: image: pgvector/pgvector:pg16 volumes: - pgdata:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U deblo"]
redis: image: redis:7-alpine ```
Four containers. One docker-compose.yml. The entire platform runs on a single server.
---
The Key Decisions
Looking back, several decisions defined the trajectory:
SSE over WebSocket. WebSockets are bidirectional; SSE is unidirectional (server to client). We chose SSE because LLM streaming is inherently unidirectional -- the server sends tokens, the client displays them. SSE is simpler to implement, works through HTTP proxies and CDNs without special configuration, and reconnects automatically. The only trade-off is that SSE cannot send binary data, which we never needed.
WhatsApp over SMS. In West Africa, SMS costs money. WhatsApp is free. Delivering OTP codes via WhatsApp instead of SMS reduces authentication cost to zero and reaches a larger audience. The trade-off: WhatsApp delivery depends on Meta's API reliability. We keep SMS as a fallback, but it has never been needed in production.
USD-cent pricing globally. Storing prices in US dollar cents and converting to local currency at display time eliminates the currency math nightmare. A credit pack costs 100 cents ($1.00). In FCFA, that is approximately 600 FCFA. In Naira, approximately 1,600 NGN. One source of truth, locale-aware display.
Queue-bridged background jobs over Celery. Detached asyncio.Task instead of a distributed task queue. Simpler deployment, no additional infrastructure, sufficient for single-server operation. The trade-off: no distributed execution, no retry queues, no dead-letter handling. When we scale, we will migrate. For now, simplicity wins.
Monorepo for mobile. Sharing packages between web and mobile through npm workspaces. The @deblo/api, @deblo/stores, @deblo/streaming, and @deblo/i18n packages are used by both the SvelteKit web app (via imports) and the React Native mobile app. This decision saved an estimated 40% of mobile development time by eliminating API client and streaming duplication.
---
The Africa Angle
Deblo was not built for Africa as an afterthought. Every design decision reflects the constraints and opportunities of the African market.
Mobile-first. The web app is responsive, but the mobile app is the primary target. African internet users are overwhelmingly on smartphones, not desktops. Screen sizes range from 320px (older feature phones with browsers) to 430px (modern flagships). Every layout was tested at 375px first.
WhatsApp-native. WhatsApp is not just a messaging app in Africa -- it is the internet. Authentication via WhatsApp OTP, document delivery via WhatsApp messages, notification via WhatsApp. Meeting users where they already are.
Price-sensitive. Credits start at 100 FCFA (approximately $0.16). The cheapest credit pack costs less than a bottle of water. There is no subscription. Pay-as-you-go respects the reality that many African students and professionals have irregular income.
French-first with African context. The system prompt is in French. The UI is in French. The curriculum references are African (BEPC, BAC, SYSCOHADA, OHADA). The examples use African names, African cities, and African scenarios. A student in Abidjan should feel that this tool was built for them, not adapted from an American product.
Local payments. Orange Money, Wave, MTN Money, Moov Money, Airtel Money. These are not "alternative payment methods" -- they are the primary payment methods for hundreds of millions of people. Credit cards are the alternative.
---
What It Took
Ninety-six web development sessions between February 14 and March 23, 2026. Twenty mobile development sessions between March 3 and March 9. Each session lasted between 2 and 6 hours. The total development time is approximately 400-500 hours spread across 6 weeks.
For context, a typical Series A edtech startup with 10 engineers would plan 6-12 months for a comparable feature set. We had zero human engineers and six weeks.
This is not a boast about speed. It is a statement about what the CEO + AI CTO model makes possible. The bottleneck was never coding speed -- Claude can generate code faster than any human. The bottleneck was decision-making: which feature to build next, which trade-off to accept, which user need to prioritize. Thales made those decisions. Claude executed them. The feedback loop was measured in minutes, not sprints.
---
What Is Next
Deblo.ai is live, but it is not finished. The roadmap for the next quarter:
RAG Pipeline. Retrieval-Augmented Generation for professional domains. Index the full text of OHADA Uniform Acts, national tax codes, and SYSCOHADA standards. When a Pro user asks a domain question, retrieve relevant document chunks and inject them into the prompt. This turns the 101 advisors from behavioral shells into knowledge-backed experts.
Admin Dashboard. Analytics, user management, content moderation, credit management, and system configuration. Currently managed via direct database access and API calls -- not sustainable as the user base grows.
Deblo Pro Mobile App. The K12 mobile app is built. The Pro equivalent -- optimized for professional workflows, document management, and organization features -- is the next mobile target.
Web Search Integration. Real-time web search via the web_search tool for current information: exchange rates, recent legislation, news, market data. Currently implemented but gated behind a feature flag pending quality tuning.
More Countries. The initial 6 (Ivory Coast, Senegal, Cameroon, Burkina Faso, Mali, Benin) cover the core OHADA francophone zone. Next: Togo, Niger, Guinea, Congo, Gabon, Chad. Then anglophone West Africa: Nigeria, Ghana. Then East Africa. The 250 million figure is the total school-age population across Sub-Saharan Africa. Reaching it requires country-by-country localization of curriculum, payment, and regulatory compliance.
---
The Partnership
This article, like the eleven before it, is authored by "both." That attribution is not a literary device. Every line of Deblo.ai was produced through a conversation between a human and an AI. Thales described the vision, the user needs, the business constraints. Claude translated those descriptions into architecture, code, and documentation. Neither could have built this alone.
The CEO + AI CTO model is not a replacement for human engineering teams. It is an alternative for a specific context: early-stage, resource-constrained, speed-critical product development where one person's vision can be directly translated into working software by an AI that understands both the technical and business dimensions.
Deblo.ai is proof that this model works. Not in theory, not as a demo, but as a production platform serving real users in real markets with real money at stake.
From Abidjan, for Africa, by a team of two.
---
This is Part 12 of a 12-part series on building Deblo.ai.
1. AI Tutoring for 250 Million African Students 2. 100 Sessions Later: The Architecture of an AI Education Platform 3. The Agentic Loop: 24 AI Tools in a Single Chat 4. System Prompts That Teach: Anti-Cheating, Socratic Method, and Grade-Level Adaptation 5. WhatsApp OTP and the African Authentication Problem 6. Credits, FCFA, and 6 African Payment Gateways 7. SSE Streaming: Real-Time AI Responses in SvelteKit 8. Voice Calls With AI: Ultravox, LiveKit, and WebRTC 9. Building a React Native K12 App in 7 Days 10. 101 AI Advisors: Professional Intelligence for Africa 11. Background Jobs: When AI Takes 30 Minutes to Think 12. From Abidjan to 250 Million: The Deblo.ai Story (you are here)