GPU inference platforms
Multi-tenant LLM serving on vLLM across GH200 and L40S. Per-model quantisation tuned against a latency and cost budget, with tenant isolation and capacity planning.
- vLLM
- GH200 / L40S
- FP8 KV-cache
- 4-bit quant
AI infrastructure, engineered for production.
We build the systems that run AI when it actually has to work: GPU inference platforms, Kubernetes and platform engineering, vector search, and high-throughput backends. Senior engineering, measured in latency, memory and throughput.
Start a conversationOr read what we build, below.
Teams we have built for
- + further clients under NDA
What we build
Production systems, delivered to spec. Each line below is something we have shipped and run, not a service category.
Platform & Kubernetes engineering
Custom operators and control-plane work in Go. Service-to-service auth, gateway routing and IAM, plus the golden paths that let product teams ship without filing tickets.
- Go operators
- S2S auth
- IAM
- GitOps
Retrieval & RAG systems
Production retrieval pipelines on Qdrant. Markdown-aware chunking, async orchestration with Celery, and a retrieval layer built to be evaluated and tuned rather than demoed once.
- Qdrant
- chunking
- Celery
- eval
Search & latency engineering
Query paths rebuilt for sub-100ms response. Trie-based autocomplete, index design, and the profiling discipline to find where the milliseconds actually go, and remove them.
- autocomplete
- indexing
- profiling
- p99
High-performance microservices
Service boundaries that survive contact with traffic. Go and Python services on gRPC and REST, with backpressure, idempotency and the consistency trade-offs made explicit.
- Go
- gRPC / REST
- event-driven
- backpressure
High-throughput & real-time backends
Real-time, high-volume systems across ad tech and marketplaces: distributed data paths, queueing, and sustained throughput under tight latency SLAs.
- real-time
- queueing
- throughput
- SLA
Case Studies
GPU inference platform
Client confidential
Built the multi-tenant inference layer for a GPU-cloud product. The core of the work was a per-model quantisation strategy chosen against a latency-and-cost budget: 4-bit weight-only for smaller models, FP8 KV-cache for larger ones. More tenants per GPU on the same hardware.
Production RAG system
Client confidential
Retrieval over a large internal document set, built to run in production rather than demo once. Qdrant vector store, markdown-aware chunking that preserves document structure, Celery for async ingestion, with the retrieval layer instrumented so quality can be measured and tuned.
Managed-cloud control plane
Client confidential
Control-plane engineering in Go for a managed database product. Service-to-service authentication and gateway routing, plus a cluster-api ↔ IAM auth path securing internal traffic between control-plane components.
Search & autocomplete rebuild
Client confidential
Rebuilt the autocomplete path for a consumer commerce platform. A Trie-based design dropped query latency from 300ms to 61ms while improving relevance. Typeahead that holds up under catalogue-scale load.
Real-time bidding backend
Client confidential
Backend engineering for a real-time advertising platform: high-QPS services on tight latency budgets, where sustained throughput and reliability under load are the product.
Marketplace-scale services
Client confidential
Services inside a large online marketplace, where high-volume systems run under continuous production traffic.
Products we’ve shipped
Beyond client delivery we design and build complete products. Proof we can own a system from architecture to running code, not just augment a team.
drvl.ai early access
Fleet intelligence platform
Driver safety scoring from smartphone sensors, with no extra hardware. Trip-by-trip behaviour analysis, event detection for harsh braking, acceleration and cornering, GPS route playback and fleet dashboards, delivered as an SDK and an app.
Recco
Conversational discovery
Conversational product discovery for occasion-wear and fashion, with an affiliate commercial model. Natural-language intake mapped to a curated catalogue.
Rippleberry
B2B outreach
B2B outreach automation, built end-to-end as a working product, from data layer through to sequencing.
How we workA senior team, not a body shop.
A small senior team, accountable for the outcome
You work directly with the engineers building your system. No account layer, no hand-off to a junior bench, no ticket queue between you and the person who wrote the code.
Senior only
Every engagement is staffed by engineers who have run systems like yours in production. The same people scope it, build it and answer for it.
Trade-offs in the open
Latency against cost, consistency against throughput. We put the choice and its price in writing before the code is written.
You keep the system
Tests, runbooks and hand-over are part of delivery. We leave your team able to operate and change what we built.
How we engage
Three shapes of work. Pick the one that fits the problem; we will say if it is the wrong one.
Embedded engineering
Senior capacity inside your team for a defined period, owning a hard system end-to-end and leaving your engineers able to run it.
Scoped delivery
A specific system built to an agreed spec and acceptance criteria, with the trade-offs made explicit before a line of code is written.
Architecture review & advisory
A second senior opinion on inference cost, scaling, distributed-systems consistency or platform design. Direct, with the reasoning shown.
See something you would like?
Tell us the problem and the constraints. You will get a direct read on whether it is something RStark should take on, and how.