Software engineering beyond the happy path.
Most software works in the demo. Null Vertex builds the version that holds up when the network drops, the queue backs up, the third party returns a 500, and every customer shows up at once.
Production-grade applications, scalable cloud infrastructure, AI-integrated systems, and real-time platforms.
the thesis
The happy path is the part that is easy to build.
Here is a payment charge. Five lines, and it works — right up until it meets production. Turn on what production will actually do to it.
def charge(order, amount) do {:ok, resp} = Payments.charge(order.customer_id, amount) {:ok, _} = Orders.mark_paid(order, resp.id) :okendSelect a failure mode
Each one is a thing that will happen to this code in production. Toggle any of them to see what handling it actually costs, and why it is the work that decides whether a system holds.
This is what the name means. A null vertex is the case that was never closed — the branch nobody drew.
If your system already lives here and you are not sure which of these it actually handles, that is exactly what an audit answers.
See what an audit coverswhat gets built
Systems that have to work when it matters.
Eight areas, one standard. Each links through to what the work involves and what makes it hard once it is real.
SaaS Platforms
Multi-tenant products with the billing, permissions, and onboarding that turn a working application into a business.
Full Stack Web Applications
End-to-end products where the interface, the API, and the data model are designed as one system instead of three.
AI-Powered Products & Chatbots
LLM-backed features with retrieval, tool use, and evaluation — built as products, not prompt demos.
Real-Time Dashboards & Operational Systems
Live operational views where the data on screen is trustworthy and stays that way under pressure.
Geospatial & Fleet Management
Location-aware platforms: tracking, routing, geofencing, and spatial analysis over live and historical data.
High-Throughput Backend Services
Services built for sustained volume, with the queueing, concurrency, and failure semantics stated up front.
Cloud-Native Infrastructure
Reproducible infrastructure with deployment, observability, and recovery treated as part of the product.
Consulting & Technical Advisory
Senior judgement on the decisions that are expensive to reverse — architecture, technology selection, and technical direction.
core expertise
The skills the work is built on.
Ten areas of depth, applied in whatever combination the problem calls for.
- System Architecture
- Deciding what the pieces are, where the boundaries fall, and which constraints the design has to hold under.
- Full Stack Development
- Interface through to database, designed as one system so the seams between layers are chosen rather than inherited.
- AI Integration
- Retrieval, tool use, evaluation, and cost control — the engineering that turns a model into a dependable feature.
- Real-Time Systems
- Push-based data with reconnection, replay, presence, and fan-out that holds up as subscriber counts grow.
- Cloud Infrastructure
- Reproducible environments, safe deploys, and recovery paths that have been tested rather than assumed.
- API Development
- Contracts that are versioned, documented, and stable enough that consumers can build against them with confidence.
- PostgreSQL & Data Engineering
- Schema design, indexing, query planning, and migrations that run against live tables without taking the service down.
- Performance Optimisation
- Profiling before changing anything, then fixing the bottleneck that measurement actually identified.
- DevOps & CI/CD
- Pipelines that catch problems before production and make releasing an ordinary event rather than a risk.
- Technical Leadership
- Setting direction, reviewing work, and explaining trade-offs to engineers and executives in the terms each needs.
how the work runs
Four commitments, held on every engagement.
01
Technology agnostic
The problem picks the stack. Not the other way round.
Null Vertex has no favourite language, framework, or cloud to sell. Every choice gets made against your actual constraints — team, timeline, budget, operational capacity, and what you already run. Sometimes that means the interesting tool. More often it means the boring one your team can still maintain in three years.
02
Production-first
Designed for the bad day, not the demo.
Timeouts, retries, idempotency, backpressure, and observability are not a hardening phase that happens after the feature works. They are part of the design, because retrofitting them means rewriting the thing you already shipped.
03
AI-accelerated, senior-reviewed
Modern speed, without giving up on judgement.
AI-assisted workflows are used heavily here, and they make delivery substantially faster. What they do not do is decide the architecture, own the trade-offs, or judge whether the result is correct. Every line still passes senior review before it reaches you, because velocity you cannot maintain is not velocity.
04
Built to hand over
Nothing should depend on Null Vertex staying.
Tests that assert behaviour, documentation that matches the code, and infrastructure defined in version control. The measure of the work is whether your team can take it forward alone — not whether they need a retainer to understand it.
Have something that needs to survive production?
Describe what you are building, or what is already built and no longer behaving. Every message gets a personal reply within one business day.