Custom WebsiteDevelopment.
Websites and web apps written from scratch in React and Next.js, so the result does exactly what your business needs.
- #1042Complete
- #1043In progress
- #1044In progress
When what you have in mind doesn't fit any off-the-shelf system, we write it from scratch, usually in React and Next.js. Our own website is a custom project.
- Best for
- Businesses that want to stand out and need more than a standard presence.
- Typical timeline
- ≈ 4–8 weeks
The foundations of a custom build
Two different projects
The word custom covers two things that are entirely different from each other. Select each category to see the differences.
Website
A website where the design and the motion are the product.
Brands presenting into a market where every competitor looks the same.
5 to 8 weeks
- React
- Next.js
- GSAP
- WebGL
- Figma
You stand out in a market where everyone presents the same way. The site becomes the argument, not the brochure.
How we work on this
Week 1
What it has to do
The first conversation is about function: exactly what the thing that does not exist yet has to do, who uses it and how it responds in every case.
What you receive
- A technical specification of the function
- What the first version contains
- Cost estimate and timeline
What we need from you
One meeting with whoever actually knows the process we are automating.
Weeks 1 to 2
Design and prototype
We design in Figma and deliver a clickable prototype: you press through it and see how the app moves before a single line of code is written. Here a change takes ten minutes instead of three weeks later on.
What you receive
- Designs for every screen
- A clickable prototype
- Colours, typography and motion
What we need from you
Your comments on the prototype. The more specific they are, the more they help us.
Weeks 2 to 6
Build
We write the code in React and Next.js, with TypeScript so errors are caught as the code is written. We work in a staging environment you can open whenever you like, without waiting for a scheduled review.
What you receive
- Code in React and Next.js
- A staging environment with access for you
- The repository in your own name
Weeks 6 to 7
Speed and testing
We measure Core Web Vitals and fix whatever weighs them down. We test on real devices and with a keyboard, so the app works for every user, on whichever device they use.
What you receive
- Core Web Vitals measurements
- Tested on real devices
- Accessibility checked
What we need from you
Your final approval, once you have seen the app on your own device.
Launch day
Handover
The app goes live and the code is handed over to you in full, together with its documentation. If tomorrow you choose another partner, they will receive a clean repository and carry on from where we stopped.
What you receive
- Live, with the domain in your name
- Complete code and documentation
- 30 days of support at no charge
The tools
Pick a tool. Where there is real code from a project of ours, you see it exactly as it is, with its file and line number.
React
The library we build the interface from, in independent pieces: a button, a form, a product card. Each piece is written once and reused wherever it is needed, so the site can grow without being rebuilt.
- New features are added without disturbing what already works
- The same piece behaves identically everywhere it appears
- Maintenance happens in one place, not ten
8type Props = {9 children: React.ReactNode;10 className?: string;11 y?: number;12 delay?: number;13};14 15/**16 * Fade + rise on scroll-into-view. Opacity-only hiding keeps the content in the17 * accessibility tree and crawlable; reduced-motion shows it immediately.18 */19export default function Reveal({ children, className, y = 26, delay = 0 }: Props) {Next.js
The framework that assembles pages on the server in advance, instead of leaving the visitor's browser to build them. The page arrives ready, so it opens immediately and Google reads all of its content.
- The page opens instantly, even on a slow connection
- Google sees the content without waiting for it
- Images load at the size each screen actually needs
79alternates: {80 canonical,81 // Greek serves at the root; English is the fallback for everyone else.82 languages: {83 el: "/",84 en: "/en",85 "x-default": "/en",TypeScript
JavaScript with declared data types, so the computer checks the code as we write it. An error surfaces inside the editor, before the app has even run.
- The code is checked as it is written
- Changes stay safe to make, even months later
- The documentation falls out of the types themselves
89export type ServiceContent = {90 path: ServicePath;91 icon: ServiceCardIcon;92 tools?: ServiceTool[];93 processTitle: Localized<string>;94 process: Localized<ProcessStep[]>;95 contactService?: "custom" | "eshop" | "seo";96 meta: Localized<{ title: string; description: string }>;97 crumb: Localized<string>;98 hero: Localized<{Tailwind
The style system where colours, spacing and typography are defined once, centrally. Every page draws from the same catalogue, so the look stays consistent as the site grows.
- The brand is applied the same way everywhere
- One colour change carries across the whole site
- The stylesheet stays small, so the page stays light
31--color-canvas: #f4f4f4;32--color-canvas-deep: #ececec;33--color-panel: #ffffff;34--color-panel-lift: #fcfcfc;35--color-hairline: #e1e2e3;36--color-fg: #242424;GSAP
The library behind the motion: reveals on scroll, transitions between screens, elements that respond to the pointer. We tune it so every movement shows the visitor where they are and what just changed.
- Motion guides the eye to the next step
- Transitions stay smooth on every device
- Motion stops automatically when the device asks for it
31gsap.registerPlugin(ScrollTrigger);32const ctx = gsap.context(() => {33 gsap.set(el, { opacity: 0, y });34 ScrollTrigger.create({35 trigger: el,36 start: "top 88%",Figma
Here we design every screen of the app and link them into a clickable prototype. You try the flow with your own pointer before development starts, while a change still costs minutes.
- You try the flow before any code exists
- You comment on the actual screens
- Decisions are settled in the design, not in development
Vercel
The hosting platform that serves the site from the server nearest each visitor. Every change goes first to its own temporary link, so you can check it before it reaches the public.
- Fast loading wherever your visitors are
- Every change reviewed on its own link
- One click back to the previous version
APIs & databases
How the app talks to the systems you already use: bookings, stock, invoicing, ERP. Data passes automatically from one to the other, with permissions set per user role.
- Data is entered once and updates everywhere
- Each role sees what concerns them
- The history of every change stays on record
Frequently asked questions
Custom is worth it when what you are after is speed, a distinctive experience, or features that do not exist off the shelf. If you are not sure where your own project sits, we look at it together in the first conversation.
Yes, wherever you need to — we build in content management for the parts that change often, and show you how it works before launch.
The code belongs to you, entirely. Code, domain, hosting and every account are registered in your name from day one. If you ever continue elsewhere, you take all of it with you.
Tell us your idea and we'll design it together.
We reply within 24 hours with the first steps and a cost estimate.
Priced from analysis, never from a price list. Tell us what you have in mind and we will cost it both ways, so you can see in writing what each route gives you.
Get a quote