Websites and apps we write from scratch, not assemble.
Six build services covering the site you sell from, the app your customers install, and the load times that decide whether either one gets used. Our developers write it, your name goes on the repository, and nothing ships until it holds its performance budget.
Four things that are true of every build we ship
We write the code
No page builder doing the thinking behind the scenes, and no theme licence you have to keep renewing to stop your homepage breaking.
You own all of it
The repository, the hosting account and the domain are in your name from the first commit. Leaving us should cost you nothing but the notice period.
We build to your stack
If your team already runs WordPress, Laravel or a headless CMS, we build to it rather than around it, and we work alongside your developers where you have them.
Speed is a requirement
Every project carries a performance budget from the first sprint. A build is not finished until it holds that budget on a mid range Android phone.
Six services, and what each one actually covers
Most projects use two of these together, usually a build and the speed work that follows it. Read the one that matches what you are trying to do. If you are not sure which that is, describe the problem and we will tell you which service it belongs to, including when the answer is that you do not need us yet.
/custom-website-development
Custom Website Development
A site built outwards from the enquiry you want, not dropped into a theme and rearranged until it fits. We start by working out what a visitor has to understand before they will contact you, then build the shortest path that gets them there.
Everything is hand coded, so the site is not carrying the weight of features you will never switch on. Your team gets a CMS that edits the parts they should be editing and leaves the layout alone, which is why these sites still look right two years after launch.
- Discovery and page mapping
- Wireframes signed off before design
- Custom design, no stock template
- Hand coded front end
- CMS your team can edit safely
- Forms, tracking and CRM handover
- Accessibility pass to WCAG AA
- 30 days of fixes after launch
one offer, one button
proof before pitch
the objection they always raise
the form, in reach
/wordpress-development
WordPress Development
Custom themes and plugins for businesses already running on WordPress that have hit the ceiling of what a page builder can do. We build the theme from scratch so each page loads what it needs and nothing else, which is usually where the first second of load time comes back.
Where a plugin does not exist for what you need, we write one. Where eleven plugins are doing the work of three, we replace them and take the rest off the site. Editors get blocks that match your brand, so publishing a page does not turn into a fight with the layout.
- Custom theme built from scratch
- Gutenberg blocks in your brand
- ACF field setup for editors
- Custom plugin development
- WooCommerce builds and fixes
- Plugin audit and cleanup
- Migration off page builders
- Core, theme and plugin updates
plugins active
- SEO
- Forms
- Cache
down from 19
/react-development
React Development
Interfaces that behave like software rather than like pages. Booking flows, quote configurators, customer portals, dashboards and internal tools, where a full page reload in the middle of a task is how you lose the customer.
We build in TypeScript on a component library your team can extend, so the tenth screen costs a fraction of the first. State lives in one place, which is why filters, baskets and permissions stay in agreement instead of drifting apart by screen four.
- Component library and design tokens
- TypeScript across the codebase
- API integration and authentication
- Predictable state management
- Dashboards and admin panels
- Unit and end to end test coverage
- Code splitting and lazy loading
- Documented handover to your team
- <BookingApp>
-
- <DatePicker />
- <Filters />
- <SlotList />
-
- <SlotCard />
- <Basket />
/nextjs-development
Next.js Development
React that search engines can read on the first request. Next.js renders the page on the server, so what arrives is finished HTML rather than an empty container waiting for a JavaScript bundle to download and decide what to draw.
We choose the rendering mode per route instead of applying one setting to the whole site. Marketing pages come back from the edge cache in milliseconds, product pages rebuild themselves on a schedule, and the signed in half of the application stays dynamic.
- App Router architecture
- Server components and streaming
- Static, revalidated or dynamic per route
- Metadata, sitemaps and schema
- Headless CMS integration
- Image and font optimization
- Edge deployment and caching rules
- Core Web Vitals budget per route
| route | rendered | first response |
|---|---|---|
| / | static | full HTML |
| /services/[slug] | revalidated | full HTML |
| /blog/[slug] | revalidated | full HTML |
| /account | per request | full HTML |
/app-development
App Development
iOS and Android apps built from one shared codebase, so a change ships to both stores in the same release instead of being written twice and drifting out of sync by the third update.
We take on the parts that are easy to get wrong and expensive to fix later: push notifications that actually arrive, data that survives a tunnel with no signal, in app purchases that pass review, and the store submissions with their screenshots, listings and privacy declarations.
- One codebase, both app stores
- Native modules where they are needed
- Push notifications and deep links
- Offline first data and sync
- In app purchases and subscriptions
- App Store and Play Console submission
- Crash reporting and analytics
- Release management and staged rollouts
iOS
Android
/website-speed-optimization
Website Speed Optimization
Work on a site you already have, aimed at a green Core Web Vitals pass on the data Google collects from real visitors, not only at a lab score that looks good in a screenshot on your desk.
We profile the site before touching anything, so the effort goes where the milliseconds actually are. In most cases that is render blocking requests, images shipped at four times the size they display at, third party scripts nobody has audited in years, and a server that takes half a second to think.
- Full performance audit with findings
- Field data from real visitors
- Image and font delivery strategy
- Render blocking requests removed
- Third party script control
- Caching and CDN configuration
- Server response time work
- Monthly monitoring and alerts
where sites usually start inside the good range
How a build runs, week by week
You are never waiting a month to see something. There is a staging link from the first build week and a written note every Friday saying what moved and what is next.
Scope and map
We go through your current site, your recent enquiries and the competitors you keep losing to, then agree the page list and the job each page has to do.
Design
Wireframes first so the structure is settled cheaply, then the visual design. You approve every template before a line of production code is written.
Build
Front end, CMS and integrations, with a staging link you can open at the end of every week and a written note of what moved.
Test and launch
Browsers, phones, forms, tracking, redirects and a speed pass against the budget. We go live on a date you pick, not on a Friday afternoon.
Support
Thirty days of fixes are included. After that you can keep us on a monthly retainer for updates, monitoring and the next round of changes.
Timings above are for a typical marketing site. Apps, ecommerce and product builds are scoped separately, and you get the real number before you commit to anything.
Tell us what the site has to do
Send us the current site, or the idea if there is no site yet, along with what it needs to bring in. We will come back with the services that apply, what they cost, how long they take, and which parts you can leave until later.
The brief takes about five minutes. Nothing is charged and nothing is signed at this stage.