Northerly.

Most AI features are demos.We ship the other kind.

The hype is loud; shipping is the quiet part. Northerly is a full-stack engineering shop in Leeds. The discipline came before the AI — tests, types, small reversible changes — and the AI is designed in on top of it, with agents in our own delivery loop.

Three things we do with AI.

Create

Design AI into the product.

Where it earns its place and where it doesn't. Model choice, prompt and eval design, and a working prototype early enough to change your mind about.

Implement

Ship it to production.

Retrieval, tool use, guardrails, observability and the eval suite that keeps it honest. The unglamorous half that decides whether it survives contact with real users.

Drive

Run AI in our own loop.

Agents in the codebase, in review and in delivery. It's why a team this size ships like a bigger one, and why one of the three of us is an agent.

What we build with, and why it's in the list.

AI
  • Agentic AI
  • Agent SDKs
  • MCP
  • Evals

Agentic AI at the core — frontier models, tools over MCP, and an eval suite per feature. Nothing AI-shaped ships without one.

Language
  • TypeScript
  • Node
  • Bun

Strict everywhere. Bun where it's allowed to be, Node where it isn't.

Interface
  • React
  • Next.js
  • Astro
  • Tailwind

Server-rendered by default. Client JS is a decision each time, not a starting position.

Data
  • PostgreSQL
  • pgvector
  • Drizzle
  • tRPC

One schema, inferred all the way up. If the shape changes, the build tells you before the user does.

Ship
  • Vite
  • Playwright
  • GitHub Actions
  • Vercel

Every commit builds, type-checks and runs the tests. Main is always deployable.

Cloud
  • AWS
  • Docker
  • Terraform
  • Cloudflare

Containers and infrastructure as code — reproducible environments, nothing clicked together by hand in a console.

Observability
  • Grafana
  • OpenTelemetry
  • Prometheus
  • Sentry

Dashboards, traces, metrics and errors wired in from the first deploy. If it's in production, we can see what it's doing.

Opinions we've earned the hard way, written down so they can be argued with.

  1. 01

    Evals before vibes.

    AI made it cheap to build the wrong thing quickly. We write the eval first, so "it seems better" becomes a number somebody can check.

  2. 02

    Ship small.

    A change nobody can review is a change nobody can trust. Small, continuous, reversible — every time.

  3. 03

    Type the seams.

    Most production bugs live at a boundary. Make the boundary say what it means and the class of bug goes away.

  4. 04

    Boring is a feature.

    We pick the dull, well-understood option for anything load-bearing, and spend the novelty budget where it's actually visible.

  5. 05

    Fast is accessible.

    Performance and accessibility are the same discipline wearing different hats: respect for the person on the other end of the connection.

Three of us. One is a dog.

Tooling we're stress-testing.

The stack we build on.

The defaults we reach for on client work, and what each is for. Versions are pulled live from the toolchain, so they stay current.

Astro7.3.2
Content-first sites with static output — server components, minimal client JS.
Tailwind4.3.3
CSS-first styling with design tokens kept in one place.
TypeScript5.9.3
Strict everywhere, and checked in CI before anything ships.
Bun
Fast package manager, bundler and task runner.
General Sans & Zodiak
Self-hosted typefaces — no third-party font CDNs.
Vercel
Static and edge hosting, deploying straight from git.