Tech Stack

Why I lean to these technologies.

React

Pixel-perfect UI, server & client, SEO ready

React (with Next.js and Vite) is my default for product UI because it lets me move from a Figma frame to a pixel-perfect, accessible interface fast — without giving up performance. Server components and static generation keep pages SEO-ready and quick to first paint, while the client layer stays rich and interactive. The ecosystem is deep enough that I'm rarely reinventing anything, and mature enough that what I ship keeps working.

Node.js

Scalable microservices at speed

Node.js with TypeScript end-to-end means one language across the whole stack — shared types, shared validation, shared mental model. It's a pragmatic choice for scalable microservices: non-blocking I/O suits the request-heavy, integration-heavy services I build, and the tooling lets a small team ship and operate a lot of surface area without friction.

Graph Native

Graph-native data modelling, no N+1 queries

When the domain is really about relationships — people, projects, dependencies, recommendations — a graph database models it honestly instead of fighting a pile of join tables. Neo4j paired with a GraphQL layer (Apollo) lets the API shape match the data shape, so clients ask for exactly what they need in one round trip and the classic N+1 problem largely disappears.

Kubernetes and Cloud Services

Horizontally scalable, cloud-native, zero-downtime deploys

Kubernetes gives me a portable, declarative platform that runs the same on AWS, Azure or Google Cloud — so the architecture isn't hostage to one vendor. It's how I deliver horizontally scalable, cloud-native services with rolling, zero-downtime deploys, self-healing workloads, and a clean separation between application code and the infrastructure it runs on.

LLMs and Agent Harnesses

Semantic search, agentic tooling

Large language models unlock genuinely new product surfaces — semantic search, assistants, and agents that can take real actions. I stay model-agnostic across OpenAI, Anthropic, DeepSeek, Mistral and open weights via Hugging Face, and build on harnesses like LangGraph so the orchestration, tool-use and guardrails are explicit and testable rather than a black box.

Trustable Testing

Unit, API, and visual-snapshot E2E regression coverage

Confidence to ship fast comes from tests you actually trust. I layer Vitest for fast unit and API coverage with Playwright for end-to-end and visual-snapshot regression, so a change that breaks behaviour — or even just shifts a pixel — gets caught before users do. That safety net is exactly what lets me keep delivery velocity high without trading away reliability.