Things I've built

A production-grade Go API that enables users to upload documents and query them using AI, returning accurate answers with source citations via a Retrieval-Augmented Generation (RAG) pipeline.

DocIntelligence is a scalable, production-ready backend system that implements a full Retrieval-Augmented Generation (RAG) pipeline for intelligent document querying. The platform allows organizations (multi-tenant architecture) to upload documents such as PDFs, DOCX, and text files, which are asynchronously processed through an ingestion pipeline. Documents are semantically chunked, embedded using OpenAI models, and stored in PostgreSQL with pgvector for efficient similarity search. When a user submits a query, the system performs hybrid search, combining vector similarity and full-text search (BM25), to retrieve the most relevant document chunks. These chunks are then used to construct a grounded prompt for an LLM, ensuring responses are accurate, context-aware, and include source citations. The system is designed with production concerns in mind, including: Asynchronous background processing with Redis queues Multi-tenant isolation with API key and JWT authentication Rate limiting and structured logging Streaming responses via Server-Sent Events (SSE) Health and readiness probes for cloud deployment Fully documented API using Swagger This project demonstrates deep expertise in backend architecture, distributed systems, and applied AI, making it suitable for real-world SaaS applications such as legal document analysis, knowledge bases, and enterprise search systems.

An AI-powered job platform API built with FastAPI that connects applicants and employers — featuring OpenAI resume parsing, Google OAuth, JWT auth, Redis rate limiting, and a full CI pipeline with GitHub Actions.

A production-style job platform backend that handles the full hiring workflow on both sides of the marketplace. Employers create and manage job listings and review applicants. Applicants browse listings, upload resumes, and submit applications — with their resumes automatically parsed by OpenAI GPT to extract skills, experience, education, and a summary from PDF or DOCX files. Authentication supports both JWT and Google OAuth with role-based access control distinguishing employer and applicant flows. Rate limiting is enforced via Redis and fastapi-limiter to protect public endpoints. Database migrations are managed with Alembic, and the repository pattern keeps data access cleanly separated from business logic. The project ships with a full developer experience setup: Ruff and Black for linting and formatting, pre-commit hooks to enforce standards before every commit, Pytest for the test suite, and GitHub Actions workflows for CI that run tests, linting, and formatting checks on every push. The whole stack runs with a single docker compose up.

A multi-tenant ERP backend built with NestJS and TypeScript — covering inventory, purchasing, sales, double-entry accounting, FIFO costing, PDF invoice generation, and Google Sheets exports via a BullMQ worker service.

A production-style ERP system designed around strict tenant isolation, clean modular architecture, and real accounting flows. Every business table is scoped by tenantId, resolved per request via header or subdomain. JWT access tokens pair with refresh sessions stored in the database, and RBAC enforces per-tenant roles and permissions across all modules. The ERP covers the full procurement-to-payment cycle: create a purchase order, approve and receive it (which creates FIFO cost layers and stock movements), raise a sales invoice, mark it sent (which consumes FIFO layers, records COGS entries, and enqueues a background job), and record payment (which posts a double-entry journal entry and auto-marks the invoice paid). The worker service runs separately from the API and processes BullMQ jobs asynchronously — generating invoice PDFs in-memory with pdfkit, emailing them via Gmail SMTP, and exporting inventory snapshots to Google Sheets via a service account. All jobs include retry logic with exponential backoff and idempotency checks to prevent duplicate sends on retry. The accounting module implements a full double-entry ledger with a seeded chart of accounts per tenant, journal entries, and debit/credit lines using Decimal precision. Reports expose FIFO inventory valuation and sales summaries with revenue, COGS, and gross profit over any date range.

A FastAPI backend that uses OpenAI function calling to interpret natural-language instructions and orchestrate backend workflows — no hardcoded routing logic required.

Traditional backends are full of brittle if/elif dispatch trees that break every time requirements change. This project replaces that with an AI-powered orchestration layer — a single endpoint accepts any plain-English instruction, the agent figures out what to do, calls the right backend functions in the right order, and returns a structured result with a full audit trail. The core is an agentic loop: the instruction goes to GPT-4o, the model selects tools from a decorator-based registry, those tools execute in parallel via asyncio.gather, results feed back to the model, and the cycle repeats until a final answer is produced. Every run is persisted to the database with full tool call traces, iteration counts, and timing data. The registry pattern is the key design win — adding a new capability is one decorator and one import, with zero wiring elsewhere. The system ships with 10 registered tools across database operations, external API calls, and utilities, plus a full async stack, structured logging, retry logic with exponential backoff, and a pytest suite with mocked OpenAI responses.

A full-featured eCommerce backend built in Go — handling auth, products, cart, orders, reviews, and Mpesa STK Push payments. Features distributed rate limiting with Redis, structured logging, and full Swagger documentation.

Built with Go and the Chi router, this API powers a complete eCommerce workflow. It implements JWT authentication, product and category management, cart tracking, order processing, and product reviews with ownership validation. The highlight is a complete Mpesa payment integration — a Node.js microservice handles STK Push initiation and Safaricom callbacks, then notifies the Go backend which stores payment records and updates order status in PostgreSQL. The entire system runs in Docker Compose with four services: Go backend, Node.js Mpesa service, PostgreSQL, and Redis for distributed rate limiting.