No WordPress.
Just personalized code.
No page builders, no plugin sprawl, no theme to fight. Every site is a hand-built application on a modern stack I know deep enough to bend. Here's exactly what runs under the hood — and why each piece earns its place.
WordPress & page builders
- Plugin stacks you don't control or understand
- Bloated markup, slow Core Web Vitals
- Security surface that needs constant patching
- Design boxed in by someone else's theme
Personalized code
- Every line written, read and owned by me
- Lighthouse-tuned, fast by construction
- Locked-down by design — no plugin lottery
- Pixel-exact design with zero compromise
Next.js — SSR & SEO, built in.
Every site is a Next.js app. Pages render on the server so the browser — and Google's crawler — receive complete HTML instantly, then only the interactive parts hydrate. I pick the render strategy per route: static where it can be, dynamic where it must be.
- App Router & Server Components
- SSG · ISR · SSR per route
- next/image optimisation
- Native i18n routing
- Metadata & structured data
- Edge-deployed on Vercel
<title>Nu — clean beauty, Antwerp</title>
<meta name="description"...>
<h1>Skincare, distilled.</h1>
Sanity — a dashboard built around the client.
Content lives in a Sanity Studio I tailor per client — decoupled from the front-end entirely. Editors update products, posts and imagery in a real-time interface; I query exactly the shape each page needs with GROQ. No developer in the loop for day-to-day edits.
// fetch only what the page renders *[_type == "product" && stock > 0]{ title, "slug": slug.current, price, "img": image.asset->url } | order(price asc)
[
{
"title": "Renew Serum",
"slug": "renew-serum",
"price": 48,
"img": "cdn.sanity.io/…"
}
]GSAP — motion on a timeline.
Every reveal, scroll chapter and hover flourish runs on GSAP. ScrollTrigger ties animation to scroll position and pins sticky sections; Draggable and MorphSVG make vector shapes grabbable and shape-shifting. It's the difference between a site that loads and one that moves — performance-budgeted, never gratuitous.
- ScrollTrigger scenes
- Sequenced timelines
- Draggable interactions
- MorphSVG shape tweens
- GPU-only transforms
- Reduced-motion aware
React — the component model.
Born at Facebook in 2013, React is how the entire UI is built: small, composable pieces of state-driven interface. Write a component once, reuse it everywhere, and the view always reflects the data. It's the layer everything else plugs into.
- Composable components
- Declarative, state-driven UI
- Hooks for logic reuse
- Huge, battle-tested ecosystem
├─ <Header>
├─ <ProductGrid>
│ └─ <ProductCard> ×24
├─ <Cart>
└─ <Footer>
TypeScript — errors caught before they ship.
Every line is typed. The compiler knows the shape of your data, your props and your API responses — so whole classes of bugs are caught in the editor, not in production. It's documentation that can't go stale and a safety net that never sleeps.
- Static type checking
- Editor autocomplete & intellisense
- Self-documenting contracts
- Safe, confident refactors
Tailwind — design tokens, not stylesheets.
Styling happens in the markup with utility classes mapped to a single design system — spacing, color, type all pulled from shared tokens. The result is consistent by default, tiny in production, and impossible to drift because there are no orphaned CSS files to rot.
- Token-driven utilities
- Zero unused CSS shipped
- Consistent spacing & scale
- Responsive in one place
The rest of the toolbox.
Everything else that ships on a typical build — chosen for the same reason: I know it well enough to own it.
Want this stack
behind your site?
From blank file to shipped product — on the exact tools above. Tell me what you have in mind.