The Stack I Build With

People ask what technologies I use. The honest answer is that the stack matters less than the reasoning behind it — but the tools still shape the work, so here's what I reach for, and why.

Nuxt and Vue

Every project starts with Nuxt. It gives me server-side rendering, file-based routing, and a component model that scales from a landing page to a full application. Vue underneath is clean and predictable — I never fight the framework.

Nuxt also handles what used to require separate tooling: SEO meta, image optimization, content management, internationalization. The module ecosystem is strong enough that I rarely build infrastructure from scratch.

TypeScript

Everything is typed. Not because I enjoy configuration, but because TypeScript catches the mistakes I'd otherwise find at three in the morning. It also makes code self-documenting — when I revisit a project months later, the types tell me what the original intent was.

Tailwind CSS

I use Tailwind for styling. It keeps the design system visible in the markup and eliminates the drift between design intent and implementation. When every spacing value, color, and font size lives in a shared configuration, consistency becomes automatic instead of just hoped for.

Custom CSS still shows up when I need precise animation control or complex layout behavior, but the foundation is always Tailwind.

GSAP

For motion, GSAP is the standard. ScrollTrigger handles scroll-based reveals, and the timeline API gives me frame-level control over sequenced animations. Performance stays solid even with dozens of animated elements on screen.

I use motion to clarify structure, not to decorate. A well-timed entrance tells the user where to look. A smooth transition protects spatial orientation. Animation without purpose is just distraction.

Convex

When a project needs a backend, I reach for Convex. It gives me a reactive database, server functions, auth, and file storage in one platform. The data model is TypeScript-native, so types flow from the database all the way to the component with no translation layer in between.

What makes Convex different is that it's real-time by default — queries update automatically when the underlying data changes. That removes an entire category of state-management problems and keeps the client simple.

Bun

Bun replaced Node for me: faster installs, faster scripts, faster dev-server starts. The difference is noticeable on every project, every day, and it runs the same JavaScript and TypeScript without any changes to the codebase.

Deployment

For projects I run myself, I deploy through Coolify on my own infrastructure. It gives me Docker-based deployments with a clean interface, automatic SSL, and full control over the environment — push to main, Coolify builds and deploys. No vendor lock-in, no surprise bills.

For client projects, the deployment target depends on their needs, but the principle stays the same: simple pipelines, no manual steps, no deployment anxiety.

Why this combination

These tools share one quality: they stay out of the way. Each solves a specific problem well without creating new ones in the process. That's the only criterion that matters when choosing a stack.

The result is a workflow where I spend my time on the product, not on tooling. When a client sees the final result, they should feel the craft in the experience — not the complexity behind it.