Bagombeka JobSoftware Engineer

Ministry of Education & Sports, Uganda

Backend / Full-Stack Engineer — SMS ONE (U) Limited

Situation

Uganda's education sector ran on data that could not be trusted. National identity records and learner records lived in separate systems with no verification at the point of entry, so the same child could be registered several times across districts, school levels and academic years without anything catching it. The ministry could not state with confidence how many learners were in the system.

The reporting problem sat on top of the data problem. Staffing, enrolment and district performance were held in different places and reconciled by hand, which meant the figures behind budget and policy decisions were always a step behind reality — and never quite reconcilable with each other.

Task

Build the learner and workforce backbone of the national platform: a learners module that registers every child in the country against a verified identity, an HR module covering the teaching workforce, and a schema capable of modelling the entire sector without needing to be rebuilt as policy changes.

Around that, deliver the access control that decides who may see and change what across a multi-agency platform, the validation that keeps the data correct under national load, the reporting the ministry actually makes decisions on, and a public-facing register that opens school data to citizens.

Action

Built the national learners module in Laravel and Vue on a PostgreSQL schema exceeding 1,000 tables, and integrated NIRA national identity verification directly into the ingestion layer. That placement is the whole design: records are validated at the moment of entry rather than reconciled in a cleanup pass afterwards, so duplicates are rejected before they ever enter the register instead of being hunted down later.

Extended the same foundation across the sector. The HR module centralised nationwide staff records and integrated national workforce management, work permit and refugee data sources. The Admin Units module, built with Livewire, Filament and Alpine.js, gave structured school-to-location mapping across every administrative unit — the mapping national reporting depends on. The Infrastructure module captured school facility data countrywide and fed capital planning for the 2025/26 financial year, and a Water & Sanitation module extended the reporting surface to school utilities without compromising scalability.

Designed and documented the data model, the 1,000+ table schema, the SRS and the system architecture that became the reference specification for the delivery team. Modelled learners, staff, schools, administrative units, facilities and examination records with constraints, referential integrity and validation enforced at the database layer rather than left to application code, and established migration and versioning discipline so structural change shipped predictably across development, staging and production.

Built the cross-agency integrations in Python FastAPI, connecting NIRA for identity, UNEB for examinations, TMIS for teacher management, and the Office of the Prime Minister and Ministry of Finance — agencies that had never exchanged data before. Because those endpoints are undocumented and inconsistent, the clients are deliberately tolerant: retries, timeouts, idempotency keys and reconciliation routines, so a partner being down degrades a sync rather than corrupting local data.

Implemented role and permission management so ministry headquarters, district officials and individual schools each see and edit only their own scope, secured with OAuth 2.0 and token-based authentication and audit logging on sensitive operations. Opened the register to the public with a search across more than 90,000 school records — unauthenticated and read-only, so it had to stay fast under open traffic while exposing only what the ministry had cleared for publication — alongside the application flows that let schools and the public submit through the same platform.

Delivered the interfaces ministry staff and district officers use daily: data-heavy dashboards, validated bulk-entry forms in Vue, Livewire and Filament that reduce error at source, and list and report views tuned with server-side pagination, filtering and query optimisation so screens stay responsive against tables holding tens of millions of rows. Long-running imports, exports and notification workloads run on queue-backed background processing so they never block the request cycle.

• Laravel
• Vue
• PostgreSQL
• FastAPI
• NIRA Integration
• RBAC
• Reporting
• Public Search

Uganda, extending to Malawi

Co-lead Engineer — SMS ONE (U) Limited

Situation

Licensed private waste-collection companies ran their operations across disconnected tools — scheduling in one place, fleet somewhere else, billing and accounting in spreadsheets. No single product covered the whole operation for this market, so every operator improvised a different partial solution.

The regulatory shape made it harder. An operator works across several city authorities, each licensing and reporting on it separately, and money moves along two entirely different paths: the subscription an operator pays for the platform, and the collection fees its own customers pay it. Conflating those two is how this class of product usually goes wrong.

Task

Build a multi-tenant, multi-territory platform where each licensed operator runs its entire business — customers, scheduling, fleet, billing, payments and accounting — on its own subdomain, isolated from every other tenant.

Sit that under a control plane that onboards tenants, bills them for the platform and runs the shared infrastructure, while keeping the two money relationships strictly separate so the platform never takes custody of tenant funds.

Action

Built a Go modular monolith on Chi spanning 44 domain modules — operations, scheduling, fleet, containers, customers, contracts, procurement, payroll, HR, billing, payments, reconciliation and accounting among them — exposing 471 routes behind a generated OpenAPI 3.1 contract, so the API surface is documented by construction rather than by hand.

Isolated tenants with schema-per-tenant PostgreSQL backed by row-level security as a second line of defence, so a query bug cannot leak across tenants even if it escapes the schema boundary. Authentication runs through Keycloak OIDC with one organisation per tenant, and cross-module communication uses a transactional outbox published onto Pub/Sub — events commit in the same transaction as the data that produced them, so a crash between write and publish cannot desynchronise the system.

Implemented a native double-entry general ledger rather than bolting reporting onto invoice tables. It is multi-currency, tax-aware and billing-source-agnostic, so revenue recognised from a platform subscription and from a collection fee lands in the same books under the same rules. Per-country fiscalisation plugs into it — EFRIS for Uganda, MRA for Malawi — alongside Mobile Money settlement and UGX-first pricing, because a ledger that cannot satisfy the local tax authority is not finished.

Deployed on Cloud Run in africa-south1 for on-continent data residency, and drew the module boundaries so Payments, Telematics and the shared premise registry can be carved out into independent services later without a rewrite. A shared, resolve-only premise registry lets a customer move between operators without their address history being duplicated or lost.

• Go
• Chi
• PostgreSQL
• Keycloak
• Pub/Sub
• Vue 3
• Flutter
• GCP

Parliament of Uganda

Software Engineer — SMS ONE (U) Limited

Situation

Parliament of Uganda needed to reach very large contact bases reliably, on a platform where a failed dispatch is visible institutionally rather than quietly retried. Government communication has no tolerance for silently dropped messages.

The volume breaks the naive approach twice over. Per-message synchronous delivery collapses long before the contact base is exhausted, and a bulk upload of tens of millions of rows cannot be processed inside a request without the upload itself timing out.

Task

Build ingestion capable of absorbing tens of millions of contacts and delivery capable of dispatching against them without degrading the rest of the platform, under strict government security standards.

Make the pipeline observable enough to prove it is healthy — not merely to debug it after a failure, but to see saturation coming while there is still time to act.

Action

Built structured bulk ingestion for large contact uploads and a contact-management module that segments recipients by administrative unit, so a message can target a district or constituency precisely rather than being broadcast at everyone. Ingestion validates and stages rows outside the request cycle, so an upload of tens of millions of contacts never blocks the user who started it.

Moved delivery onto Kafka, decoupling ingestion from dispatch. Producers write regardless of how fast consumers drain, so a slow gateway or a burst of traffic degrades throughput instead of losing messages — the failure mode becomes a growing backlog, which is visible and recoverable, rather than silent message loss, which is neither.

Implemented and supported the delivery path itself through Kannel and SMPP gateways, diagnosing delivery failures, throughput bottlenecks and binding faults down to the gateway session level, and sustaining real-time delivery under the security standards government messaging is held to.

Instrumented the pipeline with Prometheus metrics and built Grafana dashboards over ingestion rate, consumer lag and delivery outcomes. Consumer lag is the signal that matters: it rises before delivery starts failing, so the dashboards show a problem forming rather than reporting one that has already happened.

• Laravel
• Go
• Kafka
• SMPP
• Kannel
• PostgreSQL
• Prometheus
• Grafana

Open-source Go library, sole author

Author and maintainer

Situation

Integrating an AI model into a Go service means writing the same 400 lines every time: request mapping, SSE parsing, retry with jitter, rate-limit backoff, token accounting, error classification. None of it is the product, and all of it has to be right.

Change vendor, or A/B two of them, and you write it again — this time with two subtly different implementations to keep in sync. Existing options either wrap a single provider, or wrap all of them behind an abstraction so lossy that the moment you need something vendor-specific you are back to writing it yourself.

Task

Write that layer once, properly, so switching between Claude, GPT, Gemini and 400+ other models is a one-line change rather than a rewrite.

Do it without imposing a dependency graph on anyone who imports it, and without the abstraction ever becoming a ceiling — a caller must always be able to reach what the provider actually returned.

Action

Designed one Request/Response shape across every vendor, with model IDs as pass-through strings. New models work the day they launch without waiting for a release, because the library never enumerates them. Every response also carries the untouched provider JSON, so the abstraction can simplify the common path without ever blocking a caller who needs something it does not model.

Kept the core module at zero external dependencies and split the chi HTTP gateway, the OpenTelemetry integration and the Anthropic adapter into separate Go modules. Importing the library pulls in none of them — a decision that costs release complexity, four modules instead of one, and buys every consumer a build free of dependencies they never asked for.

Unified SSE streaming with proper context cancellation and no goroutine leaks, and typed errors that work with errors.Is and errors.As so callers can branch on rate limits, context length or auth failures without string-matching. Retry with jitter, rate-limit backoff and token accounting are handled once, in the one place with enough context to do them correctly.

Backed it with the engineering the code implies: more than half the codebase is tests, 8 architecture decision records document the load-bearing choices, and a threat model, benchmark figures and a feature matrix state plainly what each adapter supports and what it silently ignores. The documentation site ships a snippet compiler that extracts every Go example, assembles each into its own package against a real checkout and type-checks it — so an example that cannot compile fails the build rather than misleading a reader.

• Go
• SSE Streaming
• OpenTelemetry
• Next.js
• Playwright
• GitHub Actions

React Native mobile app and Laravel API

Sole author

• React Native
• Expo
• TypeScript
• Laravel 13
• PostgreSQL
• WebSockets

B2B marketplace platform

Sole author

• Laravel 11
• Vue 3
• Pinia
• Tailwind CSS
• PostgreSQL
• RBAC