Technology

The stack behind the work

What our engineers build with — from the database up to the AI layer. Search it, or read it top to bottom.

8disciplines
187tools and techniques
37AWS services

How it fits together

One system, eight layers

Most of what we build has the same shape. Here is each layer, and what we reach for first.

L1
Frontend
What people touch
- Flutter
- Progressive Web Apps
- Bootstrap
- React (hands-on)
L2
API
The contract between screens and logic
- FastAPI
- Django REST Framework
- Laravel
- API Gateway
L3
Business services
Where the rules live
- Django
- Laravel
- LangGraph
- Lambda
L4
Workers
Slow work, off the request path
- Celery
- asyncio
- Step Functions
- ECS
L5
Queues & events
How parts talk without waiting
- SQS
- SNS
- EventBridge
- Apache Kafka
L6
Data
The source of truth, and fast recall
- PostgreSQL
- MySQL
- Redis
- pgvector
- DynamoDB
L7
Analytics
What happened, and why
- Apache Spark
- Athena
- Power BI
- Apache Superset
L8
Monitoring
Knowing before your customers do
- CloudWatch
- New Relic
- PagerDuty
- LangSmith

AI & LLM engineering

Production AI, not demos

Retrieval, agents and generative BI with an evaluation layer around them — on your cloud, or on your own hardware.

Knowledge in — runs when your documents change

01
Parse
PDFs, sheets, pages and scans
- Document parsing & ingestion
02
Chunk
Split on meaning, not page breaks
- Smart chunking
03
Embed
Turn each chunk into a vector
- Embeddings
04
Index
Store with metadata for filtering
- pgvector
- Qdrant
- Chroma

Answer out — runs on every question

01
Retrieve
Keyword and semantic, together
- Hybrid search
- Metadata filtering
02
Rerank
Keep only what actually answers
- Reranking
03
Generate
Answer from what was retrieved, streamed
- LLM APIs
- Ollama
- Token streaming
04
Evaluate
Score, trace and guard the answers
- LangSmith
- Guardrails

Agent patterns we build with

ReAct

Reason, act with a tool, observe, repeat — until the task is done.

Reflection

The agent critiques its own draft before you ever see it.

Planning

Break a large request into ordered steps, then work the plan.

Multi-agent

Specialist agents hand work to each other under a supervisor.

Tool use

Call your APIs, databases and MCP servers — with permissions.

Routing

Send each request to the cheapest model or path that can answer it.

The trust layer

Prompt and retrieval evaluation, so quality is measured rather than assumed
Hallucination detection against the source material
Guardrails on what goes in and what comes out
Tracing with LangSmith
AI monitoring once it is live

Your data can stay in the building.

Open-source models served with Ollama and Open WebUI on your own servers — air-gapped where compliance or data residency demands it.

What we have shipped

Chatbots and conversational assistants
Copilots embedded in existing products
Document and knowledge assistants
Generative BI — ask your data in plain English
Browser automation agents
n8n workflow automation

Talk about an AI project Send a brief

The full stack

Every discipline, every tool

Filled dots are in production today; rings are hands-on experience we'd tell you about honestly before you rely on it.

AI & LLM Engineering

Assistants, copilots and agents that answer from your own documents and data — measured, guarded, and able to run on your own servers.

From the field

Async AI backends on FastAPI and asyncio, streaming tokens to many users at once.
Generative BI with WrenAI: plain-English questions answered as SQL over a modelled semantic layer.
Private models served with Ollama and Open WebUI for air-gapped, on-premise use.
Tracing and evaluation with LangSmith, with human-in-the-loop review where it matters.

Orchestration: LangChain
LangGraph
LlamaIndex
Strands Agents
Model Context Protocol
Function & tool calling
Prompt & context engineering
Human-in-the-loop
LLM APIs
Retrieval (RAG & CAG): Retrieval-Augmented Generation
Cache-Augmented Generation
Embeddings
Smart chunking
Hybrid search
Semantic search
Reranking
Metadata filtering
Document parsing & ingestion
Knowledge base design
Agent patterns: ReAct loop
Reflection
Planning
Multi-agent systems
Tool use
Routing
Generative BI: WrenAI
Text-to-SQL
Semantic layer (MDL)
Trust layer: LangSmith
Prompt evaluation
RAG evaluation
Hallucination detection
Guardrails
AI monitoring
Private & on-prem AI: Ollama
Open WebUI
Open-source LLMs
Air-gapped deployment
Token streaming

Web, Mobile & APIs

The software itself — websites, portals, admin panels, apps and APIs — in languages your future developers can maintain.

From the field

REST APIs on Django REST Framework and FastAPI, with versioning, idempotency and rate limiting.
Celery task queues, asyncio and multiprocessing for heavy background work.
Laravel, Lumen and Inertia.js for PHP platforms; Flutter for Android and iOS from one codebase.
Scraping and browser automation with Scrapy, Selenium and BeautifulSoup.

Languages: Python
PHP
JavaScript
TypeScript
SQL
HTML5
CSS
Python: Django
Django REST Framework
FastAPI
Flask
asyncio
Celery
Multiprocessing
PHP: Laravel
Lumen
WordPress
Inertia.js
Jigsaw
Front end: React (hands-on)
jQuery
Bootstrap
Progressive Web Apps
Responsive design
Cross-browser compatibility
Mobile: Flutter
Android & iOS
Scraping & browser automation: Scrapy
Selenium
BeautifulSoup

Shipped in: E-Commerce · Taxi Booking · Online Delivery App · Learning Management System · Job Portal · POS & Inventory Management · HRM & CRM

Databases & Search

Where your data lives, how fast it answers, and how it keeps answering as the business grows.

From the field

Schema-per-tenant multi-tenancy on PostgreSQL, with search-path management.
Large databases on RDS, including version upgrades, read replicas and performance tuning.
Database health monitoring with Percona PMM.
pgvector, Chroma and Qdrant as vector stores for AI search.

Relational: PostgreSQL
MySQL
SQLite
Cache, NoSQL & search: Redis
Memcached
Elasticsearch
OpenSearch
Vector stores: pgvector
Chroma
Qdrant
Database engineering: Query optimisation
Performance tuning
Read replicas
Schema-per-tenant
Search-path management
Version upgrades
Caching strategy

Data Engineering & BI

Pipelines that move data reliably, and dashboards that turn it into decisions your team trusts.

From the field

Streaming pipelines on Kafka (Amazon MSK) and Apache Flink.
Spark on EMR, Glue ETL and Athena for serverless analytics.
Dashboards in Power BI, Looker Studio, Superset and Plotly Dash.
Live reporting, report optimisation and exports.

Pipelines & streaming: ETL / ELT
Apache Kafka
Apache Flink
Apache Spark
BI & reporting: Power BI
Looker Studio
Apache Superset
Plotly Dash
BigQuery (hands-on)
Live reporting & exports

Amazon Web Services

Hands-on AWS — architected, written as code and operated day to day, not clicked together in the console.

From the field

PHP running on Lambda through a custom Node.js runtime.
Infrastructure written as code with AWS CDK, in TypeScript and Python.
Event-driven systems on SQS, SNS, EventBridge and Step Functions.
Incident coordination and escalation with AWS Support.

Compute & serverless: EC2
EC2 Auto Scaling
Elastic Beanstalk
ECS
ECR
Lambda
Step Functions
Storage & databases: S3
EFS
EBS
RDS
Aurora
DynamoDB
ElastiCache
Networking & delivery: VPC
Security Groups
CloudFront
API Gateway
Elastic Load Balancing
Messaging & events: SQS
SNS
SES
EventBridge
MSK
Analytics & AI: Athena
Glue
EMR
Managed Service for Apache Flink
Bedrock
Infrastructure as code & operations: AWS CDK
CloudFormation
CodeBuild
CodePipeline
CloudWatch
Systems Manager
Secrets Manager
IAM

Hosting & Servers

Hosting sized to the budget — from a managed VPS to CDN-fronted servers — set up and looked after properly.

From the field

A self-hosted OSRM routing server on EC2.
WordPress performance with LiteSpeed, WP Super Cache and Bunny CDN.
Servers managed through Laravel Forge, cPanel, CyberPanel and aaPanel.

Providers: DigitalOcean
Hetzner
Hostinger
GoDaddy
Heroku
Render
PythonAnywhere
Laravel Forge
Servers & panels: Linux administration
Nginx
LiteSpeed
cPanel
CyberPanel
aaPanel
Delivery & special cases: Bunny CDN
WP Super Cache
OSRM

DevOps & Reliability

Shipping safely and staying up — automated releases, monitoring that pages a person, and a plan for the bad day.

From the field

Blue/green deployments and disaster-recovery planning.
Automated monitoring reports by email, with charts.
On-call production support with PagerDuty and Squadcast, followed by root-cause analysis.
Dead-letter queues, so failed jobs are kept rather than lost.

Delivery: Docker
CI/CD pipelines
Git
pre-commit
Blue/green deployment
Environment management
Observability: New Relic
Bugsnag
Retrace
Percona PMM
APM
Logging & alerting
Dead-letter queues
Incident response: PagerDuty
Squadcast
Incident management
Root-cause analysis
High availability
Disaster recovery

Integrations & Security

Your software connected to payments, messaging, maps and the tools your team already uses — safely.

From the field

Webhooks with signature verification, idempotency and dead-letter queues.
OAuth 2.0 and social sign-in, with Fernet-encrypted token storage and refresh cycles.
Razorpay, Stripe and PayPal payments; SMS, email and push notifications.
CRM, Slack and email integrations automated through n8n.

Payments: Razorpay
Stripe
PayPal
Payment gateway integration
Messaging & real time: SMS gateways
Email integration
Push notifications
WebSockets
Platforms: Google Maps Platform
Google APIs
GA4
Webhooks
n8n
Slack & CRM integrations
Security: OAuth 2.0
Encrypted token storage
OWASP Top 10
API rate limiting

Shipped in: Taxi Booking · Online Delivery App · Learning Management System · POS & Inventory Management · HRM & CRM

How we build

The habits behind the stack

Tools change. These don't.

Architecture

API design: REST APIs with versioning, idempotency and rate limiting.
Event-driven systems: Services talk through queues and events, so one slow part can't stall the rest.
Serverless: Lambda, Step Functions and API Gateway — pay per request, scale with demand.
Multi-tenancy: Schema-per-tenant PostgreSQL: every customer's data isolated, one codebase to maintain.
Monolith first: A clean MVC monolith until load says otherwise — then services, only where they earn it.
Built for traffic: Caching, read replicas, CDNs and load balancing for systems under real, spiky load.

Practice

Test-driven development: Introduced company-wide: the test is written before the code it checks.
Spec-driven development: A written spec comes before the implementation.
Domain-driven design: The code is organised around your business language, not the framework's.
Code review: Pull requests are reviewed by another engineer before they merge.
Documentation first: Decisions, runbooks and handover notes are part of the deliverable.
AI-assisted engineering: Claude Code, Cursor and Copilot in the toolkit — their output reviewed like any other code.

Security

OWASP Top 10: The baseline for web application security.
Secrets and access: Credentials in Secrets Manager; access managed with IAM, VPCs and security groups.
Sign-in and tokens: OAuth 2.0 with encrypted token storage and refresh cycles.
Safe webhooks: Signature verification and idempotency, so retries don't create duplicates.
Rate limiting: API limits that protect systems from abuse and traffic spikes.
Data residency: Private, air-gapped AI deployments when data must stay on your premises.

Works inside your tools

Jira
ClickUp
Confluence
Notion
Trello
GitHub
Postman
Swagger
FigJam
Draw.io

On the bench

What we’re evaluating now. Not yet shipped for a client — so not sold yet.

Apache Iceberg
DuckDB
Data lakes
Databricks
Snowflake
Redshift
Real-time analytics
Platform engineering

Next step

Already have a stack? We’ll work inside it.

Talk to an engineer