Building a Payment Platform From Abidjan, Ivory Coast

On December 10, 2025, we opened the first development session for 0fee.dev. Eighty days and 86 sessions later, we had a production-ready payment orchestration platform: a full Python backend with 90+ API endpoints, 53+ provider integrations, 7 SDKs, a SolidJS dashboard, a checkout widget, a CLI tool, a marketing website, and an admin panel. The entire platform was built by two people: Juste A. GNIMAVO (CEO of ZeroSuite) sitting in Abidjan, Ivory Coast, and Claude (AI CTO) running as an AI coding assistant. Zero human engineers. Zero outsourcing. Zero compromises on quality.

This is the story of how we did it.

Abidjan: The Base of Operations

Abidjan is the economic capital of Ivory Coast and the largest city in Francophone West Africa, with over 5 million people. It is not Silicon Valley. It is not London or Lagos. But it is where ZeroSuite is headquartered, and it is where 0fee.dev was conceived.

Building a fintech platform from Abidjan comes with specific realities:

• Internet reliability: fiber optic connections are available in business districts (Cocody, Plateau, Marcory) but can be inconsistent. We maintained a backup mobile data connection for uninterrupted sessions.
• Time zone advantage: UTC+0 (no daylight saving) means overlap with European business hours and reasonable overlap with US East Coast mornings.
• African payment context: being physically in Ivory Coast meant we could test Orange Money and Wave payments on real devices, with real USSD flows, on real telco networks. This first-hand experience is impossible to replicate from a desk in San Francisco.
• Cost efficiency: operational costs in Abidjan are a fraction of Western tech hubs, which extends runway dramatically.

The most significant advantage was context. We were not building African payment support as a theoretical exercise. We were building it as people who use Orange Money and Wave daily, who understand the USSD flow because we go through it ourselves, who know that a customer in Yopougon might have a different experience than a customer in Cocody because of network coverage.

The Team: One CEO + One AI CTO

The ZeroSuite team structure is unusual by any standard:

There is no backend team. No frontend team. No DevOps engineer. No QA team. No product manager. No designer (other than Juste). The entire engineering output comes from a human-AI pair working in focused sessions.

How a Session Works

Each session follows a consistent pattern:

1. Briefing: Juste describes what needs to be built, modified, or fixed. This includes product context, technical constraints, and acceptance criteria.

1. Implementation: Claude writes the code -- backend endpoints, frontend components, database migrations, provider adapters, SDK methods, tests, documentation. Each session typically produces 2,000-10,000 lines of code.

1. Review and iteration: Juste reviews the output, tests it against real provider sandboxes (and sometimes production), and requests modifications.

1. Session log: Every session is documented with a structured log: what was built, what decisions were made, what remains to be done. These logs form the institutional memory of the project.

The session log format:

markdown## Session 042 -- 2026-01-15

### Goals
- Implement Hub2 provider adapter (Orange Money, MTN MoMo)
- Add Ivory Coast mobile money methods to routing engine
- Build USSD push status polling

### Completed
- Hub2Adapter class with create_payment, check_status, process_webhook
- Phone number validation for Ivory Coast (+225 format)
- USSD push timeout handling (120s default, configurable)
- Webhook signature verification (HMAC-SHA256)
- Added 5 payment methods: PAYIN_ORANGE_CI, PAYIN_MTN_CI, PAYIN_MOOV_CI, PAYIN_WAVE_CI, PAYIN_ORANGE_SN

### Decisions
- Use 120s timeout for USSD push (Hub2 recommendation)
- Store raw provider response alongside normalized data for debugging
- Implement automatic retry on 503 from Hub2 (up to 3 attempts)

### Files Modified
- backend/app/providers/hub2.py (new, 450 lines)
- backend/app/routing/engine.py (modified, +85 lines)
- backend/app/models/payment.py (modified, +12 lines)
- backend/app/api/v1/payments.py (modified, +35 lines)

### Next Session
- PawaPay adapter for East Africa
- M-Pesa STK Push implementation

The Numbers: 86 Sessions, 80 Days

Here is what 86 sessions produced:

Backend (Python/FastAPI)

Frontend (SolidJS)

SDKs

Other Deliverables

Timeline Highlights

The First Session: 42 Files in 45 Minutes

Session 001 deserves special attention because it established the foundation for everything that followed.

In 45 minutes, we produced:

• Project scaffolding: FastAPI application structure with modular routing, dependency injection, and configuration management.
• Core models: Organization, Application, User, Transaction, Payment, Payout, Refund, WebhookEndpoint, APIKey.
• Database setup: SQLAlchemy models, Alembic migration configuration, initial migration.
• Authentication: API key validation, JWT token generation, middleware.
• First three endpoints: health check, create payment, get payment status.
• Provider interface: abstract base class that all 53+ adapters would implement.
• Configuration: environment variables, logging, CORS, rate limiting skeleton.

42 files. 7,900 lines of code. A running server that could accept API requests.

This is the AI CTO advantage. A human engineer might take two to three days to set up this foundation, making decisions about project structure, choosing libraries, writing boilerplate. Claude generates production-quality scaffolding in a single session because the patterns are well-established -- the creative work is in the product and architecture decisions that Juste makes before and during the session.

Africa-First by Design

Most payment platforms add Africa as an afterthought -- a "coming soon" section in their country list, or a single integration with one pan-African provider that covers the basics. 0fee was built the other way around.

Mobile money was not an integration we added in session 50. It was built in session 5. The payment method naming convention (PAYIN_ORANGE_CI, PAYIN_MTN_GH) was designed in session 2. The phone number validation logic (supporting +225 for Ivory Coast, +233 for Ghana, +254 for Kenya, +234 for Nigeria, and 40+ other country codes) was implemented before card payment validation.

This is not just a philosophical stance. It affected technical decisions:

• Asynchronous-first payment flow: because mobile money is inherently asynchronous (customer confirms via USSD), we built the entire payment lifecycle around webhooks rather than synchronous responses. Card payments happen to resolve quickly, but the system treats every payment as potentially asynchronous.
• Phone number as primary identifier: many African customers do not have email addresses. The customer model supports phone-only authentication from the ground up.
• Multi-currency from day one: XOF, XAF, KES, NGN, GHS, TZS, UGX, ZAR were in the currency enum before USD and EUR.
• Low-bandwidth optimization: the SolidJS dashboard loads in under 50 KB of JavaScript because it needs to work on 3G connections in Ouagadougou as well as fiber in Paris.

The ZeroSuite Ecosystem

0fee.dev is not a standalone product. It is one of six products in the ZeroSuite ecosystem, all built by the same team of two from Abidjan:

Every product shares the same development methodology: Juste provides the vision, product direction, and architecture decisions; Claude implements the code. No human engineers. No freelancers. No agencies.

The blog you are reading this on -- ThalesAndHisAiCtoClaude.com -- documents this entire journey. Every session log, every architecture decision, every product launch. It is the world's first documented CEO + AI CTO partnership building real, production products.

What We Learned

After 86 sessions and a production payment platform, here are the key lessons:

1. The AI CTO model works for building, not just prototyping.

0fee is not a demo or a hackathon project. It processes real financial transactions through real provider APIs. The code quality, error handling, security practices, and documentation are production-grade -- because the AI CTO model does not impose a quality ceiling. It imposes a speed floor.

2. Domain expertise matters more than engineering headcount.

Juste's understanding of African payment ecosystems -- which providers work where, how USSD flows behave, what friction points exist in mobile money checkout -- is what makes 0fee useful. Engineering execution, no matter how fast, cannot replace domain knowledge.

3. Session-based development creates natural checkpoints.

Each session has a clear scope, produces a documented output, and ends with a list of what comes next. This rhythm prevents scope creep, maintains momentum, and creates an auditable history of every decision.

4. Start with the hard market.

Building for Africa first -- with its fragmented providers, asynchronous flows, and infrastructure constraints -- meant that supporting Europe and North America was trivially easy by comparison. If your system handles USSD timeouts on a 3G connection in rural Cameroon, it handles a Stripe card payment in New York without breaking a sweat.

5. Location is not a limitation.

We built a global payment platform from Abidjan. The providers are APIs. The infrastructure is cloud-hosted. The AI CTO is accessible from anywhere with an internet connection. The only thing that is local is the perspective -- and that perspective is the product's greatest competitive advantage.

What Comes Next

0fee.dev is live and processing transactions. But the roadmap is extensive:

• Payout expansion: bulk payouts to mobile money wallets across Africa (payroll, marketplace disbursements).
• Subscription billing: recurring payments with automatic provider failover.
• Multi-currency settlement: receive in XOF, settle in USD or EUR.
• Fraud detection: ML-based transaction scoring using African payment patterns.
• Additional providers: targeting 100+ providers by end of 2026.

Every feature will be built the same way: one CEO, one AI CTO, session by session, from Abidjan.

This article is part of the "How We Built 0fee.dev" series. 0fee.dev is a payment orchestrator covering 53+ providers across 200+ countries, built by Juste A. GNIMAVO and Claude from Abidjan with zero human engineers. Follow the series for the complete build story.