Web Engineering
← All servicesHand-coded React, Python, and Postgres on Cloudflare’s edge.
A studio building hand-coded React, Python, and Postgres systems for teams who refuse template AI sites. We design the schema first, ship to Cloudflare's edge, and leave you with a repo your engineers can read in three years.
38ms
Median TTFB from London on a Workers + OpenNext build
0
ts-ignore directives in committed Atellius code
94/100
Schema coverage score on our own GEO audit tool
100%
Client-owned repos and Cloudflare accounts at handoff
Hand-coded App Router applications on Next.js 15 with React Server Components, streaming, and selective hydration. No shadcn, no Lucide presets, no copy-pasted Framer scaffolds. Every primitive is built in the repo so the bundle stays small and the UI stays legible.
Async FastAPI services backed by SQLAlchemy 2.x and Alembic migrations. SSE-streamed scoring endpoints, background workers via arq or Celery, OpenAPI-typed contracts the frontend imports directly. Production-grade Python, not a notebook in a Docker container.
Row-level security, partial indexes, materialized views, and migrations that run in transactions. We design the schema first, write the queries second, and only then decide what the API looks like. The database is the source of truth, not an afterthought.
OpenNext adapter for Next.js, Workers Builds for CI, Wrangler for config-as-code. R2 for assets, KV for session and flag state, D1 for edge-local reads, Queues for async. WAF rules and rate limits live in the same repo as the application code.
Tenant isolation at the Postgres schema or RLS layer, per-tenant feature flags, per-tenant rate limits at the Worker edge, per-tenant billing hooks into Stripe or Lago. Designed so tenant 100 costs roughly the same to operate as tenant 10.
Client login, session-backed access control, Stripe-driven entitlement checks, and gated program content served from Postgres with assets on R2. One-time purchases or recurring subscriptions, a member portal at /app, and a clean separation between the public marketing surface and the paid program layer.
Internal tools built with the same engineering discipline as customer-facing product. Server-side pagination, optimistic mutations, audit logs, role-based access. Dashboards that show p95 latency and revenue on the same screen because operators need both.
GSAP timelines and OGL shaders for the moments that earn motion. WebGL hex/digit code fields, scroll-bound reveals, cursor-aware hover states. No Framer Motion preset library, no Lottie JSON dumped from a designer's export.
Scheduled Workers, Cloudflare Queues, and Python ingestion jobs that move data from third-party APIs into Postgres on a known cadence. Idempotency keys, dead-letter handling, retry budgets. The pipeline is observable from the same dashboard as the rest of the stack.
The stack, in one picture
Request hits the edge, renders from the frontend, calls the API, reads the database — and every layer ships in the same repo, to your own Cloudflare account. No rented runtime, no black-box CMS in the middle.
Four layers, one mental model. The data flows top to bottom; the contract is typed end to end — Postgres DDL to Pydantic to OpenAPI to the TypeScript client.
For service businesses that need a professional online presence without an agency project. Design, domain, hosting, SSL, smart lead forms, monthly updates, SEO, and AI-search readiness — bundled into one subscription. Delivered in 4–7 days, not 4–12 weeks.
Starter
$99/mo
Most popular
Growth
$149/mo
Scale
$249/mo
WaaS vs the alternatives
| Feature | Website as a Service | Traditional agency | DIY |
|---|---|---|---|
| Launch time | 4–7 days | 4–12 weeks | Your time |
| Upfront cost | None | $2,500 – $8,000 | $0 + your time |
| Domain stays yours | Yes, always | Usually | Yes |
| Monthly updates | Included | Extra cost | Your work |
| Lead forms | Smart + triage | Basic or extra | DIY or plugin |
| AI-search ready | Included | Varies | DIY |
| SSL + hosting | Included | Often extra | Extra subscription |
| Code you own | Yes | Usually yes | Yes |
Domain stays yours permanently. Cancel anytime.
From a four-page marketing site to a multi-tenant SaaS platform with a Python ingestion spine, we design the schema first, write the queries second, and ship the UI third — on Cloudflare’s edge, in your repo, with the dashboards already wired.
One to two weeks. We read your existing code, query your analytics, interview the operators who'll use the system. Output is a written scope, a data model sketch, and a fixed price.
Database schema, API contract, and deployment topology decided before a single React component is written. OpenAPI spec and Postgres DDL are reviewable artifacts, not implementation details.
Weekly demos against a live staging environment on your own Cloudflare account. You see the system run on real data from week two. Scope changes get costed in writing, not absorbed silently.
Lighthouse, axe, Playwright, and load tests run in CI. Schema validated against the live GEO audit scorer. Migrations run twice in staging against a production snapshot before the cutover window opens.
Cutover happens inside a defined window with a written rollback plan. Old URLs preserved via Worker routing, analytics continuity verified, observability dashboards handed over. The engineer who wrote the code is the engineer on the cutover call.
app/services/web-development/page.tsx
The file you’re reading. Hand-written TypeScript. No page builder, no MDX editor, no proprietary CMS — just a React Server Component shipped to Cloudflare Workers via OpenNext.
export const metadata: Metadata = {
title: 'Web engineering — built to load fast and read to AI',
alternates: { canonical: '/services/web-development' },
openGraph: { /* ... */ },
};
export default function WebDevelopmentService() {
return (
<main>
<JsonLd data={professionalServiceSchema(/* ... */)} />
<JsonLd data={breadcrumbSchema(/* ... */)} />
<JsonLd data={faqSchema(FAQ_ITEMS)} />
<Hero />
<ProofBar metrics={METRICS} />
<CapabilityGrid capabilities={CAPABILITIES} />
{/* ...the rest of the page */}
</main>
);
}Static and dynamic routes both render from Cloudflare's edge. Workers handle SSR, R2 carries assets, KV holds session and feature-flag state. The user's first paint happens before a traditional origin would have finished its TLS handshake.
Atellius marketing site TTFB measured at 38ms from London, 71ms from Sydney over Cloudflare Workers + OpenNext.
Strict mode on, no implicit any, no ts-ignore in committed code. Zod or Pydantic at every boundary the network touches. The result is a codebase where a refactor in the data layer surfaces in the IDE before it surfaces in production.
Atellius internal projects ship with zero ts-ignore and zero any in committed code; runtime type errors caught at the boundary, not in Sentry.
No proprietary CMS, no closed page-builder, no rented runtime. Every line is in your Git repo, deployable to your own Cloudflare account, debuggable by any engineer who reads TypeScript or Python. Walk away at any point with a working system.
Every Atellius engagement ships to a client-owned GitHub org and a client-owned Cloudflare account on day one, not handoff.
Every public page ships with JSON-LD modeled to the actual entity, not a generic Organization stub. Open Graph, sitemaps, robots, and llms.txt are part of the build, not a plugin. AI engines stop guessing what the site is about.
Atellius's own GEO audit tool scores Atellius.com at 94/100 schema coverage at launch, against an industry median of 31.
Workers Analytics, Logpush to R2, and per-route timing surface in a dashboard that ships with the product, not bolted on six months later. You see p95 latency, error rate, and cost per million requests in the same place you ship the code from.
Every Atellius platform engagement ships with a built-in /admin/ops route showing p50/p95/p99 latency, error rate, and CF Worker CPU time per route.
Strangler-fig migrations from WordPress, Shopify, Webflow, and bespoke PHP stacks. Old URLs preserved via Workers routing, redirects verified before cutover, analytics continuity maintained. The day you ship is the day traffic continues, not the day it cratered.
Recent Atellius migration from a 4,200-page WordPress site preserved 100% of indexed URLs and held GSC clicks within 3% week-over-week through cutover.
Case study
GEO SaaS for service businesses
Multi-tenant SaaS, dual-gateway billing, six-dimension scoring engine, edge delivery. 94/100 schema coverage at launch on the platform that scores schema coverage.
Founders shipping a SaaS product who need real engineering, not a Webflow facade with a Stripe button.
Operators migrating off a WordPress, Shopify, or Webflow stack they've outgrown and want the code in their own repo.
Marketing leads who need a site that ranks in ChatGPT, Perplexity, and Google AI Overviews — not just Google's blue links.
CTOs who need an embedded studio for a quarter without the hiring loop, the agency layer, or the offshore handoff.
Fixed scope. No setup fees, no monthly retainers, no hidden hours.
For founders and operators who know what they need built and want a deliverable date attached to it.
Two to twelve weeks. Defined scope, fixed price, weekly demos. Ships to a repo you own on a Cloudflare account you own. Starts at $10,160 for marketing sites, $30,480 for SaaS MVPs, $76,200+ for platforms.
For teams who need an engineering practice they don't have to hire, manage, or onboard.
Monthly retainer, fixed weekly capacity, one shared backlog. Weekly demos, no agency layer, direct Slack with the engineer writing the code. Starts at $7,620 per month.
For companies on a SaaS stack they've outgrown — WordPress, Shopify, Webflow, bespoke PHP — who want the code in their own repo.
Discovery and audit fixed-fee, then a strangler-fig migration on a phased timeline. URL parity verified before cutover, analytics continuity guaranteed, old stack decommissioned only after a two-week parallel run.
Page builders generate markup you can't audit, ship dependencies you don't need, and produce bundles that fail Core Web Vitals on the day they're built. A hand-coded Next.js app starts smaller, stays smaller, and remains legible to a senior engineer in three years. The total cost of ownership over a five-year horizon is measurably lower.
Workers run on Cloudflare's edge in 330+ cities, with a cold-start budget measured in microseconds rather than the hundreds of milliseconds typical of Lambda. R2 has no egress fees, which materially changes the economics of media-heavy sites. The OpenNext adapter means we ship Next.js apps to Workers without rewriting them, and Workers Builds gives us a CI pipeline in the same dashboard as the runtime.
No. We use Tailwind as a utility layer but we build every primitive ourselves — buttons, inputs, dialogs, navigation. The reason is voice: a shadcn site looks like every other shadcn site, and a Tailwind UI page looks like every other Tailwind UI page. Hand-built primitives are the authorship fingerprint and they stay maintainable because we wrote them.
FastAPI services handle anything the edge runtime shouldn't — long-running scoring jobs, SSE-streamed model outputs, batch ingestion from third-party APIs, scheduled report generation. Postgres is the system of record, SQLAlchemy 2.x is the ORM, Alembic manages migrations, and the OpenAPI spec is imported directly into the TypeScript frontend so the contract stays honest.
You do, from day one. The GitHub repository is created in your organization, the Cloudflare account is yours, the Postgres database lives in your cloud account. We commit as collaborators. At any point you can revoke our access and the system continues to run, because nothing in the stack depends on Atellius being a vendor.
Small. Nawab leads every engagement and writes the load-bearing code himself, with a tight bench of trusted contractors brought in for specific work — motion, illustration, copy. You will not be handed off to a junior, you will not get an account manager, and the person on the kickoff call is the person writing the migrations.
Weekly demos mean a project that's drifting is visible by week two, not week eight. Fixed-scope work has a written scope and a written exit clause — if it isn't working, both sides can stop. Retainer clients give 30 days notice. We have never had a client request a refund and we have never had a project end mid-build, but the contract assumes both are possible.
Write us a paragraph about the system you want and the date you want it by. You will get a written scope, a fixed price, and a calendar invite — not a discovery workshop.