Field notes on AI, automation & cloud
Production stories, architecture patterns, and lessons by Islam Gamal from building AI agents, n8n workflows, and data platforms. Every post ships with real code and real trade-offs.
The Senior AI Engineer Portfolio That Actually Gets You Hired in 2026
Not another 'I built a chatbot' repo. The 4-project portfolio, the writeup format, and the interview signals that separate real senior candidates from prompt tinkerers.
Latest articles
SLO-Driven Incident Response: From Alert Fatigue to Actual Reliability
Error budgets, burn-rate alerts, incident classification, and the post-incident review format that turns firefights into engineering.
Streaming ETL With CDC and Materialized Views: Real-Time Without a New Data Stack
Debezium, Kafka, and Postgres materialized views give you sub-minute freshness without rebuilding your warehouse — here's the architecture and its trade-offs.
Feature Stores Without a Platform Team: A Pragmatic Blueprint
You don't need Tecton or Feast on day one. Here's how to get 80% of a feature store's benefits with dbt, Postgres, and a Redis cache — and when to graduate.
LLM Evaluation With Golden Datasets: The Only Way to Ship With Confidence
How to build a golden dataset, when to use LLM-as-judge vs rules vs humans, and the CI setup that catches regressions before your users do.
Human-in-the-Loop Automation Patterns That Actually Work
Approval gates, escalations, review queues, and Slack-native workflows — the design patterns for automation you can trust with real money and real customers.
Idempotency Keys in Distributed Systems: The Rules That Save You From Duplicates
How Stripe-style idempotency actually works, what to store, how long to keep it, and the failure modes retries create when you get it wrong.
Building n8n Custom Nodes: The Guide I Wish I Had
Declarative vs programmatic nodes, credentials, pagination, binary data, and the packaging steps that turn a folder of TypeScript into an installable community node.
Observability-Driven Development: Ship, Watch, Learn, Repeat
SLOs, structured logs, high-cardinality metrics, and the discipline of designing every feature with 'how would I debug this at 3am' as a first question.
Python Typing in Production: Beyond mypy Hello-World
TypedDict, Protocol, Literal, generics, and how to actually enforce types on a large Python codebase without slowing your team down.
Agentic RAG: When Your Retriever Should Think Before It Searches
Query rewriting, sub-question decomposition, tool routing, and self-correction — the patterns that turn a static RAG pipeline into an agent that reasons about retrieval.
Terraform for Data Teams: BigQuery, Cloud Run, and the Blueprint That Scales
Modules, workspaces, drift, and CI/CD — a working Terraform layout for teams shipping data platforms without becoming full-time infra engineers.
GraphQL vs REST in 2026: A Decision Framework, Not a Religious War
The honest, benchmarked take on when GraphQL earns its complexity — and when REST plus JSON schemas beats it decisively.
Event-Driven Architecture With Just Postgres (Until You Really Can't)
Outbox pattern, LISTEN/NOTIFY, logical replication, and pg_cron — the surprising amount of event-driven system you can run on one Postgres before reaching for Kafka.
Semantic Search at Scale: Hybrid, Rerank, and Filtering Done Right
Dense-only retrieval falls apart past a few hundred thousand documents. This is how the working systems combine BM25, vectors, filters, and rerankers.
Defending LLM Apps Against Prompt Injection: A Practical Playbook
Direct and indirect prompt injection, tool-use exploits, data exfiltration — and the layered defenses that actually work in production.
RAG Chunking Strategies That Actually Work in Production
Fixed-size, semantic, hierarchical, and late-chunking approaches — with benchmarks, failure modes, and a decision tree for picking the right one.
Vector Databases in 2026: pgvector vs Pinecone vs Qdrant vs Weaviate vs Milvus
A hands-on 2026 comparison of the five vector databases I actually ship — pricing, latency, hybrid search, filtering, sharding, re-embed cost, and the decision tree I use in client architecture reviews.
Workflow Automation Blueprints: 12 Patterns Every Team Ships (and the Envelope That Ties Them Together)
The 12 automation blueprints I reuse across every client — lead routing, invoice processing, content ops, incident response — with the exact triggers, guards, envelopes, DLQs, and human-in-the-loop patterns that make them survive production.
LangGraph vs n8n for Agent Orchestration in 2026: A Decision Framework
The honest comparison between LangGraph and n8n for building agentic systems in 2026 — where each excels, where each fails, and the hybrid pattern used by teams shipping both.
Building Production AI Agents with n8n: Architecture, Guardrails, Evals, and Cost Control
The full n8n agent playbook — reference architecture, memory design, tool routing, JSON-schema guardrails, retries, DLQs, evals, observability, and the small handful of decisions that keep the token bill sane at scale.
Building Multilingual AI That Actually Works in Arabic and English
The real engineering behind Arabic + English AI systems — tokenization traps, RTL rendering, dialect vs MSA, retrieval with mixed-script queries, embeddings that respect both languages, and the eval sets nobody publishes.
The n8n Error Handling Playbook: Retries, DLQs, Circuit Breakers, and Replay
The full production playbook for n8n reliability: how to classify failures, design retry policies that don't melt upstreams, build a Postgres DLQ with safe replay, run circuit breakers per integration, and wire the observability that catches incidents before your customers do.
Fine-Tuning vs RAG in 2026: A Real Decision Framework (Not a Religious War)
Stop treating fine-tuning and RAG as opposing camps. The right question is which problem each solves — with a concrete decision matrix, cost math, eval strategy, and the hybrid pattern most production systems actually use.
Evaluating LLMs and Classical ML: A Practical Metrics Guide
The metric you pick decides the model you ship. A deep field guide to choosing, computing, and defending metrics for classification, ranking, generation, RAG, and agents — with the traps that catch senior teams.
RAG That Actually Works: Chunking, Hybrid Search, Reranking, and Evals
The full production playbook: why naïve RAG demos die on the second question, how to chunk, index, retrieve, rerank, cite, evaluate, and cost-engineer a retrieval-augmented system that survives real users.
Designing REST APIs LLMs Can Actually Use: A Field Guide for Tool-Using Agents
The API design choices that make or break tool-using LLM agents — naming, error shapes, idempotency, discoverability, JSON schema hygiene, pagination, and the eight anti-patterns that confuse every model.
Postgres for Product Engineers: Indexing, JSONB, RLS, and the 20% That Ships Millions of Users
The Postgres playbook I've used across product teams — index type per workload, JSONB without regret, RLS that doesn't leak or crawl, connection pooling that survives spikes, and the observability that turns guessing into ground truth.
Building an LLM Cost Dashboard in BigQuery That Actually Changes Behavior
The end-to-end blueprint for tracking every LLM call in BigQuery — schema, ingestion patterns, cost attribution by team/feature/user, unit-economics dashboards, and the alerts that catch runaway spend before finance does.
The Modern Data Stack in 2026: What Actually Matters (and What to Skip)
A no-hype 30-minute tour of the 2026 data stack: ingestion, warehouse, transformation, orchestration, semantic layer, reverse ETL, observability, and the AI layer on top — with concrete tool picks, cost anchors, and the anti-patterns that quietly eat budgets.
Prompt Engineering for Agents: A Structured, Testable, Version-Controlled Approach
Prompt engineering isn't vibes. Treat prompts like code — with schemas, versions, evals, diffs, and rollback. The full production workflow that scales past a single developer, with copy-paste patterns for structured output, few-shot design, LLM-as-judge, and prompt registries.
Becoming an AI + Data Engineer in 2026: The Honest 12-Month Roadmap
A no-fluff roadmap for aspiring AI + Data engineers: exact skills, exact order, exact projects, and the interview loops you'll actually face — with hiring-manager signal at every step.
BigQuery Cost Control That Scales: 12 Patterns from Real Warehouses
Twelve battle-tested patterns to cut BigQuery spend 30–70% without touching data quality — partitioning, clustering, materialized views, reservations, and the FinOps loop that keeps savings from decaying.
Async Python for AI Pipelines: Concurrency, Backpressure, and Not Melting Your API Bill
A pragmatic 30-minute deep-dive into asyncio for AI workloads — semaphores, timeouts, retries with jitter, streaming responses, connection pooling, and the patterns that let one Python process fan out to thousands of concurrent LLM calls without exploding.
Cloud Run + Cloud SQL: The Boring Blueprint That Runs Half My Production Systems
A complete production blueprint for Cloud Run + Cloud SQL on GCP — connection pooling, IAM, secrets, migrations, blue/green deploys, cost control, and the failure modes to prevent before they hit.
dbt in Anger: Modeling, Contracts, Testing, CI, and the Setup That Scales to 500+ Models
The dbt setup that survives real teams — layered models, contracts on every mart, tests that catch business bugs, CI that runs only what changed, semantic layer for one metric one place, and the ops habits that keep the graph healthy at 500+ models.
Webhooks That Don't Lie: Idempotency, Signatures, Replay, and a Playbook
An opinionated production guide to receiving webhooks — signature verification, idempotency keys, store-then-process pipelines, dead-letter queues, replay UIs, provider quirks, and a local testing loop your team will actually use.
MLOps on a Shoestring: A Complete Stack for Under $200/Month
The pragmatic MLOps stack for solo builders and small teams — model registry, experiment tracking, feature store, drift monitoring, and CI/CD — all under $200/month with open-source and free tiers.
Observability for AI Systems: Traces, Prompts, Tokens, and the SLOs That Actually Matter
A 30-minute production guide to instrumenting LLM applications — what to log (and what never to), how to trace agent calls end-to-end, the four golden signals for AI, drift detection on outputs, and the dashboards you actually check at 2 a.m.
Self-Hosting n8n on Kubernetes: HA, Queue Mode, Autoscaling, and Backups That Actually Restore
The complete production playbook for n8n on Kubernetes — queue mode topology, KEDA autoscaling on Redis depth, Postgres HA and PITR, encryption-key rotation, zero-downtime upgrades, and the backup drill you must actually run.
Want more depth on a topic?
Explore the Knowledge Hub for topic-clustered guides, cheat sheets, and learning paths.
Open Knowledge Hub