Skip to content
Dennis Ndung'u, the engineer behind CDenn

CDennDennis Ndung'uNairobi, working across time zones

I build operational systems that keep working.

I find the gap a business can feel, work out what closing it is worth, and build to that. Multi-tenant platforms, payments and reconciliation, offline-first products, AI-assisted operations.

React · Next.js · TypeScript · Node · Rust · PostgreSQL · Flutter · FastAPI

Open to workConfirmed 12 November 2026

Open to remote, hybrid and on-site engineering roles and selected consulting engagements. Available across time zones.

At a glance

  • Frontend Engineer at E&M Technologies since January 2025, leading frontend architecture and contributing to enterprise product development.
  • Three systems described in depth: Bancassurance (E&M Technologies client work), Opsis (independent CDenn work commissioned by two clients), and WarehouseLens (self-initiated personal project).
  • A broad engineering combination: TypeScript and Next.js across the frontend, Rust for an always-on control core, Flutter for field applications, and FastAPI and Python for data and model services.
  • Design system adopted across five teams: designed and built a shared component foundation approximately one year ago.
  • Two deployed systems you can explore: Opsis and WarehouseLens. WarehouseLens runs illustrative data, not customer operations.
  • Code: github.com/CDenn03

My work spans enterprise client delivery through E&M Technologies, independently commissioned projects through CDenn, and products I initiate and build myself.

Selected work

Three systems, presented in the order of my engineering journey. Each demonstrates a different kind of ownership: enterprise frontend architecture, independent end-to-end delivery and self-initiated product development.

SaaS / Fintech · E&M Technologies client work · Under NDA

Bancassurance Platform

At E&M Technologies, I worked as Frontend Lead on a multi-tenant platform for a financial services provider selling insurance through several bank partnerships.

The problem

The provider was selling through banks that compete with each other. Each one needed its own branding, products and compliance rules, with certainty that its customers would never be visible to a rival.

The obvious route was a separate copy of the system for each bank. That multiplies the maintenance bill, and the copies eventually drift apart.

The value mapped

One codebase, with partner boundaries enforced in the architecture rather than remembered by whoever writes the next query. That makes onboarding a new bank a configuration exercise instead of a separate release, while keeping the record of decisions available when finance or compliance needs it.

What was built in Bancassurance Platform and how it pays for itself
What was builtHow it pays for itself
Multi-tenant RBAC with tenant-scoped JWTsA new partner is configured rather than forked
Maker-checker approvals across seven entity typesDecisions have a defined review process before money or policies move
Action-level audit loggingWho did what, to which record, can be established without reconstructing events from application logs

What this proves

I can translate a complex partner organisation into a permission model, lead frontend architecture around those requirements and build interfaces that reflect how the business actually operates.

Code under NDA; architecture described, not shown.

The next big build took the same discipline somewhere very different: enterprise-grade reliability demanded by an organisation with neither an enterprise budget nor an ops team.

Media Tech / Self-Hosted · Independent CDenn work · Commissioned by two clients · In progress

Opsis

A self-hosted platform that monitors and controls a church's live-production stack. My first full end-to-end system: I owned the authentication contract, both services, the deployment and the hardware it runs on.

The problem

A volunteer team runs a live service every week. When the stream drops mid-service, the remote congregation is simply gone, and nobody in the room can diagnose it while the service is still running.

Commercial tooling assumes an operations team and a budget these organisations do not have.

The value mapped

Put the production stack behind one screen a volunteer can understand, and make it affordable to run on hardware already in the building.

The objective is reliable live production without the cost of hiring a dedicated operations team.

What was built in Opsis and how it pays for itself
What was builtHow it pays for itself
Next.js frontend and BFF over an always-on Rust control coreEach service verifies authentication independently against a shared contract
Live OBS integration over WebSocketOperators can control production rather than just watch it fail
Target: under 200 MB RAM and 5% idle CPUDesigned to run on hardware the organisation already owns
Docker Compose deploymentRepeatable deployment and handover without requiring me to be on call

What this proves

I can take a system from an authentication contract through two languages, live hardware integration and deployment, while designing around a resource budget defined before implementation.

Most recently, I've taken the same approach (find the gap, map the value) into AI-assisted operations.

SaaS / Logistics / AI · Personal project · Deployed with illustrative data

WarehouseLens

The most recent application of the same discipline: a multi-tenant warehouse operations platform covering inventory, procurement and outbound logistics.

This is a self-initiated product project, deployed and reachable, running illustrative data rather than a customer's live operations.

The problem

A warehouse manager who needs to know which supplier is slipping or what to reorder this week often has to ask an analyst and wait. By the time the report arrives, the decision may already have been made on instinct.

The tempting fix, letting a language model query the warehouse directly, trades that delay for a worse risk: answers nobody can audit, drawn from data the asker was never cleared to see.

The value mapped

Natural-language answers backed by approved tools rather than model-generated queries, with permissions checked inside the agent. An out-of-scope question is refused rather than answered.

The goal is to make operational decisions easier to investigate without opening up unrestricted access to warehouse data.

What was built in WarehouseLens and how it pays for itself
What was builtHow it pays for itself
Natural-language copilot with tool routing; the planner writes no SQLAnswers trace to approved, parameterised queries
Six roles across 21 warehouse-scoped permissionsQuestions outside someone's remit are refused
Prophet and XGBoost forecasting with rolling-fold backtestingForecasts are evaluated against held-out history before being presented
Next.js BFF over FastAPI with a background aggregation workerTokens stay out of client JavaScript; data processing stays separate from interactive requests

Honest status

Deployed and reachable, running illustrative data rather than customer operations.

What this proves

I can put a language model inside a permission system rather than beside it, and validate a forecast before presenting it as one.

Other work

Other systems demonstrate the same engineering approach across different business contexts:

  • Ndoa Plan - financial governance and payment reconciliation.
  • Sefer - offline-first field tools.
  • Mathesis - offline-first product development.
  • Near Field - offline-first field applications.
  • Email Refiner - a browser extension that works inside the live Gmail interface.
View all work

How I work

Start from the gap, not the stack.

The work usually turns on something a business can feel: a bank partnership that would expose another bank's customers, money arriving twice that finance cannot reconcile, or a sales team losing a working day to a dead zone.

Name the problem first and the technology argument mostly settles itself.

Map the solution and anticipate the result.

I work out what the solution needs to do before writing code. What happens when something goes wrong? Who notices? What does it cost? How will the people using it know what to do next?

These are questions worth answering before the first commit, not discovering during the first incident.

Improve what exists, with value in mind.

Not every problem needs another feature. Much of my work has involved strengthening existing systems rather than removing functionality.

At E&M, that has meant extending approval workflows to support edit requests, multi-step decisions and change history; establishing better deployment foundations; and improving the way frontend decisions account for user experience.

Good engineering is collaborative. I've had the opportunity to work with a strong team, and I value improvements that make the product and the people building it better.

Own the result, not just the ticket.

That has meant leading frontend architecture on a bank-partnership platform, building a browser extension that works inside live Gmail, establishing Docker foundations for a deployment pipeline, and taking Opsis from an authentication contract to a deployed system running on physical hardware.

Build systems that pay for themselves. Ship products that work. Own the outcome.

Working across React, Next.js, TypeScript, Node, Rust, PostgreSQL, Flutter and FastAPI.

Experience

January 2025 - Present

Frontend Engineer

E&M Technologies

  • Led frontend architecture for the core product using React and Next.js, owning architectural decisions and establishing patterns that support consistent product development.
  • Designed and built a shared design system, adopted across five teams approximately one year ago, giving teams a consistent component foundation for new interfaces.
  • Built a self-service customer portal with chat, extending how customers interact with the platform and access support.
  • Designed an approval model supporting maker-checker workflows, edit requests, multi-step approvals and change history, giving complex business decisions a structured and traceable process.
  • Established Docker deployment foundations for a monorepo combining frontend and backend applications that previously relied on JAR and dist deployments. The DevOps team subsequently implemented the deployment pipeline using this foundation.
  • Drove requirements with backend and product teams, translating business rules into interfaces and resolving ambiguity before implementation.
  • Introduced TypeScript patterns and reusable component structures into legacy code, making the codebase easier to understand and safer to extend.
  • Helped shift frontend decision-making towards a stronger UX focus, encouraging implementation choices to account for how people actually use the product.

Technologies: React, Next.js, TypeScript, TailwindCSS, REST APIs, Docker.

CDenn is my independent engineering practice. I work at E&M Technologies and take commissioned client work under CDenn alongside it.

Start a conversation.

Hiring?

Tell me about the team, the product and the problems you're working through. I'll reply with the work closest to what you need and my CV if you'd like it.

Need something built?

Tell me what's getting in the way. I'll reply with what I think the actual problem is and how I'd approach it.

Good fits for a first conversation

  • A frontend that needs an owner, not just a ticket-taker.
  • A payments or reconciliation flow where accuracy matters as much as speed.
  • A platform serving client organisations that need real roles, permissions and isolation.
  • A product that must keep working through patchy connectivity.
  • An AI feature that needs human review, controlled access and traceable answers.

How a client engagement starts

We begin with scoped, paid discovery. I work with you to understand the business problem, explore possible solutions and define the scope before committing to a full build.

The outcome is a clearer understanding of the problem, the proposed approach and the work involved before making a larger commitment.

I usually reply within one working day.

Nairobi, Kenya - working across time zones.