What we know, we write down.
Articles, whitepapers and a growing wiki — from people who also build what they write about.
AI builds in days: why month-long projects are over.
How LLM-assisted implementation lets us ship 10× faster — and why quality doesn’t suffer.
Signal intelligence in sales.
How KAITUM AI generates proactive action signals — the full architecture whitepaper as PDF.
Digital Product Passport (DPP).
What ESPR means for products, manufacturers and supply chains — and what you can ship today.
Adaptive content automation in retail.
Why generic signage loops no longer cut it — and how adaptive content doubles dwell time and conversion.
ISO 27001 in practice.
What certification really means day to day — processes, audits, and where ISO creates customer value.
KAITUM AI.
What KAITUM is, how it works and where it runs in production.
AI Agents.
Software systems that — based on a language model — plan, execute and verify tasks within clearly defined boundaries.
Agent Swarms.
Multiple specialised agents working on a task in parallel — orchestrated, not one generalist.
LLM — Large Language Model.
The foundation of modern AI products: Claude, GPT, Gemini. How we use them in the product.
RAG — Retrieval-Augmented Generation.
Language model plus your own knowledge sources — and why quality hinges on preparation, not on the model.
Prompt Engineering.
Prompts are specs. What works and why evaluations are part of it.
Fine-Tuning.
When fine-tuning is worth it, when RAG is enough and when neither — a decision guide.
MCP — Model Context Protocol.
The open standard for agent integrations. USB-C for AI — and why it radically simplifies integrations.
On-Device AI.
AI that never leaves the device. Privacy, offline capability, latency — and why that can matter categorically.
Edge AI.
AI at the edge of the network — manufacturing, vehicles, signage. Where the cloud is too far away.
Digital Phenotyping.
Behaviour data as a health signal — and why "privacy first" isn’t a platitude here.
React Native.
One codebase, two platforms. When React Native is the right call — and when it isn’t.
Expo.
React Native, but with tools. SDK, EAS Build, over-the-air updates.
TypeScript.
JavaScript with a contract. Why it’s standard in professional product development today, not an option.
Cross-Platform.
One idea, many devices. When it’s strategically right — and what that means for AI products.
Python.
The lingua franca of AI. Where we use Python — and where we deliberately mix other languages in.
API / REST.
An API is a product. Why versioning, validation and error semantics matter more than the style choice.
Backend development.
The layer that carries it. What the backend additionally takes on in AI products — and our stack for it.
Database & vector store.
Structured, unstructured, semantic. When PostgreSQL, when pgvector, when Pinecone.
Machine Learning.
Models that learn from data. What actually lands in the product — and what LLMs have replaced.
React.
The UI library behind the web we build. Components, state, hooks — and why this is the lingua franca of modern products.
Next.js.
React, connected to reality. SSR, routing, streaming — when it carries weight and when it overdoes things.
Tailwind CSS.
Utility-first. Why it lets consistent design systems emerge faster — and where the approach runs out.
Design System.
Tokens, components, patterns. How a maintained system makes design and code speak the same language.
Figma.
Where designs are made — and how we hand them cleanly to code. Variables, auto-layout, branching.
GraphQL.
One query, exactly the data you need. When GraphQL really beats REST — and when it doesn't.
WebGL & Three.js.
GPU in the browser. For AR filters, product configurators, data visualisations — where 2D isn't enough.
Progressive Web App (PWA).
A web app that feels native. Installable, offline-capable, fast — where PWAs are enough instead of going native.
Accessibility (WCAG, BFSG).
Accessibility is mandatory from 2025 (BFSG). What WCAG 2.2 AA means in practice — and how we make sure of it in the build.
Docker.
Containers as standard packaging. Why "works on my machine" is no longer an argument.
Kubernetes.
Container orchestration in production. When K8s is the right tool — and when it is too big.
CI/CD.
Continuous Integration / Continuous Delivery. Every push is built, tested, deployed — the prerequisite for shipping fast.
Infrastructure as Code.
Terraform, Pulumi & co. Infrastructure as versioned code — reproducible, reviewable, reversible.
Observability.
Metrics, logs, traces. What a system actually does — not what it should do. Tools: OpenTelemetry, Grafana, Datadog.
Cloud (AWS, Azure, GCP).
Which cloud for which purpose. EU data residency, vendor lock-in, cost — and why the question is rarely a technical one.
Serverless.
Lambda, Cloud Run, Vercel Functions. When pay-per-request is cheaper than a server — and when it isn't.
Edge Computing.
Running logic close to the user. Cloudflare Workers, Vercel Edge, Fastly — latency over vendor.
Microservices vs. Monolith.
When a monolith is enough, when you split. Conway's Law, team topologies — and why the answer isn't "microservices".
ETL & Data Pipelines.
Extract, transform, load. How data moves between systems — and why this is the underrated half of every data project.
Data Warehouse / Lakehouse.
Snowflake, BigQuery, Databricks. Where structured analysis happens — and where the lakehouse merges both worlds.
Data Mesh.
Data as a product, organised by domain. Why this is more of an org question than a tech one.
Product Analytics.
Mixpanel, PostHog, Amplitude. How we measure behaviour — and which events actually tell you something.
Event Tracking & CDP.
Customer Data Platform: Segment, RudderStack. Clean event schemas beat any later clean-up.
A/B tests & Experimentation.
Testing hypotheses cleanly — statistics, sample sizes, lessons. Tools: GrowthBook, Statsig, Optimizely.
Agile.
Ship incrementally, learn early. What Agile is — and what is just Scrum theatre. We use it selectively.
Scrum.
Sprints, rituals, roles. Where Scrum helps — and where it slows things down because the product ticks differently.
Kanban.
Flow over sprint. When WIP limits and pull systems are more productive than fixed iterations.
Shape Up.
Six-week cycles, fixed time / variable scope. Basecamp's method for small, experienced teams — and where we use it.
Continuous Discovery.
Weekly customer contact, opportunity-solution tree. Teresa Torres' approach — and why discovery never ends.
Jobs-to-be-Done.
Users "hire" products for a job. Why this holds up in strategy and roadmap prioritisation.
Definition of Done.
"Done" is a contract, not a feeling. What is on our list — tests, docs, telemetry, accessibility.
Roadmap (Now/Next/Later).
Date-based roadmaps lie. Why Now/Next/Later is more honest — and how to structure it for stakeholder meetings.
GDPR.
What data protection really means when building products — data minimisation, data processing agreements, third-country transfers.
OAuth 2.0 & OIDC.
The standard for "log in with X". Flows, tokens, PKCE — and where home-grown auth gets dangerous.
JWT.
JSON Web Tokens — compact, signed tokens for auth. When they are useful, when they are overrated.
Zero Trust.
"Never trust, always verify." How Zero Trust replaces the old castle-and-moat model.
OWASP Top 10.
The 10 most common web vulnerabilities — the required reading for anyone building web backends.
Penetration Testing.
External testers try to break in — before someone else does. What a pentest delivers, what it doesn't.
SOC 2 & ISO 27001.
The two big compliance frameworks. Where the difference lies — and which audit counts for which market.
EU AI Act.
Risk classes, transparency obligations, high-risk systems. What really applies from August 2026 — and what already does.
Agentic AI.
Systems that don’t just answer but act — with a goal, a plan, tools and self-correction.
Agent orchestration.
The coordination layer that directs multiple agents, keeps state and logs every step traceably.
Tool Use.
How language models call external functions — and why an agent can only truly act once it has tools.
Function Calling.
Structured, typed tool calls instead of free text — the reliable contract between model and code.
Structured Output.
Formally validated LLM output — JSON schema instead of hoping for the right format.
Guardrails.
The protective layer between a probabilistic model and the real world — an architecture decision, not a patch.
Evaluation (evals).
Measuring agent quality systematically — correctness, hallucination rate, latency, cost. Continuously, not once.
Human-in-the-Loop.
Where a human reviews, approves or steps in — and how to set up the handover properly.
Workflow automation.
Fixed path or agentic decision — when each approach is the right one.
Multi-agent system.
Several specialised agents solve a larger task together — each one small and good at exactly one thing.
Agent memory.
What an agent remembers across sessions — and what should stay out of memory for data-protection reasons.
Reasoning.
Models that think before they answer — and what we use them for in agent architectures.
Enterprise AI.
What AI needs in real system landscapes — integration, governance, audit trails and an operating model.
Customer Intelligence.
Continuously analysing customer and market signals to act proactively — not just to fill dashboards.
Signal Detection.
Spotting patterns in data that signal a need to act — from data point to reason to act.
Anomaly Detection.
What falls outside the norm statistically or semantically — and why that is a common trigger for agents.
AI Governance.
Structures that keep AI systems traceable, secure and compliant — from model choice to monitoring.
Build vs. Buy.
An off-the-shelf agent from your suite or a custom build — an honest guide to the decision.
One essay every two weeks.
No marketing. One piece on what we built, saw or learned this week.