Open to opportunities

Full-Stack Developer Building Fast, Scalable Web Applications

I design and build high-performance web systems using Next.js, TypeScript, and modern backend architecture—focused on performance, scalability, and clean code, with thoughtful integration of modern tools where they add real value.

Transactional Data Sync (Multi-Source Inventory)
await prisma.$transaction(async (tx) => {
  for (const store of prioritize(stores)) {
    const data = await fetchStoreData(store);

    await tx.inventory.upsert({
      where: { storeId: store },
      update: data,
      create: { storeId: store, ...data },
    });
  }
});

Cached Fetch with Revalidation
const getProduct = cache(async (id: string) => {
  return prisma.product.findUnique({ where: { id } });
});

export async function getProductCached(id: string) {
  return revalidateTag(`product-${id}`, () => getProduct(id));
}

Composable Service Pattern
const createOrder = (deps: Dependencies) => async (input: CreateOrderInput) => {
  const user = await deps.getUser(input.userId);
  const items = await deps.getItems(input.itemIds);

  return deps.db.order.create({
    data: buildOrder(user, items),
  });
};

Selected Work

A selection of projects focused on performance, scalability, and real-world impact.

Technical Strength

I focus on building production-ready systems with an emphasis on performance, scalability, and maintainability, applying modern engineering patterns to solve real-world problems efficiently. Below are some of the key engineering principles and patterns I apply in my work.

Performance & Optimization

Reduced unnecessary re-renders through optimized component structure and memoization strategies

Minimized layout shifts by constructing dynamic content off-DOM before injection

Centralized timezone and locale formatting to avoid repeated computation

Improved event handling efficiency using delegation patterns

Backend & System Design

Optimized database operations using transactional workflows and query batching

Designed APIs with clear separation of concerns and predictable data contracts

Ensured consistency across distributed operations through controlled sync strategies

Structured systems for scalability without unnecessary complexity

Frontend Engineering

Built scalable UI systems using component-driven architecture

Leveraged App Router patterns for efficient routing and data handling

Managed complex client state using lightweight state management

Focused on clean abstractions for maintainability

Intelligent Systems (AI Integration)

Integrated LLM APIs into structured workflows

Designed fallback and retry mechanisms for AI responses

Optimized request batching and caching to reduce cost

Core Technologies

A curated set of technologies I use to build scalable, maintainable, and high-performance applications.

Frontend

Building scalable UI and performant user experiences

Next.js (App Router, SSR, routing)

TypeScript (type-safe architecture)

Mantine (UI systems & components)

Backend

Designing reliable systems with strong data integrity

Node.js (API design & services)

PostgreSQL (relational data modeling)

Prisma (transactions, batching)

Tooling

Ensuring efficient workflows and consistent code quality

Git / GitHub (version control & workflows)

Vercel (deployment & edge delivery)

ESLint / Prettier (code quality & consistency)

Intelligent Systems

Designing structured AI integrations within scalable applications

LLM APIs (structured prompting, response handling)

Caching & batching strategies (cost and latency optimization)

Streaming responses (UX optimization)

Workflow integration (AI within user-driven and backend processes)

About

I’m a full-stack developer specializing in building scalable, high-performance web applications using Next.js, TypeScript, and PostgreSQL, with a focus on clean architecture and long-term maintainability.

I focus on writing efficient, maintainable systems—from optimizing Prisma transactions and structuring APIs to improving frontend performance and reducing unnecessary re-renders. I’m particularly interested in how systems scale and behave under load, and I prioritize clean architecture and predictable data flow.

Most of my work involves turning complex requirements into well-structured, production-ready applications with a strong emphasis on performance and reliability.

How I Approach Problems

A few principles I follow when building and optimizing systems:

Break systems down before writing code to avoid unnecessary complexity

Optimize for performance early, not as an afterthought

Prefer clear, maintainable solutions over clever abstractions

Design with scalability and data consistency in mind

Continuously refine and simplify existing implementations

4 +

Years of Real World Experience

20 +

Projects in Production

5700 +

Hours Spent in IDE

Interested in working together or hiring me?

I’m currently open to Full-time roles, Remote work, and Freelance projects.

contact@kevon.net

Based in Kenya

await prisma.$transaction(async (tx) => { for (const store of prioritize(stores)) { const data = await fetchStoreData(store); await tx.inventory.upsert({ where: { storeId: store }, update: data, create: { storeId: store, ...data }, }); } });

const createOrder = (deps: Dependencies) => async (input: CreateOrderInput) => { const user = await deps.getUser(input.userId); const items = await deps.getItems(input.itemIds); return deps.db.order.create({ data: buildOrder(user, items), }); };