Every tool, explained.

Large language models that read and write text; we build assistants, agents and automation on them.

Retrieval-augmented generation: the model answers from your own documents, with sources, not from memory.

Open-source deep-learning framework; we use it to train, fine-tune and export custom models.

Google's machine-learning framework; we train models with it and deploy them to servers, browsers and phones.

Hub and libraries for open models; we use them to pick, fine-tune and run open-weight models.

Framework for chaining prompts, tools and retrieval; we use it to wire up RAG pipelines and agents.

High-throughput LLM serving engine; we use it to run open models fast and cheaply on your GPUs.

Runs open models locally with one command; we use it for private prototypes and on-premises assistants.

llama.cppOn-device inference

Lean C/C++ inference for quantised models; we use it to run LLMs on CPUs and edge devices.

Python's classic machine-learning toolkit; we use it for classification, regression, clustering and quick baselines.

Fast multi-dimensional arrays for Python; the numerical foundation under our data and ML code.

Fast DataFrame library written in Rust; we use it to clean and reshape large datasets in Python.

Open-source computer-vision library; we use it to resize, clean and analyse images and video frames.

Real-time object-detection models; we train them to find and count objects in images and live video.

Classic Python toolkit for language data; we use it to tokenise, tag and clean text before modelling.

Distributed, durable event log; we use it as the real-time backbone that moves events between systems.

Reliable message broker; we use it for task queues, retries and routing work between services.

Messaging platform that combines streams and queues; we use it for multi-tenant, geo-replicated pipelines.

Google Cloud's serverless messaging service; we use it to fan events out across GCP without running brokers.

Stateful stream processor; we use it for real-time aggregations, alerts and exactly-once event pipelines.

Engine for large-scale batch and streaming jobs; we use it to transform huge datasets across a cluster.

Spark's stream-processing API; we use it to process live data with the same code as batch jobs.

Spark's Python API; we use it to write distributed data jobs in familiar Python and SQL.

Framework for storing and processing data across clusters; we run, migrate and modernise Hadoop estates.

Hadoop's distributed file system; stores very large files across many machines with built-in replication.

Hadoop's resource manager; shares a cluster's CPU and memory between Spark, Hive and MapReduce jobs.

Hadoop's original batch model; we maintain existing MapReduce jobs and move them to Spark.

Column-family database on HDFS; we use it for fast random reads and writes over billions of rows.

SQL over files in HDFS and object storage; its metastore also catalogues tables for Spark and Trino.

HueSQL workbench

Web SQL editor for Hadoop; lets analysts query Hive and Impala and browse data from a browser.

Coordination service for distributed systems; keeps configuration, leader election and locks consistent.

Workflow scheduler for Hadoop jobs; we maintain existing Oozie pipelines and migrate them to Airflow.

Distributed SQL engine that queries many data sources where they live, without copying data first.

Fast distributed SQL engine forked from Presto; we use it to query lakes and databases together.

Massively parallel SQL engine for Hadoop; we use it for interactive queries over HDFS and HBase data.

Open table format for huge analytic tables; adds ACID transactions, schema evolution and time travel to lakes.

Delta LakeTable format

Open table format created by Databricks; brings ACID transactions, versioning and upserts to Parquet files.

Columnar file format; we store analytics data in it because it compresses well and scans fast.

Compact, schema-based row format; we use it for event messages so producers and consumers agree on structure.

Columnar file format optimised for Hive; we use it on Hadoop for compact storage and fast scans.

Visual dataflow tool; we use it to pull data from files, APIs and databases, tracking every record.

Workflow orchestrator; we use it to schedule pipelines as code, with retries, alerts and dependencies.

Extract, transform, load: data is cleaned and reshaped before it lands in the warehouse.

Extract, load, transform: raw data lands first, then gets modelled inside the warehouse with SQL.

Processing data in scheduled chunks; cheaper and simpler whenever results can wait minutes or hours.

Processing events continuously as they arrive; we use it when answers are needed in seconds, not tomorrow.

Holding data in a queue between systems, so traffic spikes never overwhelm the services downstream.

Google's serverless data warehouse; we use it for SQL analytics over large datasets without managing servers.

Cloud data platform that separates storage from compute; we use it for shared, scalable SQL analytics.

Managed Spark lakehouse platform; we use it for pipelines, SQL analytics and ML on Delta tables.

Open-source relational database with strong transactions, rich SQL, JSON support and extensions like pgvector.

Stores flexible, JSON-like documents; a good fit for fast-changing product data, content and catalogues.

Community-developed fork of MySQL; we run and migrate it for web apps that need familiar SQL.

The standard language for relational data; we write and tune it for reports, migrations and fast queries.

Enterprise relational database; we integrate with, tune and migrate Oracle systems in larger organisations.

In-memory data store; we use it for caching, sessions, rate limits, queues and live leaderboards.

Store embeddings for similarity search; the memory behind RAG, semantic search and recommendations.

Document database with built-in replication; we use it for offline-first apps that sync when back online.

Distributed database for massive write volumes that stays available across data centres.

Distributed search and analytics engine; we use it for full-text search, filters and log analytics.

Apache-licensed fork of Elasticsearch; we use it for search and log analytics, especially on AWS.

Mature search platform built on Lucene; we maintain and extend Solr search for catalogues and archives.

Database built for timestamped data; we use it for sensor readings, monitoring metrics and live dashboards.

PostgreSQL extension for time-series data; fast time-based queries with plain SQL and Postgres tooling.

Distributed in-memory database and cache; we use it to speed up heavy reads and computations.

Column-oriented database for real-time analytics; aggregates very large event tables quickly for dashboards.

Self-hosted storage cluster that provides object, block and file storage, often on your own hardware.

S3-compatible object storage: Amazon S3 in the cloud, MinIO when data must stay on your servers.

Cheap, durable storage for files, media, backups and data-lake tables, reached over simple HTTP APIs.

JavaScript on the server; we use it for fast, I/O-heavy APIs and real-time services.

Fast all-in-one JavaScript runtime, bundler and test runner; we use it to speed up services and tooling.

Structured TypeScript framework for Node.js; we use it for large back ends with modules and dependency injection.

Minimal Node.js web framework; we use it for lightweight APIs, webhooks and middleware.

Lean Node.js framework from the team behind Express, built around async middleware for small services.

Readable, versatile language; we use it for APIs, data pipelines, automation scripts and AI work.

Compiled language built for concurrency; we use it for fast, small-footprint services and infrastructure tools.

Memory-safe systems language with C-level speed; we use it for performance-critical services and tooling.

Mature, strongly typed JVM language; the backbone of many enterprise systems we build and modernise.

Production-ready Java framework; we use it for enterprise APIs and microservices.

Expressive, developer-friendly language; we use it mainly with Rails for product back ends.

Convention-over-configuration web framework; we use it to ship and extend full-featured products quickly.

Low-level systems language; we use it for native extensions, embedded code and performance-critical routines.

High-performance compiled language; we use it for native modules, inference engines and latency-sensitive code.

Splitting a system into small, independently deployable services, so teams ship and scale parts separately.

Resource-based HTTP APIs; we design them versioned, documented with OpenAPI and easy for partners to use.

Query language for APIs; clients ask for exactly the data they need in a single round trip.

Fast, typed remote calls over HTTP/2 with Protocol Buffers; we use it between internal services.

XML-based web-service protocol; we integrate with the SOAP services still common in enterprise and finance.

Standard for delegated access; we use OAuth 2.0 and OpenID Connect for secure sign-in and API tokens.

Persistent two-way connection between browser and server; we use it for live chat, dashboards and collaboration.

Real-time audio, video and data between browsers; we use it for calls, meetings and live sessions.

Server-sent events: one-way streaming over plain HTTP, ideal for live feeds and streamed AI responses.

The lightweight text format nearly every modern API speaks; we design clean, versioned JSON contracts.

Structured markup format still common in enterprise, finance and government integrations, which we map and validate.

The semantic structure of every page; we write accessible, standards-based markup that search engines understand.

Layout and style for the web; modern grid, container queries and custom properties keep UIs responsive.

The language of the web; powers interactivity in every browser and, with Node.js, on servers too.

JavaScript with static types; we use it front to back to catch bugs before users do.

Component-based UI library; we use it to build fast, interactive interfaces from reusable pieces.

Server-rendered React framework; we build fast, crawlable products on it - this site included.

Google's full-featured TypeScript framework; we use it for large enterprise apps that need strict structure.

Compiler-based UI framework that ships very little JavaScript, so interfaces stay small and fast.

Content-first web framework that ships zero JavaScript by default; ideal for fast marketing sites and docs.

Utility-first CSS framework; we use it to build consistent, responsive design systems quickly.

CSS with variables, mixins and nesting; we maintain and modernise Sass codebases in larger design systems.

Copy-in React components built on Radix and Tailwind; a fast, fully ownable start for a design system.

Unstyled, accessible React primitives - dialogs, menus, tabs - that we style into custom design systems.

Predictable global state for complex React apps, with a strict update flow and time-travel debugging.

ZustandState management

Tiny, hook-based state library for React; we reach for it when Redux would be overkill.

Fetches, caches and syncs server data in React, with background refresh and optimistic updates.

Atom-based React state library from Meta, now archived; we maintain Recoil apps and migrate them off it.

WebGL 3D library; we use it for product viewers, data visualisations and interactive scenes in the browser.

Augmented and virtual reality on the web with WebXR, from 3D product previews to training simulations.

Technical SEO built into every build: fast pages, structured data, clean markup and crawlable rendering.

Apple's modern language; we use it with SwiftUI for fully native iPhone and iPad apps.

Google's preferred language for Android; we use it with Jetpack Compose for native Android apps.

Google's UI toolkit; one Dart codebase compiled to native iOS and Android apps with a custom look.

Native mobile apps written in React, sharing skills and logic with your web team.

Google's mobile platform; we design, build and ship apps to Google Play across phones and tablets.

Apple's mobile platform; we build, test and release apps through TestFlight and the App Store.

Google's app platform; we use it for sign-in, push notifications, crash reports and analytics.

Packages an app and everything it needs into a container that runs the same everywhere.

Runs containers across a cluster - scheduling, scaling, rolling updates and self-healing.

Defines cloud infrastructure as reviewable code, so every environment is repeatable and auditable.

Google's cloud; we build on services such as GKE, Cloud Run, BigQuery and Vertex AI.

Microsoft's cloud; we deploy on AKS, App Service and Azure's AI services for Microsoft-centric teams.

Distributed version control; every change is tracked, reviewed and reversible.

Code hosting and collaboration; we run reviews, issues and releases there, often inside your organisation.

DevOps platform with built-in CI/CD; ideal when code and pipelines should live together, or self-hosted.

CI/CD built into GitHub; we use it to test, build and deploy on every push.

Global edge network for CDN, DNS, DDoS protection and serverless Workers that run close to users.

Platform for deploying Next.js and other frontends, with a preview URL for every pull request.

Fast web server and reverse proxy; we use it for TLS termination, load balancing and routing.

VarnishHTTP cache

HTTP accelerator that caches responses in front of your app, cutting the load on busy sites.

Dashboards and alerting for metrics, logs and traces; we use it to watch systems in production.

The Unix shell; we use it for build scripts, automation and glue code in CI pipelines.