Open for Software Engineering Opportunities

Engineering Scalable Systems,
Robust APIs & Modern UIs

Nairobi, Kenya • Murang'a University of Technology CS

Hi, I'm Milton Odhiambo. I am a software engineer focused on building verified end-to-end applications—ranging from transactional database engines in C++17 and full-stack monorepos in NestJS & React, to asynchronous AI/NLP pipelines in Python & FastAPI.

Verified Stack & Specializations

TypeScript / React / Next.jsPython / FastAPI / NLIC++17 / Database EnginesNode.js / NestJS / ExpressPostgreSQL / MongoDB / PrismaDocker / CI/CD Pipelines
Drag 3D World to Rotate
Base: Nairobi, Kenya• EAT (UTC+3)
Global Remote Availability
50+

Active Repositories

Consistent Version Control & Projects

8+

Flagship & Systems Projects

C++17, NestJS, FastAPI & React 19

4+

Live Web & API Deployments

Deployed on Vercel, Render & Netlify

100%

CI/CD & Testing Rigor

Docker, GitHub Actions & Fuzz Testing

Demonstrated Ecosystem
TypeScriptReact 19Next.jsC++17PythonFastAPINestJSNode.jsPostgreSQLMongoDBPrisma ORMDockerGit
Engineering Background

Computer Science Foundations & Hands-On Delivery

I connect core computer science fundamentals—data structures, disk storage mechanics, and transaction recovery—with modern full-stack application development in TypeScript and Python.

Milton Odhiambo profile photo

Milton Odhiambo

Software Engineer

Nairobi, Kenya • Murang'a University CS Student • Builder of Systems, Full-Stack Apps & AI Microservices.

Full-StackC++ SystemsFastAPI & AI
Engineering Approach & Values
  • Evidence Over Claims: Every project listed has a working repository, tests, container configuration, or live deployment.
  • Defensive Architecture: From ACID transaction logging to JWT cookie rotation, security and crash consistency are treated as first-class constraints.
  • Continuous Verification: Automated CI workflows, Supertest suites, and fuzz testing ensure code remains maintainable and resilient.
Verified Certifications
Software Development Track CertificatePower Learn Project
Responsive Web Design CertificationfreeCodeCamp
JavaScript Algorithms & Data StructuresfreeCodeCamp
Introduction to CybersecurityCisco NetAcad
Cybersecurity EssentialsCisco NetAcad
Experience & Technical Track Record

Full-Stack & Systems Developer

Independent & Open-Source Projects

2024 - Present

Architected end-to-end full-stack applications, transactional database storage engines, and high-throughput AI microservices.

  • Authored LuminaDB, a transactional database engine in C++17 with slotted-page layout, ARIES WAL crash recovery, and in-memory B+Tree indexing.
  • Engineered the MicroJob Kenya monorepo with NestJS, Prisma ORM, PostgreSQL, React 19, Docker, and GitHub Actions CI pipelines.
  • Implemented production dual-token auth (short-lived JWT + HTTP-only cookie refresh rotation) on the Murang'a Events Reloaded platform deployed on Vercel.

Software Engineering Fellow

Power Learn Project (PLP)

2024

Immersive pan-African software development track focusing on Python, web technologies, relational databases, and collaborative agile engineering.

  • Collaborated on agile sprint teams utilizing Git/GitHub feature branches, code reviews, and automated deployment pipelines.
  • Engineered full-stack applications with modular API structures, database schemas, and client-side UI optimization.

BSc. Computer Science Student

Murang'a University of Technology

2022 - Present

Pursuing theoretical computer science and practical software systems engineering foundations.

  • In-depth focus on Data Structures & Algorithms, Systems Programming in C++, Operating System internals, and Database Management Systems (DBMS).
  • Applied concurrency control principles (optimistic locking, WAL logs, multi-threading) to standalone software engineering implementations.
Technical Competencies

Categorized by Demonstrated Engineering Use

No arbitrary percentage bars. Each capability below is substantiated by an active codebase, architectural component, or production service.

Core Programming Languages

TypeScript

MicroJob Monorepo, React 19, Next.js

Python

FastAPI, NLI, Groq Chatbot, Scikit-learn

C++ (C++17)

LuminaDB Storage Engine & B+Tree

JavaScript (ES6+)

Node.js, Express REST APIs, DOM

Java 17

Aura Document Processor & Gradle

SQL

PostgreSQL, Prisma, Schema Design

Backend & Systems Architecture

NestJS / Express.js

Modular Domain APIs & Middleware

FastAPI

Asynchronous Python Microservices

Storage Engines

Slotted-Page Files & Buffer Pools

Transaction Recovery

ARIES Write-Ahead Logging (WAL)

Authentication Security

Short-lived JWT & HTTP-Only Cookies

RESTful API Design

Clean Architecture & DTO Validation

Databases & Data Modeling

PostgreSQL

Relational Schemas, Constraints & Indexes

MongoDB & Mongoose

Document Modeling & Compound Indexes

Prisma ORM

Type-Safe Migrations & Relations

In-Memory B+Tree

O(log n) Key Lookup & Node Splits

Concurrency Controls

Optimistic Versioning & Isolation

Database Seeding

Kenyan Counties & Trade Classification

AI, Machine Learning & NLP

Natural Language Inference

Cross-Encoder Contradiction Scoring

Vector Similarity Search

Dense Sentence Transformers & Cosine

Groq LPU Acceleration

Sub-200ms Token Generation

LangChain

Sliding Conversational Context Buffers

Scikit-Learn & Pandas

TF-IDF Vectorization & Spotify Dataset

LLM Benchmarking

Inference Latency & Evaluation

Frontend Engineering & UI/UX

React 18 / 19

Component Architecture & Custom Hooks

Next.js (App Router)

Server Components & Static Generation

Tailwind CSS

Design Tokens, Dark/Light Theming

Progressive Web Apps

Service Workers & Mobile Caching

Framer Motion

Performance-Conscious Transitions

Responsive & Accessible

WCAG AA Contrast & Keyboard Navigation

DevOps, CI/CD & Testing

Docker

Multi-Stage Containers & Compose

GitHub Actions

Automated Supertest CI Pipelines

Fuzz Testing

ClusterFuzzLite & Jazzer Fuzz Targets

Cloud Deployments

Vercel, Render & Netlify

Linux & Bash

Shell Scripting & Process Management

Git Workflows

Feature Branches, Rebasing & Code Review

Engineering Depth

Core Architectural Capabilities

How I approach system design, database mechanics, security boundaries, and automated quality assurance.

API Design & Concurrency Control

REST & Scalability

Building production-grade RESTful APIs with strict boundary validation, rate limiting, and optimistic concurrency controls.

  • Dual-token authentication: Short-lived JWT access tokens + HTTP-only cookie refresh rotation.
  • Optimistic concurrency control with Mongoose/Prisma version keys to prevent race conditions during ticket booking and job escrows.
  • Strict DTO schema validation and uniform error serialization across NestJS and Express.
Verified in MicroJob Kenya & Murang'a Events Reloaded✓ Verified

Database Modeling & Storage Engines

C++17 & Relational DBs

Deep understanding of how databases actually work under the hood—from disk page layouts to index traversals.

  • Engineered slotted-page disk management allocating variable-length records on 4KB OS filesystem blocks.
  • Implemented in-memory B+Tree indexing with automatic internal/leaf node splitting for O(log n) lookups.
  • Designed relational PostgreSQL schemas with Prisma and high-throughput compound MongoDB indexes.
Verified in LuminaDB (C++17) & PostgreSQL Monorepo✓ Verified

AI, NLP & Inference Optimization

FastAPI & Embeddings

Developing evidence-first AI applications and optimizing inference latency for responsive user workflows.

  • Natural Language Inference (NLI) pipelines classifying statement consistency without editorial bias.
  • Dense vector embeddings via Sentence Transformers and cosine similarity nearest-neighbor search.
  • Sub-200ms LLM token generation utilizing Groq's LPU acceleration with LangChain conversational memory.
Verified in AuthenticityAI & Chatbot- on Render✓ Verified

Systems Reliability, CI/CD & Fuzzing

DevOps & Quality

Ensuring applications are defensively engineered, tested against malicious inputs, and containerized for deployment.

  • Write-Ahead Logging (WAL) with ARIES recovery ensuring zero state corruption after process crashes.
  • Automated GitHub Actions CI pipelines executing Supertest E2E integration test suites on pull requests.
  • Continuous fuzz testing harness integrated via ClusterFuzzLite and Jazzer to detect memory safety bugs.
Verified in LuminaDB, MicroJob CI & Aura Document Processor✓ Verified
Engineering Case Studies

Verified Systems, Monorepos & Deployed Applications

Every project below includes verifiable source code, technical architectural breakdowns, and working demonstrations where hosted.

Featured Flagship Monorepo
MicroJob Kenya – Informal Workforce Digital Marketplace
Full-Stack Monorepo • CI/CDFlagship Monorepo

MicroJob Kenya – Informal Workforce Digital Marketplace

Full-Stack Architect & Monorepo Engineer

An enterprise-grade monorepo marketplace bridging Kenya's informal workforce (fundis, electricians, masons, carpenters) with verified clients, secure escrow milestones, and county-specific geo-dispatching.

The Engineering Problem:

Over 80% of Kenya's working population operates in the informal sector, facing rampant wage insecurity, payment defaults, zero verified credentials, and high middleman exploitation.

NestJSTypeScriptPrisma ORMPostgreSQLReact 19ViteTailwind CSSDockerGitHub Actions

Project Explorer

Filter by engineering domain and architectural complexity

LuminaDB – Transactional Relational Database Engine in C++17
Systems Programming • C++17

LuminaDB – Transactional Relational Database Engine in C++17

Systems & Database Internals Engineer

A transactional relational-style database engine built from scratch in C++17, featuring slotted-page file layouts, in-memory B+Tree primary key indexing, ARIES-style Write-Ahead Logging (WAL), and a SQL parser/executor.

The Engineering Problem:

Traditional lightweight file stores lack ACID crash recovery, while standard SQL engines are monolithic black boxes that obscure low-level disk I/O, cache management, and lock contention.

C++17CMakeGoogleTestClusterFuzzLiteData StructuresSystems Architecture
theeBloggers – Modern SaaS Publishing Platform & Notion Block Editor
Full-Stack SaaS • Gemini AI • Stripe

theeBloggers – Modern SaaS Publishing Platform & Notion Block Editor

Lead Full-Stack Developer (PLP Capstone)

A production-grade SaaS publishing platform built to compete directly with Substack and Medium, featuring a Notion-style block editor, Google Gemini AI writing assistance, and Stripe creator paywalls.

The Engineering Problem:

Independent writers and journalists struggle with restrictive publishing platforms that charge exorbitant platform fees, lack modern block-editing ergonomics, and offer zero built-in AI writing workflows.

Next.js 16React 19TypeScriptPrisma ORMPostgreSQLStripeNextAuth v5Gemini 1.5 FlashTailwind CSSZod
AuthenticityAI – Evidence-First Political Statement Registry & NLI Engine
AI/NLP • FastAPI • Vector Search

AuthenticityAI – Evidence-First Political Statement Registry & NLI Engine

Lead AI & Backend Systems Developer

An open-source political accountability platform tracking public assertions over time using Natural Language Inference (NLI) and semantic vector similarity search without subjective editorial bias.

The Engineering Problem:

Political discourse suffers from widespread contradictions and historical misquotes with no tamper-resistant, evidence-backed tool for citizens and journalists to verify consistency across years.

PythonFastAPISentence TransformersNLI Cross-EncodersPostgreSQLDocker Compose
Murang'a Events Reloaded – Distributed Event & Ticketing Platform
Full-Stack • Deployed on Vercel

Murang'a Events Reloaded – Distributed Event & Ticketing Platform

Full-Stack Engineer & Backend Lead

A production-grade full-stack event orchestration and ticketing system featuring short-lived JWT access tokens with HTTP-only refresh cookies, Cloudinary asset pipelines, and QR code ticket delivery.

The Engineering Problem:

Event organizers suffer from registration bottlenecks, ticket overselling during peak traffic surges, and security vulnerabilities associated with local storage token persistence.

ReactNode.jsExpress.jsMongoDBMongooseJWTCloudinaryVercel
NYUMBA – Kenya-First Editorial Furniture Ecommerce Showcase
Frontend Architecture • Deployed on Vercel

NYUMBA – Kenya-First Editorial Furniture Ecommerce Showcase

Frontend Engineer & UI/UX Specialist

An editorial, high-performance ecommerce platform engineered specifically for contemporary Nairobi urban living, featuring interactive doorway spatial clearance calculators and M-Pesa STK push simulation.

The Engineering Problem:

Furniture buyers in Nairobi frequently face spatial mismatches (sofas failing to clear apartment elevators or narrow stairwells) and unexpected delivery surcharges.

React 18TypeScriptTailwind CSSLucide IconsViteVercel
Chatbot- – Low-Latency Conversational Assistant with Groq LPU
AI/FastAPI • Deployed on Render

Chatbot- – Low-Latency Conversational Assistant with Groq LPU

AI Backend Engineer

A high-throughput conversational AI microservice built with FastAPI, LangChain, and Groq's LPU acceleration, providing sub-200ms token generation and MongoDB Atlas persistent memory.

The Engineering Problem:

Standard cloud LLM endpoints exhibit 2-4 second response latencies that degrade conversational interactivity in technical assistant workflows.

PythonFastAPIGroq LPU APILangChainMongoDB AtlasUvicornRender
Spotify ML Recommendation Engine – TF-IDF & Cosine Similarity
Machine Learning • Python

Spotify ML Recommendation Engine – TF-IDF & Cosine Similarity

Machine Learning Engineer

A content-based music recommendation engine using TF-IDF vectorization and cosine similarity scoring over high-dimensional audio metadata.

The Engineering Problem:

Collaborative filtering recommendation systems fail for new tracks with zero listening history (the classic cold-start problem).

PythonFastAPIScikit-LearnPandasNumPy
Aura Document Processor – Structured Layout Engine in Java
Systems & Compilers • Fuzz-Tested

Aura Document Processor – Structured Layout Engine in Java

Core Systems Developer

A robust layout engine and binary document processor in Java featuring custom XON configuration parsers, LZ77 and Run-Length compression codecs, DOM graph query evaluation, and ClusterFuzzLite fuzzing.

The Engineering Problem:

Parsing complex user-uploaded document layouts often introduces memory corruption, denial-of-service loops, and unhandled edge cases in enterprise document workflows.

Java 17GradleClusterFuzzLiteJazzerAST ParsersCodecs
AI Evaluation & Model Benchmarking

LLM Code Auditing, RLHF Rubrics & Inference Verification

Interactive examples of how I evaluate model completions, audit systems code for subtle concurrency bugs, and benchmark inference pipelines across C++17, Python, and TypeScript.

Systems Code Evaluation • LuminaDB

C++17 Storage Engine Concurrency & WAL Audit

Ground-Truth Verified
Evaluation Task / Prompt Specification:

Implement TransactionManager::Commit(txn_id) ensuring ARIES Write-Ahead Logging durability before buffer pool pages are unpinned.

Baseline Completion (Hallucinated Ordering)Rejected
// FLAW: Unpins dirty pages BEFORE flushing WAL log!
buffer_pool_->UnpinDirtyPages(txn_id);
auto lsn = wal_->AppendCommitRecord(txn_id);
wal_->FlushAsync(lsn); // Race condition on crash

Root Cause Analysis: Violates the fundamental Write-Ahead Logging invariant: if the OS crashes before FlushAsync completes, dirty pages already evicted to disk cannot be rolled back.

Reference Ground-Truth (ACID Verified)Production Reference
// VERIFIED: Synchronous LSN flush prior to lock release
const lsn_t commit_lsn = wal_manager_->AppendRecord({
  .type = LogType::COMMIT, .txn_id = txn_id
});
wal_manager_->FlushToDisk(commit_lsn); // Blocks until fsync
buffer_pool_->UnpinDirtyPages(txn_id);

Engineering Verification: Enforces synchronous fsync up to commit_lsn before unpinning dirty pages. Verified against ClusterFuzzLite crash-recovery harness.

Scoring Rubric & Benchmark Telemetry
Evaluation DimensionBaseline ModelVerified ReferenceVerification Criteria
ACID Crash ConsistencyFail (Data Corruption)Pass (Strict WAL)Log record must reach non-volatile disk before page eviction.
Memory & Thread SafetyPartial (Race Condition)Pass (Deterministic)No unguarded asynchronous state mutation across threads.
Instruction Adherence60%100%Adheres to C++17 RAII and LuminaDB buffer pool contract.
Synchronized GitHub Feed

Active GitHub Repositories

Direct feed of repositories actively pushed and maintained on my GitHub profile.

Get In Touch

Let's Discuss Engineering Opportunities

I am actively seeking software engineering positions, international remote opportunities, freelance backend contracts, and technical AI benchmark roles. Feel free to reach out directly.

Send an Inquiry