Markup language
HTML
Describes the structure and meaning of every page and screen.
Why we choose it
Correct structure gives accessibility, search visibility and predictable styling for free, so we treat it as engineering rather than decoration.
Technology stack
Tools chosen to fit the system, team and operating reality.
A complete catalogue of 186 tools across 21 disciplines. Every entry explains what the tool does and why we select it.
Showing 186 of 186 tools
8 tools
Frontend languages and core standards
The foundation every browser product depends on, whatever framework sits above it.
Styling language
CSS
Controls layout, spacing, colour, motion and responsive behaviour.
Why we choose it
Modern layout features remove the need for heavy libraries, which keeps pages lighter and faster on low powered devices.
Programming language
JavaScript
Adds behaviour, interaction and data handling in the browser.
Why we choose it
It is the only language browsers run natively, so every other choice compiles down to it and needs to be understood deeply.
Typed language
TypeScript
Adds a type system on top of JavaScript for larger codebases.
Why we choose it
Types catch contract mistakes before release and make handover safer, which matters most on systems that live for years.
Binary format
WebAssembly
Runs compiled code in the browser at near native speed.
Why we choose it
We use it only for heavy work such as media processing or complex calculation, where JavaScript alone becomes the bottleneck.
Browser standard
Web Components
Creates reusable elements that work without a framework.
Why we choose it
Useful when a component must be shared across products built with different frameworks.
Style preprocessor
Sass
Extends CSS with variables, nesting and shared partials.
Why we choose it
Still valuable on established codebases that depend on it, so we maintain it rather than force a rewrite.
Style toolchain
PostCSS
Transforms styles during the build for compatibility and optimisation.
Why we choose it
It gives us control over browser support without writing fallback code by hand.
10 tools
Frontend frameworks and rendering
Interface frameworks and rendering models chosen against the product, not fashion.
Interface library
React
Builds component based interfaces with a large ecosystem.
Why we choose it
Deep talent availability and mature tooling make it a safe default for products that must be maintained by many people over time.
React framework
Next.js
Adds routing, server rendering and build tooling around React.
Why we choose it
Server rendering improves first load and search visibility for content heavy and public facing products.
Full stack React framework
TanStack Start
Combines typed routing, server functions and rendering.
Why we choose it
Strong type safety from route to server call reduces integration mistakes on complex applications.
Interface framework
Vue
Builds reactive interfaces with a gentle learning curve.
Why we choose it
A good fit when an internal team needs to take ownership quickly with limited frontend depth.
Vue framework
Nuxt
Adds rendering, routing and structure to Vue projects.
Why we choose it
Gives Vue teams the same rendering benefits that Next.js gives React teams.
Application framework
Angular
Provides an opinionated full framework with built in patterns.
Why we choose it
Its structure suits large enterprise teams that value consistency and long support cycles over flexibility.
Compiler framework
Svelte and SvelteKit
Compiles components to small, efficient JavaScript.
Why we choose it
Produces very light bundles, which helps on products used mainly on slow mobile connections.
Content framework
Astro
Ships mostly static pages with interactive parts only where needed.
Why we choose it
Ideal for marketing and publishing sites where speed and search performance matter more than application behaviour.
React framework
Remix
Focuses on web standards, forms and progressive enhancement.
Why we choose it
A strong option when resilience without JavaScript is a requirement.
Build tool
Vite
Runs the development server and production build.
Why we choose it
Fast rebuilds keep engineers productive, and its output is well optimised by default.
8 tools
Styling, design systems and interface libraries
How a consistent visual language is implemented and kept consistent.
Utility styling framework
Tailwind CSS
Applies design decisions directly in markup from a shared token set.
Why we choose it
Design tokens in one place stop styles drifting apart across a large product and across teams.
Component collection
shadcn ui
Provides accessible components that live inside the codebase.
Why we choose it
We own and can change every component, which avoids fighting a closed library later.
Accessibility primitives
Radix Primitives
Supplies unstyled behaviour for menus, dialogs and complex controls.
Why we choose it
Correct keyboard and screen reader behaviour is very hard to build by hand, so we start from a proven base.
Component library
Material UI
Delivers a complete component set based on Material Design.
Why we choose it
Fast route to a familiar, complete interface for internal tools and enterprise dashboards.
Component workshop
Storybook
Develops, documents and reviews components in isolation.
Why we choose it
It gives designers and clients a living record of every component state before assembly into screens.
Design method
Design tokens
Stores colour, spacing and typography decisions as shared values.
Why we choose it
One change updates the whole product, which is essential for rebrands and multi theme requirements.
Animation library
Framer Motion
Adds controlled animation and transitions to interfaces.
Why we choose it
Motion communicates state and hierarchy when used with restraint, and this library keeps it predictable.
Animation platform
GSAP
Builds complex timeline based animation and scroll effects.
Why we choose it
Used for high impact marketing experiences where fine control over sequencing is required.
8 tools
State management and data fetching
Keeping application state predictable and server data fresh.
Server state library
TanStack Query
Fetches, caches and refreshes server data.
Why we choose it
It removes most hand written loading and caching code, which is where interface bugs usually come from.
State container
Redux Toolkit
Manages complex shared client state with strict rules.
Why we choose it
Its discipline pays off on large applications where many teams change the same state.
State library
Zustand
Provides small, simple shared state stores.
Why we choose it
Enough for most products, with far less code than a full state container.
Form library
React Hook Form
Manages form state, validation and submission.
Why we choose it
Efficient re rendering keeps long business forms responsive on modest devices.
Validation library
Zod
Validates data shapes on client and server from one definition.
Why we choose it
Shared validation stops the common gap where the browser and the server disagree about valid input.
Data layer
GraphQL clients
Fetches exactly the fields a screen needs.
Why we choose it
Valuable when many clients read the same data differently and payload size matters.
Rendering strategy
Server side rendering
Renders pages on the server for faster first view.
Why we choose it
Improves perceived speed and search indexing for public content.
Transport
Web sockets and realtime channels
Pushes live updates to connected clients.
Why we choose it
Required for dashboards, messaging and tracking where refreshing by hand is unacceptable.
10 tools
Backend languages and runtimes
Server side languages selected for the workload, the team and the support horizon.
JavaScript runtime
Node.js
Runs JavaScript and TypeScript on the server.
Why we choose it
One language across client and server reduces context switching and lets a smaller team cover the whole product.
Programming language
Python
Powers services, automation, data work and machine learning.
Why we choose it
The strongest ecosystem for data and artificial intelligence work, with very readable code for long term maintenance.
Programming language
Java
Runs large scale enterprise services.
Why we choose it
Proven stability, tooling and long support cycles suit regulated and long lived enterprise systems.
Platform and language
C sharp and dot NET
Builds enterprise services, APIs and desktop software.
Why we choose it
The natural choice for organisations already invested in Microsoft infrastructure and tooling.
Programming language
PHP
Powers content platforms and established web applications.
Why we choose it
Modern versions are fast and well supported, and most content management work still depends on it.
Programming language
Go
Builds small, fast network services and tooling.
Why we choose it
Low memory use and simple deployment make it efficient for high traffic services and infrastructure tools.
Programming language
Ruby
Builds web applications quickly with strong conventions.
Why we choose it
Excellent speed to market for product teams validating an idea.
Systems language
Rust
Builds performance critical and memory safe components.
Why we choose it
Used where safety and speed both matter, such as processing pipelines and low level services.
Programming language
Kotlin on the server
Builds services on the Java platform with modern syntax.
Why we choose it
Lets Java teams modernise gradually without losing their existing ecosystem.
Programming language
Elixir
Runs highly concurrent, fault tolerant services.
Why we choose it
Strong fit for messaging, presence and realtime features at scale.
9 tools
Backend frameworks
Frameworks that give server code structure, security defaults and speed.
Node framework
Express
Builds simple, flexible HTTP services.
Why we choose it
Minimal and well understood, which suits small services and custom architectures.
Node framework
NestJS
Adds modular structure and dependency injection to Node services.
Why we choose it
Its structure keeps large Node codebases organised the way enterprise teams expect.
Python framework
Django
Delivers a full web framework with admin, authentication and data layer.
Why we choose it
Enormous amount of standard functionality out of the box, which shortens delivery for data driven applications.
Python framework
FastAPI
Builds fast, typed APIs with automatic documentation.
Why we choose it
Preferred for machine learning and data services because documentation and validation come from the code itself.
Java framework
Spring Boot
Builds enterprise services with mature patterns.
Why we choose it
Integrates with almost every enterprise system an organisation already runs.
Microsoft framework
ASP.NET Core
Builds high performance APIs and web applications.
Why we choose it
First choice inside Microsoft centred organisations for performance and tooling.
PHP framework
Laravel
Builds modern PHP applications with strong conventions.
Why we choose it
Very productive for business applications and portals with a clear structure that new developers can follow.
Ruby framework
Ruby on Rails
Builds complete web applications rapidly.
Why we choose it
Convention over configuration lets a small team ship a working product quickly.
Node framework
Fastify
Serves high throughput APIs with low overhead.
Why we choose it
Chosen when a Node service must handle heavy request volume efficiently.
9 tools
API design and integration
How systems talk to each other reliably and in a documented way.
API style
REST
Exposes resources over standard HTTP methods.
Why we choose it
Universally understood, easy to cache and simple for third parties to consume.
Query language
GraphQL
Lets clients request exactly the data they need.
Why we choose it
Reduces round trips and payloads when many different screens read overlapping data.
Remote call framework
gRPC
Provides fast typed communication between services.
Why we choose it
Efficient for internal service to service traffic where speed and strict contracts matter.
Specification
OpenAPI
Describes an API in a machine readable contract.
Why we choose it
Documentation, client code and tests can be generated from one source, so they stay aligned.
Event delivery
Webhooks
Notifies systems when something happens.
Why we choose it
Event driven updates avoid constant polling, which lowers cost and latency.
Asynchronous transport
Message queues
Passes work between services without blocking users.
Why we choose it
Protects the user experience when downstream systems are slow or briefly unavailable.
Event streaming platform
Apache Kafka
Moves high volume event streams between systems.
Why we choose it
The right tool when many systems must consume the same stream of events reliably.
API client
Postman
Explores, documents and tests APIs.
Why we choose it
Gives clients and non engineers a way to see and try an integration during delivery.
Middleware
Enterprise integration platforms
Connects enterprise applications and data flows.
Why we choose it
Reduces custom point to point code in organisations with many legacy systems.
9 tools
Mobile engineering
Native and shared code approaches for products that live on phones.
Apple platform
Swift and SwiftUI
Builds native iOS and iPadOS applications.
Why we choose it
Best possible performance, device feature access and platform feel on Apple devices.
Android platform
Kotlin and Jetpack Compose
Builds native Android applications.
Why we choose it
The current Android standard, with full access to platform capability and long term support.
Cross platform framework
Flutter
Builds iOS and Android apps from one codebase.
Why we choose it
Consistent interface across platforms and fast delivery when two native teams are not justified.
Cross platform framework
React Native
Builds mobile apps using React.
Why we choose it
Lets a React team deliver mobile without learning two new platforms, while still reaching native modules when needed.
React Native toolkit
Expo
Simplifies building, testing and releasing React Native apps.
Why we choose it
Removes much of the release and build machinery that slows small teams down.
Mobile backend services
Firebase
Provides authentication, storage, messaging and analytics.
Why we choose it
Fast, dependable foundation for mobile products that do not need a custom backend on day one.
Messaging
Push notification services
Delivers alerts and updates to devices.
Why we choose it
Correct delivery and permission handling protects both engagement and user trust.
Quality tooling
Device testing services
Tests apps across many real devices and versions.
Why we choose it
Fragmentation means a feature can pass on one device and fail on another, so real device coverage is required.
Release platforms
App Store Connect and Google Play Console
Submits, reviews and distributes applications.
Why we choose it
Release readiness, review rules and staged rollout are part of engineering, not an afterthought.
11 tools
Databases and storage
Where information lives, how it is protected and how quickly it can be read.
Relational database
PostgreSQL
Stores structured business data with strong guarantees.
Why we choose it
Reliability, rich features and open licensing make it our default for business critical data.
Relational database
MySQL and MariaDB
Serves widely used web and content workloads.
Why we choose it
Well supported by hosting providers and existing platforms, which simplifies migration work.
Relational database
Microsoft SQL Server
Runs enterprise reporting and transactional workloads.
Why we choose it
Deeply integrated with Microsoft estates and existing reporting investments.
Relational database
Oracle Database
Supports large regulated enterprise systems.
Why we choose it
Often a fixed constraint in established organisations, so we integrate with it carefully rather than replace it.
Document database
MongoDB
Stores flexible document shaped records.
Why we choose it
Useful when records vary in structure or evolve quickly during early product stages.
In memory store
Redis
Caches data, holds sessions and manages queues.
Why we choose it
Cuts response times dramatically and protects the main database from repeated identical reads.
Search engine
Elasticsearch and OpenSearch
Powers fast text search and analytics over large sets.
Why we choose it
Search quality becomes a product feature once catalogues or document sets grow large.
Cloud data warehouse
Snowflake
Stores and queries analytical data at scale.
Why we choose it
Separates analysis from live systems so reporting never slows down the product.
Cloud data warehouse
BigQuery
Runs large analytical queries without managing servers.
Why we choose it
Cost effective for organisations with variable analysis workloads.
File storage
Object storage
Stores documents, media and backups durably.
Why we choose it
Cheaper and more reliable than storing large files inside a database.
Similarity store
Vector databases
Stores embeddings for semantic search and retrieval.
Why we choose it
Required to make artificial intelligence answers grounded in the organisation's own content.
8 tools
Cloud platforms and hosting
Where systems run, and what that choice means for cost, reach and compliance.
Cloud platform
Amazon Web Services
Provides compute, storage, data and network services.
Why we choose it
The broadest service range and regional coverage, which suits complex or global requirements.
Cloud platform
Microsoft Azure
Provides cloud services with deep Microsoft integration.
Why we choose it
Best fit where identity, licensing and internal systems are already Microsoft based.
Cloud platform
Google Cloud
Provides cloud services with strong data and machine learning tooling.
Why we choose it
Preferred for analytics and artificial intelligence heavy workloads.
Edge network
Cloudflare
Delivers content, protects traffic and runs edge code.
Why we choose it
Improves speed for international audiences while absorbing common attack traffic.
Application hosting
Vercel and Netlify
Hosts modern web applications with automated deployment.
Why we choose it
Removes most hosting operations for frontend heavy products, which lowers running cost.
Managed backend platform
Supabase
Supplies database, authentication, storage and functions.
Why we choose it
Gives small teams a complete, standards based backend without operating servers.
Cloud provider
DigitalOcean
Provides straightforward servers and managed databases.
Why we choose it
Predictable pricing and simplicity suit smaller products and internal systems.
Infrastructure model
Private and hybrid hosting
Runs systems in a controlled or on site environment.
Why we choose it
Sometimes required by regulation, data residency rules or existing investment.
8 tools
DevOps, containers and infrastructure
Making environments repeatable, observable and safe to change.
Container platform
Docker
Packages applications with their dependencies.
Why we choose it
The same image runs in development, testing and production, which removes a whole class of environment bugs.
Container orchestration
Kubernetes
Runs and scales containers across machines.
Why we choose it
Worth its complexity only when a system genuinely needs scale, resilience and many services.
Infrastructure as code
Terraform
Defines cloud infrastructure in version controlled files.
Why we choose it
Infrastructure becomes reviewable and rebuildable rather than a series of forgotten manual clicks.
Configuration management
Ansible
Configures servers and applications consistently.
Why we choose it
Keeps existing server estates aligned without rewriting them into containers.
Kubernetes packaging
Helm
Packages and versions Kubernetes deployments.
Why we choose it
Makes complex cluster deployments repeatable and reversible.
Web server and proxy
Nginx
Serves content and routes traffic between services.
Why we choose it
Efficient, stable and well understood for routing, caching and secure termination.
Traffic infrastructure
Load balancers and content delivery networks
Spreads traffic and serves assets close to users.
Why we choose it
Protects availability during traffic spikes and improves speed in distant regions.
Security tooling
Secrets management
Stores and rotates credentials safely.
Why we choose it
Credentials in code are one of the most common causes of serious incidents.
8 tools
Continuous integration and delivery
Automating the path from a code change to a safe release.
Version control
Git
Tracks every change with history and authorship.
Why we choose it
Nothing else in the delivery system works without a reliable change history.
Code platform
GitHub
Hosts repositories, reviews and automation.
Why we choose it
Reviews, issues and pipelines in one place keep accountability visible to the client.
Code platform
GitLab
Hosts code with built in pipelines and governance.
Why we choose it
Often preferred where self hosting or stricter internal control is required.
Delivery platform
Azure DevOps
Manages boards, repositories and releases.
Why we choose it
Natural choice inside Microsoft centred enterprises with existing process requirements.
Automation service
GitHub Actions
Runs build, test and deployment workflows automatically.
Why we choose it
Every change is tested the same way, so release quality does not depend on who is on duty.
Automation server
Jenkins
Runs complex or legacy build pipelines.
Why we choose it
Still the right answer for established pipelines that integrate with older internal systems.
Code quality analysis
SonarQube
Measures code quality and security issues continuously.
Why we choose it
Turns maintainability into a visible metric rather than an opinion.
Release technique
Feature flags
Turns features on and off without a new deployment.
Why we choose it
Lets us release code early, test with a small group and reverse a change instantly.
8 tools
Observability and reliability
Knowing what the system is doing before customers tell you.
Metrics system
Prometheus
Collects and stores operational metrics.
Why we choose it
Open standard for metrics, which avoids being locked into one monitoring vendor.
Dashboard platform
Grafana
Visualises metrics and logs for teams.
Why we choose it
Shared dashboards let business and engineering look at the same evidence during an incident.
Monitoring platform
Datadog
Monitors infrastructure, applications and logs together.
Why we choose it
Reduces time to diagnose because traces, logs and metrics are already connected.
Error tracking
Sentry
Captures application errors with context.
Why we choose it
Shows real user facing failures with the detail needed to fix them quickly.
Instrumentation standard
OpenTelemetry
Produces traces, metrics and logs in a portable format.
Why we choose it
Instrument once and keep the option to change monitoring vendor later.
Availability checks
Uptime and synthetic monitoring
Tests critical journeys from outside the system.
Why we choose it
Confirms the product works from a customer position, not only inside the network.
Logging
Log aggregation
Centralises logs from every service.
Why we choose it
Investigating an incident across separate machines is impractical without it.
Operational practice
Incident response runbooks
Documents how to detect, escalate and recover.
Why we choose it
Under pressure, teams need a written path rather than improvisation.
10 tools
Security and compliance
Protecting data, access and reputation across the whole delivery life cycle.
Security standard
OWASP practices
Guides prevention of common application vulnerabilities.
Why we choose it
Most breaches use well known weaknesses, so a shared checklist prevents avoidable mistakes.
Authorisation standards
OAuth and OpenID Connect
Delegates sign in and access safely between systems.
Why we choose it
Standard flows avoid home made authentication, which is a frequent source of serious flaws.
Access control
Multi factor authentication
Requires a second proof of identity.
Why we choose it
The single most effective control against stolen passwords.
Authorisation model
Role based access control
Grants permissions by role rather than individual.
Why we choose it
Keeps access reviewable and simple to correct when people change roles.
Database control
Row level security
Enforces data access rules inside the database.
Why we choose it
Protection stays in place even if an application layer mistake occurs.
Security testing
Vulnerability scanning
Finds known weaknesses in code and dependencies.
Why we choose it
Dependencies change constantly, so scanning must be continuous rather than annual.
Security assessment
Penetration testing
Tests defences the way an attacker would.
Why we choose it
Independent testing finds the logic flaws that automated scanning misses.
Data protection
Encryption in transit and at rest
Protects data while moving and while stored.
Why we choose it
Required by regulation in most markets and expected by every serious client.
Accountability control
Audit logging
Records who did what and when.
Why we choose it
Essential for investigation, dispute resolution and compliance evidence.
Resilience practice
Backup and disaster recovery
Restores service and data after a failure.
Why we choose it
A backup that has never been restored is an assumption, so we test recovery.
10 tools
Quality assurance and testing
Evidence that the product works now and will keep working after the next change.
Browser automation
Playwright
Tests complete user journeys across browsers.
Why we choose it
Reliable modern automation that catches integration failures a unit test cannot see.
Browser testing
Cypress
Tests interfaces with fast developer feedback.
Why we choose it
Its debugging experience encourages engineers to write and maintain tests.
Browser automation
Selenium
Automates browsers across many environments.
Why we choose it
Still needed for wide legacy browser coverage in enterprise contexts.
Mobile automation
Appium
Automates tests on real mobile devices.
Why we choose it
Mobile release cycles are slow to fix, so defects must be caught before submission.
Unit testing frameworks
Jest and Vitest
Tests functions and components in isolation.
Why we choose it
Fast feedback at the smallest level keeps refactoring safe.
Unit testing frameworks
JUnit and NUnit
Tests Java and dot NET code.
Why we choose it
Standard tools inside enterprise stacks, with strong reporting integration.
Python testing framework
PyTest
Tests Python services and data pipelines.
Why we choose it
Concise tests make data logic verification practical rather than theoretical.
Performance testing
JMeter and k6
Measures behaviour under load.
Why we choose it
Performance problems are far cheaper to fix before launch than during a busy trading period.
Accessibility tooling
Axe accessibility testing
Detects accessibility violations automatically.
Why we choose it
Automated checks catch the majority of issues early, leaving manual review for judgement based ones.
Quality method
ISTQB aligned test process
Structures strategy, cases, execution and reporting.
Why we choose it
A recognised process makes quality results comparable and defensible to clients.
12 tools
Data engineering, analytics and artificial intelligence
Turning raw information into trusted reporting and useful automation.
Workflow orchestration
Apache Airflow
Schedules and monitors data pipelines.
Why we choose it
Visible dependencies and retries make data delivery dependable instead of fragile.
Analytics engineering tool
dbt
Transforms warehouse data with tested, version controlled models.
Why we choose it
Brings engineering discipline and testing to reporting logic.
Distributed processing
Apache Spark
Processes very large data sets in parallel.
Why we choose it
Used when volumes exceed what a single database can process in an acceptable time.
Business intelligence
Power BI
Builds reports and dashboards for business teams.
Why we choose it
Strong fit for Microsoft based organisations and familiar to most finance teams.
Business intelligence
Tableau
Explores and visualises data interactively.
Why we choose it
Excellent for analysts who need to investigate rather than only view fixed reports.
Reporting tool
Looker Studio
Creates shareable dashboards from connected sources.
Why we choose it
Low cost route to shared reporting for smaller organisations.
Data libraries
Pandas and NumPy
Prepares and analyses data in Python.
Why we choose it
The practical foundation for analysis, cleaning and feature preparation.
Machine learning library
Scikit learn
Trains classical machine learning models.
Why we choose it
For most business prediction problems it is more appropriate and cheaper than deep learning.
Deep learning frameworks
TensorFlow and PyTorch
Builds and trains neural network models.
Why we choose it
Needed for image, audio and language problems that classical models cannot solve well.
Artificial intelligence services
Large language model services
Adds language understanding, drafting and extraction.
Why we choose it
Hosted models remove training cost, so value can be tested before heavy investment.
Artificial intelligence pattern
Retrieval augmented generation
Grounds model answers in approved company content.
Why we choose it
It is the practical way to reduce invented answers in business use.
Quality practice
Model evaluation and monitoring
Measures accuracy, cost and drift in production.
Why we choose it
Without measurement, automated decisions degrade quietly and damage trust.
8 tools
Automation and integration platforms
Connecting everyday business tools without writing a system from scratch.
Workflow automation
n8n
Builds automated workflows that can be self hosted.
Why we choose it
Self hosting keeps sensitive data inside the client environment.
Automation service
Zapier
Connects common business applications quickly.
Why we choose it
Fast way to prove an automation is valuable before engineering it properly.
Automation service
Make
Builds visual multi step integrations.
Why we choose it
Useful for operations teams who need to adjust their own workflows.
Microsoft automation
Power Automate
Automates tasks across Microsoft services.
Why we choose it
Best fit where work already happens inside Microsoft tools.
Automation method
Robotic process automation
Automates repetitive work in systems without APIs.
Why we choose it
Sometimes the only practical route to automate an old system that cannot be changed.
Extraction tooling
Document processing services
Reads text and fields from documents and images.
Why we choose it
Removes manual data entry, which is slow and error prone at volume.
Operational automation
Scheduled jobs
Runs recurring work on a defined schedule.
Why we choose it
Used only where work is genuinely time based, because unnecessary schedules add cost.
Automation pattern
Event driven triggers
Starts work when something actually happens.
Why we choose it
More efficient and more responsive than repeatedly checking for changes.
8 tools
Content management and commerce platforms
Platforms that let business teams publish and sell without engineering support.
Content management system
WordPress
Publishes and manages website content.
Why we choose it
Familiar to most marketing teams, with a very large plugin ecosystem.
Content management
Headless content platforms
Stores content for delivery to any channel.
Why we choose it
One content set can serve a website, an app and a kiosk without duplication.
Commerce platform
Shopify and Shopify Plus
Runs online stores, checkout and payments.
Why we choose it
Handles payment compliance and scale so effort goes into conversion instead of infrastructure.
Storefront technologies
Shopify Liquid and Hydrogen
Builds custom Shopify storefront experiences.
Why we choose it
Needed when a brand requires more than a theme can express.
Commerce plugin
WooCommerce
Adds commerce to WordPress sites.
Why we choose it
Sensible for smaller catalogues already living inside WordPress.
Commerce platform
Magento and Adobe Commerce
Supports large, complex catalogues and business rules.
Why we choose it
Appropriate for enterprise commerce with complicated pricing and multi store needs.
Data platform
Product information management
Centralises product data across channels.
Why we choose it
Prevents inconsistent product information across storefronts and marketplaces.
Commerce tooling
Search and merchandising tools
Improves discovery and product ranking.
Why we choose it
Search quality is one of the strongest levers on commerce conversion.
8 tools
Design, research and content tooling
The tools behind clear interfaces and evidence based decisions.
Design platform
Figma
Designs interfaces and prototypes collaboratively.
Why we choose it
Clients can review and comment in the same file engineers build from, which removes version confusion.
Collaboration board
FigJam
Runs workshops, mapping and planning sessions.
Why we choose it
Distributed discovery sessions need a shared visual space.
Research tooling
Usability testing tools
Observes real users completing tasks.
Why we choose it
Five sessions usually reveal more than weeks of internal debate.
Measurement
Analytics and behaviour tools
Shows how people actually move through the product.
Why we choose it
Design decisions should be corrected by evidence after launch, not defended.
Inclusive design
Accessibility review tools
Checks contrast, structure and assistive technology support.
Why we choose it
Accessibility is a legal expectation in many markets and improves usability for everyone.
Content practice
Content style guides
Keeps language clear and consistent.
Why we choose it
Clear wording reduces support requests more cheaply than new features do.
Design tooling
Prototyping and motion tools
Demonstrates interaction before build.
Why we choose it
Cheaper to change a prototype than a released feature.
Delivery practice
Design handover documentation
Records states, rules and edge cases for engineers.
Why we choose it
Prevents interpretation gaps that appear late in testing.
8 tools
Project management and collaboration
How work is planned, tracked and reported so clients always know where things stand.
Work tracking
Jira
Plans and tracks delivery work in detail.
Why we choose it
Strong reporting and traceability for multi team programmes.
Issue tracking
Linear
Tracks product work with a fast, focused workflow.
Why we choose it
Lightweight and quick for product teams that value momentum.
Task management
Trello and Asana
Coordinates simpler workstreams visually.
Why we choose it
Easy for client side stakeholders to follow without training.
Documentation
Confluence and Notion
Holds decisions, specifications and operating notes.
Why we choose it
Written decisions protect the project when people change.
Communication
Slack and Microsoft Teams
Runs daily collaboration and escalation.
Why we choose it
One agreed channel prevents decisions getting lost in private messages.
Delivery method
Agile and Scrum practices
Delivers in short reviewed increments.
Why we choose it
Frequent review reduces the risk of building the wrong thing for months.
Delivery method
Kanban
Manages continuous flow and support work.
Why we choose it
Better suited than sprints to maintenance and unpredictable request volume.
Governance practice
Structured reporting
Reports progress, risk and spend regularly.
Why we choose it
Clients should never have to ask where a project stands.
8 tools
Payments, communication and growth tooling
Operational services that turn a product into a working business.
Payment platform
Stripe
Processes payments and subscriptions.
Why we choose it
Strong developer tooling and compliance coverage across many markets.
Payment services
PayPal and regional gateways
Offers locally trusted payment methods.
Why we choose it
Local payment preference has a direct effect on completed sales.
Messaging
Transactional email services
Delivers receipts, alerts and account email.
Why we choose it
Deliverability engineering matters more than message design for these messages.
Business system
Customer relationship platforms
Tracks customers, deals and service history.
Why we choose it
Integrating the product with the customer record avoids duplicated manual work.
Growth tooling
Search engine optimisation tooling
Monitors indexing, performance and visibility.
Why we choose it
Technical search issues waste marketing budget quietly, so they need monitoring.
Compliance
Consent and privacy tooling
Manages cookie and tracking consent.
Why we choose it
Required in many regions and protects the organisation from avoidable exposure.
Measurement
Product analytics
Measures feature adoption and retention.
Why we choose it
Tells us which features deserve further investment and which should be removed.
Service tooling
Customer support platforms
Handles support requests and knowledge articles.
Why we choose it
Support data is the cheapest source of product improvement ideas.
Build the next critical product with us.
Bring us the business problem. We’ll help shape the right technology response.