Web apps for the agentic era.

Billions of requests. Light. Work.

More visitors. More agents. Less infrastructure drama.

Global presence under 100 milliseconds.

Continuous evidence

of continuous fuzzing

inputs tested

Last sealed
Peachy since
packages
targets

What it tests

Peachfuzz sends millions of malformed, unexpected, and adversarial inputs through Kernel.

Why it matters

It uncovers crashes and security flaws before they can weaken the platform every Numinos surface inherits.

Runs continuously. Every figure above comes from tamper evident, replayable run records.

Agent posture

Fast by default. No ceremony required.

A.I. stays off until the job asks for it. The public page gets speed first: fewer moving parts, quicker reads, cleaner delivery.

A.I. Off

Enjoy the speed. Keep the surface simple.

  • Fast reads
  • Small surface
  • Low drama
BLINK SPEED

Performance

The public page tax is real.

Your app stack still matters. Blink gives it less public traffic to carry.

Target marker

1M

requests / second

Treat each row as one benchmark-class app server. Then the question is simple: how many boxes stay warm?

Go / Blink
1 server / ~$36 mo
Java / Spring Boot
4 servers / ~$144 mo
PHP / PHP-FPM
4 servers / ~$144 mo
Python / FastAPI
8 servers / ~$288 mo
Ruby / Rails
13 servers / ~$468 mo

Server-month estimate

~$36

one always-warm 6.25M/sec box

$36 buys the box 6.25x target headroom
1M target

Blink clears the 1M marker with one box. Slower rows buy more boxes to stand in the same place.

Blink benefit

Returns compound

The page arrives sooner. The bill has less room to grow.

Throughput comparison

One public page. Five server stacks.

Same job: return the page. More throughput means each hosting dollar carries more visitors before scale-up becomes urgent.

Black marker = 1M RPS target. Server counts round up.

  • Go / Blink 1 server · ~$36/mo

    6.25M/ sec

  • Java / Spring Boot 4 servers · ~$144/mo

    279K/ sec

  • PHP / PHP-FPM 4 servers · ~$144/mo

    278K/ sec

  • Python / FastAPI 8 servers · ~$288/mo

    140K/ sec

  • Ruby / Rails 13 servers · ~$468/mo

    81K/ sec

Spend
Buys more room.
Visitors
Meet the page sooner.
Market
Makes slow rivals feel slower.

Business impact

Let the product arrive before doubt does.

Speed is not a vanity metric. It is product quality people feel before they can name it.

What changes

WaitIntentAction
Bounce
Blink helps the visitor meet the product before waiting becomes the memory.
Conversion
Intent cools down with every visible hitch between click and payment.
Friction
Delay gives visitors time to question the product, the price, and the company behind it.

Owners

More operating room.

Relief without turning the roadmap into a rewrite story.

For users

Fast reads as competence.

  • Less waiting before the page proves it is alive.
  • Less hesitation at sign-in, checkout, or payment.
  • Less reason to try a competitor instead.

For owners

Same product layer. Less public drag.

The team gets more headroom, steadier tails, and fewer emergency architecture meetings.

Insights

One public page. Three first impressions.

People, crawlers, and agents all meet the same first impression.

Black Friday carts. Breaking-news readers. Chatbots checking sources. Different arrivals, same first question: did the page show up?

First impression test

One door. Three kinds of intent.

People
A shopper or reader feels the brand before they understand the stack.
Crawlers
Search systems reward pages that answer cleanly and consistently.
Agents
Chatbots still search the web. Fast pages are easier to find, read, and cite.

Compare

Slow pages leak the moment. Blink keeps it usable.

Same arrival. Different aftertaste.

  • Slow public page

    People: Wait. Doubt. Leave.

    Blink public path

    People: Arrive. Trust. Act.

  • Slow public page

    Crawlers: Defer the page.

    Blink public path

    Crawlers: Index the page.

  • Slow public page

    Agents: Skip the source.

    Blink public path

    Agents: Cite the source.

About Us

Built by builders. Answerable to operators.

Numinos combines company-building, private-market sales, and low-level systems work. Blink exists because public-web delivery is now an operating cost leaders can feel.

Mike Driver

CEO

Mike Driver

Mike sold his first company, a document management business, to private equity for £50m in 2006. That sale helped him recognise there was a need for an independent advisory firm to help sell privately held companies. He subsequently founded Convex Capital to fill that gap. In 2019, Mike sold Convex Capital to a UK listed professional services company for £22.5m after having advised on the sale of over 100 private companies with a combined valuation of over £3billion.

Having sold his own businesses and advised on the sales of so many others Mike knows the biggest post-sale challenge facing entrepreneurs is working out what to do with the money. Here again, Mike recognised the need for an independent investment firm catering to the needs of entrepreneurs.

Mike became a client of Equitile, shortly after the firm launched in 2016. In 2026, after a decade as a client and after his initial investment with Equitile had tripled in value, he joined the company as Chief Sales Officer.

When not working Mike turns his hand to farming. His latest venture is a remote fruit farm which he is using to preserve endangered varieties of fruit trees, herbs and other traditional agricultural plants.

Ase Deliri

CTO

Ase Deliri

Ase Deliri is a full stack engineer and the creator of Blink, the delivery engine behind Numinos.

Before building Numinos, he worked in telecom engineering at Rogers Communications, where he developed an interest in latency, network behavior, system capacity, and the operational cost of inefficiency at scale.

His work focuses on Go, distributed systems, Google Cloud infrastructure, frontend delivery, low level performance engineering, security, and automated test systems. He tends to work closest to the parts of software where runtime behavior, network delivery, infrastructure, and user experience intersect.

Blink grew out of that approach. Measure real bottlenecks, reduce unnecessary runtime work, and build systems that can verify behavior directly instead of relying on assumptions. The goal is simple. Make web delivery faster, more predictable, and easier to reason about under load.

Transport

Marketing, product, and admin keep separate rooms without becoming separate stories.

Org Benefit

The platform can match the team.

Teams get clear boundaries without buying stack drift, duplicated operations, and uneven reliability.

Switchboard

One entrance. Clean dispatch.

Website, webapp, and admin resolve at the routing layer. Shared ground stays shared.

Service Boundaries

Failure stays in its lane.

Website stays lean. Product keeps tenant and workflow depth. Admin keeps its own control posture.

Deployment Split

Each surface keeps its own release clock.

Marketing can ship without waiting on admin. Admin can ship without freezing product.

Team Continuity

One platform vocabulary across the org.

Leaders and engineers reason about the same platform even when their work lives on different surfaces.

Transport Flow

Fewer integration seams. Lower coordination drag.

The gain is organizational as much as technical: fewer dependencies, fewer staged releases, and fewer local changes waking unrelated systems.

  • Split codebases.
  • Release coupling.
  • Context switching.
  • Transport drift.

Outcome

Shared platform. Clean isolation.

Tenants

Tenant boundaries stay tied to explicit platform scope.

Campaigns

Campaign surfaces can come and go without pulling the whole estate with them.

Change

Blast radius stays local. Refactors do not become platform-wide negotiations.

Delivery

Nanosecond delivery. Flat memory. Stable tails.

The public path no longer carries normal app-shaped cost. Response time and memory stay easy to read under load.

Lumen

Complete document on first byte.

The visitor receives a usable document immediately. Live state does not hold first paint hostage.

Ballast

The front-end cost is paid once.

Repeat visits stop buying the same payload again.

Live Data

Dynamic state without full-page drag.

Live updates stay attached to the parts that need them.

Chisel

137 KB total typographic budget.

Full hierarchy without making typography a vanity payload.

Waiter

Calm behavior on bad networks.

Failure stays bounded instead of turning weak networks into user-facing chaos.

Business Effect

The economics improve before the architecture debate starts.

Lower cost per page view. More public capacity per compute dollar. More time before the next forced infrastructure meeting.

Measured On This Build

  • Page Delivery

    Under 300 ns

    The document path stays in nanosecond-class latency.

  • Asset Delivery

    Under 300 ns

    Static assets keep the same discipline.

  • Font Budget

    137 KB total

    Three families, full hierarchy, and a tight payload.

Security

Clear route classes. Scoped identity. Closed failure.

Security belongs in the structure. Public routes, authenticated routes, admin surfaces, tenant boundaries, and runtime posture share one model.

Wall

Reduce threat surface before app dispatch.

Invalid traffic is rejected before feature code starts work.

  • Surface

    Route intent is explicit, not guessed from naming.

  • Gate

    Public and authenticated paths keep different contracts.

  • Admin

    Missing admin authorization is a hard stop.

  • Fairness

    Tenant limits protect shared service quality.

Identity Shape

Sessions
Identity states have clear scope.Elevation, revocation, and privilege changes stay unambiguous.
Tenants
Tenant isolation is structural.Separation is part of the platform contract, not a habit every feature must remember.
WebAuthn
Stronger proof without a second security story.Higher-assurance authentication fits the same model.

Route Contract

Each route class carries its own obligations.

Public, protected, elevated, and admin are platform contracts. They do not live in tribal knowledge.

  • Public
  • Protected
  • Elevated
  • Admin

Proof

Security posture stays visible at runtime.

Posture, checks, and evidence stay queryable in the running system.

  • Catalog

    Named checks with clear boundaries.

  • History

    Audit lineage that survives production.

Public traffic, sessions, tenant boundaries, and admin control stay inside one security posture.

  • Boundary

    Tenant isolation stays structural.

  • Session

    Identity state changes are explicit and reversible.

  • Admin

    The control plane fails closed when authorization is missing.

  • Traffic

    Invalid traffic is rejected before it becomes application work.

Telemetry

Correlated telemetry from browser event to root cause.

When a route fails in the browser, the evidence stays connected. Client events, traces, logs, metrics, and alerts stay on one path.

Golden Thread

One identity across the incident.

Cyclops establishes the golden thread. Browser evidence comes back on the same path.

Outcome

A checkout failure can be followed from user action to backend fault.

Cyclops

Trace identity stays attached to the response.

Photon

Performance evidence returns on the original trace.

Prism

Browser exceptions keep their request story.

Server Side

Telescope
Structured logs keep trace and request identity intact.Server evidence keeps the identity needed to move from symptom to context.
Horizon
Metrics stay segmented by route class.Fast and slow paths stay separate, so averages stop hiding sick routes.
Siren
Alerting follows posture, not noise.Escalation stays tied to seriousness and context.

The gain is diagnostic speed. Support, product, and engineering can read the same path.

  • Client

    Browser evidence stays attached to the same identity.

  • Server

    Logs and metrics stay route-aware.

  • Support

    A failed payment resolves to traceable evidence, not guesswork.

  • Ops

    Alert volume reflects posture, not raw event count.

Infra

Portable integrations. Negotiable infrastructure.

Payments, writes, storage, export, search presence, and release discipline stay inside one operating model. Infrastructure should widen choice, not narrow it.

Money Rails

Multiple payment rails. One commercial surface.

More payment rails should not mean more payment stories.

  • Stripe
  • PayPal
  • Apple Pay
  • Google Pay
  • Checkout

    One commercial entry point with room for more rails.

  • Fulfillment

    Payment behavior stays auditable and clean.

Write Posture

Storage posture changes by need, not panic.

A wider data surface should add choices, not accidental choreography.

  • Single

    One backend when simplicity is right.

    The platform does not force choreography when one durable store is enough.

  • Dual

    Parallel writes for staged migration.

    Migration can proceed in steps instead of one expensive cutover.

  • Multi

    Clear boundaries across a wider data surface.

    As storage concerns widen, the operating model stays deliberate.

Backends

Storage should be a contract, not a hostage situation.

  • Contracts

    Application code points at stable contracts.

  • Boundaries

    External dependencies stay bounded enough to replace.

Backend choices should stay negotiable. Migration should feel operational, not existential.

Exodus

Data portability should be structural.

Customer data should remain exportable, verifiable, and transferable.

Ceremony

Integration posture stays inspectable.

Presence

Business data should serve people and machines together.

Contacts, hours, and business details should power the product and stay legible to search engines and machine crawlers.

  • Search

    Structured metadata stays part of delivery.

  • Release

    Deployment posture stays deliberate.

  • Kernel

    Shared ground supports new products without forks.

  • Result

    More reuse without flattening the product.

Conclusion

Broad capability. Minimal forced coupling.

The principle is optionality. Adopt the delivery layer alone, keep existing auth and payments, or widen scope only where the gain is real.

Take What Fits

Capabilities stay independently adoptable.

Delivery, auth, payments, telemetry, export, and storage posture can arrive without an all-or-nothing migration.

  • No Trap

    Start narrow. Expand where return is measured.

  • No Drift

    Shared ground stays coherent as surfaces diverge.

What Stays Open

  • Edge

    The delivery layer can stand alone.

  • Identity

    Existing identity can stay until migration earns its place.

  • Money

    Payment posture stays modular.

  • Data

    Storage, export, and migration paths stay open.

Platform Longevity

Age with the platform. Not against it.

A smaller surface means updates feel like housekeeping, not negotiations with abandoned dependencies.

  • Ballast
  • HTML
  • Auth
  • Payapi
  • Telemetry
  • Wall
  • Witness
  • Exodus
  • Store
  • Bridge
On release day
adopted
  • Upgrades

    Maintenance, not negotiation.

  • Dependencies

    Fewer stall reasons. Less upgrade drag.

  • Kernel

    New products behave like distributions, not forks.