AI Strategy
The state of physical AI at the edge
Physical AI is a placement decision. The safety stop stays on the machine, the site may coordinate, and the lab only releases a policy. A dropped link must not move the stop.
9 min read
Insights
Notes from the field.
Practical writing on enterprise architecture, software engineering, and AI integration — from twenty years of delivery.
Filter
AI Infrastructure
Enterprise-local inference needs a control plane: a reference architecture for governed AI
Local AI is not cloud inference moved into a server room. The durable design is a federation of autonomous inference cells that places computation near authoritative context without surrendering policy, evidence, or operational control.
16 min read
Enterprise Architecture
The agent internet is not one protocol: a four-plane architecture for enterprise autonomy
MCP, A2A, delegation, gateways, skills, and sandboxes are converging into an Internet-shaped agent stack. The enterprise design problem is how to separate interaction, trust, control, and execution.
15 min read
Enterprise Architecture
Inference Gateway vs. AI Gateway: two control planes, one production path
A practical architecture guide to model access, inference-aware routing, ownership boundaries, failure modes, and the cases where AI and inference gateways should be deployed together.
13 min read
Supply Chain Architecture
SCM Automation, Part 1: The Architecture of a Delivery Promise
Reliable supply chains connect commercial intent to operational evidence. A KMS ITC perspective on planning, decision ownership and the economics of promises.
12 min read
Supply Chain Architecture
SCM Automation, Part 2: From Backward Planning to Feasible Schedules
A due date establishes a target. Materials, capable resources, calendars and dependencies determine whether it can be met. How to connect the two without false precision.
11 min read
Supply Chain Architecture
SCM Automation, Part 3: From Workflows to Accountable Decisions
An implementation architecture for reliable SCM automation: clear data ownership, constraint engines, bounded actions and evidence that connects decisions to outcomes.
12 min read
Enterprise Architecture
From RAG to Enterprise Context Fabric: the next stage of enterprise AI architecture
Retrieval is one capability within a larger architecture. Enterprise agents need governed access to knowledge, state and evidence—and a control plane that defines what they may do.
16 min read
AI Strategy
After AI flattens skill: mastery, agency and identity in the generative era
Generative AI is not only changing how creative work is produced. It is moving the scarce layer of value upward: from execution, to judgement, to agency, and ultimately to identity.
8 min read
AI Infrastructure
SGLang, vLLM and the rise of the inference operating system
The most important AI infrastructure shift is no longer just faster GPUs or larger models. SGLang, vLLM and Kubernetes-native serving stacks show that enterprise AI now needs an inference operating system: a governed runtime for latency, memory, routing, cost and risk.
8 min read
AI Strategy
When a team becomes one person: AI and the minimum viable organisation
AI is not just making existing teams faster. It is changing the minimum number of people required to deliver an outcome safely and well — and exposing how much organisational work is really work about work.
5 min read
Enterprise Architecture
AI Gateway as Control Plane: the enterprise pattern for Bedrock at scale
The biggest Bedrock architecture decision is not model choice. It is whether you run direct model access or establish an AI gateway control plane for policy, reliability, and cost governance.
8 min read
AI Architecture
Amazon Bedrock in the enterprise landing zone: a control-plane pattern for AI access, governance, and cost
The critical shift is architectural: centralize GenAI capability, decentralize workload ownership. Here’s how the Bedrock landing-zone baseline maps to enterprise control planes and what to standardize next.
8 min read
Enterprise Architecture
MCP Toolbox Java SDK: the control-plane pattern for transactional enterprise agents
Google’s MCP Toolbox Java SDK signals a practical architecture shift: move from custom integration glue to a policy-driven agent control plane where tool contracts, identity, and governance are first-class.
8 min read
Enterprise Architecture
Fractional GPUs + Inference Gateway: a control-plane pattern for enterprise agentic AI
Google Cloud’s new fractional G4 VMs and Dynamo + GKE Inference Gateway integration point to a practical enterprise pattern: separate workload classes, route by policy, and treat GPU capacity as a governed control plane rather than an ad-hoc pool.
8 min read
AI + Enterprise Architecture
Your data strategy is your AI strategy: the database as context engine
The API era of AI is over. Enterprise-grade agents need databases that serve as context engines—with vector pipelines, row-level security, and architecture-first thinking.
6 min read
AI & Cloud Architecture
Stateful AI agents arrive on Bedrock: what the AWS–OpenAI runtime means for enterprise architecture
AWS and OpenAI's new Stateful Runtime Environment shifts AI agents from fire-and-forget prompts to persistent, memory-bearing workflows—and it changes what enterprise architects need to plan for.
7 min read
AI & Enterprise Architecture
From AI copilots to AI agents: the architecture of enterprise process ownership
The shift from copilot-assisted tasks to agent-owned processes demands a new enterprise architecture layer—orchestration, governance, and human escalation by design, not as an afterthought.
7 min read
Cloud & Platform Engineering
GKE Inference Gateway: the missing control point for production LLM serving
If your LLM platform is still using generic load balancing, you’re leaving latency, cost, and reliability on the table. Inference-aware routing (queue + KV cache + admission control) turns GPU serving from an app problem into a platform capability.
7 min read
Cloud Architecture
Platform engineering as a control plane: Santander’s Catalyst pattern (EKS + Crossplane + GitOps + policy)
A bank reduced provisioning from ~90 days to hours by standardising *claims* and reconciling them into approved stacks. This is the pattern enterprise GenAI platforms need: a governed control plane, not a thousand bespoke pipelines.
8 min read
Enterprise Architecture
Provisioned Throughput for LLMs: the missing layer between SLOs and FinOps
On-demand LLM inference is great for experiments—and brutal for production SLOs. Provisioned throughput turns capacity into an architectural primitive: predictable latency, deliberate burst handling, and a budget you can actually govern.
8 min read
Enterprise Architecture
Monday.com platform architecture: how a Work OS becomes an integration hub
Monday.com looks like a simple boards app. Under the hood it behaves like a Work OS: a data model (boards/items/columns), an automation engine, an app marketplace, and an integration layer. This article maps the architectural layers and the enterprise trade-offs.
7 min read
Enterprise Architecture
MCP over gRPC isn’t a transport tweak — it’s an enterprise integration decision
Google is contributing a gRPC transport for MCP. The win isn’t just performance — it’s aligning agent tool-calls with your existing service mesh, identity, and observability. The risk: confusing ‘typed APIs’ with ‘LLM-usable tools’.
8 min read
Enterprise Architecture
Agent evaluation is a control plane (not a dashboard)
Agentic systems fail in tool-use, memory, and recovery—not just ‘wrong answers’. Treat evaluation like a control plane: traces → metrics → release gates, with scorecards that point to root causes.
8 min read
Cyber Security
Security-by-design in enterprise architecture: using AI to embed cyber security across the full lifecycle
Security-by-design fails when it becomes a late-stage review. Here’s a lifecycle blueprint that uses AI to make controls continuous: from requirements and architecture to build, release, and operations.
10 min read
Platform Engineering
Scaling Postgres without sharding: the real control plane is reliability engineering
Why a single-writer Postgres architecture can go further than you think—if you treat caching, pooling, rate limits, and blast-radius isolation as first-class design primitives.
8 min read
Engineering
The day Git taught me the difference between merge and rebase
A deep dive into accidental merges, silent deletions, and why Git’s three-way merge can ‘correctly’ make your files disappear.
9 min read
AI Architecture
Evaluation is the control plane for enterprise GenAI: what Bedrock Evaluations implies for architecture and operating model
When evaluation becomes a managed capability (LLM-as-judge, algorithmic metrics, human review, RAG scoring), you can finally gate GenAI changes like software releases. Here’s the reference architecture and tradeoffs.
9 min read
Enterprise Architecture
SAP classic enterprise architecture: landscapes, transports, and deployment patterns
SAP’s ‘classic’ model still underpins many S/4HANA programs: a three-tier landscape (DEV/TEST/PRD), controlled change promotion, and resilient central services. This guide explains the patterns that keep SAP environments stable at scale.
12 min read
Cloud Architecture
EC2 G7e (Blackwell) changes the shape of enterprise inference: fewer compromises, new failure modes
AWS’s G7e instances (NVIDIA RTX PRO 6000 Blackwell, up to 8 GPUs and 1600 Gbps EFA) are now in APAC (Tokyo). Here’s what that means for LLM serving, agent workloads, and platform architecture.
8 min read
AI Strategy
Soul files, heartbeats, and why assistants are becoming ‘someone’: the agent OS pattern
The next jump in personal/work assistants won’t come from a smarter model. It’ll come from an operating model: durable identity contracts, memory layers, and background loops that surface only what matters.
8 min read
Enterprise Architecture
OpenClaw vs ZeroClaw vs Agent Zero vs frameworks: choosing a workstation AI assistant (2026)
The decision isn’t ‘which agent is smartest?’. It’s which operating model you want on your workstation: chat-first assistant, secure daemon, deep execution agent, or a framework you assemble yourself.
9 min read
AI Strategy
World models and the next generation of AI: from chat to simulation, planning, and control
The next capability jump won’t come from bigger prompts. It’ll come from agents that can simulate futures, plan under uncertainty, and verify outcomes—using world models as an internal control plane.
9 min read
Enterprise Architecture
AI agents need an evaluation control plane: traces → metrics → release gates
If you can’t measure task success, tool correctness, safety, latency, and cost—at the trace level—you don’t have an AI agent. You have an incident waiting to happen.
7 min read
AI Platform
Gated open-source models: treat your model catalog like a control plane
When ‘use this model’ becomes an approval flow, your model catalog stops being a list—and becomes the control plane for licensing, risk, evaluation, and cost guardrails.
6 min read
Enterprise Architecture
GenAI architecture needs a review loop: operationalising the Well-Architected GenAI Lens
The fastest way to scale GenAI safely is to turn governance into a repeatable architecture review loop—with reference patterns, measurable guardrails, and a funded backlog.
6 min read
AI Tooling
Policy-as-Code for AI Agents: Stop Hardcoding Authorization in Prompts
Enterprise agents don’t fail because they can’t call tools — they fail because nobody can prove the calls were allowed. Here’s the reference architecture for decoupled, auditable authorization using policy engines (Cedar/Verified Permissions).
9 min read
Security
Apple dyld Zero‑Day (CVE‑2026‑20700): Why This Patch Window Is Different — and How to Move Fast with MDM Rings
Apple shipped emergency updates after reporting CVE‑2026‑20700 (dyld) was exploited in an ‘extremely sophisticated’ targeted attack. Here’s a practical playbook: scope impact, enforce update rings via MDM, validate compliance, and reduce exposure while change windows catch up.
6 min read
Security
Microsoft February 2026 Patch Tuesday: 6 Exploited Zero‑Days + KEV Deadlines — How to Triage Fast
February’s Patch Tuesday includes six zero-days exploited in the wild, now tracked in CISA’s KEV. Here’s a practical triage pattern to patch the right systems first, validate quickly, and reduce blast radius while change windows catch up.
6 min read
Security
BeyondTrust Remote Support / PRA: Patch the Pre‑Auth RCE (CVE‑2026‑1731) Before It Becomes Your Next Incident
A critical pre-auth OS command injection bug in BeyondTrust RS/PRA can lead to remote code execution. If you run self-hosted and are internet-exposed, this is a ‘patch now’ item—plus a few fast controls to cut risk even before the window.
7 min read
Enterprise Architecture
FEAF vs TOGAF vs Zachman (and friends): How Enterprise Architecture Methodologies Compare—and How to Combine Them
FEAF, TOGAF, Zachman, DoDAF—none of them is a silver bullet. Here’s what each is for, where they break down, and a practical way to use them together without drowning in ceremony.
12 min read
Security
Microsoft Feb 2026 Patch Tuesday: 6 Exploited Zero‑Days — Patch Triage for the First 72 Hours
February’s Patch Tuesday is unusually urgent: Microsoft fixed six zero‑days being exploited in the wild. Here’s a practical, low-drama plan to patch fast without breaking production.
7 min read
Cybersecurity
SmarterMail CVE-2026-24423: The KEV Signal MSPs Can’t Ignore
CISA says CVE-2026-24423 is being used in ransomware campaigns. If you run SmarterMail (especially for customers), treat this as an exposure + patch + verification exercise — not a ‘we’ll catch it next cycle’ update.
7 min read
Security
n8n Expression Escape → RCE (CVE-2026-25049): Patch Fast, Then Contain
A critical n8n expression-sandbox escape can turn ‘workflow author’ access into server-level command execution. Here’s what changed, why it matters, and a practical hardening checklist.
7 min read
Security
Lock Down GitHub Actions Without Breaking CI: Allowlisting, Pinning, and Fork Safety (2026)
GitHub Actions just made allowlisting easier across plans. Here’s a practical security baseline: restrict what can run, pin actions to SHAs, and keep forks safe—without murdering developer velocity.
8 min read
Software Engineering
When GitHub Actions Goes Down: CI Resilience Lessons (2026)
Recent GitHub Actions incidents highlight a hard truth: hosted CI is a dependency. Here’s how to design pipelines so outages degrade gracefully instead of freezing delivery.
8 min read
Security
Notepad++ Update Hijack: Supply-Chain Lessons for Enterprises (2026)
A targeted Notepad++ updater compromise shows how ‘small’ tools can become initial access. Here’s what happened, why it matters, and how to harden third‑party update channels.
9 min read
Security
APT28 Exploits CVE-2026-21509: Why This Microsoft Office ‘Bypass’ Needs a Real Incident Response
A newly patched Microsoft Office vulnerability (CVE-2026-21509) is already being exploited in targeted phishing campaigns. Here’s what changed, why it matters, and a practical response checklist for IT and security teams.
8 min read
AI Tooling
Wall Street vs SaaS: What the AI ‘Agent Layer’ Selloff Really Means
A wave of selling hit enterprise software names after new AI automation tooling raised ‘subscription replacement’ fears. Here’s what’s real, what’s hype, and how SaaS leaders should respond.
10 min read
Software Engineering
Beyond Request–Response: Distributed Messaging Patterns for 2026
Synchronous HTTP across microservices creates brittle distributed monoliths. Here’s a practical guide to modern messaging delivery models, outbox, saga workflows, and when CQRS/event sourcing actually makes sense.
12 min read
AI Tooling
OpenClaw: a Local AI Assistant That Actually Acts (Tools, Memory, Cron, Browser Relay)
A practical, engineering-focused walkthrough of OpenClaw’s architecture and configuration—how tools, memory, cron jobs, and browser relay combine to turn prompts into real actions.
AI Tooling
Trae vs OpenCode: Two Very Different Ways to Use AI for Coding
Trae brings AI into an IDE-style workflow; OpenCode brings an agent into your terminal. Here’s how they differ, what each is good at, and how to choose.
Enterprise Architecture
ArchiMate: Turning Enterprise Complexity into a Shared Language
In large organisations, failure rarely comes from a lack of technology—it comes from misalignment. ArchiMate provides a common visual language to bridge strategy, business, and IT, making architecture decisions visible and defensible.
10 min read
Programming
Getting Started with TypeScript: A Practical Guide for JavaScript Developers
Learn how TypeScript can transform your JavaScript development workflow with static typing, better tooling, and improved code quality. This guide covers everything from setup to advanced patterns.
8 min read
Software Engineering
Vibe Coding Reality Check: What 2 Months of AI-Assisted Enterprise Development Taught Me
AI coding promised to revolutionize development. After deploying it on a high-stakes financial system, here's what really happened—the good, the painful, and the lessons learned.
15 min read
Development
The Complete Guide to Full Stack Web Development in 2026
Full stack development has evolved dramatically. This guide covers the modern tech stack, architecture patterns, and best practices for building scalable web applications from frontend to backend.
12 min read
Development
How to Become a Frontend Master: A Practical Roadmap
Frontend development has grown from simple HTML pages to complex application development. This guide provides a practical roadmap for mastering modern frontend development, from fundamentals to advanced patterns.
10 min read
Fundamentals
Essential Data Structures & Algorithms for Software Engineers
Understanding data structures and algorithms is fundamental to writing efficient code. This guide covers the essential concepts every software engineer should know, with practical examples and real-world applications.
15 min read
CMS & Security
Umbraco + Auth0 with RBAC: Secure Authentication for Your CMS
A technical guide on integrating Umbraco CMS with Auth0 for authentication, implementing role-based access control (RBAC) for secure, scalable user management.
12 min read