/ Studio
Atellius is a small team led by Nawab Islam. We engineer custom React, Next.js, and Python systems — and we own them in production. The same craft bar across web, GEO, and pipeline.
Every pattern we ship on a client project has been load-bearing in something we run ourselves. The only honest test of an architecture is whether you would still defend it at 3am with your own payroll attached. The wallet ledger in your billing system is the wallet ledger in our SaaS. The scanner in your GEO audit is the scanner that powers geo.atellius.com. Nothing reaches a client repo until it has earned its keep in ours.
We use the framework that fits the job — never the one that fits the resume. Stack tribalism is how teams ship the wrong system for the right reason. Next.js for content-rich apps with editorial routing. FastAPI for typed async services where the contract matters more than the cleverness. Cloudflare Workers for the edge. Postgres for everything that earns a row. The point is the system, not the badge.
Any metric in a deliverable comes with a way to verify it. A number without a measurement is a marketing claim, and marketing claims rot the trust a studio runs on. TTFB is in the response header you can curl. Citation lift is in the dashboard you can log into. Schema coverage is in the JSON-LD you can view-source. No 10x without the chart. No production-ready without the page.
One file owns each fact — colour tokens, status enums, pricing schedules, copy strings. The rest of the system reads from there. Drift is the slow tax that turns a clean codebase into a haunted one in eighteen months. Design tokens compile to CSS variables, type literals, and Tailwind config from a single TS file. Pricing lives in one record the marketing site and the billing webhook both read. Drift is treated as a defect, not a style choice.
You should be able to look at this page and decide. A studio that cannot ship its own site to the bar it sells is selling a story it cannot keep. Every page here is hand-coded — no shadcn, no Lucide icon set, no Framer preset, no stripped Tailwind starter. If this site does not convince you, the case studies will. If those do not, the live products will.
We do not ship template AI sites, generated component dumps, or any output a competitor could regenerate in an afternoon. AI search engines are already learning to discount homogeneous content — the sites that rank in 2027 will be the ones whose authorship is visible at the markup level. Every component is written, not generated. Every illustration is a real artifact or it does not exist. Every copy block is sentence-by-sentence editorial work. The authorship fingerprint is the moat.
If the timeline cannot carry the craft, or the scope cannot fit the budget, we name it before the contract — not after the first sprint. A studio’s reputation is the average of the projects it accepts, not the ones it pitches. Discovery ends in either a scoped proposal we will both sign, or a written referral to someone better suited. Roughly one in three inbound conversations ends in a referral. That is the point.
Every engagement ends with the client able to run the system without us — or with a retainer that exists because they chose it, not because they were trapped. Lock-in is the easiest way to bill an extra year, and the fastest way to lose the next three referrals. Every repo ships with a README a new engineer can follow on day one, an architecture note explaining the load-bearing decisions, and a 60-minute recorded walkthrough. Then the keys are yours.
Three practice areas, one craft bar. Engineering builds the system, Visibility makes it legible to AI engines, and Operations keeps it running — every pattern here is load-bearing in something we run ourselves first.
Capability matrix · engineering → visibility → operations
Custom systems, hand-coded — no template, no regenerable component dump.
Making a system legible to AI answer engines — the scanner we run ourselves.
We build it, then we live with it — production, on a fixed-scope retainer.
1–2 weeks
We read the existing system end-to-end — code, analytics, schema, support tickets, the bits the previous team did not document. We talk to the people who actually use it, not just the people who own the budget. We write down what we find, including the parts that contradict the brief.
What you get
A written discovery memo: the system as it is, the system as you described it, the gap between the two, and the smallest possible scope that closes the gap. Plus a fixed-scope proposal — or a referral if we are not the right studio.
1–3 weeks
We draft the data model, the route map, the component primitives, and the deployment topology before a line of production code is written. Design tokens, type contracts, and schema shapes are agreed on paper first. If a third-party API will not survive the load, we find out here, not in week six.
What you get
An architecture document, a typed schema, a component inventory with hand-built primitives (no shadcn lift), and a clickable prototype of the critical paths. Reviewed with you in a 60-minute walkthrough before build starts.
4–12 weeks
Hand-coded implementation in two-week cycles. Every cycle ends with a deployed preview URL and a written changelog naming what shipped, what slipped, and why. No silent scope creep — additions are quoted and signed before they enter the sprint.
What you get
A working system at the end of every cycle, deployed to a preview environment you can break without consequence. Weekly demo call, fortnightly written status note, a Linear or GitHub Project board you can read without us in the room.
1–2 weeks
We run the system against the success metrics named in discovery — TTFB, schema coverage, citation lift, conversion rate, whatever was promised. Anything that fails verification is fixed before launch, not added to a post-launch ticket queue. Lighthouse, Playwright, and real-device QA are all in scope, not extras.
What you get
A verification report mapping each promised metric to its measurement, with screenshots and reproducible commands. Plus a written sign-off list — what is launch-ready, what is known-deferred, and what is explicitly out of scope.
1 week
DNS, redirects, schema migration, analytics handoff, status-page setup, on-call rota for the first 72 hours. We do the launch from our side and watch the dashboards with you, not from the other side of a Slack thread.
What you get
A live system on your domain, a launch runbook in your repo, an incident channel that stays open for a week, and a postmortem if anything bent. The first month of production telemetry is reviewed together.
Ongoing or 2 weeks
Two paths, agreed in discovery. Handover: we record a walkthrough, write the architecture note, and transfer ownership of repo, infra, and accounts. Run: we keep the system on a fixed-scope retainer — weekly demos, monthly written report, no agency layer between you and the engineer writing the code.
What you get
Handover: a README a new engineer can follow on day one, a recorded architecture walkthrough, and a clean break. Run: a named primary engineer, a defined response window, and a monthly written report against the metrics that mattered in discovery.
Five ways to work with the studio. The right one falls out of discovery — but here is the shape, the fit, and the price band before you ask.
4–12 weeks · $15k–$76k
For founders and teams who know the system they need and want a defined start, scope, and finish.
One written brief, one fixed price, one delivery date. Discovery is paid and produces the scope. The build follows the discovery memo line by line. Change requests are quoted and signed before they enter the sprint — no surprise invoices, no creeping retainer.
Ongoing · $8k–$25k / month
For teams who need an embedded engineering function without hiring three roles to get it.
A fixed monthly scope — typically one senior engineer and a fraction of a designer or ops engineer — working on your roadmap, in your repos, with your tools. Weekly demos, monthly written report, no agency PM layer between you and the person writing the code. Two-month minimum, monthly thereafter, one month notice.
6–16 weeks · $23k–$102k
For teams who have engineers but no capacity, and want the system back in-house once it is stable.
We build to your standards, ship to production, and then transfer ownership — repo, infra, accounts, and a recorded architecture walkthrough. Optional two-week shadowing period where your engineers pair with ours. After that, the keys are yours and we are gone.
Build 4–12 weeks · then $4k–$15k / month
For founders without an engineering team, who need the system shipped and kept running without learning to be a CTO.
Fixed-scope build followed by a defined run engagement — uptime, incident response, monthly improvements, and a single named engineer who knows the system. The build phase always produces a handover-ready system, so you can leave the run engagement at any time without re-platforming.
1–3 weeks · $5k–$19k
For teams with an existing build who need a second opinion before the next big decision — replatform, rebuild, hire, sell.
A fixed-scope review of the codebase, the architecture, and the team’s working patterns. Ends in a written report — what is load-bearing, what is technical debt the team can live with, what needs to be addressed before the next round of growth. Optional follow-on implementation, no obligation.
Vertical-agnostic by design — the patterns travel. These are the sectors the studio has shipped into so far.
“The projects I most wanted to work on were not being offered by the agencies I would otherwise hire.”
I started Atellius because the projects I most wanted to work on were not being offered by the agencies I would otherwise hire. The good shops were either too big to take the brief seriously, or too small to ship the scope. The mid-tier was already shipping template AI sites at premium rates. None of it matched the bar I had spent ten years trying to hold.
The last decade I have been building products — some for clients, more for myself. A hospitality WiFi platform serving thousands of properties. A GEO audit SaaS now running at geo.atellius.com. A healthcare directory. A reviews portal. A reputation tool. Seven case studies in production, all live, all earning their keep. The patterns repeated across them. The bar for what counted as good kept rising, and the gap between studios selling the bar and studios actually clearing it kept widening.
Atellius is the studio that gets to apply all of that on the next project. The ledger pattern from a fintech build. The scanner from a GEO audit. The staged-write rigour from an admin portal. The hand-built component primitives that survive an audit. None of it is template work, none of it is regenerable, and none of it ships until it has earned its place in a system I would still defend at 3am.
We are small on purpose, and we will stay small on purpose. The studio that takes on the next project is the one writing the code on this one. If that is what you need — a system built by the people who will own its decisions — send a note. If it is not, we will say so, and point you at someone better suited. That is the only way the bar holds.
— Nawab Islam, Studio Lead