What does proprietary mean here, in plain words?

It means the system is built for one business and then belongs to that business. No template shared with other clients, no platform renting the site back by the month, no account held in the studio's name. Paid for once, owned outright, transferable to another developer at any time.

Why not just use a website builder subscription?

A subscription rents the site, the design and often the domain, on terms a platform can change. A proprietary system is scoped in writing, priced once, and handed over in the client's name. The monthly fee is not saved money; it is a hostage arrangement that ends the day the business stops paying.

What happens if the business wants to change developers later?

Nothing needs permission. The code, the design, the content, the domain and the accounts are the client's once the invoice is paid, and the scope and inventory documents travel with them. Another developer can pick the system up from the paperwork.

Proprietary systems: built for one business, owned by that business

A proprietary system is not a template with a logo on it and it is not a platform the business rents by the month. It is built once, for one trade in one town, from a written scope — and when it is paid for, it belongs to the business outright, accounts and all.

Scope mechanics

A written scope and fixed price agreed before anything is built: what the system includes, what it does not, and the one number the client is held to.
Yours outright at handover: the site, the domain, the hosting account and the analytics, in the client's name, with no monthly rent and no account held back.
Pages, paths and search structure built for this trade and this town specifically — the scope names the trade, so the build is answerable to it.
Documentation the owner can hand to another developer: the scope, the search map and the account inventory travel with the system.

How the funnel works

The brief. The owner answers plain questions about the business: the trade, the town, the work, the way enquiries arrive. The brief becomes the written scope, and the scope becomes the fixed price.
The build. One build, for one business. The pages, the booking or quote path and the search structure are made for this trade, not adapted from another client's site with the noun changed.
The proof. Before handover the system is read on a real phone, the enquiry path is tested end to end, and the accounts are checked. What is true at handover is what was promised in the scope.
The ownership. Everything transfers into the client's name: site, domain, hosting, analytics. The client can maintain the system, move it, or hand it to another developer without asking anyone's permission.

Engine parts

Single-tenant by design: no shared templates, no other client's content, no platform whose shutdown takes the business site down with it.
The written scope as the contract of record: if it is not in the scope, it is not in the price, and if it is in the scope, it is in the build.
Account ownership as a build step, not an afterthought: accounts are created in the client's name from the start, never in the studio's.
No retainer, no rent: the system is paid for once and owned outright, which is what makes it proprietary rather than leased.

Artefacts you keep

The written scope: pages, paths, price and exclusions, signed before work starts.
The account inventory: every account the system uses, listed with its owner, handed over at launch.
The handover checklist: tested paths, live pages and transferred accounts, checked off at handover.
The build record: what was built, when, and what it cost, kept with the client paperwork.

The field guide: Proprietary systems

The problem

A rented site feels like ownership until the invoice surprises the owner. The subscription looks simple at the start: pick a template, swap in a logo, pay a monthly fee. Then the fee keeps arriving, the domain turns out to be registered to the platform, the hosting account sits in the studio name, and the analytics cannot be taken anywhere else. Cancelling does not just end a payment; it ends the address the business was found by. This is the trap that proprietary systems exist to close. The problem is not that a template exists. The problem is that rent is presented as ownership, and by the time the owner discovers the difference, the business is found by a URL it does not control.

How it works

A proprietary system is single-tenant by construction: built once, for one business, from a written scope that names the trade, the town, the pages and the price. The scope is the contract of record. If it is not in the scope, it is not in the price, and if it is in the scope, it is in the build. Accounts are created in the clients name from the first week, never in the studio name with a promise to transfer later. The build itself uses no shared template, so no other clients content, no platform themes, and no subscription flag can take the site down by accident or by repricing. When the invoice is paid, the code, the design, the content, the domain and every account pass over outright, with a handover checklist and a build record the owner can hand to any other developer.

Worked example — Dentist in Vancouver

A Vancouver dentist and the handover that makes the site yours

Consider a new dentist in Vancouver as the illustration. The practice needs patients to book quickly, to see insurance and hours without digging, and to find the clinic in Metro searches. The scope names those pages and the booking path, fixes the price in writing, and lists what the system does not include. During the build, the domain, the hosting account and the analytics are registered to the practice, so the inventory grows alongside the pages. At handover the front desk tests the booking path on a real phone, confirms that enquiries land in the practice accounts, and signs the checklist. After that the practice can maintain the site, move it, or hand it to another developer without asking anyone permission. The monthly rent the practice does not pay is not savings. It is the absence of a hostage arrangement.

Checklist

Sign a written scope, pages, paths, price and exclusions, before anything is built.
Create the domain, hosting and analytics accounts in the clients name from the start.
Build single-tenant pages for this trade and this town, never a shared template with the noun changed.
Test the enquiry path end to end on a real phone and record the handover checklist.
Hand over the inventory, scope and build record so another developer can pick the system up cold.

Build it once, own it outright, and leave every account in your name.

Ask what owning your system costs

Direct answers

What does proprietary mean here, in plain words?: It means the system is built for one business and then belongs to that business. No template shared with other clients, no platform renting the site back by the month, no account held in the studio's name. Paid for once, owned outright, transferable to another developer at any time.
Why not just use a website builder subscription?: A subscription rents the site, the design and often the domain, on terms a platform can change. A proprietary system is scoped in writing, priced once, and handed over in the client's name. The monthly fee is not saved money; it is a hostage arrangement that ends the day the business stops paying.
What happens if the business wants to change developers later?: Nothing needs permission. The code, the design, the content, the domain and the accounts are the client's once the invoice is paid, and the scope and inventory documents travel with them. Another developer can pick the system up from the paperwork.

What arrives for a business

Ten things, every build. The list is the ceiling, not a marketing sentence — if it is not on this list it is not in the price.

A written scope and one fixed price
Agreed before any work starts. The number you sign is the number you pay.
The words, written for the customer
Every page answers what a buyer asks, not what the owner wants to say.
The design, from a system already live
Not a template you fill in. A layout built from the same system as every other build, adapted to the trade.
The build, fast on a real phone
Tested on cellular data, not on the studio's wi-fi.
The enquiry path
Form, notification, and a record of what came in — wired in, not bolted on.
Local search structure
Real headings, structured data, a sitemap, and the town named in the words.
The launch
Domain pointed, certificate checked from outside, redirects in place.
One revision round, in writing
A list of changes, agreed, done, and closed — not an open-ended tab.
The handover
Code, design, content and logins, in the business's name. Nothing held back.
Changes after launch, through the portal
Queued and done when we are in there. No retainer required to ask.

The full list, tier by tier →

What it costs, line by line

These are the published prices, in Canadian dollars before tax, from the same table the plan page charges from. A build is quoted as one fixed number against a written scope — this is what the lines add up to, not an offer.

Published line prices for a Nimos build.
The site	$2,500
The site plan	$450
A funnel	$450
Local search setup	$350
Care	$150
Site Watch	$49

Price your own build →No card, no call, no email required to see a number.

What you can check before you call

There are no testimonials on this page, because there are none to show. What there is instead is four things you can open in another tab and judge for yourself.

The build log

Every change this studio ships to its own site, dated, with the commit behind it.

Read the log →

The work

Five real builds, named, with what was actually done on each one.

See the work →

The accessibility rules

The contrast, type and motion limits this site enforces on itself, stated publicly.

Read the rules →

The status page

What is up, what is down, and what changed — not a badge that always says green.

Check the status →

LATELY, ON THIS SITE

2026-11-06The field, named — Sixty-six tools and people get a page each, and every city gets a hub.
2026-11-04The local engine — Twenty trades across a hundred and eighteen cities, from one data file.
2026-10-20The build table — The six numbered steps become one table of real handoffs — HELLO to LIVE.

Nothing on this page is a claim we cannot point at. The four links above are the evidence, and every one of them is a click away.

Two ways to start, and neither is a sales call.

Price your system line by line on the plan page, or run the free leak report on the site you have now and read the findings yourself. Neither one is a sales call.

Price it in 90 seconds Run the free leak report