Seven technical disciplines,and the roles we fill in each.

Batch & streaming ingestion

change-data-capture off operational databases, event streams through Kafka and Flink, and file drops that arrive late or out of order

Warehouse & lakehouse modelling

dimensional and wide-table designs on Snowflake, BigQuery and Databricks, with Iceberg where the table format has to outlive the engine

Transformation layers

dbt projects with tested, documented models, so the definition of a metric lives in version control rather than in six different dashboards

Orchestration

Airflow DAGs with sensible retries, backfills and dependencies, built so a job that fails at 3am is diagnosable in the morning

Data quality & contracts

freshness, volume and schema tests at the boundary, and alerts that fire before a stakeholder notices

Performance & cost

partitioning, clustering, file sizing and query tuning; warehouse spend is usually a design problem rather than a pricing one

Governance & access

lineage, cataloguing, PII handling and row-level access that holds up to an audit

Analytics enablement

semantic layers and BI models that let analysts answer new questions without reopening the pipeline

LLM applications

assistants, copilots, document extraction and summarisation, built on hosted or open-weight models

RAG pipelines

chunking strategy, embeddings, hybrid and vector retrieval, re-ranking, and answers grounded in citable sources

Custom model development

forecasting, recommendation, classification, anomaly detection and computer vision trained on your data

Fine-tuning & adaptation

LoRA and full fine-tunes for the point where prompting stops being enough

Agentic systems

tool use, multi-step orchestration, and human-in-the-loop review on anything consequential

Evaluation & guardrails

offline eval sets, LLM-as-judge scoring, hallucination, PII and prompt-injection checks before release

MLOps

feature stores, model registries, versioning, drift detection, monitoring and scheduled retraining

Inference & cost engineering

quantisation, batching, caching and serving choices that keep the bill proportional to the value

API design & services

REST and GraphQL boundaries in Spring, Django, .NET and Node, versioned so today's clients survive tomorrow's release

Front-end applications

React and Angular interfaces in TypeScript, with state management that stays legible past the first thousand lines

Domain & data modelling

schemas and aggregates that match how the business actually works, not the first screen someone drew

Legacy modernisation

strangler-fig migrations off monoliths, keeping the old system serving traffic while the new one takes over route by route

Integration work

third-party APIs, payment and identity providers, message queues, and the retry and idempotency logic that makes them safe

Authentication & authorisation

OAuth and OIDC, single sign-on, role and tenant isolation implemented once and reused

Testing & delivery

unit, integration and contract tests wired into CI so a merge is a decision rather than a gamble

Performance & observability

profiling, caching, query tuning and tracing that shows where a slow request actually spent its time

Assessment & wave planning

dependency mapping and an honest sequence, so the first thing to move isn't the thing everything else depends on

Landing zones

accounts, networking, identity and guardrails on AWS, Azure or Google Cloud, in place before a single workload lands

Infrastructure as code

Terraform modules and state management, so an environment can be rebuilt rather than remembered

Containerisation

Docker packaging and Kubernetes deployment with resource limits, health probes and rollout strategies that hold under load

Data migration

bulk transfer, replication and cutover rehearsals, with a rollback path that has actually been tested

Re-platform or refactor

deciding per workload which ones move as they are and which earn the rewrite

Cost management

right-sizing, commitment planning, autoscaling and tagging, so the bill is attributable to a team

Resilience

multi-zone design, backup and restore drills, and recovery targets that are measured rather than asserted

Test strategy

deciding what belongs in unit, integration, contract and end-to-end layers instead of pushing everything through the UI

End-to-end automation

Playwright, Cypress and Selenium suites built on stable selectors and real user journeys

API & contract testing

service-level coverage in pytest and JUnit that catches breakage before the front end ever sees it

CI pipelines

Jenkins and GitHub Actions wiring, with parallelisation and sharding so the suite finishes inside a coffee break

Flake control

isolating non-deterministic tests, fixing waits and shared state, and quarantining rather than deleting

Performance testing

k6 load and soak profiles with thresholds that fail the build, not a PDF nobody opens

Test data & environments

seeding, fixtures and ephemeral environments so parallel runs don't corrupt each other

Release readiness

coverage signals, smoke packs and rollback checks that make a go/no-go call evidence-based

Native applications

Swift with SwiftUI on iOS and Kotlin with Jetpack Compose on Android, where platform feel is worth the two codebases

Cross-platform builds

React Native and Flutter when one codebase across both stores is the better trade

Offline-first behaviour

local persistence, background sync and conflict resolution for apps used on bad connections

Device integration

camera, location, biometrics, push notifications, background tasks and the permission prompts around them

Release engineering

signing, provisioning, staged rollouts, TestFlight and Play tracks, and the review cycle each store imposes

Performance on real devices

startup time, frame pacing, memory and battery, measured on the hardware people actually carry

Accessibility

VoiceOver and TalkBack support, dynamic type and contrast, designed in rather than retrofitted

Backend-for-frontend

the API shaping, caching and payload trimming that decide how fast an app feels on cellular

Server estate

Linux and Windows Server builds, patching and hardening, standardised so hosts are interchangeable

Virtualisation

VMware clusters, capacity planning and consolidation, including the hosts nobody has dared touch for years

Networking

Cisco routing, switching, segmentation, VPNs and firewall policy, documented as it actually is

Configuration management

Ansible roles and playbooks, so the same change is applied the same way everywhere

Monitoring & alerting

Prometheus metrics and Grafana dashboards, with alerts tied to symptoms users feel rather than raw counters

Backup & recovery

schedules, retention and restore tests, because an untested backup is only a hope

Identity & access

directory services, privileged access and joiner-mover-leaver processes that keep pace with the org

Support model

runbooks, escalation paths and on-call rotations that make handover possible