DEV Community: sharkflow ltd

MpesaBooks — devto

sharkflow ltd — Wed, 10 Jun 2026 04:00:08 +0000

{
  "title": "How to Track M-Pesa Transactions for Business: The Technical Architecture Behind MpesaBooks",
  "content": "# How to Track M-Pesa Transactions for Business: The Technical Architecture Behind MpesaBooks\n\nIf you're a Kenyan developer building fintech tools, you've probably asked yourself: *How do we actually track M-Pesa transactions at scale without destroying our database?*\n\nM-Pesa processes over $1.2 billion in daily transactions across Kenya. For SMEs, this volume is both a blessing and a nightmare—they get paid instantly, but tracking those payments for accounting becomes a manual, error-prone hell.\n\nThis is the problem MpesaBooks solves. But the real story isn't about the UI. It's about how we designed the backend to handle real-time M-Pesa reconciliation on Africa's mobile networks.\n\nLet's talk architecture.\n\n## The Problem: Why Traditional Accounting Doesn't Work for M-Pesa\n\nM-Pesa's strength—instant settlement across Africa's largest telecom network—becomes a liability for SMEs trying to reconcile accounts.\n\nHere's what happens:\n\n1. **Real-time transactions arrive asynchronously** — Your customer sends payment at 2:14 PM. The SMS arrives at 2:14:03 PM. Your webhook fires at 2:14:07 PM. Meanwhile, your business logic is running somewhere else.\n\n2. **Network uncertainty** — Kenya's 4G coverage is ~85% in urban areas, but drops to 30% in rural zones. Webhooks fail. SMS gets delayed. Transactions get duplicated.\n\n3. **Manual reconciliation is death by a thousand cuts** — Most SMEs still download CSV files from M-Pesa, manually enter them into Excel, then into QuickBooks. When you process 50+ transactions daily, this becomes your full-time job.\n\n4. **Accounting complexity** — Is this revenue or a refund? Who is this customer? Did they already pay? Which invoice is this for?\n\nMost Kenyan businesses solve this with **spreadsheets and prayers**. We decided to solve it with **event-driven architecture and idempotent APIs**.\n\n## Architecture Layer 1: API Design for Reliability\n\nThe first principle: **every M-Pesa API call must be idempotent**.\n\nHere's our transaction ingestion endpoint:\n\n```

typescript\n// POST /api/v1/transactions/ingest\n// Purpose: Accept M-Pesa transaction data from multiple sources\n// Sources: Safaricom Daraja API, SMS parsing, M-Pesa B2B API\n\ninterface MpesaTransactionPayload {\n  mpesaReceiptNumber: string; // Unique ID: e.g., \"NLJ7RF2QH3\"\n  phoneNumber: string;\n  amount: number;\n  timestamp: ISO8601;\n  senderName: string;\n  transactionType: 'payment' | 'refund' | 'reversal';\n  source: 'daraja' | 'sms_webhook' | 'ussd';\n}\n\n@Post('/ingest')\nasync ingestTransaction(@Body() payload: MpesaTransactionPayload) {\n  const idempotencyKey = `${payload.mpesaReceiptNumber}-${payload.source}`;\n  \n  // Check if we've already processed this\n  const existing = await db.transactions.findOne({ \n    idempotencyKey \n  });\n  \n  if (existing) {\n    return { success: true, transaction: existing };\n  }\n  \n  // Validate against M-Pesa's unique receipt number\n  const isValid = await validateWithSafaricom(payload.mpesaReceiptNumber);\n  if (!isValid) {\n    throw new InvalidTransactionError();\n  }\n  \n  // Atomically insert the transaction\n  const transaction = await db.transactions.insertOne({\n    ...payload,\n    idempotencyKey,\n    createdAt: new Date(),\n    status: 'pending_reconciliation',\n  });\n  \n  // Emit event for async processing\n  await eventBus.emit('transaction.received', transaction);\n  \n  return { success: true, transaction };\n}\n

```\n\nWhy idempotency matters: If our webhook handler crashes after processing but before responding, Safaricom will retry. Without idempotent keys, we'd create duplicate transactions. With them, the second attempt returns the same result.\n\n## Architecture Layer 2: Database Design for African Networks\n\nWe don't use a single monolithic database. We use **event sourcing** with a **write-optimized store** and **read-optimized views**.\n\n```

javascript\n// Database Schema: PostgreSQL with Partitioning\n\nCREATE TABLE transactions (\n  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n  idempotency_key VARCHAR(255) UNIQUE NOT NULL,\n  mpesa_receipt_number VARCHAR(20) UNIQUE NOT NULL,\n  phone_number VARCHAR(13) NOT NULL,\n  amount DECIMAL(10, 2) NOT NULL,\n  currency VARCHAR(3) DEFAULT 'KES',\n  timestamp TIMESTAMP NOT NULL,\n  sender_name VARCHAR(255),\n  transaction_type VARCHAR(20) CHECK(transaction_type IN ('payment', 'refund', 'reversal')),\n  source VARCHAR(20),\n  status VARCHAR(50) DEFAULT 'pending_reconciliation',\n  created_at TIMESTAMP DEFAULT NOW(),\n  updated_at TIMESTAMP DEFAULT NOW(),\n  INDEX idx_phone_timestamp (phone_number, timestamp),\n  INDEX idx_mpesa_receipt (mpesa_receipt_number),\n  INDEX idx_status (status)\n) PARTITION BY RANGE (YEAR(timestamp));\n\n// Denormalized View for Daily Reporting (updated hourly)\nCREATE MATERIALIZED VIEW daily_reconciliation AS\nSELECT

SharkFlow Legal — devto

sharkflow ltd — Thu, 04 Jun 2026 04:00:07 +0000

{
  "title": "AI Legal Advice Kenya: Complete Guide for Africa — How SharkFlow Legal Works Under the Hood",
  "content": "# AI Legal Advice Kenya: Complete Guide for Africa — How SharkFlow Legal Works Under the Hood\n\n## Why AI Legal Advice Kenya Matters Right Now\n\nLet's be real: Kenya has 5M+ registered businesses, but fewer than 15,000 practicing lawyers. That's a ratio that would make any developed economy blush. Across Africa, we're looking at 400M+ unbanked people, millions of small businesses operating without proper legal frameworks, and a continental startup ecosystem moving faster than traditional law firms can handle.\n\nWhen a Nairobi SaaS founder needs to quickly understand employment law before hiring their first team, or a Lagos fintech needs to navigate regulatory compliance for their mobile money integration, waiting weeks for a lawyer's appointment isn't realistic. That's where AI legal assistance comes in—not as a replacement for lawyers, but as a force multiplier for the continent's legal infrastructure gap.\n\nSharkFlow Legal solves this by making legal guidance instant, affordable, and contextually aware of African regulatory environments. But how do we actually build this at scale, across mobile networks that fluctuate between 3G and spotty WiFi?\n\n## The Architecture: From Tokens to Regulatory Databases\n\n### API Design for Mobile-First Africa\n\nOur core challenge: African developers and business owners often access services via unstable connections. We built SharkFlow Legal's API with this reality in mind—not as an afterthought, but as a first-class constraint.\n\n```

python\n# SharkFlow Legal API - Lightweight, resumable requests\nfrom fastapi import FastAPI, BackgroundTasks\nfrom pydantic import BaseModel\nimport redis\n\napp = FastAPI()\nredis_client = redis.Redis(host='localhost', db=0)\n\nclass LegalQuery(BaseModel):\n    question: str\n    jurisdiction: str  # \"Kenya\", \"Nigeria\", \"Ghana\", etc.\n    business_type: str\n    context: str\n    client_id: str\n\n@app.post(\"/api/v1/legal-advice\")\nasync def get_legal_advice(query: LegalQuery, background_tasks: BackgroundTasks):\n    \"\"\"\n    Returns immediate response with option to resume if connection drops.\n    Uses progressive streaming rather than waiting for full response.\n    \"\"\"\n    # Store request in Redis for resumability\n    request_key = f\"legal_query:{query.client_id}:{int(time.time())}\"\n    redis_client.setex(request_key, 3600, query.json())\n    \n    # Start streaming response immediately\n    return StreamingResponse(\n        generate_legal_advice(query),\n        media_type=\"application/json\",\n        headers={\"X-Resume-Token\": request_key}\n    )\n\nasync def generate_legal_advice(query: LegalQuery):\n    \"\"\"\n    Stream tokens as they're generated, allowing clients to display\n    answers in real-time even on slow connections.\n    \"\"\"\n    prompt = construct_legal_prompt(\n        question=query.question,\n        jurisdiction=query.jurisdiction,\n        business_type=query.business_type\n    )\n    \n    async for token in llm_stream(prompt):\n        yield token.encode() + b\"\\n\"\n

```\n\nThis design lets a user on a 2G connection start reading legal guidance while the full response is still generating. If their connection drops? The X-Resume-Token lets them pick up where they left off.\n\n### Database Architecture: Regulatory Compliance at Scale\n\nHere's where it gets interesting. We can't just use a generic vector database. African regulatory environments change rapidly—Kenya's Data Protection Act (2019) updates, Nigeria's fintech guidelines, Ghana's new crypto regulations. We needed a database that could handle:\n\n1. **Real-time regulatory updates** from African legal databases\n2. **Jurisdiction-specific context** (Kenya ≠ Nigeria ≠ Ghana)\n3. **Low-latency retrieval** for M-Pesa integration queries\n\n```

python\n# Hybrid approach: PostgreSQL + vector embeddings + regulatory feed\nimport asyncpg\nfrom pgvector.sqlalchemy import Vector\nfrom sqlalchemy import Column, String, DateTime, Integer\n\nclass RegulatoryDocument(Base):\n    __tablename__ = \"regulatory_documents\"\n    \n    id = Column(Integer, primary_key=True)\n    jurisdiction = Column(String(50))  # \"Kenya\", \"Nigeria\", etc.\n    document_type = Column(String(100))  # \"Employment Law\", \"Data Protection\"\n    content = Column(Text)\n    embedding = Column(Vector(1536))  # OpenAI embeddings\n    source_url = Column(String(500))\n    last_updated = Column(DateTime)\n    confidence_score = Column(Float)  # Crowdsourced verification by actual lawyers\n    \n    __table_args__ = (\n        Index('idx_jurisdiction_type', 'jurisdiction', 'document_type'),\n        Index('idx_embedding', 'embedding', postgresql_using='ivfflat'),\n    )\n

```\n\nWe embed all regulatory documents and store them with jurisdiction tags. When a query comes in for \"Can I fire someone in Kenya for performance?\", we:\n\n1. Embed the question\n2. Vector search for Kenya-specific employment law\n3. Rank by recency (regulatory updates matter)\n4. Cross-reference with our confidence score (how many Kenyan lawyers have verified this)\n\n### M-Pesa Integration: Payment as Part of the Flow\n\nThis is crucial for Africa. A Kenyan SME shouldn't need a credit card to access premium legal guidance. We built M-Pesa payment straight into the API:\n\n```

python\n# M-Pesa STK Push integration via Daraja API\nfrom mpesa_api import MpesaClient\n\n@app.post(\"/api/v1

MpesaBooks — devto

sharkflow ltd — Wed, 03 Jun 2026 04:00:05 +0000

{
  "title": "How to Track M-Pesa Transactions for Business: Building Accounting Systems for African Mobile Money",
  "content": "# How to Track M-Pesa Transactions for Business: Building Accounting Systems for African Mobile Money\n\nIf you're a Kenyan developer working with SMEs, you've probably heard this: \"We receive money on M-Pesa, but our accounting is a nightmare.\" With M-Pesa processing over $320 billion annually in Kenya alone, and 60M+ mobile money users across East Africa, the gap between transaction velocity and accounting clarity is *massive*. This is where systems like MpesaBooks come in—and understanding how they work technically can teach us a lot about building financial infrastructure for Africa.\n\nLet's talk about the engineering challenges, architectural decisions, and practical solutions for tracking M-Pesa transactions at scale.\n\n## The Problem: Why M-Pesa Accounting is Hard\n\nHere's what happens in reality:\n\n1. A customer pays 15,000 KES via M-Pesa\n2. The SME owner sees it on their phone\n3. Three other payments come in\n4. By end of day, they have no idea which customer paid for what\n5. Their accountant is manually cross-referencing M-Pesa statements with invoices\n\nFor a business doing 50+ transactions daily, this is 2-3 hours of busywork. For one doing 500+ transactions, it's unworkable without automation.\n\nThe technical solution requires three components:\n- **Real-time transaction capture** from M-Pesa\n- **Intelligent matching** of payments to invoices/customers\n- **Scalable storage** that handles spike traffic on mobile networks\n\n## API Design: Connecting to M-Pesa\n\nM-Pesa exposes two main integration points for businesses: **STK Push** (for initiating payments) and **B2B API** (for receiving payments). For accounting, we care primarily about inbound tracking.\n\nSafaricom provides callback webhooks when money comes in. Here's how a basic receiver might look:\n\n```

python\nfrom fastapi import FastAPI, Request\nfrom datetime import datetime\nimport hashlib\nimport json\n\napp = FastAPI()\n\n# M-Pesa sends callbacks with transaction details\n@app.post(\"/api/mpesa/callback\")\nasync def mpesa_callback(request: Request):\n    \"\"\"\n    M-Pesa sends JSON like:\n    {\n        \"TransactionType\": \"Pay Bill Online\",\n        \"TransID\": \"OHI20D5N6Y\",\n        \"TransTime\": \"20231215143521\",\n        \"TransAmount\": 15000,\n        \"BusinessShortCode\": \"174379\",\n        \"BillRefNumber\": \"INV-2023-001\",\n        \"InvokedParty\": \"254712345678\",\n        \"OriginatorPartyCode\": \"254700000000\",\n        \"OriginatedParty\": null,\n        \"FirstName\": \"John\",\n        \"MiddleName\": \"\",\n        \"LastName\": \"Doe\"\n    }\n    \"\"\"\n    \n    body = await request.json()\n    \n    try:\n        # Extract key data\n        trans_id = body.get(\"TransID\")\n        amount = body.get(\"TransAmount\")\n        phone = body.get(\"OriginatorPartyCode\")\n        ref = body.get(\"BillRefNumber\")  # Critical: customer reference\n        trans_time = body.get(\"TransTime\")\n        \n        # Verify callback authenticity (Safaricom sends validation tokens)\n        if not verify_mpesa_signature(body):\n            return {\"ResultCode\": 1, \"ResultDesc\": \"Invalid signature\"}\n        \n        # Store immediately (idempotent key = trans_id)\n        transaction = await db.transactions.insert_one({\n            \"mpesa_id\": trans_id,\n            \"amount\": amount,\n            \"phone\": phone,\n            \"reference\": ref,\n            \"timestamp\": datetime.strptime(trans_time, \"%Y%m%d%H%M%S\"),\n            \"status\": \"pending\",\n            \"created_at\": datetime.utcnow()\n        })\n        \n        # Queue for matching (async job)\n        await queue.enqueue(\n            \"match_transaction\",\n            transaction_id=str(transaction.inserted_id),\n            reference=ref,\n            phone=phone\n        )\n        \n        # Acknowledge immediately to M-Pesa\n        return {\n            \"ResultCode\": 0,\n            \"ResultDesc\": \"Accepted\"\n        }\n    \n    except Exception as e:\n        logger.error(f\"Callback processing failed: {e}\")\n        # Don't crash—M-Pesa will retry\n        return {\"ResultCode\": 0, \"ResultDesc\": \"Accepted\"}\n\n\ndef verify_mpesa_signature(body: dict) -> bool:\n    # Safaricom provides a validation field in callbacks\n    # In production, validate with their public key\n    return True  # Placeholder\n

```\n\nKey design decisions here:\n\n1. **Idempotent storage**: M-Pesa callbacks can retry. Using `mpesa_id` as a unique key prevents duplicate entries.\n2. **Async processing**: We acknowledge to M-Pesa immediately, then do matching in background. Mobile networks in Kenya are unpredictable—don't block on slow database writes.\n3. **Reference extraction**: SMEs pass invoice numbers in `BillRefNumber`. This is gold for auto-matching.\n\n## Database Schema: What Actually Scales\n\nAfter processing millions of transactions, here's what works:\n\n```

javascript\n// MongoDB schema for

SharkFlow Legal — devto

sharkflow ltd — Thu, 28 May 2026 04:00:06 +0000

{
  "title": "Online Legal Advice Kenya Free: How SharkFlow Legal Works Under the Hood",
  "content": "# Online Legal Advice Kenya Free: How SharkFlow Legal Works Under the Hood\n\n## Why Online Legal Advice Matters in Kenya (And Why Your Tech Stack Matters More)\n\nLet's start with a fact: Kenya has over 3 million registered businesses, but fewer than 50,000 practicing lawyers. That's roughly 1 lawyer per 60 businesses. For SMEs in Nairobi's tech corridor, Kisumu's trading hubs, and Mombasa's port zones, accessing legal counsel has always meant choosing between expensive retainers or doing it yourself and hoping for the best.\n\nSharkFlow Legal exists to invert that equation. But building AI-powered legal assistance for Africa's mobile-first, low-bandwidth realities isn't just about training a good LLM—it's about rethinking every architectural decision from the ground up.\n\nThis article walks you through the actual tech: why we chose specific databases, how we optimized for 3G networks, and what we learned about serving 60M+ mobile money users in East Africa.\n\n---\n\n## Key Benefits of Online Legal Advice for Kenya's Businesses\n\n### Benefit 1: Cost-Effective Legal Guidance (The Real Numbers)\n\nA single legal consultation in Nairobi runs KES 5,000–15,000 ($40–120). For bootstrapped founders and small traders, that's prohibitive. SharkFlow's free tier provides instant templates, contract reviews, and guidance on Kenya's Business Registration Act, Employment Act, and Competition Act—without the retainer fees.\n\n**The infrastructure angle:** This means handling millions of requests on a tight margin. We use edge caching heavily and distribute document processing across regional nodes to keep latency under 2 seconds, even on slower networks.\n\n### Benefit 2: 24/7 Availability on Your Phone\n\nKenyan lawyers work 9–5 (if you're lucky). Your M-Pesa payment dispute happens at midnight. SharkFlow's API is always on, and our mobile UI works on 2G data.\n\n### Benefit 3: Localized Legal Knowledge Without Regional Travel\n\nA trader in Eldoret needs to understand Nairobi's County Business Licensing requirements. A Mombasa exporter needs KEBS certification guidance. Our training data includes Kenya's 47 county laws, the Central Bank's digital lending guidelines, and CBK's latest AML/KYC requirements.\n\n---\n\n## How SharkFlow Legal Works: The Technical Architecture\n\n### 1. API Design: Stateless, Async-First, Mobile-Optimized\n\nOur core API is built on gRPC with fallback REST endpoints (because not all African startups have gRPC clients yet). Here's why this matters:\n\n```

protobuf\n// legal_service.proto\nservice LegalAssistance {\n  rpc ReviewContract(ContractReviewRequest) returns (ContractReviewResponse);\n  rpc GetTemplate(TemplateRequest) returns (TemplateResponse);\n  rpc QueryLaw(LegalQueryRequest) returns (LegalQueryResponse);\n}\n\nmessage ContractReviewRequest {\n  string document_url = 1;  // S3 URI or base64 embedded for offline\n  string jurisdiction = 2;  // \"KE\", \"UG\", \"TZ\"\n  string business_type = 3; // \"tech\", \"trade\", \"healthcare\"\n  int32 timeout_seconds = 4; // Default: 30s for 3G\n}\n\nmessage ContractReviewResponse {\n  string analysis = 1;\n  repeated Risk risks = 2;\n  repeated Suggestion suggestions = 3;\n  int32 confidence_score = 4;\n}\n

```\n\nWhy async-first? Because a 2MB contract on a 2G connection takes time. We queue processing jobs and return a `job_id` immediately, with webhooks for completion.\n\n```

typescript\n// Example client: React Native (common in Kenya)\nimport { LegalClient } from '@sharkflow/legal-sdk';\n\nconst client = new LegalClient({\n  apiKey: process.env.SHARKFLOW_KEY,\n  region: 'east-africa', // Routes to Nairobi servers\n  timeout: 30000,\n});\n\nconst jobId = await client.reviewContract({\n  documentBase64: base64Document,\n  jurisdiction: 'KE',\n  businessType: 'tech_startup',\n});\n\n// Poll or webhook—works on patchy 3G\nclient.onJobComplete(jobId, (result) => {\n  console.log('Risks found:', result.risks);\n});\n

```\n\n### 2. Database Choices: Why We Use PostgreSQL + Vector Store\n\nSharkFlow Legal's backend uses:\n\n- **PostgreSQL** (primary): Transactional legal data, user profiles, templates. We run it on AWS RDS Multi-AZ (Lagos + N. Virginia) with read replicas in Nairobi (via EC2).\n- **Weaviate** (vector store): Embeddings for case law, templates, and legal reasoning. This powers semantic search—\"Am I liable if an employee is injured working from home?\" retrieves Kenya-specific precedent across hundreds of documents instantly.\n- **Redis** (cache layer): Template cache, API response caching, rate limiting (100 requests/min on free tier). Crucial for cutting database load by 70%.\n\n```

sql\n-- PostgreSQL schema\nCREATE TABLE legal_queries (\n  id UUID PRIMARY KEY,\n  user_id UUID NOT NULL,\n  query_text TEXT NOT NULL,\n  jurisdiction VARCHAR(2), -- \"KE\", \"UG\", \"TZ\"\n  business_category VARCHAR(50),\n  response_json JSONB,\n  processing_time_ms INT,\n  created_at TIMESTAMP DEFAULT NOW()\n);\n\nCREATE INDEX idx_jurisdiction_category ON legal

MpesaBooks — devto

sharkflow ltd — Wed, 27 May 2026 04:00:04 +0000

{
  "title": "How to Track M-Pesa Transactions for Business: The Technical Architecture Behind MpesaBooks",
  "content": "# How to Track M-Pesa Transactions for Business: The Technical Architecture Behind MpesaBooks\n\nIf you're running an SME in Kenya, you've probably asked yourself: *\"How do I actually track M-Pesa money without losing my mind in a spreadsheet?\"*\n\nSharkFlow's MpesaBooks solves exactly this problem—but the real story is *how* we built it to handle Kenya's chaotic, beautiful reality of mobile money. Let me walk you through the technical decisions that make it work.\n\n## The Problem We Started With\n\nKenya has 60M+ mobile money users, and M-Pesa processes $320B annually. Yet most SMEs still use:\n- SMS screenshots in WhatsApp groups\n- Manual Excel entries (good luck with reconciliation)\n- Bank statements they check once a month\n\nScaling accounting software for this reality means building for:\n- **Unreliable networks** (3G/EDGE in rural areas)\n- **Low-end devices** (budget Android phones with 1GB RAM)\n- **High transaction volume** (a kiosk owner doing 200+ transactions/day)\n- **Zero latency tolerance** (Kenyan traders need instant reconciliation)\n\n## API Design: Real-Time vs. Batch Sync\n\nWe started with a naive approach: poll Safaricom's M-Pesa API every 30 seconds. It failed immediately.\n\nHere's why: a single kiosk owner in Nairobi's informal sector does ~150 transactions/day. Polling every 30 seconds meant 2,880 API calls *per location per day*. Scale that to 10,000 SMEs and you're looking at 28.8M API calls daily. Safaricom's rate limits? 50 calls/minute. Dead on arrival.\n\n**Solution: Hybrid pull-push architecture.**\n\n```

javascript\n// Our transaction sync service\nconst mpesaTransactionSync = async (accountId) => {\n  // 1. Check for webhook callbacks (push)\n  const webhookTransactions = await db.webhooks\n    .find({ accountId, processed: false })\n    .lean();\n\n  // 2. Only poll API for missing transactions (pull)\n  const lastSyncTime = await getLastSyncTimestamp(accountId);\n  const apiTransactions = await safaricomAPI.queryTransactions({\n    accountId,\n    startDate: lastSyncTime,\n    limit: 100 // Small batch to respect rate limits\n  });\n\n  // 3. Deduplicate and merge\n  const merged = deduplicateByTransactionId([\n    ...webhookTransactions,\n    ...apiTransactions\n  ]);\n\n  // 4. Reconcile with local state\n  const reconciled = await reconcileWithLedger(merged);\n\n  return reconciled;\n};\n

```\n\nWebhooks give us real-time updates; polling handles edge cases when callbacks fail (and they do, on African networks).\n\n## Database Architecture: The Ledger Problem\n\nAccounting software lives or dies by its ledger design. We use a **double-entry ledger model** but optimized for M-Pesa's unique properties:\n\n```

javascript\n// Schema: Transactions are immutable, ledger entries are append-only\ndb.createCollection('transactions', {\n  validator: {\n    $jsonSchema: {\n      bsonType: 'object',\n      required: ['transactionId', 'mpesaRef', 'amount', 'timestamp'],\n      properties: {\n        _id: { bsonType: 'objectId' },\n        accountId: { bsonType: 'string' }, // SME identifier\n        transactionId: { bsonType: 'string', unique: true }, // Safaricom's unique ID\n        mpesaRef: { bsonType: 'string', index: true }, // User-visible receipt\n        amount: { bsonType: 'decimal128' }, // Never use float for money\n        type: { enum: ['receive', 'send', 'withdrawal'] },\n        counterparty: { bsonType: 'string' }, // Who paid/received\n        timestamp: { bsonType: 'date', index: true },\n        status: { enum: ['pending', 'confirmed', 'reversed'] },\n        ledgerEntries: { bsonType: 'array' }, // Links to accounting entries\n        metadata: { bsonType: 'object' } // Tags, invoice refs, etc.\n      }\n    }\n  }\n});\n\ndb.createCollection('ledger', {\n  validator: {\n    $jsonSchema: {\n      bsonType: 'object',\n      required: ['accountId', 'account', 'amount', 'timestamp'],\n      properties: {\n        _id: { bsonType: 'objectId' },\n        accountId: { bsonType: 'string' },\n        account: { enum: ['cash', 'revenue', 'expense', 'payable', 'receivable'] },\n        amount: { bsonType: 'decimal128' },\n        debit: { bsonType: 'boolean' },\n        transactionRef: { bsonType: 'objectId' },\n        timestamp: { bsonType: 'date', index: true },\n        balanceSnapshot: { bsonType: 'decimal128' } // Cache for speed\n      }\n    }\n  }\n});\n

\n\n*Why MongoDB?* We chose it because:\n1. Flexible schema for different transaction types (C2B, B2B, M-Pesa to bank)\n2. Horizontal scaling via sharding by accountId (critical for Kenya's distributed SMEs)\n3. TTL indexes for auto-archiving old data (storage is expensive in Africa)\n

ReserveFlow — devto

sharkflow ltd — Tue, 26 May 2026 04:00:04 +0000

{
  "title": "Book Hotel Online Kenya: How ReserveFlow's AI Powers Africa's Hotel Booking Layer",
  "content": "# Book Hotel Online Kenya: How ReserveFlow's AI Powers Africa's Hotel Booking Layer\n\nIf you've tried booking a hotel in Nairobi, Mombasa, or Kisumu using international platforms, you know the friction. Slow load times on 3G networks. Payment gateways that don't accept M-Pesa. Real-time availability data that's three hours stale. This is the Africa problem that ReserveFlow, SharkFlow's hospitality AI product, was built to solve.\n\nBut the technical story is what makes it interesting for developers. Building a real-time hotel booking system optimized for Africa's mobile-first, payment-constrained reality requires architectural decisions that most standard SaaS platforms never face. Let's talk about how ReserveFlow actually works under the hood.\n\n## Why \"Book Hotel Online Kenya\" Is a Solved Problem That Still Isn't Solved\n\nKenya has 60+ million mobile money users. M-Pesa alone processes $320B in annual transactions. Yet most hotel booking experiences in Kenya feel like they were built for users in Frankfurt with gigabit fiber.\n\nThe numbers tell the story:\n- **Average mobile internet speed in Kenya**: 12-18 Mbps (vs. 100+ Mbps in developed markets)\n- **Peak traffic periods**: 7-9 PM when most people book (network congestion is real)\n- **Payment failure rate on international gateways**: 15-20% (vs. <2% with M-Pesa)\n- **Offline capacity**: 40% of booking interactions happen with spotty connectivity\n\nReserveFlow's backend was architected specifically for this reality. Here's how.\n\n## The API Design: Building for Latency and Unreliability\n\nOur core booking API uses a **queue-based, eventually-consistent architecture** instead of the synchronous request-response pattern you'd see in standard REST APIs.\n\n```

typescript\n// ReserveFlow Booking API - Queue-based pattern\n\ninterface BookingRequest {\n  hotelId: string;\n  roomType: string;\n  checkIn: Date;\n  checkOut: Date;\n  guestEmail: string;\n  paymentMethod: 'mpesa' | 'card' | 'airtel_money';\n}\n\n// Client submits booking (can be done offline)\nPOST /api/v1/bookings/queue\n{\n  \"hotelId\": \"greystone_nairobi_001\",\n  \"roomType\": \"deluxe_double\",\n  \"checkIn\": \"2024-02-15\",\n  \"checkOut\": \"2024-02-17\",\n  \"guestEmail\": \"traveler@example.com\",\n  \"paymentMethod\": \"mpesa\"\n}\n\n// Immediate response (booking ID given regardless of payment status)\n{\n  \"bookingId\": \"BK_7f3e4a2c_9k1l\",\n  \"status\": \"pending_payment\",\n  \"expiresAt\": \"2024-01-20T14:30:00Z\",\n  \"cached\": true\n}\n

```\n\nWhy this matters: The client gets a booking ID **immediately**, even if the network hiccups. The actual payment processing, inventory lock, and confirmation happen asynchronously in the background. The user can close the app, lose connection, and pick up exactly where they left off.\n\n## Database Architecture: Denormalization for Speed, Consistency as a Feature\n\nWe made an unconventional choice: **PostgreSQL as primary store + Redis for inventory + DynamoDB for historical data**.\n\nHere's why:\n\n**PostgreSQL** handles:\n- Hotel master data (properties, rooms, rates)\n- Guest profiles and booking history\n- Real-time inventory locks (crucial for overbooking prevention)\n\n```

sql\n-- Simplified schema for real-time inventory\nCREATE TABLE room_inventory (\n  hotel_id VARCHAR(50),\n  room_type VARCHAR(50),\n  date_key DATE,\n  available_count INT,\n  locked_count INT,\n  PRIMARY KEY (hotel_id, room_type, date_key)\n);\n\nCREATE TABLE booking_locks (\n  lock_id UUID PRIMARY KEY,\n  hotel_id VARCHAR(50),\n  room_type VARCHAR(50),\n  date_key DATE,\n  guest_id VARCHAR(50),\n  created_at TIMESTAMP,\n  expires_at TIMESTAMP,\n  status ENUM('locked', 'converted', 'expired')\n);\n

```\n\n**Redis** handles:\n- Hot data caching (hotel availability in user's city, last 7 days)\n- Session management and offline booking queues\n- Rate limiting per mobile IP (prevent booking bot attacks)\n\n```

python\n# Redis caching for availability (expires after 30 mins)\nredis_key = f\"availability:{hotel_id}:{room_type}:{date}\"\nredis_client.setex(\n    redis_key,\n    1800,  # 30 minutes\n    json.dumps({\n        'available': 12,\n        'last_updated': datetime.now().isoformat()\n    })\n)\n

```\n\n**DynamoDB** handles:\n- Historical booking data (archives after 6 months)\n- Analytics queries (never block the hot path)\n- Audit logs (compliance requirement for Kenyan hotels)\n\n## Scaling for African Mobile Networks: The Real Challenge\n\nHere's where most developers' playbooks break down. Our payload strategy is obsessive about size:\n\n```

typescript\n// Bad: 450KB of JSON\n{\n  \"hotels\": [\n    {\n      \"id\": \"...\",\n      \"name\": \"...\",\n      \"description\": \"2000 character prose\",\n      \"amenities\": [...100

Trading Bot (QUANT ELITE) — devto

sharkflow ltd — Sat, 23 May 2026 04:00:07 +0000

{
  "title": "Building a Forex Trading Bot for Kenya's Gold Market: The Technical Architecture Behind QUANT ELITE",
  "content": "# Building a Forex Trading Bot for Kenya's Gold Market: The Technical Architecture Behind QUANT ELITE\n\nWhen you're building a **forex trading bot Kenya gold** market, you're not just dealing with fast markets—you're dealing with 2G networks, intermittent connectivity, and traders who need sub-second decisions on devices with 512MB RAM. This is why the technical stack behind SharkFlow's QUANT ELITE looks nothing like a Wall Street quant platform.\n\nLet's talk about how we actually built this.\n\n## The African Developer's Problem Statement\n\nFirst, context: Kenya's gold market sits at the intersection of three worlds. You've got:\n\n- **The forex overlay**: USD/KES volatility driven by Central Bank interventions\n- **The gold commodity layer**: XAU/USD swings that hit Kenyan miners and jewelry traders hard\n- **The mobile-first reality**: Your traders are on MTN, Safaricom, Airtel. They're not on fiber. Average download speed in Nairobi is ~8 Mbps. In Mombasa, it's closer to 4 Mbps.\n\nYour trading bot can't assume persistent WebSocket connections. It can't expect 50ms latency. And it absolutely cannot require constant polling—that burns through data bundles at 10 KES per MB.\n\nSo QUANT ELITE was built with bandwidth scarcity as a first-class design constraint.\n\n## API Design: The Lean Protocol\n\nMost trading bots use REST APIs with full JSON payloads. We built a **binary protocol layer** on top of REST that compresses market data by ~85%.\n\n```

python\n# QUANT ELITE's Lean Market Data Protocol\n# Instead of sending full JSON updates every 1 second,\n# we send compressed delta frames\n\nfrom dataclasses import dataclass\nimport struct\n\n@dataclass\nclass MarketDelta:\n    \"\"\"Minimal market state update (12 bytes vs 200+ bytes JSON)\"\"\"\n    timestamp: int  # 4 bytes, Unix epoch in deciseconds\n    bid: int        # 4 bytes, price * 10000 as integer\n    ask: int        # 4 bytes, price * 10000 as integer\n    volume: int     # 2 bytes, volume in hundreds\n    \n    def serialize(self) -> bytes:\n        return struct.pack(\n            '>IiiH',  # Big-endian: unsigned int, 3x signed int, unsigned short\n            self.timestamp,\n            self.bid,\n            self.ask,\n            self.volume\n        )\n    \n    @classmethod\n    def deserialize(cls, data: bytes):\n        ts, bid, ask, vol = struct.unpack('>IiiH', data)\n        return cls(ts, bid, ask, vol)\n

```\n\nA full market update from 5 forex pairs (USD/KES, EUR/KES, GBP/KES, XAU/USD, XAU/KES) over JSON = ~1.2 KB. Same data over QUANT ELITE protocol = 72 bytes. That's 95% compression.\n\nFor a trader on a 2G network, that's the difference between a 500ms update and a 50ms update.\n\n## Database Architecture: The Dual-Layer Approach\n\nWe can't assume traders have good connectivity to a central database. So QUANT ELITE uses a **hybrid database pattern**:\n\n**Layer 1: Edge SQLite (On-Device)**\n```

sqlite\nCREATE TABLE market_ticks (\n    id INTEGER PRIMARY KEY,\n    pair TEXT NOT NULL,\n    timestamp INTEGER NOT NULL,\n    bid REAL NOT NULL,\n    ask REAL NOT NULL,\n    volume INTEGER,\n    synced_to_cloud INTEGER DEFAULT 0\n);\n\nCREATE INDEX idx_pair_timestamp ON market_ticks(pair, timestamp DESC);\n

```\n\nThis runs on the trader's phone. It captures every tick locally, so even if they lose connectivity for 2 hours, they don't lose data. The bot can backtest against local data and re-sync when connectivity returns.\n\n**Layer 2: TimescaleDB (Cloud)**\n```

sql\nCREATE TABLE market_data (\n    time TIMESTAMPTZ NOT NULL,\n    pair TEXT NOT NULL,\n    bid NUMERIC NOT NULL,\n    ask NUMERIC NOT NULL,\n    volume BIGINT,\n    source TEXT,\n    trader_id TEXT\n);\n\nSELECT create_hypertable('market_data', 'time', if_not_exists => TRUE);\nSELECT add_compression_policy('market_data', INTERVAL '7 days');\n

```\n\nTimescaleDB gives us compression (~20x for historical data) and built-in downsampling. When a trader syncs, we only upload local ticks that aren't already in the cloud.\n\n## M-Pesa Integration: The Friction Point Nobody Talks About\n\nThis is where it gets real. You can't execute a trade and wait 24 hours for M-Pesa settlement. Kenyan traders need **instant credit** on their trading account.\n\nWe built a liquidity layer:\n\n```

python\n# QUANT ELITE Liquidity Manager\n# Sits between M-Pesa API and trading engine\n\nfrom dataclasses import dataclass\nfrom enum import Enum\nimport requests\n\nclass LiquidityStatus(Enum):\n    INSTANT = \"instant\"      # Credit within 10 seconds\n    PRIORITY = \"priority\"    # Credit within 60 seconds\n    STANDARD = \"standard\"    # Credit within 4 hours\n\n@dataclass\nclass LiquidityRequest:\n    mpesa_phone: str\n    amount_kes: int\n    requested_status

SharkFlow CFA — devto

sharkflow ltd — Fri, 22 May 2026 04:00:15 +0000

{
  "title": "XAUUSD Trading Signals Kenya: Complete Guide for African Developers & Traders",
  "content": "# XAUUSD Trading Signals Kenya: Complete Guide for African Developers & Traders\n\n## Why XAUUSD Trading Signals Matter in Kenya (And Why We Built It)\n\nLet's be honest: Kenya's fintech boom isn't just about mobile money anymore. While M-Pesa processes $320B annually and reaches 60M+ users, a quieter revolution is happening in wealth management and investment platforms. XAUUSD (Gold/USD) trading has become increasingly relevant to Kenyan investors seeking USD-denominated hedges against KES volatility.\n\nHere's the problem we solved: Most XAUUSD trading signal platforms are built for Wall Street traders with fiber-optic connections and $10K minimum deposits. They time out on 3G. They don't speak M-Pesa. They assume you live in a timezone where market hours align with sleep.\n\nAt SharkFlow, we reverse-engineered this. We asked: **How do you build real-time XAUUSD trading signals that work reliably on Africa's mobile networks, integrate with local payment systems, and help traders—especially those preparing for CFA exams—understand the *why* behind each signal?**\n\nThe answer involves unconventional API design, edge caching, and market-making logic that respects African internet realities.\n\n---\n\n## Why XAUUSD Trading Signals Are Critical for Kenyan Investors\n\n### Benefit 1: KES Volatility Hedging\n\nThe Kenyan shilling has depreciated ~15% against USD in the last 18 months. Institutional traders and high-net-worth individuals use gold as a volatility hedge. XAUUSD signals help retail investors ride this same trend without needing Bloomberg terminals or institutional connections.\n\n**Real context**: A Nairobi-based small business owner who exports coffee can use XAUUSD signals to hedge forex exposure. Instead of guessing, they get algorithmic intelligence.\n\n### Benefit 2: CFA Exam Preparation Through Live Markets\n\nSharkFlow's primary user base includes CFA Level II candidates across East Africa studying derivatives pricing, technical analysis, and quantitative methods. Reading about gold price correlations is abstract. *Trading* XAUUSD signals while studying teaches the material viscerally.\n\nOur platform shows the signal logic behind every trade recommendation:\n- RSI divergence detection\n- Moving average crossovers\n- Market microstructure insights\n- Correlation with DXY (Dollar Index) and real-time geopolitical sentiment\n\nThis bridges the gap between academic theory and market reality—exactly what CFA examiners want to see.\n\n### Benefit 3: Accessibility Without Gatekeeping\n\nTraditional forex/commodities trading requires:\n- $5K minimum account (most platforms)\n- Desktop apps (slow on mobile)\n- Phone numbers from developed nations (API restrictions)\n- Passive documentation in English-only materials\n\nSharkFlow's XAUUSD signals work with:\n- KES 500 minimum account ($3.70 USD)\n- Mobile-first interfaces (tested on 3G/4G, offline-capable)\n- M-Pesa funding (no forex accounts needed)\n- Bilingual explanations (English/Swahili for some features, expanding)\n\n---\n\n## How SharkFlow's XAUUSD Trading Signals Work Under the Hood\n\n### API Architecture: Designed for Latency & Unreliability\n\nMost financial APIs assume:\n- Stable, high-bandwidth connections\n- Ability to retry failed requests instantly\n- Low-latency WebSocket streams\n\nAfrican mobile networks don't guarantee any of this. Here's our design:\n\n```

typescript\n// Resilient signal subscription\n// Graceful degradation: WebSocket → HTTP polling → SMS fallback\n\nimport { SignalClient } from '@sharkflow/trading-sdk';\n\nconst client = new SignalClient({\n  apiKey: process.env.SHARKFLOW_API_KEY,\n  strategy: 'ADAPTIVE', // Auto-switches based on connection quality\n  fallbackChain: ['websocket', 'polling', 'sms'], // SMS for critical alerts\n  pollingInterval: 5000, // 5s on 3G, 1s on 4G\n});\n\nclient.subscribeToSignals('XAUUSD', {\n  timeframe: '1h',\n  strategy: 'rsi_divergence', // CFA-level technical analysis\n  onSignal: (signal) => {\n    console.log(`Signal: ${signal.type} at ${signal.price}`);\n    console.log(`Confidence: ${signal.confidence}%`);\n    console.log(`Why: ${signal.rationale}`); // Educational value\n  },\n  onError: (error) => {\n    console.log(`Connection lost. Using cached signals...`);\n    // Fetch last 24h of signals from local storage\n  },\n});\n

```\n\n### Database & Caching: Edge-First Strategy\n\nWe use a hybrid approach:\n\n```

\nCentral Database (PostgreSQL + TimescaleDB)\n    ↓\nAfrican Regional Caches (Redis, deployed in AWS Nairobi region)\n    ↓\nEdge Caches (IndexedDB on client devices)\n

```\n\n**TimescaleDB** handles tick-level XAUUSD data (1.2B ticks/month), queries compress by 10x. **Redis** in eu-west-1 (closest AWS region to Kenya) keeps the last 7 days of signals hot. **IndexedDB** means your phone stores the last 30 days of signals—you can review them offline during CFA study.\n\n```

python\n# Signal generation with regional awareness\nimport pandas as pd\nfrom timescaledb import TimescaleDB\n\ndb = TimescaleDB(region='africa_east') # Routes to Nairobi\n\ndef generate_xau

FundFlow — devto

sharkflow ltd — Mon, 11 May 2026 04:00:04 +0000

{
  "title": "Building an East Africa Startup Investment Platform: The FundFlow Technical Architecture",
  "content": "# Building an East Africa Startup Investment Platform: The FundFlow Technical Architecture\n\n## Why East Africa Startup Investment Platform Matters in Kenya\n\nKenyans founded over 500 tech startups in 2023 alone. Yet here's the brutal truth: 73% of African founders report that accessing investor capital is their biggest challenge. The gap isn't just financial—it's informational and logistical.\n\nTraditional investment platforms built for Silicon Valley don't work in Nairobi. They assume reliable electricity, fiber-fast internet, and banking infrastructure that simply doesn't exist at scale here. A Kenyan fintech founder in Kisumu shouldn't need to wait 72 hours for an investor response because of network latency. An investor in Lagos shouldn't lose visibility because the platform can't handle 3G speeds.\n\nThis is where FundFlow's technical foundation becomes critical. We're building for Africa's actual constraints, not pretending they don't exist.\n\n## The Core Problem We're Solving\n\nInvestor-founder matching in East Africa involves:\n- **Data fragmentation**: Startup data lives in pitch decks, Twitter threads, Google Sheets, and nowhere standardized\n- **Network asymmetry**: Investors cluster in Nairobi; founders scatter across East Africa\n- **Trust verification**: Without credit scores or traditional financial history, how do investors verify founder credibility?\n- **Currency complexity**: A Kenyan founder raises in USD but operates in KES with M-Pesa\n- **Offline-first demands**: You need the app to work on 2G when WiFi drops\n\n## FundFlow's Technical Architecture\n\n### 1. Database Design for African Constraints\n\nWe chose PostgreSQL with a **geographically-distributed replication strategy** rather than relying on single-region cloud infrastructure.\n\n```

sql\n-- Simplified schema for startup-investor matching\nCREATE TABLE startups (\n    id UUID PRIMARY KEY,\n    founder_id UUID NOT NULL,\n    name VARCHAR(255),\n    sector VARCHAR(100),\n    stage VARCHAR(20), -- 'pre-seed', 'seed', 'series-a'\n    raised_amount BIGINT, -- in cents, handles KES/USD\n    location VARCHAR(100), -- country + region\n    created_at TIMESTAMP DEFAULT NOW(),\n    updated_at TIMESTAMP DEFAULT NOW(),\n    offline_sync_token UUID -- for mobile conflict resolution\n);\n\nCREATE TABLE investors (\n    id UUID PRIMARY KEY,\n    name VARCHAR(255),\n    sectors_interested TEXT[], -- array for flexible filtering\n    ticket_size_min BIGINT,\n    ticket_size_max BIGINT,\n    country_focus TEXT[],\n    response_time_hours INT,\n    created_at TIMESTAMP DEFAULT NOW()\n);\n\nCREATE TABLE matches (\n    id UUID PRIMARY KEY,\n    startup_id UUID REFERENCES startups(id),\n    investor_id UUID REFERENCES investors(id),\n    match_score DECIMAL(3,2), -- 0.00 to 1.00\n    created_at TIMESTAMP DEFAULT NOW(),\n    status VARCHAR(20), -- 'pending', 'contacted', 'meeting', 'rejected'\n    UNIQUE(startup_id, investor_id)\n);\n\nCREATE INDEX idx_startup_sector ON startups(sector);\nCREATE INDEX idx_startup_location ON startups(location);\nCREATE INDEX idx_investor_sectors ON investors USING GIN(sectors_interested);\n

```\n\nKey decision: **We store amounts in cents (integers)** to avoid floating-point errors when converting between KES and USD. M-Pesa transactions are naturally integer-based anyway.\n\n### 2. Offline-First Mobile API Design\n\nEast Africa's mobile networks dropout constantly. We built FundFlow's API around eventual consistency:\n\n```

javascript\n// Node.js/Express API endpoint with offline-first design\nconst express = require('express');\nconst app = express();\n\n// Every response includes a sync token\napp.post('/api/v1/startups', authenticate, async (req, res) => {\n  const { name, sector, stage, location, offline_sync_token } = req.body;\n  \n  try {\n    // Check if this is a duplicate from offline sync\n    const existingSync = await db.query(\n      'SELECT id FROM startups WHERE offline_sync_token = $1',\n      [offline_sync_token]\n    );\n    \n    if (existingSync.rows.length > 0) {\n      return res.json({ \n        id: existingSync.rows[0].id, \n        synced: true,\n        message: 'Already synced'\n      });\n    }\n    \n    // Create new startup\n    const startup = await db.query(\n      `INSERT INTO startups (id, founder_id, name, sector, stage, location, offline_sync_token)\n       VALUES ($1, $2, $3, $4, $5, $6, $7)\n       RETURNING *`,\n      [crypto.randomUUID(), req.user.id, name, sector, stage, location, offline_sync_token]\n    );\n    \n    res.status(201).json({\n      ...startup.rows[0],\n      sync_token: offline_sync_token,\n      cached: false\n    });\n  } catch (err) {\n    res.status(500).json({ error: 'Server error', sync_token: offline_sync_token });\n  }\n});\n\n// Sync endpoint for batch operations when reconnected\napp.post('/api/v1/sync', authenticate, async (req, res) => {\n  const { changes } = req.body;\n  const results = [];\n  \n  for (const change of changes) {\n    try {\n      // Process each change, skipping duplicates\n      const result = await processS

FlowTasks — devto

sharkflow ltd — Sun, 10 May 2026 04:00:06 +0000

{
  "title": "Task Management App Kenya: How SharkFlow's FlowTasks Works Under the Hood",
  "content": "# Task Management App Kenya: How SharkFlow's FlowTasks Works Under the Hood\n\n## Why Task Management Matters in Kenya's Startup Ecosystem\n\nKenyans are building faster than ever. From Nairobi's Silicon Savannah to Kisumu's tech hubs, entrepreneurs juggle multiple projects, clients, and deadlines on devices that often have just 2GB of RAM and spotty 3G connections. The problem? Most productivity tools were designed for Silicon Valley bandwidth and MacBook Pro specs.\n\nSharkFlow's FlowTasks isn't another Asana clone. It's engineered from first principles for African entrepreneurs—especially those operating on 4G LTE that cuts out randomly, with payment workflows tied directly to M-Pesa, and the ability to work offline without losing critical data.\n\nLet's dive into how we built it.\n\n## The API Architecture: Lightweight and Resilient\n\nOur core philosophy: **minimize payload, maximize reliability**.\n\nWe designed FlowTasks around a GraphQL API (not REST) because it lets clients request *only* the fields they need. On a 2G fallback connection, this matters. A typical task object is ~50KB with REST over-fetching; with GraphQL, it's 8-12KB.\n\n```

graphql\nquery GetUserTasks($userId: ID!, $status: TaskStatus) {\n  user(id: $userId) {\n    tasks(status: $status) {\n      id\n      title\n      dueDate\n      assignee {\n        name\n        phone\n      }\n      subtasks {\n        id\n        completed\n      }\n    }\n  }\n}\n

```\n\nThis single query replaces what would be 3-4 REST endpoints. For users on Safaricom's edge network in rural areas, every KB counts.\n\n### Mutation-First Design\n\nWe designed mutations to be **idempotent**—critical for spotty networks where users might tap \"Save\" multiple times thinking nothing happened.\n\n```

graphql\nmutation CreateTask(\n  $title: String!\n  $idempotencyKey: String!\n) {\n  createTask(title: $title, idempotencyKey: $idempotencyKey) {\n    id\n    createdAt\n    status\n  }\n}\n

```\n\nEvery mutation includes an `idempotencyKey` (UUID generated client-side). Our backend deduplicates requests within a 24-hour window. Try to create the same task twice? You get the same response both times, with no duplicate in the database.\n\n## Database Architecture: PostgreSQL + SQLite Hybrid\n\n**Production server:** PostgreSQL (hosted on AWS RDS in `af-south-1` for latency to East Africa)\n\n**Client-side:** SQLite, synced via a custom offline-first engine\n\nWhy not just Firestore or MongoDB? Cost. Firestore costs scale badly in Africa where users create many small operations (tasks, comments, time entries). We built a time-series optimized schema instead:\n\n```

sql\n-- Tasks table (denormalized for reads)\nCREATE TABLE tasks (\n    id UUID PRIMARY KEY,\n    workspace_id UUID NOT NULL,\n    creator_id UUID NOT NULL,\n    title VARCHAR(500) NOT NULL,\n    description TEXT,\n    status VARCHAR(20) NOT NULL DEFAULT 'open',\n    due_date TIMESTAMP,\n    priority SMALLINT DEFAULT 3,\n    created_at TIMESTAMP NOT NULL DEFAULT NOW(),\n    updated_at TIMESTAMP NOT NULL DEFAULT NOW(),\n    deleted_at TIMESTAMP,\n    FOREIGN KEY (workspace_id) REFERENCES workspaces(id),\n    FOREIGN KEY (creator_id) REFERENCES users(id)\n);\n\n-- Event log (immutable, audit trail)\nCREATE TABLE task_events (\n    id BIGSERIAL PRIMARY KEY,\n    task_id UUID NOT NULL,\n    event_type VARCHAR(50) NOT NULL,\n    actor_id UUID NOT NULL,\n    payload JSONB NOT NULL,\n    created_at TIMESTAMP NOT NULL DEFAULT NOW(),\n    FOREIGN KEY (task_id) REFERENCES tasks(id),\n    FOREIGN KEY (actor_id) REFERENCES users(id)\n);\n\nCREATE INDEX idx_task_events_task_id ON task_events(task_id);\nCREATE INDEX idx_task_events_created_at ON task_events(created_at DESC);\n

```\n\nWe use an **event log** instead of updating rows. Why? It gives us:\n- Perfect audit trails (regulators in Kenya love this)\n- Easy conflict resolution for offline sync\n- Ability to replay state at any point in time\n\n## Offline-First Sync: The Real Magic\n\nThis is where SharkFlow differentiates from Notion, Monday.com, or Jira.\n\nUsers work entirely offline. FlowTasks syncs in the background when connectivity returns—intelligently batching requests and handling conflicts.\n\n```

typescript\n// Client-side sync engine (simplified)\nclass SyncEngine {\n  private queue: PendingMutation[] = [];\n  private lastSyncTimestamp: number = 0;\n\n  async queueMutation(mutation: CreateTaskMutation): Promise<void> {\n    // Immediately apply optimistically\n    this.db.tasks.insert({\n      id: uuid(),\n      ...mutation,\n      _syncStatus: 'pending',\n    });\n\n    // Add to queue\n    this.queue.push({\n      type: 'createTask',\n      payload: mutation,\n      clientId: this.clientId,\n      timestamp: Date.now(),\n    });\n\n    // Trigger sync when online\n    if (this.isOnline) this.sync();\n  }\n\n  async sync(): Promise<void> {\n    if (this.

Trading Bot (QUANT ELITE) — devto

sharkflow ltd — Sat, 09 May 2026 04:00:11 +0000

{
  "title": "Building a Forex Trading Bot for African Markets: How SharkFlow's QUANT ELITE Works Under the Hood",
  "content": "# Building a Forex Trading Bot for African Markets: How SharkFlow's QUANT ELITE Works Under the Hood\n\nIf you've been following the fintech explosion in East Africa, you've probably noticed something: traditional forex trading infrastructure was built for London and New York traders with fiber-optic connections and unlimited data. Africa has 60M+ mobile money users, but most forex trading platforms still assume you're sitting in front of a desktop in Manhattan.\n\nAt SharkFlow, we spent 18 months rebuilding quantitative trading from first principles for African markets. This is the story of QUANT ELITE—our forex trading bot that actually works on 4G networks, respects M-Pesa latency realities, and turns the continental context into a feature, not a bug.\n\n## The Problem We Solved\n\nMost forex bots fail in Africa for three reasons:\n\n1. **Latency assumptions**: NYSE trades in microseconds. A Kenyan trader on Safaricom gets 200-400ms to an international exchange. Traditional bots assume sub-100ms connectivity.\n2. **Data bandwidth**: Real-time market feeds are data-heavy. Most bots stream 50-100MB daily. Our users often have 2-3GB monthly data limits.\n3. **Settlement friction**: Standard forex workflows assume instant wire transfers. We have M-Pesa's 30-second settlement, bank delays, and currency conversion spreads that add 2-4% to every transaction.\n\nQUANT ELITE was built to thrive in this environment, not despite it.\n\n## Architecture: Edge-First Design\n\nHere's our core principle: **compute at the edge, decide locally, execute with conviction**.\n\n```

\n┌─────────────────────────────────────────────────┐\n│         Market Data (Reduced Feed)              │\n│    ~2-5MB daily, compressed OHLC + signals     │\n└────────────────┬────────────────────────────────┘\n                 │\n┌────────────────▼────────────────────────────────┐\n│     Edge Inference Layer (Device-Side)         │\n│  • Local ML model (quantized, ~8MB)            │\n│  • Pattern recognition on 4G-friendly data     │\n│  • Decision threshold: confidence > 87%        │\n└────────────────┬────────────────────────────────┘\n                 │\n        ┌────────┴─────────┐\n        │                  │\n   ┌────▼────┐      ┌──────▼──────┐\n   │  SIGNAL │      │  NO SIGNAL  │\n   │ QUEUING │      │  (SILENCE)  │\n   └────┬────┘      └─────────────┘\n        │\n┌───────▼──────────────────────────────────────┐\n│  Decision Queue (Local SQLite)               │\n│  • Timestamp, confidence, rationale          │\n│  • Retry logic for failed submissions        │\n│  • Rate limiting (max 2 trades/hour)        │\n└───────┬──────────────────────────────────────┘\n        │\n┌───────▼──────────────────────────────────────┐\n│  Execution Layer (Hybrid M-Pesa + Forex)    │\n│  • Batch trades every 15min (bandwidth opt) │\n│  • M-Pesa for KES pairs, forex API for USD  │\n└───────────────────────────────────────────────┘\n

```\n\nNotice what's *not* here: constant websocket streams, real-time market feeds, or sub-second latency requirements. We batch, we compress, we decide locally.\n\n## Database: SQLite at the Edge, PostgreSQL in the Cloud\n\nOur tech stack reflects African network reality:\n\n**Device Layer (SQLite)**\n```

sql\nCREATE TABLE trading_signals (\n  id INTEGER PRIMARY KEY,\n  timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,\n  asset_pair TEXT NOT NULL, -- e.g., 'KES/USD', 'GOLD/USD'\n  signal_type TEXT NOT NULL, -- 'BUY', 'SELL', 'HOLD'\n  confidence REAL NOT NULL, -- 0.0 to 1.0\n  predicted_return REAL,\n  rationale TEXT, -- Why did the model signal this?\n  status TEXT DEFAULT 'PENDING', -- PENDING, SUBMITTED, FILLED, FAILED\n  retry_count INTEGER DEFAULT 0,\n  UNIQUE(timestamp, asset_pair)\n);\n\nCREATE TABLE market_state (\n  asset_pair TEXT PRIMARY KEY,\n  last_close REAL,\n  last_update DATETIME,\n  volatility_14day REAL,\n  trend TEXT -- 'UP', 'DOWN', 'RANGING'\n);\n

```\n\nWhy SQLite, not PostgreSQL? Three reasons:\n- **Zero setup**: SQLite lives in the app bundle. No separate database server.\n- **Bandwidth**: Changes sync to cloud only when a trade is ready—not constant streaming.\n- **Offline-first**: If connectivity drops mid-trade, decisions are already made and queued locally.\n\n**Cloud Layer (PostgreSQL)**\n```

sql\nCREATE TABLE executed_trades (\n  id UUID PRIMARY KEY,\n  user_id UUID NOT NULL,\n  asset_pair TEXT NOT NULL,\n  trade_type TEXT NOT NULL, -- 'BUY' or 'SELL'\n  volume DECIMAL(10,2),\n  entry_price DECIMAL(10,4),\n  entry_time TIMESTAMP,\n  exit_price DECIMAL(10,4) NULL,\n  exit_time TIMESTAMP NULL,\n  pnl DECIMAL(10,2) NULL,\n  status TEXT,\n

SharkFlow CFA — devto

sharkflow ltd — Fri, 08 May 2026 04:00:11 +0000

{
  "title": "CFA Study Kenya: How We Built SharkFlow's AI-Powered Exam Platform on African Infrastructure",
  "content": "# CFA Study Kenya: How We Built SharkFlow's AI-Powered Exam Platform on African Infrastructure\n\nIf you're a developer in Africa working on fintech, you've probably hit the same wall we did: building for financial markets requires bulletproof infrastructure, but African network conditions aren't exactly forgiving. When SharkFlow set out to build a CFA exam preparation platform specifically for Kenya and the broader African market, we couldn't just copy-paste solutions from Silicon Valley.\n\nHere's how we engineered SharkFlow CFA from the ground up—and what we learned about building financial tech that actually works on 2G networks.\n\n## The Problem: Why Existing CFA Platforms Fail in Africa\n\nLet's be honest. The CFA Institute curriculum is dense. But that's not why African candidates struggle—they struggle because every existing platform assumes you have unlimited bandwidth, low latency, and reliable electricity.\n\nKenny, a candidate from Nairobi, told us: *\"I pay Ksh 3,500/month for internet. I can't afford to re-download a 50MB video because I lost connection for 3 seconds.\"*\n\nThat statement shaped our entire architecture.\n\nCFA exam prep in Kenya alone represents a ~Ksh 500M+ market (rough estimate: 4,000 candidates × Ksh 125k average spend on prep materials). But we knew we'd only capture that market if we solved for:\n\n1. **Bandwidth scarcity** (many Kenyan users still on 3G/4G with data caps)\n2. **Intermittent connectivity** (Nairobi's power grid issues, rural network blackouts)\n3. **Payment fragmentation** (M-Pesa dominance, limited credit card adoption)\n4. **Offline-first requirements** (users need to study without data)\n\n## Architecture Decision 1: API-First, Async-Heavy Design\n\nWe went full-async. Here's why:\n\n```

javascript\n// Bad: Synchronous, assumes fast connection\napp.get('/api/study-material/:topicId', (req, res) => {\n  const material = db.query(`SELECT * FROM materials WHERE id = ?`, req.params.topicId);\n  const questions = db.query(`SELECT * FROM questions WHERE material_id = ?`, req.params.topicId);\n  const explanations = db.query(`SELECT * FROM explanations WHERE material_id = ?`, req.params.topicId);\n  res.json({ material, questions, explanations });\n});\n

```\n\nThis fails on slow networks. The user waits 8+ seconds, connection drops mid-request, nothing caches properly.\n\n```

javascript\n// Good: API endpoints designed for offline-first sync\napp.get('/api/sync/study-material/:topicId', async (req, res) => {\n  try {\n    const material = await getMaterial(req.params.topicId);\n    const etag = generateETag(material);\n    \n    // Client sends If-None-Match header if it has cached version\n    if (req.headers['if-none-match'] === etag) {\n      return res.status(304).end();\n    }\n    \n    // Compressed, chunked response\n    res.set('ETag', etag);\n    res.set('Cache-Control', 'public, max-age=604800'); // 1 week\n    res.json({\n      material,\n      syncTimestamp: Date.now(),\n      nextSyncWindow: calculateNextWindow()\n    });\n  } catch (err) {\n    res.status(500).json({ error: err.message, offline: true });\n  }\n});\n

```\n\nEach endpoint returns:\n- **ETag headers** for conditional requests (saves data)\n- **Cache-Control directives** (respects bandwidth)\n- **Sync timestamps** (the app knows what's fresh)\n- **Graceful degradation** (errors don't break offline experience)\n\n## Architecture Decision 2: Database Strategy for Scale\n\nWe chose **PostgreSQL for relational data + Redis for sync queues**. Here's the specific schema:\n\n```

sql\n-- Core study material (immutable, heavily cached)\nCREATE TABLE study_materials (\n  id SERIAL PRIMARY KEY,\n  topic_code VARCHAR(10) NOT NULL, -- e.g., 'L1_ETH_001'\n  content JSONB NOT NULL, -- Stores curriculum section\n  content_version INT DEFAULT 1,\n  compressed_size INT,\n  created_at TIMESTAMP DEFAULT NOW(),\n  updated_at TIMESTAMP DEFAULT NOW(),\n  is_active BOOLEAN DEFAULT TRUE\n);\n\nCREATE INDEX idx_topic_code ON study_materials(topic_code);\nCREATE INDEX idx_content_version ON study_materials(content_version);\n\n-- User progress (hot data, frequent writes)\nCREATE TABLE user_progress (\n  id BIGSERIAL PRIMARY KEY,\n  user_id BIGINT NOT NULL,\n  material_id INT NOT NULL,\n  last_accessed_at TIMESTAMP DEFAULT NOW(),\n  completion_percentage NUMERIC(5,2),\n  local_sync_token VARCHAR(64), -- UUID for offline sync\n  FOREIGN KEY (material_id) REFERENCES study_materials(id)\n);\n\nCREATE INDEX idx_user_progress ON user_progress(user_id, last_accessed_at DESC);\n\n-- Exam mock questions (immutable, cached aggressively)\nCREATE TABLE mock_questions (\n  id BIGSERIAL PRIMARY KEY,\n  topic_id INT NOT NULL,\n  question_text TEXT NOT NULL,\n  options JSONB NOT NULL,\n  correct_option INT NOT NULL,\n  explanation TEXT,\n  created_at TIMESTAMP DEFAULT NOW(),\n  FOREIGN KEY (topic_id) REFERENCES study_materials(id)\