The usual small business site is nineteen plugins in a trench coat: a theme someone bought, a builder to arrange it, a slider, a form, a cookie banner, and a chat widget added last summer. Each one is code you didn't write, can't read, and have to keep updated forever. We build the other kind — written by hand, only as large as the job requires, with the systems you already use connected properly instead of copied across by someone on a Friday afternoon.
These are the four things people arrive with once a site has been live for a year or two. None of them is a design problem — every one of them was decided by how the thing was built.
Nineteen extensions, each written by someone else, each with its own update schedule and its own opinion about your markup. Half of them exist to patch the other half, and the day one of them stops being maintained becomes your problem rather than its author's.
Spacing invented on the spot, hover states missing, the mobile layout squeezed rather than laid out, and the empty and error screens never built at all. The design was approved in Figma and then quietly renegotiated in the browser, without anyone being told.
Bookings arrive in one place, the newsletter list lives in another, invoices in a third, and someone spends Friday afternoon copying rows between them. The website sits next to all of it, connected to none of it.
A tracking script here, a chat bubble there, a hero video nobody compressed — and a homepage that now weighs four megabytes. Nothing broke, so nobody noticed; the visitors on mobile data noticed, and they left before the first line of text arrived.
Every build runs the same way: we agree what is built and what is connected before anything is written, the work goes up on a staging URL from the first week, and what we hand over is a repository you own rather than a login to a platform we do.
No page builder, no theme licence, no framework of someone else's compromises. The design implemented as drawn, including the screens nobody enjoys drawing.
The point of connecting two systems is that nobody has to retype anything. Every integration we build replaces a task someone was doing by hand.
Speed and accessibility are decided while the code is written. Bought back afterwards, they cost several times as much and never fully arrive.
The handover is the part that decides whether the site is still true in a year — and whether the next developer thanks us or curses us.
None of these is a homepage with sections. Each one existed to make a specific thing happen — a booking taken, an order confirmed, a table read at a glance — and the code was written for that.
An admin interface for an e-commerce platform, where every component was drawn rather than imported. Empty, loading and error states are implemented, not left for the browser to improvise on the day the API is slow.
Service, date, time, confirmation. The form writes into a real calendar, holds the slot while the visitor finishes, and sends the confirmation email — so the same slot can't be sold twice and nobody has to answer a message about Thursday.
Every service, duration and price rendered from content the owner edits, not typed into the markup. Changing a price is a field and a save, which is why the prices on the site are still the real ones a year later.
A wedding built as a single page: six stages of the day, two venues, and an RSVP that lands in a sheet the couple could read. Opened on hotel wifi, on phones five years old, in two languages.
What the site has to do, what already exists, and which tools you're not willing to give up. If you have a design, we look at it here and say plainly which parts will need a decision in the browser. You leave knowing the shape of the build — including in the cases where the honest answer is that you don't need one.
What gets built, what gets connected, where the content lives, where it's hosted, and what it costs to run per month. Written down before any code exists, because this is the document that stops a project growing sideways — and it's what the fixed quote is based on.
Hand-coded from the approved design, on a staging URL you can open from day one and watch fill in. Tested on real devices as it goes. Speed, search structure and accessibility are part of writing the code, not a phase bolted on at the end.
Domain, hosting, analytics and Search Console connected, old URLs redirected so you keep the rankings you already have, then a walkthrough of the CMS. We stay on hand for the first month, and the repository is yours from the first commit.
You already have the design. We build it, and it behaves the way it looked.
The usual choice — a site with a CMS behind it and the tools you already use connected to it.
When the site is the product: an online shop, a booking engine, an area customers log into.
Prices are starting points and move with the number of templates and how much the site has to do — not with how long it takes us. You get a fixed quote after the technical plan. Smaller jobs — a single landing page, one integration, or a speed and technical-SEO pass on an existing site — start at €350 and are quoted on their own. Hosting, domains and third-party services are paid directly to the provider, and usually come to between €10 and €60 a year for a site of this kind.
Yes — that's the Design to Code package. Figma is easiest, but any file we can open and measure works. Before quoting we go through it and flag the parts that don't survive contact with a browser: text that only fits at that exact length, layouts with no mobile version, and the empty, loading and error states that almost never make it into the file. Better to settle those in a conversation than to invent them silently while building.
Vue and Nuxt for anything with a CMS or an application behind it, and plain HTML, CSS and JavaScript when a site genuinely needs nothing more. Hosting is on an edge network, so pages are served close to the visitor. No WordPress theme, no page builder, no plugin stack — which is why there's nothing to keep updated after launch.
Often, yes. If it's hand-coded or on a modern stack, we can take it over, add to it, and speed it up. If it's a theme carrying a dozen plugins, rebuilding is usually cheaper within the first year than patching around it — and we'll tell you which of the two it is after looking, not before.
You do, entirely. The repository is in your account from the first commit, hosting and domain are registered in your name, and there's no licence, no lock-in and no monthly fee owed to us. If you ever hand the site to a different developer, they get a codebase with comments and a README rather than an archaeological site.
Anything the site has to talk to: a booking flow synced with Google Calendar, Stripe for payments and invoices, a form that creates the contact in your CRM, a newsletter signup that lands in your list, stock or prices pulled from the system you already run. The test is simple — if someone in the business is currently retyping it by hand, it's a candidate.
90+ mobile PageSpeed at launch and the largest element painted inside two and a half seconds on a normal 4G connection. It stays that way because there's nothing accumulating: no plugin updates, no theme upgrades, no builder rendering markup nobody asked for. The one thing that can spoil it later is third-party scripts, so we'll tell you what each one costs before you add it.
Thirty days of support are included, for the questions that only appear once real people are using it. After that a maintenance plan is optional, not required — the site keeps working whether or not you pay us anything, which is the whole point of building it this way.
Yes, and a good share of the build-only work comes that way. We work to your design, under your name if that's how the client engagement runs, and we don't approach your client afterwards.
Every site has two prices. The first is the invoice, and it's the one everybody negotiates. The second is what it costs to keep the thing alive: the platform subscription, the plugin licences, the developer called in when an update breaks the layout, and the afternoon someone spends each month moving data between two systems that were never introduced. Nobody quotes the second price, and over three years it is almost always the larger of the two.
That second price is set on the day the site is built, not on the day it's launched. A build made of parts — a theme, a builder, a dozen extensions — inherits every one of those parts' futures: their updates, their abandonments, their security patches, their opinions about your markup. A build written by hand inherits nothing. It does what it does, it keeps doing it, and the only reason to touch it again is that the business changed, which is a much better reason than an update.
Hand-writing the code also decides how fast the site is, and speed is not a vanity metric on a phone. A page that carries a builder, six plugins and an uncompressed hero image spends four seconds arriving; a page carrying only what it uses arrives in under one. That gap is not an optimisation you buy afterwards — it's a consequence of there being less code in the page. The same is true of everything search engines read: clean markup, real headings, structured data and fast responses are cheap while the code is being written and expensive to retrofit into someone else's theme.
We build for small businesses, studios and agencies in Novi Sad and across Europe — sites with booking, shops with real payments, admin screens people use all day, and a fair number of straightforward sites that simply had to be quick and easy to edit. The design can be ours or yours. The repository is yours either way.
Half an hour, no obligation. Tell us what the site has to do — or show us the one that isn't doing it. You'll leave with a technical recommendation and a price, and no sales script in between.
Book a free consultation