Forem: sharkflow ltd

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)\

ReserveFlow — devto

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

{
  "title": "Building ReserveFlow: AI-Powered Property Search for Kenya's Mobile-First Market",
  "content": "# Building ReserveFlow: AI-Powered Property Search for Kenya's Mobile-First Market\n\nLast month, a developer in Kisumu used ReserveFlow to find a bedsitter in Karen, Nairobi—without visiting a single property in person. Three WhatsApp messages. Two AI-powered property recommendations. One completed booking via M-Pesa in under 20 minutes.\n\nThis is the future of real estate in Africa, and it's built on some seriously interesting engineering challenges. Let me walk you through how ReserveFlow actually works under the hood.\n\n## The Problem We're Solving\n\nKenya's real estate market is fragmented. You've got:\n- **Fragmented data**: Properties listed across 50+ websites, WhatsApp groups, and spreadsheets\n- **Mobile-first users**: 60M+ mobile money users, but most property platforms are desktop-optimized\n- **Inconsistent connectivity**: Average speeds of 8-12 Mbps in Nairobi, dropping to 2-3 Mbps in secondary cities\n- **Trust gaps**: Unverified listings, inflated prices, and sketchy agents dominate the market\n\nWe built ReserveFlow to aggregate, verify, and intelligently surface properties using AI—optimized for 2G fallback and offline-first architectures.\n\n## Architecture Overview\n\n```

\n┌─────────────────────────────────────────┐\n│  Mobile Client (React Native)           │\n│  - Offline-first with SQLite            │\n│  - Compressed image syncing             │\n└────────────┬────────────────────────────┘\n             │\n             ▼\n┌─────────────────────────────────────────┐\n│  API Gateway (Kong)                     │\n│  - Rate limiting (100req/min for free)  │\n│  - Request compression (gzip)           │\n│  - M-Pesa webhook routing               │\n└────────────┬────────────────────────────┘\n             │\n        ┌────┴────┐\n        ▼         ▼\n   ┌─────────┐  ┌──────────────┐\n   │ GraphQL │  │ REST (Legacy)│\n   │ Server  │  │ Endpoints    │\n   └────┬────┘  └──────┬───────┘\n        │               │\n        └───────┬───────┘\n                ▼\n     ┌──────────────────────┐\n     │  Service Layer       │\n     │ - Property AI        │\n     │ - Payment Handler    │\n     │ - Verification Bot   │\n     └──────────┬───────────┘\n                ▼\n     ┌──────────────────────┐\n     │  Data Layer          │\n     │ - PostgreSQL (props) │\n     │ - Redis (cache)      │\n     │ - Elasticsearch      │\n     └──────────────────────┘\n

```\n\n## Database Design for African Constraints\n\nWe use **PostgreSQL for structured data** (properties, bookings, users) and **Elasticsearch for search**. Here's why this matters in Kenya's context:\n\n### 1. Property Schema (Optimized for Queries)\n\n```

sql\nCREATE TABLE properties (\n  id UUID PRIMARY KEY,\n  title VARCHAR(255) NOT NULL,\n  description TEXT,\n  price_ksh BIGINT NOT NULL,\n  location_point GEOGRAPHY(POINT, 4326), -- Indexed for spatial queries\n  bedrooms SMALLINT,\n  bathrooms SMALLINT,\n  area_sqm DECIMAL(10, 2),\n  amenities JSONB, -- Flexible schema for varied data\n  images_urls TEXT[] -- Array for multiple images\n  verification_score DECIMAL(3, 2), -- AI confidence (0-1)\n  verified_at TIMESTAMP,\n  agent_id UUID REFERENCES agents(id),\n  created_at TIMESTAMP DEFAULT NOW(),\n  updated_at TIMESTAMP DEFAULT NOW()\n);\n\nCREATE INDEX idx_location ON properties USING GIST(location_point);\nCREATE INDEX idx_price ON properties(price_ksh);\nCREATE INDEX idx_verified ON properties(verification_score DESC, created_at DESC);\n

```\n\n**Why JSONB for amenities?** Real estate data in Kenya is messy. One agent lists \"WiFi+Generator,Solar\" as a string. Another lists it as an array. JSONB lets us normalize queries across inconsistent sources.\n\n### 2. Booking Schema with M-Pesa Integration\n\n```

sql\nCREATE TABLE bookings (\n  id UUID PRIMARY KEY,\n  property_id UUID REFERENCES properties(id),\n  user_id UUID REFERENCES users(id),\n  check_in_date DATE,\n  check_out_date DATE,\n  total_price_ksh BIGINT,\n  payment_status VARCHAR(20) DEFAULT 'pending', -- pending, processing, completed, failed\n  mpesa_transaction_id VARCHAR(10) UNIQUE,\n  mpesa_receipt_number VARCHAR(32),\n  mpesa_initiated_at TIMESTAMP,\n  mpesa_completed_at TIMESTAMP,\n  status VARCHAR(20) DEFAULT 'confirmed', -- confirmed, cancelled, completed\n  created_at TIMESTAMP DEFAULT NOW()\n);\n\nCREATE INDEX idx_user_bookings ON bookings(user_id, created_at DESC);\nCREATE INDEX idx_mpesa_status ON bookings(payment_status, mpesa_transaction_id);\n

\n\n## API Design: GraphQL + REST Hybrid\n\nWe expose GraphQL for complex queries (ideal for mobile with slow connections) and REST

FundFlow — devto

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

{
  "title": "How FundFlow Matches Angel Investors with Kenya Startups: The Technical Deep Dive",
  "content": "# How FundFlow Matches Angel Investors with Kenya Startups: The Technical Deep Dive\n\nKenyan startups raise roughly $400M annually, but here's the brutal truth: most never meet a single angel investor. Why? The infrastructure doesn't exist. There's no standardized way for a founder in Kisumu to connect with an angel in Nairobi who invests in fintech. There's no API layer connecting Kenya's fragmented investor networks.\n\nThis is what FundFlow's engineering team built. We're a Kenyan tech company solving one of Africa's hardest problems: *how do you programmatically match founders with the right capital, over unreliable networks, in markets where investor data is fragmented?*\n\nLet's talk about how we did it.\n\n## The Problem: Africa's Unique Infrastructure Constraints\n\nBefore we wrote a single line of code, we had to understand our constraints:\n\n- **Network reliability**: Kenya's mobile networks have ~95% uptime in urban areas, ~65% in rural areas. Your API calls might timeout. Your database connection might drop mid-transaction.\n- **Data fragmentation**: Angel investor data lives in spreadsheets, WhatsApp groups, LinkedIn, and closed Facebook communities. There's no central registry.\n- **Mobile-first users**: 60M+ Kenyans use M-Pesa daily. Most founders checking their funding status do it on a 3G connection from a matatu.\n- **Cost sensitivity**: Every API call, every database query, every megabyte of data costs real money.\n\nThis shaped every architectural decision we made.\n\n## FundFlow's Architecture: API-First Design\n\nWe built FundFlow around three core services:\n\n```

\n┌─────────────────────────────────────────┐\n│         Mobile Client Layer              │\n│  (React Native + offline-first)          │\n└──────────────┬──────────────────────────┘\n               │\n┌──────────────▼──────────────────────────┐\n│     API Gateway (Kong)                   │\n│  Rate limiting, circuit breakers         │\n└──────────────┬──────────────────────────┘\n               │\n    ┌──────────┼──────────┐\n    │          │          │\n┌───▼──┐  ┌────▼───┐  ┌──▼────┐\n│Match │  │Profile │  │Payment│\n│ API  │  │ API    │  │API    │\n└───┬──┘  └────┬───┘  └──┬────┘\n    │          │         │\n└───┴──────────┴─────────┘\n        │\n    ┌───▼─────────────────┐\n    │  PostgreSQL + Redis  │\n    │  (Replication ready) │\n    └──────────────────────┘\n

```\n\n**Why this design?**\n\n1. **Kong API Gateway**: Handles rate limiting (crucial when your user base jumps from 1,000 to 50,000 overnight). Implements circuit breakers so if our investor-matching service slows down, we don't cascade failures across other services.\n\n2. **Microservices**: Decoupled services mean we can scale the matching engine independently from payment processing. If M-Pesa integration gets hammered, our matching API stays responsive.\n\n3. **Offline-first mobile**: The app syncs investor profiles and portfolio data when connection is available. When it's not, founders can still browse matches and draft pitches.\n\n## The Matching Algorithm: Building a Smart Recommendation Engine\n\nHere's where it gets interesting. We couldn't use off-the-shelf recommendation engines because:\n\n- Investor data is sparse and incomplete\n- Investors in Kenya have deep domain expertise but no standardized way to tag it\n- Success is binary: did the investor actually fund this startup?\n\nWe built a hybrid approach:\n\n```

python\n# Simplified version of our matching algorithm\nfrom enum import Enum\nfrom typing import List, Tuple\n\nclass InvestorType(Enum):\n    ANGEL = \"angel\"\n    MICRO_VC = \"micro_vc\"\n    CORPORATE = \"corporate\"\n\nclass StartupProfile:\n    def __init__(self, founder_id, sector, stage, amount_seeking, location):\n        self.founder_id = founder_id\n        self.sector = sector  # fintech, agritech, etc.\n        self.stage = stage    # pre-seed, seed, series-a\n        self.amount_seeking = amount_seeking  # KES\n        self.location = location  # Nairobi, Kisumu, etc.\n        self.pitch_sentiment = None\n        self.team_quality_score = None\n\nclass InvestorProfile:\n    def __init__(self, investor_id, sector_focus, check_size, location):\n        self.investor_id = investor_id\n        self.sector_focus = sector_focus  # tags: [\"fintech\", \"climate\"]\n        self.check_size = check_size  # (min_kes, max_kes)\n        self.location = location\n        self.portfolio_quality_score = None\n\ndef calculate_match_score(\n    startup: StartupProfile,\n    investor: InvestorProfile\n) -> Tuple[float, dict]:\n    \"\"\"\n    Multi-factor matching score (0-100).\n    Weights tuned from 2 years of real funding data.\n    \"\"\"\n    score = 0.0\n    factors = {}\n    \n    # Factor 1: Sector alignment (40% weight)\n    if startup.sector in investor.sector_focus:\n        sector_score = 40.0\n    else:\n        sector_score = 10.0\n    score += sector_

FlowTasks — devto

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

{
  "title": "Building FlowTasks for Africa's Mobile-First Entrepreneurs: The Engineering Behind Productivity at Scale",
  "content": "# Building FlowTasks for Africa's Mobile-First Entrepreneurs: The Engineering Behind Productivity at Scale\n\nWhen we started building FlowTasks at SharkFlow, we weren't thinking about Silicon Valley's productivity stack. We were thinking about a Nairobi-based logistics entrepreneur managing 50+ daily deliveries on a 3G connection, or a Kampala fashion business owner juggling inventory and client orders during peak hours.\n\nThat constraint — unreliable connectivity, limited bandwidth, low-end devices — became our north star for technical design. Here's how we built productivity software that actually works in Africa.\n\n## The API Philosophy: Offline-First, Sync-Later\n\nMost task management tools assume constant connectivity. We built the opposite.\n\n```

typescript\n// Core sync strategy: works offline, syncs when possible\ninterface Task {\n  id: string;\n  title: string;\n  status: 'pending' | 'in-progress' | 'completed';\n  priority: number;\n  createdAt: number;\n  updatedAt: number;\n  syncStatus: 'local' | 'syncing' | 'synced' | 'conflict';\n  localVersion: number;\n  serverVersion?: number;\n}\n\nclass TaskService {\n  async addTask(task: Omit<Task, 'id' | 'syncStatus'>): Promise<Task> {\n    // 1. Write to local storage immediately\n    const localTask = {\n      ...task,\n      id: generateUUID(),\n      syncStatus: 'local',\n      localVersion: 1\n    };\n    await this.localDB.insert('tasks', localTask);\n    \n    // 2. Queue for sync (doesn't block the user)\n    this.syncQueue.enqueue(localTask);\n    \n    // 3. Return immediately to UI\n    return localTask;\n  }\n}\n

```\n\nThis pattern is critical. On African networks, you can't afford to wait for API responses before letting users see their work. We use SQLite on mobile and IndexedDB on web — local-first databases that exist entirely on the device.\n\n## Database Strategy: SQLite + EdgeDB + Smart Replication\n\nOur stack is deliberately minimal:\n\n- **Mobile**: SQLite (battle-tested, 600KB, zero dependencies)\n- **Edge**: EdgeDB (typed queries, built-in migrations, excellent JSON support)\n- **Sync logic**: Custom conflict-resolution engine\n\nWhy not PostgreSQL directly? Three reasons:\n\n1. **Network unpredictability**: A dropped connection mid-transaction on spotty 3G is painful with traditional SQL. Our replication layer handles partial syncs.\n2. **Schema versioning**: With 60M+ mobile money users spreading across Africa, we needed schema evolution without API versioning hell.\n3. **Real-time collaboration**: EdgeDB's subscription API gives us WebSocket-based sync for free, critical when three team members are updating tasks simultaneously.\n\n```

typescript\n// Conflict resolution: last-write-wins with tombstones\nclass SyncEngine {\n  async resolveConflict(\n    local: Task,\n    server: Task\n  ): Promise<Task> {\n    // If both changed, compare timestamps\n    if (local.updatedAt > server.updatedAt) {\n      return local; // Trust local if more recent\n    }\n    \n    // For critical fields (like payment status), require manual merge\n    if (this.isCriticalField(local, server)) {\n      return { ...server, syncStatus: 'conflict' };\n    }\n    \n    return server;\n  }\n  \n  async bulkSync(localTasks: Task[]): Promise<SyncResult> {\n    // Batch uploads to minimize API calls\n    const chunks = chunk(localTasks, 50);\n    const results = await Promise.all(\n      chunks.map(c => this.api.batchUpsert('/tasks', c))\n    );\n    \n    return this.mergeSyncResults(results);\n  }\n}\n

```\n\n## Bandwidth Optimization: Why We Cache Aggressively\n\nM-Pesa's $320B annual transaction volume runs on 2G. Your task app needs to respect that.\n\n```

typescript\n// Request batching + compression\nclass NetworkOptimizer {\n  private requestBatch: any[] = [];\n  private batchTimeout: NodeJS.Timeout;\n  \n  async queueRequest(endpoint: string, data: any) {\n    this.requestBatch.push({ endpoint, data });\n    \n    // Wait 2 seconds for more requests to batch\n    clearTimeout(this.batchTimeout);\n    this.batchTimeout = setTimeout(() => this.flushBatch(), 2000);\n  }\n  \n  private async flushBatch() {\n    if (!this.requestBatch.length) return;\n    \n    const payload = JSON.stringify(this.requestBatch);\n    const compressed = await gzip(payload);\n    \n    // Typical reduction: 40KB → 8KB\n    await fetch('/api/batch', {\n      method: 'POST',\n      headers: { 'Content-Encoding': 'gzip' },\n      body: compressed\n    });\n    \n    this.requestBatch = [];\n  }\n}\n

```\n\nWe compress all payloads by default. On a typical task sync (50 tasks), this drops from 40KB to 8KB. Over a month, that's 1GB saved for users in high-cost data markets.\n\n## Smart Scheduling: Syncing When It's Free\n\nHere's something most productivity apps miss: in Kenya, Uganda, Tanzania, many plans offer free data during specific hours. We detect and exploit that.\n\n```

typescript\n// Intelligent sync scheduler\nclass SyncScheduler {\

Trading Bot (QUANT ELITE) — devto

sharkflow ltd — Sat, 02 May 2026 04:00:12 +0000

{
  "title": "Building Profitable MT5 Expert Advisors for Kenya: The SharkFlow QUANT ELITE Technical Deep Dive",
  "content": "# Building Profitable MT5 Expert Advisors for Kenya: The SharkFlow QUANT ELITE Technical Deep Dive\n\nIf you're a developer in Nairobi, Lagos, or Cape Town watching the fintech explosion, you've probably wondered: *How do trading bots actually work?* More importantly—how do you build one that's actually profitable, especially when you're deploying it across Africa's unreliable networks?\n\nAt SharkFlow, we spent two years building QUANT ELITE, our algorithmic trading engine that runs on MT5 (MetaTrader 5) and optimizes for African market conditions. This article breaks down the technical architecture, the engineering decisions we made, and why some approaches that work in Wall Street data centers completely fail when your users are trading from Kampala on a 3G connection.\n\n## Why MT5 for African Markets?\n\nFirst, context: MetaTrader 5 dominates forex and derivatives trading across Africa. It's lightweight, it works offline, and brokers here already support it. Building on top of MT5 rather than against it was our key architectural decision. Unlike building a proprietary trading engine (expensive, risky, reinventing wheels), MT5 Expert Advisors let us focus on the quant logic while the platform handles order execution, chart data, and broker connectivity.\n\nThe trade-off? We're constrained by MQL5 (MetaTrader's language), which is C++-ish but not quite C++. But the ecosystem advantage is massive: 90%+ of retail traders in East Africa already have MT5 installed.\n\n## API Architecture: The Bridge Between Cloud Quant and Edge Trading\n\nOur first design challenge: the algo logic needs to run both on user devices (for speed, offline resilience) and in cloud servers (for backtesting, risk management, signal generation).\n\nHere's our three-layer architecture:\n\n```

\n┌─────────────────────────────────────────────────┐\n│  Cloud Layer (Google Cloud, Nairobi region)     │\n│  - Signal generation                            │\n│  - Historical data aggregation                  │\n│  - Risk management rules                        │\n└─────────────┬───────────────────────────────────┘\n              │ REST API (optimized for 2G/3G)\n              │\n┌─────────────▼───────────────────────────────────┐\n│  Edge Layer (User's MT5 instance)               │\n│  - Execute signals                              │\n│  - Real-time order management                   │\n│  - Offline fallback logic                       │\n└─────────────────────────────────────────────────┘\n

```\n\n### API Design for Bandwidth-Constrained Networks\n\nThis is where most fintech solutions fail in Africa. A typical REST API call to a US-based trading system might be 50KB of JSON. On a Kenyan 3G connection at 500KB/s, that's latency hell.\n\nOur solution: **Compressed Protocol Buffers** for cloud communication.\n\n```

protobuf\n// signal.proto - Minimal message definition\nsyntax = \"proto3\";\n\nmessage TradingSignal {\n  int32 symbol_id = 1;        // 0=EURUSD, 1=GBPUSD, etc. (lookup table)\n  enum Action { BUY = 0; SELL = 1; CLOSE = 2; }\n  Action action = 2;\n  float price = 3;            // Entry price\n  float stop_loss = 4;\n  float take_profit = 5;\n  int64 timestamp = 6;        // Unix ms\n}\n

```\n\nA typical signal that's 8KB in JSON is ~200 bytes in protobuf. Over a 50-signal update (worst case), that's 400KB saved. When you're refreshing every 15 seconds, you're looking at 2.3MB/day vs 46MB/day. That matters when users are on KES-priced data bundles.\n\n### The MQL5 Expert Advisor: Signal Reception & Execution\n\n```

cpp\n// QuantElite.mq5 - Simplified version\n#property copyright \"SharkFlow Ltd\"\n#property strict\n\n// Incoming signal from cloud\nstruct CloudSignal {\n    int symbolCode;\n    int action;     // 0=BUY, 1=SELL, 2=CLOSE\n    double price;\n    double sl;\n    double tp;\n    long timestamp;\n};\n\nclass QuantEliteBot {\nprivate:\n    CTrade trade;                  // MT5's trading object\n    string CloudAPIKey;            // Secured in encrypted storage\n    int lastSignalTime = 0;\n    double maxDrawdown = 0.05;     // 5% max\n    double riskPerTrade = 0.01;    // 1% per trade\n    \npublic:\n    void OnTick() {\n        // Every tick, check for new cloud signals\n        CloudSignal signal = FetchSignalFromCloud();\n        \n        if (signal.timestamp > lastSignalTime) {\n            lastSignalTime = signal.timestamp;\n            \n            // Risk check before execution\n            if (!CheckRiskLimits()) {\n                PrintFormat(\"Risk limit breached. Skipping signal.\");\n                return;\n            }\n            \n            ExecuteSignal(signal);\n        }\n    }\n    \n    CloudSignal FetchSignalFromCloud() {\n        // Offline fallback: use last valid signal if network fails\n        string response = HTTPRequestWithRetry(\n            \"https://api.sharkflow.ai/signal\",\n            CloudAPIKey,\n            3  // 3 retry attempts\n        );\n        \n        if (response == \"\") {\n            // Network

SharkFlow CFA — devto

sharkflow ltd — Fri, 01 May 2026 04:00:12 +0000

{
  "title": "Building a CFA Study Platform That Actually Works on African Mobile Networks: SharkFlow's Technical Deep Dive",
  "content": "# Building a CFA Study Platform That Actually Works on African Mobile Networks: SharkFlow's Technical Deep Dive\n\nPreparing for the CFA exam is brutal. Doing it on a 2G connection in Nairobi? That's a different kind of hell.\n\nWhen we started building SharkFlow's CFA preparation module, we realized most EdTech platforms treat African markets as afterthoughts. They optimize for Wi-Fi. They assume reliable power. They ignore that Kenya's 60M+ mobile money users work on devices with 512MB RAM and unstable networks.\n\nThis article breaks down how we engineered a CFA study platform that doesn't just *exist* in Africa—it genuinely thrives here.\n\n## The Problem We Solved\n\nThe CFA curriculum is dense: 300+ hours of study across derivatives, portfolio management, ethics, and quantitative methods. Traditional platforms require constant connectivity and heavy data transfer. In Kenya, where mobile data costs ~KES 50 ($0.38 USD) for 100MB, every kilobyte matters.\n\nWe had three non-negotiable constraints:\n1. **Work offline-first**: Download once, study everywhere\n2. **Handle ~10Mbps fluctuations**: Network conditions are real\n3. **Scale to 50,000 concurrent users** without melting our infrastructure\n\n## Our Architecture: Offline-First by Default\n\n### Progressive Data Sync\n\nWe built a two-tier content system:\n\n```

typescript\n// Content strategy: Cloud-sourced, device-stored\ninterface ContentTier {\n  tier1: {\n    size: '85MB',\n    content: 'Core curriculum (Ethics, Quantitative)',\n    syncStrategy: 'aggressive_prefetch',\n    frequency: 'weekly'\n  },\n  tier2: {\n    size: '250MB',\n    content: 'Full question banks + video lectures',\n    syncStrategy: 'background_sync',\n    frequency: 'on_demand'\n  },\n  tier3: {\n    size: '15MB',\n    content: 'Real-time market data + performance analytics',\n    syncStrategy: 'delta_sync',\n    frequency: 'hourly'\n  }\n}\n

```\n\nUsers can start studying immediately with Tier 1 (~85MB), which covers the essentials. Tier 2 downloads in the background during low-cost hours (most Kenyan carriers offer off-peak data). Tier 3 syncs only when connected.\n\n### Smart Compression\n\nOur content pipeline compresses ruthlessly:\n\n```

python\n# Content compression strategy\nclass ContentCompressor:\n    def compress_materials(self, material_type: str):\n        if material_type == 'video':\n            # H.265 codec, 480p target (not 4K)\n            # Bitrate: 800kbps (vs 5Mbps standard)\n            return self._transcode_video()\n        \n        elif material_type == 'pdf':\n            # Remove embedded fonts, compress images\n            # Target: 60% size reduction\n            return self._optimize_pdf()\n        \n        elif material_type == 'questions':\n            # Plain JSON with heavy gzip\n            # 10,000 questions = 12MB (uncompressed: 85MB)\n            return self._serialize_questions()\n

```\n\nOur question bank of 10,000 CFA questions compressed from 85MB to 12MB. That's the difference between \"I'll download later\" and \"done in 2 minutes.\"\n\n## Database Architecture: SQLite Locally, PostgreSQL Globally\n\nMost EdTech platforms use Firebase or MongoDB. Both are overkill and expensive at scale in Africa.\n\nWe use a hybrid:\n\n```

sql\n-- Local SQLite schema (device-side)\nCREATE TABLE questions (\n    id INTEGER PRIMARY KEY,\n    level INTEGER,  -- L1, L2, L3\n    topic TEXT,\n    question_text BLOB,  -- Compressed\n    answers BLOB,\n    explanation BLOB,\n    last_reviewed INTEGER,\n    performance_score REAL,\n    FOREIGN KEY(topic) REFERENCES topics(id)\n);\n\nCREATE INDEX idx_topic_level ON questions(topic, level);\nCREATE INDEX idx_performance ON questions(performance_score);\n\n-- User progress (syncs bidirectionally)\nCREATE TABLE sync_queue (\n    id INTEGER PRIMARY KEY,\n    action TEXT,  -- 'quiz_completed', 'bookmark_added'\n    payload BLOB,\n    timestamp INTEGER,\n    synced BOOLEAN DEFAULT 0\n);\n

```\n\n**Why SQLite?**\n- Zero setup. Instant. ~300KB footprint.\n- Handles 100K+ records per device without breaking a sweat\n- Built-in on iOS and Android\n- Sync conflicts? We handle them client-side with timestamp-based resolution\n\n**Backend (PostgreSQL):**\n\n```

sql\n-- Aggregates user progress across 50K students\nCREATE TABLE user_performance (\n    user_id UUID PRIMARY KEY,\n    level_1_score REAL,\n    level_2_score REAL,\n    level_3_score REAL,\n    total_questions_answered INTEGER,\n    last_active TIMESTAMP,\n    device_type TEXT,  -- iOS, Android, Web\n    region TEXT  -- For performance tracking\n);\n\nCREATE MATERIALIZED VIEW topic_difficulty AS\nSELECT \n    topic,\n    AVG(performance_score) as avg_difficulty,\n    COUNT(*) as attempts,\n    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY time_spent) as median_time\nFROM user_attempts\nGROUP