Skip to main content
Open to select collaborations

Kenya · FigBloom Digital Group

Ancel Ajanga

Senior Software Engineer

I build and strengthen the systems people depend on — across software, infrastructure and day-to-day operations.

Currently

Senior Software Engineer at FigBloom Digital Group

November 2026 — Present · Production systems, IT operations and durable engineering.

View experience

Also contributing part-time as an AfterQuery Expert Software Engineer (2026–Present).

Engineering identity

The kind of engineer I am

Derived from production ownership and the systems documented in Selected Work — not personality marketing.

  1. 01

    Production ownership

    Take software from requirement framing and domain modeling through backend/frontend implementation, security hardening, deployment and post-release support.

  2. 02

    Transactional & operational integrity

    Ledgers, row-locked state transitions, idempotent workflows and append-only audit trails — systems where wrong state is expensive.

  3. 03

    Failure-aware integration boundaries

    Server-side integration boundaries, response normalization, circuit breakers, rate limiting and explicit recovery paths.

  4. 04

    Domain-separated modular systems

    Modular monoliths in Go and Laravel, three-tier storage splits and clear contracts between mobile/web clients and backend APIs.

  5. 05

    Policy & permission enforcement

    Role-based access control, approval hierarchies, anonymous-submission privacy firewalls and OPA-gated infrastructure execution.

Selected work

Systems that show how I think

Prioritized by engineering significance — decisions and tradeoffs, not badge rows.

01 · Mobile Engineering · Kotlin Multiplatform · API Architecture

Mobile Token Retrieval Experience

Lead Software Engineer (Mobile & Backend Architecture)

  • Kotlin Multiplatform
  • Compose Multiplatform
  • Ktor Client
  • PHP
  • Laravel
  • REST API
  1. KMP / Compose Multiplatform client
  2. Laravel modular monolith REST API
  3. Request validation + rate limiting
  4. Server-side upstream token-record adapter

Problem

Customers needed a reliable self-service channel to retrieve previously purchased prepaid electricity tokens when standard SMS delivery failed or when recent token details needed to be looked up directly on their mobile device.

What was built

A hosted customer-facing Kotlin Multiplatform and Compose Multiplatform mobile application backed by a modular Laravel REST API that mediates retrieval workflows against an existing upstream token-record system.

Decision that mattered

Separated token retrieval from the system of record via a dedicated Laravel API boundary that keeps upstream credentials server-side, validates meter inputs, enforces per-instance rate limiting, and dispatches analytics recording after the HTTP response.

Tradeoff

Accepted maintaining an intermediate backend API service rather than direct mobile-to-upstream calls to guarantee credential isolation, uniform response contracts, and independent rate-limit controls.

Outcome

Hosted production application rolled out to all users on 1 November 2026 and actively used by customers to retrieve primary-meter and submeter token records.

Hosted production system rolled out to all users on 1 November 2026; architecture documented in case study.

02 · Go · PostgreSQL · Modular Monolith · Enterprise Systems

Internal Operations & Accountability Platform

Systems Architect & Lead Full-Stack Engineer

  • Go
  • Chi Router
  • PostgreSQL
  • pgx v5
  • sqlc
  • Next.js
  • TypeScript
  • Docker
  1. Next.js 14 App Router + TanStack Query
  2. Go modular monolith (Chi + sqlc + pgx v5)
  3. PostgreSQL 16+ ACID + SELECT FOR UPDATE
  4. Transactional Outbox + FOR UPDATE SKIP LOCKED workers

Problem

Asset custody, incident escalation, departmental weekly reporting, and employee feedback were fragmented across spreadsheets and informal message threads without permission boundaries or audit trails.

What was built

A hosted internal operations platform built with a Go modular monolith backend (Chi, pgx v5, sqlc, PostgreSQL 16+) and a Next.js 14 App Router frontend unifying assets, incidents, reporting, governance, and RBAC.

Decision that mattered

Chose a Go modular monolith with eight business modules, nine PostgreSQL schemas, sqlc compile-time SQL verification, optimistic concurrency for mutable entities, a Transactional Outbox with FOR UPDATE SKIP LOCKED worker queue, and an explicit anonymous-submission firewall.

Tradeoff

Chose a modular monolith and PostgreSQL-backed outbox over distributed microservices and external message brokers to eliminate cross-service distributed transaction failure modes and reduce operational overhead.

Outcome

Hosted internal enterprise platform actively used in daily operations for asset custody tracking, incident tracking, departmental reporting, and auditable approvals.

Hosted internal enterprise system; architecture documented in case study.

03 · Secure messaging · Real-time · Privacy

Inkly

Lead Systems Architect & Full-Stack Developer

  • WebSockets
  • PostgreSQL
  • MongoDB
  • Redis
  • Cryptography
  1. Clients ↔ WebSocket cluster
  2. Redis coordination / rooms
  3. PostgreSQL durable state
  4. MongoDB event / log store

Problem

Centralized messaging models struggle to combine zero-knowledge privacy with horizontal real-time scale.

What was built

A high-availability secure messaging architecture with cryptographic lifecycle controls and three-tier storage (PostgreSQL, MongoDB, Redis).

Decision that mattered

Separated hot path delivery from durable truth: Redis for coordination, PostgreSQL for relational integrity, MongoDB for flexible event/log shapes.

Tradeoff

Accepted storage complexity to keep privacy boundaries and delivery resilience independent under partition.

Outcome

Production-oriented architecture for low-latency real-time delivery patterns with resilient storage separation.

Architecture documented in case study; public repo not available.

04 · Infrastructure · AIOps · Policy

Aegis

Systems / Infrastructure Engineer

  • OPA
  • Agents
  • Zero-Trust
  • OpenTelemetry
  1. Control plane proposes intents
  2. OPA / signed intent gate
  3. Agents pull tasks
  4. Shadow mode before autonomy

Problem

AI-driven remediation can act faster than operators can trust — creating a gap between automation and safety.

What was built

An autonomous infrastructure guardrail system where suggestions are gated by Open Policy Agent rules and signed intents.

Decision that mattered

Pull-based agents with OPA-evaluated signed intents so the control plane can propose work but cannot push execution into a cluster.

Tradeoff

Chose pull latency (seconds) over push speed to keep inbound cluster attack surface closed and policy declarative via GitOps.

Outcome

A pull-based control plane pattern that keeps remediation policy-bound. Work in progress; architecture published in the case study.

In progress — see case study and architecture docs.

05 · Fintech · Multi-tenancy · Audit

LedgerX

Full-Stack Software Engineer

  • Next.js
  • NestJS
  • PostgreSQL
  • Prisma
  • MongoDB
  1. Next.js + NestJS
  2. PostgreSQL ledger / orgs
  3. MongoDB activity logs
  4. Payment adapters + circuit breakers

Problem

Financial operations need invoicing, payments, double-entry accounting, audit and fraud signals in one coherent system.

What was built

A multi-tenant financial platform spanning invoicing, payments, ledger correctness, compliance hooks and diagnostics.

Decision that mattered

PostgreSQL for transactional/compliance data; MongoDB for high-volume activity logs; in-process domain events for audit and diagnostics.

Tradeoff

Kept an in-process event bus instead of an external queue to reduce moving parts while documenting single-process limits.

Outcome

A production-grade platform case study covering ledger-backed workflows and multi-tenant financial operations.

06 · Fintech · Payments · Resilience

NestFi

Full-Stack Software Engineer

  • NestJS
  • PostgreSQL
  • M-Pesa
  • Redis
  1. PostgreSQL transactional ledger
  2. MongoDB audit / callback events
  3. Redis coordination locks
  4. Idempotent Daraja adapters

Problem

Mobile money and async payment flows fail in ways that corrupt wallet state when correctness is treated as optional.

What was built

A financial coordination platform with ledger-first wallets, idempotent M-Pesa integration and hybrid storage.

Decision that mattered

Balances derived from ledger entries (not mutable columns); pending→settled payment flow with Redis locks for withdrawal coordination.

Tradeoff

Chose PostgreSQL ACID for the ledger over NoSQL convenience — eventual consistency is unacceptable for money movement.

Outcome

Correctness-first payment architecture documented for high-risk, low-trust payment environments. In progress.

In progress — architecture docs available via case study links.

Experience

Where the work happens

Current production ownership first. Previous engineering leadership, independent and progression context stays secondary — full detail on the experience page.

Current

  1. November 2026 — Present

    Kenya

    Senior Software Engineer

    FigBloom Digital Group

    Design, build and maintain production software systems across backend, full-stack and operational architectures. Focus on reliable service boundaries, transactional data integrity, clear API contracts and maintainable product delivery.

    • Architect and deliver full-stack and backend features across production web and API platforms.
    • Enforce transactional integrity, structured access control and explicit failure handling across service boundaries.
    • Collaborate across product and engineering to ship maintainable, well-documented software systems.
  2. April 1, 2026 — Present

    Remote

    Expert Software Engineer

    AfterQuery Experts

    Contribute part-time as an AfterQuery Expert Software Engineer (April 1, 2026 — Present) alongside full-time engineering work.

    • Applies production engineering judgment in expert software engineering contributions.

Previous

  • Lead Software Engineer & Head of IT

    Utility Metering Solutions (UMS Kenya)

    August 2026 – 3 November 2026

  • Independent Systems Engineer & Fullstack Developer

    Independent practice

    2024 — 2026

  • Engineering progression

    Self-directed practice & earlier freelance delivery

    2021 → 2026

View full experience

How I build

Engineering depth without a case-study wall

Principles a senior engineer can scan — each tied to systems already on this site.

Data integrity first

In financial and operational systems, balances, custody state and approvals are enforced inside ACID transactions with explicit row-level locks and append-only audit records rather than mutable shortcuts.

Evidence · Internal Operations & Accountability Platform · NestFi · LedgerX

Isolate integration and failure domains

External systems of record, payment callbacks and real-time channels fail in distinct ways. I place normalized backend API boundaries and transactional outboxes between clients and upstream dependencies.

Evidence · Mobile Token Retrieval Experience · Inkly · NestFi

Enforce permissions and privacy in the data model

Role-based access control, multi-step approval hierarchies and anonymous submission firewalls are enforced at the service and database boundary rather than hidden only in the UI.

Evidence · Internal Operations & Accountability Platform · Aegis

Ship with explicit architectural tradeoffs

Modular monolith vs microservices, sqlc vs ORM, server-side mediation vs direct client access — I document the operational constraint that drove each decision.

Evidence · All Case Studies

Prefer interactive experiments? Open Labs.

Engineering

Capability, grouped by how systems are built

Technologies that appear in shipped work and case studies — not every package ever imported.

Frontend

  • React
  • Next.js (App Router & Pages Router)
  • TypeScript
  • Tailwind CSS
  • Radix UI / shadcn/ui
  • TanStack Query
  • Kotlin Multiplatform
  • Compose Multiplatform
  • Flutter

Backend

  • Go (Chi, pgx v5, sqlc)
  • PHP (Laravel)
  • NestJS
  • Node.js
  • Express
  • Django
  • REST APIs
  • WebSockets
  • Modular Monolith Architecture

Data

  • PostgreSQL 18 (prod) / 16+ (local)
  • MySQL / MariaDB / SQLite
  • MongoDB
  • Redis
  • Prisma
  • sqlc
  • Transactional Outbox
  • Transactional Outbox (FOR UPDATE SKIP LOCKED)

Infrastructure

  • Docker & Docker Compose
  • Linux VPS Administration
  • Kubernetes
  • CI/CD (GitHub Actions)
  • Cloudflare
  • Android Release Signing (R8)

Architecture

  • Modular Monolith Design
  • Domain-Driven Boundaries
  • Multi-tenant SaaS
  • Event-driven Design
  • Idempotency & Concurrency Control
  • Hybrid Storage

Reliability and Security

  • RBAC & Permission Matrix Enforcement
  • JWT & Refresh Token Rotation
  • CSRF Protection & Security Headers
  • Rate Limiting & Request Validation
  • Audit Trails & Row-Level Locking
  • Circuit Breakers & OPA Policy Gates

Prefer charts and project mappings? Open the full stack page.

Collaboration

How I work with teams

Open to a small number of thoughtful collaborations involving reliable software, operational systems and technically demanding product work.

End-to-end product ownership

I take software from operational problem analysis and domain modeling through backend/frontend implementation, security hardening, deployment and production rollout — including Senior Software Engineer delivery at FigBloom Digital Group.

Tradeoffs are documented

Expect explicit decisions: why a modular monolith or service split, why this consistency model, how upstream credentials are isolated, and what breaks first under load.

Select collaborations

Open to a small number of thoughtful collaborations around reliable software, operational systems and technically demanding product work.

Labs

Where I pressure-test ideas

Experiments framed as hypotheses and constraints — not random animations.

Policy-gated remediation

In progress

Can AI suggest infrastructure fixes without being allowed to execute unsafely?

Pull-based agents · OPA · signed intents

Learned: Shadow mode is a trust prerequisite before autonomy.

Related case study

Correctness under async payments

In progress

What happens to wallet state when M-Pesa callbacks arrive late, twice, or never?

Ledger-first balances · idempotency · Redis locks

Learned: Pending→settled beats optimistic credit for money movement.

Related case study

Privacy vs horizontal realtime

Live architecture

Can zero-knowledge messaging still scale across WebSocket clusters?

3-tier storage · cryptographic lifecycle

Learned: Separate delivery coordination from durable truth stores.

Related case study
Ancel Ajanga, Senior Software Engineer

About

How I approach software

I build systems the way I want to operate them later: clear boundaries, explicit failure modes and data that stays trustworthy under load and partial outage.

The work I enjoy sits at the intersection of product engineering, operations and architecture — financial and utility workflows, real-time collaboration, multi-tenant isolation and infrastructure that can be reasoned about.

Based in Kenya. Senior Software Engineer at FigBloom Digital Group in Kenya — building and strengthening production systems people depend on. I currently serve as Senior Software Engineer at FigBloom Digital Group, previously served as Lead Software Engineer & Head of IT at UMS Kenya, and contribute part-time as an AfterQuery Expert Software Engineer (April 1, 2026 — Present).

Contact

Start a conversation

Open to a small number of thoughtful collaborations involving reliable software, operational systems and technically demanding product work.