{
  "posts": [
    {
      "slug": "2026/04/engine-single-brain",
      "title": "When Your Engine Has A Single Brain",
      "publishedAt": "2026-04-08T21:15:38+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-263d661b-83eb-46aa-8448-d51c064ea45e.png",
      "socialMediaPost": "When your engine has a single brain, how do you keep it from collapsing under its own weight? This explores what happens when one place runs the whole show.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/engine-single-brain",
      "file": "/data/automated-blog/2026/04/engine-single-brain.json",
      "hashtags": "#software #architecture #engines #orchestration"
    },
    {
      "slug": "2026/04/daemon-orchestration-scale",
      "title": "Daemon Orchestration at Container Scale",
      "publishedAt": "2026-04-08T04:07:41+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-395bcd92-a00c-4126-99f3-42274023c213.png",
      "socialMediaPost": "Most teams focus on container runtimes, not the control plane. Daemon Orchestration at Container Scale digs into how the daemon actually keeps fleets in line.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/daemon-orchestration-scale",
      "file": "/data/automated-blog/2026/04/daemon-orchestration-scale.json",
      "hashtags": "#containers #orchestration #devops #infrastructure"
    },
    {
      "slug": "2026/04/prometheus-tsdb-sanity",
      "title": "How Prometheus Keeps Its TSDB Sane",
      "publishedAt": "2026-04-03T07:28:30+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b2776337-0bc6-4c06-88a7-d16456eddd0a.png",
      "socialMediaPost": "Working with time-series data at scale? “How Prometheus Keeps Its TSDB Sane” breaks down how Prometheus keeps its own storage manageable and safe.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/04/prometheus-tsdb-sanity",
      "file": "/data/automated-blog/2026/04/prometheus-tsdb-sanity.json",
      "hashtags": "#Prometheus #TSDB #timeseries #observability"
    },
    {
      "slug": "2026/03/invisible-arguments-tools",
      "title": "The Invisible Arguments Powering LangChain Tools",
      "publishedAt": "2026-03-29T10:46:44+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-68b3d79b-f715-44d8-bb5d-f9546766e8ac.png",
      "socialMediaPost": "Most LangChain examples focus on visible tool inputs. This dives into the invisible arguments that actually drive LangChain tools at runtime.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/invisible-arguments-tools",
      "file": "/data/automated-blog/2026/03/invisible-arguments-tools.json",
      "hashtags": "#LangChain #LLM #developers #AItools"
    },
    {
      "slug": "2026/03/wrapper-stack-environments",
      "title": "The Wrapper Stack That Shapes RL Environments",
      "publishedAt": "2026-03-24T13:08:27+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-983e16d5-24d8-4ca9-b278-9dedb7b6fb47.png",
      "socialMediaPost": "Most RL tutorials focus on agents, not what they’re actually interacting with. This dives into the wrapper stack that quietly shapes RL environments.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/03/wrapper-stack-environments",
      "file": "/data/automated-blog/2026/03/wrapper-stack-environments.json",
      "hashtags": "#ReinforcementLearning #MachineLearning #AI"
    },
    {
      "slug": "2026/03/trainer-orchestrator",
      "title": "When Your Trainer Becomes an Orchestrator",
      "publishedAt": "2026-03-19T16:29:07+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0c624ec4-ece5-48e2-bce2-650ed09bb1a0.png",
      "socialMediaPost": "When does a simple ML training loop stop being “just training” and start acting like an orchestrator for your whole system? This post digs into that shift.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/trainer-orchestrator",
      "file": "/data/automated-blog/2026/03/trainer-orchestrator.json",
      "hashtags": "#machinelearning #training #mlops #engineering"
    },
    {
      "slug": "2026/03/orchestration-becomes-product",
      "title": "When Orchestration Becomes the Product",
      "publishedAt": "2026-03-14T19:48:33+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-bb6bdadf-9941-4b22-b24f-bb0e9bdd62d7.png",
      "socialMediaPost": "When does coordination logic stop being just glue and start being what users actually feel? “When Orchestration Becomes the Product” digs into that shift.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/orchestration-becomes-product",
      "file": "/data/automated-blog/2026/03/orchestration-becomes-product.json",
      "hashtags": "#orchestration #engineering #devtools"
    },
    {
      "slug": "2026/03/database-traffic-cop",
      "title": "When a Database Becomes a Traffic Cop",
      "publishedAt": "2026-03-09T23:10:17+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-cc6d2f03-efd4-4019-a681-13c5f806416f.png",
      "socialMediaPost": "When a database becomes a traffic cop, it’s not just about storing rows—it’s about orchestrating chaos at scale. Curious how that control loop really works?",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/03/database-traffic-cop",
      "file": "/data/automated-blog/2026/03/database-traffic-cop.json",
      "hashtags": "#databases #architecture #backend #programming"
    },
    {
      "slug": "2026/03/agent-god-object",
      "title": "When One Agent Class Knows Too Much",
      "publishedAt": "2026-03-05T02:27:10+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-bd7ab229-5a7f-4164-a1c9-42150c84f842.png",
      "socialMediaPost": "When one agent class knows too much, you don’t just get convenience—you risk a God object. How do you keep your core agent powerful without turning it into a blob?",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/03/agent-god-object",
      "file": "/data/automated-blog/2026/03/agent-god-object.json",
      "hashtags": "#softwaredesign #architecture #agents #LLM"
    },
    {
      "slug": "2026/02/silent-tomcat-bootstrap",
      "title": "The Silent Script That Boots Tomcat",
      "publishedAt": "2026-02-28T05:46:59+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b2ecb967-5ada-4123-a019-2c2a091c528c.png",
      "socialMediaPost": "Ever wonder what really brings your Tomcat JVM to life? “The Silent Script That Boots Tomcat” digs into the unseen startup path running every time.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/silent-tomcat-bootstrap",
      "file": "/data/automated-blog/2026/02/silent-tomcat-bootstrap.json",
      "hashtags": "#Tomcat #Java #JVM #webserver"
    },
    {
      "slug": "2026/02/fastapi-production-routers",
      "title": "How FastAPI Turns Functions Into Production Routers",
      "publishedAt": "2026-02-23T09:11:57+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6fdce3f1-d8bd-4186-b641-eed5875dbcd6.png",
      "socialMediaPost": "How does FastAPI take plain Python functions and run them as real production routers? This unpacking of that transformation is worth a closer look.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/fastapi-production-routers",
      "file": "/data/automated-blog/2026/02/fastapi-production-routers.json",
      "hashtags": "#FastAPI #Python #webdevelopment #backend"
    },
    {
      "slug": "2026/02/conversation-traffic-controller",
      "title": "The Conversation Traffic Controller Pattern",
      "publishedAt": "2026-02-18T12:30:15+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0b0ef8cf-b60a-430d-bc7e-63609cdf6a23.png",
      "socialMediaPost": "Most LLM bugs aren’t in the model, they’re in the messy loops around it. The Conversation Traffic Controller Pattern gives you a cleaner way to orchestrate chats.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/conversation-traffic-controller",
      "file": "/data/automated-blog/2026/02/conversation-traffic-controller.json",
      "hashtags": "#LLM #AIagents #softwaredesign #architecture"
    },
    {
      "slug": "2026/02/ai-gateway-file",
      "title": "When One File Becomes Your AI Gateway",
      "publishedAt": "2026-02-13T15:43:49+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-49d66bad-d3e9-4711-ab78-0c88920837a1.png",
      "socialMediaPost": "When one file becomes your AI gateway, you’re not just organizing code—you’re defining how every request touches your models. How close is your setup to that?",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/02/ai-gateway-file",
      "file": "/data/automated-blog/2026/02/ai-gateway-file.json",
      "hashtags": "#AI #softwarearchitecture #backend #developers"
    },
    {
      "slug": "2026/02/node-http2-engine",
      "title": "How Node Speaks HTTP‑2 Without You Noticing",
      "publishedAt": "2026-02-08T19:03:20+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-fc13809d-926d-4a05-9859-cb9e3e801801.png",
      "socialMediaPost": "Ever wonder how Node handles HTTP‑2 while your code just sees familiar APIs? This piece walks through how Node “speaks” HTTP‑2 without you noticing.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/02/node-http2-engine",
      "file": "/data/automated-blog/2026/02/node-http2-engine.json",
      "hashtags": "#NodeJS #HTTP2 #JavaScript #WebDev"
    },
    {
      "slug": "2026/02/orchestrator-ai-reply",
      "title": "The Orchestrator Behind Every AI Reply",
      "publishedAt": "2026-02-03T22:22:22+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-19d567ae-4177-41b7-babe-dfa272584562.png",
      "socialMediaPost": "Every AI answer hides an orchestrator deciding what to call, when to respond, and how it all fits together. The Orchestrator Behind Every AI Reply digs into that layer.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/orchestrator-ai-reply",
      "file": "/data/automated-blog/2026/02/orchestrator-ai-reply.json",
      "hashtags": "#AI #developers #LLM #architecture"
    },
    {
      "slug": "2026/01/stategraphs-distributed-conversations",
      "title": "How StateGraphs Turn Functions Into Distributed Conversations",
      "publishedAt": "2026-01-30T01:44:22+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0108ab5b-404b-4110-ac62-cb3582a15f6d.png",
      "socialMediaPost": "How do you go from plain functions to a distributed conversation? This piece on StateGraphs digs into how that transformation actually works.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/stategraphs-distributed-conversations",
      "file": "/data/automated-blog/2026/01/stategraphs-distributed-conversations.json",
      "hashtags": "#distributedSystems #softwareDesign #async #concurrency"
    },
    {
      "slug": "2026/01/async-clients-hanging",
      "title": "When Async Clients Refuse To Hang",
      "publishedAt": "2026-01-27T17:05:16+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6725a69e-d885-44cc-8ca9-4c52ef30f994.png",
      "socialMediaPost": "When async clients refuse to hang, everything about reliability changes. If you care about async behavior under failure, this one’s worth a read.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/async-clients-hanging",
      "file": "/data/automated-blog/2026/01/async-clients-hanging.json",
      "hashtags": "#async #python #networking #reliability"
    },
    {
      "slug": "2026/01/keybindings-language",
      "title": "When Keybindings Become a Language",
      "publishedAt": "2026-01-26T04:42:41+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-c85570e0-6a67-4161-a17d-ffcc5ae97653.png",
      "socialMediaPost": "When keybindings become a language, config stops being random shortcuts and starts acting like a small, programmable system you can actually reason about.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/keybindings-language",
      "file": "/data/automated-blog/2026/01/keybindings-language.json",
      "hashtags": "#programming #UX #keymaps #softwaredesign"
    },
    {
      "slug": "2026/01/agent-translation-layer",
      "title": "The Translation Layer That Makes Agents Feel Smart",
      "publishedAt": "2026-01-24T16:41:03+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-46857853-998c-4e76-a814-9562259743a0.png",
      "socialMediaPost": "Most agent setups focus on bigger models, not better communication. This post dives into the translation layer that makes agents actually feel smart 🤖",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/agent-translation-layer",
      "file": "/data/automated-blog/2026/01/agent-translation-layer.json",
      "hashtags": "#AI #agents #softwaredesign #architecture"
    },
    {
      "slug": "2026/01/how-to-find-tech-mentor",
      "title": "How To Find The Right Tech Mentor",
      "publishedAt": "2026-01-24T12:00:00+04:00",
      "featured": true,
      "imageUrl": "/images-optimized/blog/blog-5b-medium.webp",
      "socialMediaPost": "Choosing a mentor is less about titles and more about fit, goals, and evidence of impact. This guide breaks down how engineers can evaluate mentors and get real career progress.",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/01/how-to-find-tech-mentor",
      "file": "/data/manual-blog/how-to-find-tech-mentor.json",
      "category": "insights",
      "hashtags": "#TechMentor #CareerGrowth #EngineeringCareer #AIMentor"
    },
    {
      "slug": "2026/01/front-controller-stealth",
      "title": "The Front Controller That Stays Out Of Your Way",
      "publishedAt": "2026-01-23T04:43:40+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b00de5cd-9988-4a12-93ec-8599373759e5.png",
      "socialMediaPost": "Most front controllers become god objects. “The Front Controller That Stays Out Of Your Way” explores how to keep one central entry point without cluttering your code.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/front-controller-stealth",
      "file": "/data/automated-blog/2026/01/front-controller-stealth.json",
      "hashtags": "#softwaredesign #architecture #webdev"
    },
    {
      "slug": "2026/01/metaclass-guardrails",
      "title": "The Metaclass That Turns Type Hints Into Guardrails",
      "publishedAt": "2026-01-21T16:44:42+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-cb8d5aa0-ec2e-4413-8a8a-037496b23d42.png",
      "socialMediaPost": "Turning type hints from passive comments into active guardrails sounds wild. Curious how a single metaclass can reshape your whole data model? 🤔",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/metaclass-guardrails",
      "file": "/data/automated-blog/2026/01/metaclass-guardrails.json",
      "hashtags": "#python #typing #metaprogramming #softwaredesign"
    },
    {
      "slug": "2026/01/graph-orchestration-power",
      "title": "When Graph Orchestration Becomes a Power Tool",
      "publishedAt": "2026-01-20T04:37:04+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d93e20b7-c201-49cf-b3fc-dae8712f07fb.png",
      "socialMediaPost": "When does graph orchestration stop being glue code and start feeling like a real power tool? This explores that shift and why it matters for your systems.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/graph-orchestration-power",
      "file": "/data/automated-blog/2026/01/graph-orchestration-power.json",
      "hashtags": "#orchestration #graphs #softwaredesign #distributedsystems"
    },
    {
      "slug": "2026/01/ai-consultant-guide",
      "title": "What to Expect from an AI Consultant",
      "publishedAt": "2026-01-19T12:00:00+02:00",
      "featured": true,
      "imageUrl": "/images-optimized/blog/blog-4c-medium.webp",
      "socialMediaPost": "From prototype to production, the hard part isn’t AI, it’s decisions about data, evaluation, and ownership. This article maps the steps teams skip and how to avoid them.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/ai-consultant-guide",
      "file": "/data/manual-blog/ai-consultant-guide.json",
      "category": "insights",
      "hashtags": "#AIStrategy #AIConsulting #AIRoadmap"
    },
    {
      "slug": "2026/01/hidden-linear-engine",
      "title": "The Hidden Engine Behind LinearRegression",
      "publishedAt": "2026-01-18T16:37:59+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-dce78015-9939-4456-a8cc-a63ae656f886.png",
      "socialMediaPost": "What actually powers LinearRegression under the hood? This piece digs into the hidden engine behind it and why that internal design matters for your models.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/hidden-linear-engine",
      "file": "/data/automated-blog/2026/01/hidden-linear-engine.json",
      "hashtags": "#LinearRegression #MachineLearning #MLModels #SoftwareDesign"
    },
    {
      "slug": "2026/01/dspy-module-gateway",
      "title": "The Gateway Class Behind DSPy Modules",
      "publishedAt": "2026-01-17T04:36:21+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-11bc8122-bed8-4258-8a16-e16e45b48243.png",
      "socialMediaPost": "Curious how DSPy routes every pipeline step before it touches an LLM? This piece breaks down the gateway class behind DSPy modules and why it matters.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/dspy-module-gateway",
      "file": "/data/automated-blog/2026/01/dspy-module-gateway.json",
      "hashtags": "#DSPy #LLM #Python #softwaredesign"
    },
    {
      "slug": "2026/01/blueprint-lock-fastify",
      "title": "The Blueprint Lock Behind Fastify",
      "publishedAt": "2026-01-15T16:36:02+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d13f77f8-497a-4e37-acc5-158357ae07a1.png",
      "socialMediaPost": "Curious how Fastify keeps a high‑performance HTTP server stable under load? This breakdown of the “blueprint lock” shows the core idea behind its design.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/blueprint-lock-fastify",
      "file": "/data/automated-blog/2026/01/blueprint-lock-fastify.json",
      "hashtags": "#Fastify #NodeJS #webframework #softwaredesign"
    },
    {
      "slug": "2026/01/agent-contract-core",
      "title": "The Contract Behind Every AI Agent",
      "publishedAt": "2026-01-14T04:36:03+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-1ea3a720-0732-40ca-999e-6a04b623e384.png",
      "socialMediaPost": "Every AI agent hides an implicit contract. If you’re building with agents, understanding that contract is what keeps your systems predictable and sane.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/agent-contract-core",
      "file": "/data/automated-blog/2026/01/agent-contract-core.json",
      "hashtags": "#AI #agents #softwaredesign #architecture"
    },
    {
      "slug": "2026/01/mongodb-client-tower",
      "title": "The MongoDB Client as Control Tower",
      "publishedAt": "2026-01-12T16:36:54+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6340acb7-06cc-4ec7-8282-da2db0f2dea5.png",
      "socialMediaPost": "If you think of the MongoDB client as just a connection handle, you’re missing the point. Treat it like a control tower coordinating everything around it.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/mongodb-client-tower",
      "file": "/data/automated-blog/2026/01/mongodb-client-tower.json",
      "hashtags": "#MongoDB #database #backend #softwaredesign"
    },
    {
      "slug": "2026/01/linux-module-world",
      "title": "How Linux Shapes Its Module World",
      "publishedAt": "2026-01-11T16:38:57+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6887b0a9-3253-49cb-8198-f8da1da8f520.png",
      "socialMediaPost": "Curious how a kernel keeps its module chaos under control? “How Linux Shapes Its Module World” breaks down the ideas behind its module design.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/linux-module-world",
      "file": "/data/automated-blog/2026/01/linux-module-world.json",
      "hashtags": "#Linux #kernel #modules #systems"
    },
    {
      "slug": "2026/01/tiny-tokenizer-llama",
      "title": "The Tiny Tokenizer That Shapes Llama",
      "publishedAt": "2026-01-11T05:59:17+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-2087a30c-2648-4aa7-8916-b2e1f6cd09ae.png",
      "socialMediaPost": "Most people focus on model size, but The Tiny Tokenizer That Shapes Llama shows how a small text step quietly steers everything your LLM does 🔎",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/tiny-tokenizer-llama",
      "file": "/data/automated-blog/2026/01/tiny-tokenizer-llama.json",
      "hashtags": "#LLM #tokenization #Llama #machinelearning"
    },
    {
      "slug": "2026/01/boring-kernel-modules",
      "title": "The Header That Makes Kernel Modules Boring",
      "publishedAt": "2026-01-11T04:34:08+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4088cbb2-1c68-4d15-a9d4-658046682d3b.png",
      "socialMediaPost": "Why would anyone want kernel modules to be boring? This piece digs into the one header that quietly makes Linux module behavior feel predictable.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/boring-kernel-modules",
      "file": "/data/automated-blog/2026/01/boring-kernel-modules.json",
      "hashtags": "#linux #kernel #programming #softwaredesign"
    },
    {
      "slug": "2026/01/react-chaos-commit",
      "title": "How React Turns Chaos Into a Commit",
      "publishedAt": "2026-01-10T02:41:11+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-8ed91127-caab-4e3d-9ef3-3cdab5d00024.png",
      "socialMediaPost": "How does React turn a storm of updates into one clean commit? This piece breaks down the path from chaos to a predictable UI pipeline.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/react-chaos-commit",
      "file": "/data/automated-blog/2026/01/react-chaos-commit.json",
      "hashtags": "#React #frontend #webdev #softwarearchitecture"
    },
    {
      "slug": "2026/01/plain-functions-prompts",
      "title": "When Plain Functions Become Robust Prompts",
      "publishedAt": "2026-01-08T01:59:00+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-dbeadaa9-4af9-4720-983f-cd69495a253d.png",
      "socialMediaPost": "When plain functions become robust prompts, you stop thinking in prompt templates and start thinking in code, while still getting reliable prompt behavior.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/plain-functions-prompts",
      "file": "/data/automated-blog/2026/01/plain-functions-prompts.json",
      "hashtags": "#promptengineering #python #softwaredesign"
    },
    {
      "slug": "2026/01/numpy-pad-smart",
      "title": "How NumPy Teaches Us to Pad Smart",
      "publishedAt": "2026-01-07T20:57:08+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4100eacf-641e-4deb-8cd7-36764a963c3d.png",
      "socialMediaPost": "How NumPy teaches us to pad smart isn’t just about adding zeros to arrays; it’s about designing padding that stays flexible, predictable, and clean.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/numpy-pad-smart",
      "file": "/data/automated-blog/2026/01/numpy-pad-smart.json",
      "hashtags": "#NumPy #Python #DataScience #softwaredesign"
    },
    {
      "slug": "2026/01/local-llm-microservice",
      "title": "The Local Microservice Behind Every Model",
      "publishedAt": "2026-01-05T18:26:34+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-ff1a71fb-17aa-44db-8b75-2f4f07f19b2c.png",
      "socialMediaPost": "What does “The Local Microservice Behind Every Model” really mean in practice? Think of each model as its own small service running right beside your app.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/local-llm-microservice",
      "file": "/data/automated-blog/2026/01/local-llm-microservice.json",
      "hashtags": "#microservices #softwarearchitecture #machinelearning #backend"
    },
    {
      "slug": "2026/01/eval-execution-engine",
      "title": "When Eval Becomes an Execution Engine",
      "publishedAt": "2026-01-03T10:52:35+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-19dd9139-4b65-4b2d-b04e-98e82df2cc5e.png",
      "socialMediaPost": "When does a simple eval stop being a helper and start acting like a full execution engine? Exploring the boundary where evaluation turns into control.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/eval-execution-engine",
      "file": "/data/automated-blog/2026/01/eval-execution-engine.json",
      "hashtags": "#programming #softwaredesign #runtime #execution"
    },
    {
      "slug": "2026/01/pandas-facade",
      "title": "The Facade That Makes Pandas Feel Simple",
      "publishedAt": "2026-01-01T03:19:46+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-87f63bde-85f5-4989-adec-7dfc4c44b75f.png",
      "socialMediaPost": "Ever wondered why working with pandas can feel so straightforward despite what’s under the hood? This dives into the facade that keeps it simple.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/pandas-facade",
      "file": "/data/automated-blog/2026/01/pandas-facade.json",
      "hashtags": "#pandas #python #datascience #softwaredesign"
    },
    {
      "slug": "2025/12/one-function-llm",
      "title": "One Function To Call Every LLM",
      "publishedAt": "2025-12-29T19:46:06+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-8d90914d-f1d7-4f07-b6a1-39c2a60f8802.png",
      "socialMediaPost": "What if your stack only needed one function to talk to every LLM? This piece breaks down the idea and why it can simplify your architecture.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/12/one-function-llm",
      "file": "/data/automated-blog/2025/12/one-function-llm.json",
      "hashtags": "#LLM #AI #softwarearchitecture #devtools"
    },
    {
      "slug": "2025/12/training-conductor",
      "title": "The Training Conductor Behind Keras Models",
      "publishedAt": "2025-12-29T13:46:38+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b1e381ec-5abd-4f98-a2aa-e8abab8bc1f9.png",
      "socialMediaPost": "How does Keras actually run your training under the hood? Think of a training conductor quietly coordinating every step behind model.fit().",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/training-conductor",
      "file": "/data/automated-blog/2025/12/training-conductor.json",
      "hashtags": "#Keras #DeepLearning #MachineLearning #NeuralNetworks"
    },
    {
      "slug": "2025/12/tiny-grafana-bootstrap",
      "title": "The Tiny Struct That Boots Grafana",
      "publishedAt": "2025-12-27T12:12:23+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e351c42a-a860-4d45-b814-6ebe3e8d0ca7.png",
      "socialMediaPost": "A huge observability platform, kicked off by a tiny struct. “The Tiny Struct That Boots Grafana” is a neat reminder of how small coordination logic can be.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/12/tiny-grafana-bootstrap",
      "file": "/data/automated-blog/2025/12/tiny-grafana-bootstrap.json",
      "hashtags": "#grafana #observability #golang #softwaredesign"
    },
    {
      "slug": "2025/12/guidance-engine",
      "title": "The Guidance Engine Behind Stable Diffusion",
      "publishedAt": "2025-12-25T04:43:13+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-3e3a2dfc-d393-418f-83cb-66f1f70933c1.png",
      "socialMediaPost": "Curious how a single text prompt becomes a full image? This breakdown of the guidance engine behind Stable Diffusion focuses on the orchestration, not the magic ✨",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/guidance-engine",
      "file": "/data/automated-blog/2025/12/guidance-engine.json",
      "hashtags": "#stablediffusion #genai #diffusionmodels"
    },
    {
      "slug": "2025/12/linux-next-slice",
      "title": "How Linux Chooses Your Next CPU Time Slice",
      "publishedAt": "2025-12-23T01:32:35+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d3692d0f-c2f1-490d-8f01-8f2f28e16ee5.png",
      "socialMediaPost": "Wondering how Linux decides what runs next on your machine? This breakdown of how it picks each new CPU time slice makes the scheduler’s logic much clearer.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/linux-next-slice",
      "file": "/data/automated-blog/2025/12/linux-next-slice.json",
      "hashtags": "#Linux #kernel #scheduler #CPU"
    },
    {
      "slug": "2025/12/bitcoin-boot-safely",
      "title": "How Bitcoin Boots Safely",
      "publishedAt": "2025-12-23T00:10:35+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e4a6d5e3-833e-4411-8e47-85375207d0bb.png",
      "socialMediaPost": "How does Bitcoin actually start up without putting funds at risk? “How Bitcoin Boots Safely” breaks down the boot process and the safety mindset behind it.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/bitcoin-boot-safely",
      "file": "/data/automated-blog/2025/12/bitcoin-boot-safely.json",
      "hashtags": "#Bitcoin #cryptocurrency #security #softwareengineering"
    },
    {
      "slug": "2025/12/electron-app-control-tower",
      "title": "The App Module as Electron’s Control Tower",
      "publishedAt": "2025-12-22T21:07:40+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-a0922042-d913-4ac8-82e3-eaa4765b78f2.png",
      "socialMediaPost": "Building desktop apps with Electron? Think of the App Module as your control tower, coordinating everything from one place instead of scattered hooks ✈️",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/12/electron-app-control-tower",
      "file": "/data/automated-blog/2025/12/electron-app-control-tower.json",
      "hashtags": "#Electron #desktopapps #softwarearchitecture #javascript"
    },
    {
      "slug": "2025/12/filesystem-sync-sleep",
      "title": "When a Filesystem Sync Decides Your Sleep",
      "publishedAt": "2025-12-20T16:40:34+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-a654d4c9-7f21-4d90-b4a5-961ddbdab7a9.png",
      "socialMediaPost": "Ever had a “sleep” request vetoed by storage? This piece digs into how a filesystem sync can be the final arbiter of whether your system actually sleeps 😴",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/12/filesystem-sync-sleep",
      "file": "/data/automated-blog/2025/12/filesystem-sync-sleep.json",
      "hashtags": "#linux #filesystem #powersaving #kernel"
    },
    {
      "slug": "2025/12/vllm-attention-switchboard",
      "title": "The Hidden Switchboard Behind vLLM Attention",
      "publishedAt": "2025-12-20T13:35:08+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-15aa4c78-a8ee-4216-9b0e-b14560b6db96.png",
      "socialMediaPost": "Working with vLLM and ever wonder what’s really happening inside its attention layers? This post traces the hidden switchboard wiring that makes it all work.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/vllm-attention-switchboard",
      "file": "/data/automated-blog/2025/12/vllm-attention-switchboard.json",
      "hashtags": "#vLLM #LLM #attention #AIinference"
    },
    {
      "slug": "2025/12/kafka-broker-cop",
      "title": "Kafka’s Broker As A Traffic Cop",
      "publishedAt": "2025-12-18T06:05:13+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-5b5ab3f1-58cf-4239-a824-e5850d35ecdd.png",
      "socialMediaPost": "Kafka’s broker as a traffic cop: once you see it as a single point directing every request, a lot of its design choices suddenly make sense 🚦",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/kafka-broker-cop",
      "file": "/data/automated-blog/2025/12/kafka-broker-cop.json",
      "hashtags": "#Kafka #distributedSystems #streaming"
    },
    {
      "slug": "2025/12/engine-room-models",
      "title": "The Engine Room of Massive Models",
      "publishedAt": "2025-12-15T22:28:26+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-9a2e28b9-72bb-47ef-9d4b-db1bf48cb1f2.png",
      "socialMediaPost": "Curious what really keeps massive models running? “The Engine Room of Massive Models” digs into the hidden machinery behind large-scale training.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/engine-room-models",
      "file": "/data/automated-blog/2025/12/engine-room-models.json",
      "hashtags": "#machinelearning #largemodels #training #engineering"
    },
    {
      "slug": "2025/12/kubelet-micro-os",
      "title": "Kubelet As A Pod Micro‑OS",
      "publishedAt": "2025-12-13T15:00:05+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-347fdb6b-5832-4a6b-bfb0-5d97b4ea4cff.png",
      "socialMediaPost": "What if you treated kubelet like a tiny operating system just for pods? Viewing it as a pod micro‑OS can change how you think about Kubernetes internals.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/kubelet-micro-os",
      "file": "/data/automated-blog/2025/12/kubelet-micro-os.json",
      "hashtags": "#Kubernetes #kubelet #cloudnative #devops"
    },
    {
      "slug": "2025/12/torch-control-tower",
      "title": "The Control Tower Behind `import torch`",
      "publishedAt": "2025-12-11T07:26:57+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-2733b294-3dab-49a1-adaf-82ac275c25c9.png",
      "socialMediaPost": "Every PyTorch script begins with `import torch`—but what actually happens in that moment? This explores the control tower quietly running behind it.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/torch-control-tower",
      "file": "/data/automated-blog/2025/12/torch-control-tower.json",
      "hashtags": "#PyTorch #Python #MachineLearning #SoftwareArchitecture"
    },
    {
      "slug": "2025/12/vscode-startup-tower",
      "title": "The Control Tower Behind VS Code Startup",
      "publishedAt": "2025-12-08T23:52:55+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-81f5d8a8-aae2-48c6-84b7-ea3669ae44e4.png",
      "socialMediaPost": "Ever wondered what coordinates everything before VS Code even shows a window? The Control Tower Behind VS Code Startup breaks down the orchestration.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/12/vscode-startup-tower",
      "file": "/data/automated-blog/2025/12/vscode-startup-tower.json",
      "hashtags": "#VSCode #Electron #softwarearchitecture #startupsequence"
    },
    {
      "slug": "2025/12/checkpoint-ledger-langgraph",
      "title": "The Checkpoint Ledger Behind LangGraph",
      "publishedAt": "2025-12-06T16:19:22+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-a1fba479-53be-4207-a39c-466b8b352cdd.png",
      "socialMediaPost": "Curious how LangGraph keeps long-running workflows consistent? This breakdown of the checkpoint ledger behind it shows how the story stays coherent over time.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/12/checkpoint-ledger-langgraph",
      "file": "/data/automated-blog/2025/12/checkpoint-ledger-langgraph.json",
      "hashtags": "#LangGraph #LLM #checkpointing #distributedSystems"
    },
    {
      "slug": "2025/12/lightweight-imports",
      "title": "Why Transformers Imports Feel Lightweight",
      "publishedAt": "2025-12-05T03:14:38+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-47c476a7-35f2-4f4c-bb19-a7ecdcc24fb1.png",
      "socialMediaPost": "Why do transformers imports feel so light for such a big library? This digs into how that “lightweight” feeling happens and what it means for your own code.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/lightweight-imports",
      "file": "/data/automated-blog/2025/12/lightweight-imports.json",
      "hashtags": "#python #transformers #softwaredesign #devtools"
    },
    {
      "slug": "2025/12/one-class-cluster",
      "title": "When One Class Runs Your Cluster",
      "publishedAt": "2025-12-04T08:46:31+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-2118f3ad-9fb4-4fa1-959a-9cd7ec3a56b3.png",
      "socialMediaPost": "When one class runs your cluster, you get power and risk in the same place. Curious how that trade-off plays out in real distributed systems? ⚙️",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/one-class-cluster",
      "file": "/data/automated-blog/2025/12/one-class-cluster.json",
      "hashtags": "#distributedSystems #softwareDesign #architecture #scalability"
    },
    {
      "slug": "2025/12/transformers-listen",
      "title": "When Transformers Learn To Listen",
      "publishedAt": "2025-12-02T01:10:30+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-c271a904-dfe0-40a1-99a2-d4df73956ef4.png",
      "socialMediaPost": "When transformers learn to listen, they stop being just text models and become full speech partners. Curious how that shift changes what we build? 🎧",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/12/transformers-listen",
      "file": "/data/automated-blog/2025/12/transformers-listen.json",
      "hashtags": "#Transformers #MachineLearning #SpeechAI #DeepLearning"
    },
    {
      "slug": "2025/11/cli-operating-system",
      "title": "When a CLI Becomes an Operating System",
      "publishedAt": "2025-11-29T17:38:08+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-55340d3e-5edb-45ea-a908-389697d3d32a.png",
      "socialMediaPost": "When a CLI starts feeling more like an operating system than a simple command, you know something interesting is going on. Where’s that line for your tools?",
      "readingTime": "35m",
      "url": "https://zalt.me/blog/2025/11/cli-operating-system",
      "file": "/data/automated-blog/2025/11/cli-operating-system.json",
      "hashtags": "#cli #operatingsystem #developers #softwaredesign"
    },
    {
      "slug": "2025/11/jax-transformation-machine",
      "title": "How JAX Turns Ordinary Python Into a Transformation Machine",
      "publishedAt": "2025-11-27T10:07:49+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-5293f5c0-a887-45cc-a1d0-01b7d6f97857.png",
      "socialMediaPost": "What does it really mean for JAX to turn ordinary Python into a transformation machine? This walks through how that shift changes how you think about code.",
      "readingTime": "35m",
      "url": "https://zalt.me/blog/2025/11/jax-transformation-machine",
      "file": "/data/automated-blog/2025/11/jax-transformation-machine.json",
      "hashtags": "#JAX #Python #MachineLearning #Programming"
    },
    {
      "slug": "2025/11/batching-tokens-mind",
      "title": "Batching Tokens Without Losing Your Mind",
      "publishedAt": "2025-11-25T02:30:39+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d2971f8b-e76f-44e4-b286-7dca2739cf04.png",
      "socialMediaPost": "Working on high-throughput AI and juggling batching logic? “Batching Tokens Without Losing Your Mind” breaks down how to stay fast without drowning in complexity.",
      "readingTime": "35m",
      "url": "https://zalt.me/blog/2025/11/batching-tokens-mind",
      "file": "/data/automated-blog/2025/11/batching-tokens-mind.json",
      "hashtags": "#AI #LLM #inference #scaling"
    },
    {
      "slug": "2025/11/linux-time-namespaces",
      "title": "How Linux Bends Time Safely",
      "publishedAt": "2025-11-22T18:15:40+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-f8604db4-634d-4e28-aae1-87ebe5d2b0fb.png",
      "socialMediaPost": "How does an OS bend time without breaking everything that depends on it? This breakdown of Linux shows how time can be shifted while staying safe 🕒",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/11/linux-time-namespaces",
      "file": "/data/automated-blog/2025/11/linux-time-namespaces.json",
      "hashtags": "#Linux #kernel #systems"
    },
    {
      "slug": "2025/11/rails-application-security-nerve",
      "title": "Rails::Application as a Security Nerve Center",
      "publishedAt": "2025-11-18T16:02:26+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-781c1f17-63cb-494d-8de3-97f75525930a.png",
      "socialMediaPost": "Make Rails::Application your security nerve center: centralize your app's security into one clear, auditable place so wiring and behavior become easier to reason about.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/11/rails-application-security-nerve",
      "file": "/data/automated-blog/2025/11/rails-application-security-nerve.json",
      "hashtags": "#FrameworkDesign #SecureArchitecture #EngineeringPractices"
    },
    {
      "slug": "2025/11/node-esm-resolver",
      "title": "How Node’s ESM Resolver Balances Strictness and Helpfulness",
      "publishedAt": "2025-11-15T14:34:33+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-5c87ae85-6800-4e68-bfda-430de8f76263.png",
      "socialMediaPost": "How Node’s ESM resolver balances strictness and helpfulness: it enforces tight module rules yet offers actionable hints so engineers see precise errors and quicker paths to fix imports.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/11/node-esm-resolver",
      "file": "/data/automated-blog/2025/11/node-esm-resolver.json",
      "hashtags": "#ModuleResolution #DevDX #JSModules"
    },
    {
      "slug": "2025/11/frontend-performance",
      "title": "Frontend Performance Optimization Guide",
      "publishedAt": "2025-11-08T16:00:00+02:00",
      "featured": true,
      "imageUrl": "/images-optimized/blog/blog-3-medium.webp",
      "socialMediaPost": "Master the art of achieving perfect Lighthouse scores! Learn the ultimate frontend best practices for Performance, SEO, and Accessibility in this comprehensive guide.",
      "readingTime": "1h 35m",
      "url": "https://zalt.me/blog/2025/11/frontend-performance",
      "file": "/data/manual-blog/frontend-performance.json",
      "category": "Code Cracking",
      "template": "collapsible",
      "hashtags": "#Lighthouse #SEO #Accessibility #Frontend"
    },
    {
      "slug": "2025/11/decoding-linux-boot-start-kernel",
      "title": "Decoding Linux Boot: start_kernel",
      "publishedAt": "2025-11-07T20:45:41+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-28798968-30ac-40e6-9c4a-f2b4bd698bbb.png",
      "socialMediaPost": "Curious how Linux actually starts? Decoding Linux Boot: start_kernel walks through the start_kernel entry point so engineers can follow the initial boot sequence and its responsibilities.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/11/decoding-linux-boot-start-kernel",
      "file": "/data/automated-blog/2025/11/decoding-linux-boot-start-kernel.json",
      "hashtags": "#OSInternals #KernelInternals #StartupSequence"
    },
    {
      "slug": "2025/11/inside-elasticsearch-node-orchestrator",
      "title": "Inside Elasticsearch’s Node Orchestrator",
      "publishedAt": "2025-11-04T23:54:55+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e5977b2d-ab89-4649-87d0-d835a7f478af.png",
      "socialMediaPost": "Curious how Elasticsearch’s Node Orchestrator manages a node’s lifecycle? A clear inside look with practical takeaways for engineers who design or operate distributed systems.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/11/inside-elasticsearch-node-orchestrator",
      "file": "/data/automated-blog/2025/11/inside-elasticsearch-node-orchestrator.json",
      "hashtags": "#Elasticsearch #NodeLifecycle #Orchestration"
    },
    {
      "slug": "2025/11/inside-fastmcp-context",
      "title": "Inside the fastmcp Context",
      "publishedAt": "2025-11-02T00:26:23+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-43a4d8ff-8fdf-423e-8a3b-ad5e5e904bc0.png",
      "socialMediaPost": "Don't treat the Context as a black box — Inside the fastmcp Context pulls back the curtain so engineers can see what the Context contains and how it frames request handling in fastmcp.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/11/inside-fastmcp-context",
      "file": "/data/automated-blog/2025/11/inside-fastmcp-context.json",
      "hashtags": "#MCP #Server #Engineering"
    },
    {
      "slug": "2025/11/taming-llama-generation",
      "title": "Taming LLaMA Generation APIs",
      "publishedAt": "2025-11-01T20:54:50+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d4359e22-7792-4926-8622-c62488053f63.png",
      "socialMediaPost": "Struggling with LLaMA generation APIs? Tame them for predictable, safer outputs and smoother integration — practical steps engineers can apply to make model serving less surprising.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/11/taming-llama-generation",
      "file": "/data/automated-blog/2025/11/taming-llama-generation.json",
      "hashtags": "#LLM #MLOps #Inference"
    },
    {
      "slug": "2025/10/inside-pydantics-lazy-facade",
      "title": "Inside Pydantic\u0019s Lazy Facade",
      "publishedAt": "2025-10-29T17:57:30+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d88b9fa7-247c-40c8-ab88-f38a344dae77.png",
      "socialMediaPost": "Get a clear view of Pydantic's lazy facade: Inside Pydantic's Lazy Facade explains how the package surface defers work until needed and what that means for library authors.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-pydantics-lazy-facade",
      "file": "/data/automated-blog/2025/10/inside-pydantics-lazy-facade.json",
      "hashtags": "#Python #APIDesign #DesignPatterns"
    },
    {
      "slug": "2025/10/inside-fastapi-routing",
      "title": "Inside FastAPI’s Routing Core",
      "publishedAt": "2025-10-26T14:55:56+01:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-26158c97-3054-4ee6-8048-eed4ba4d2ab6.png",
      "socialMediaPost": "Most resources skim routing; Inside FastAPI’s Routing Core opens the router internals so backend engineers can reason about routing behavior and design choices for production APIs.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-fastapi-routing",
      "file": "/data/automated-blog/2025/10/inside-fastapi-routing.json",
      "hashtags": "#python #webframework #architecture"
    },
    {
      "slug": "2025/10/chatgpt-apps-playbook",
      "title": "A Strategic Guide to Building ChatGPT Apps",
      "publishedAt": "2025-10-25T10:17:00+02:00",
      "featured": true,
      "imageUrl": "/images-optimized/blog/blog-2-medium.webp",
      "socialMediaPost": "The Next Frontier of Software is Here: Where Intent is the Currency and Conversation is the Operating System. The current, dense marketplaces of apps are expected to dissolve, giving way to a new ecosystem that trades the friction of rigid UIs for the natural fluency of human conversation!",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2025/10/chatgpt-apps-playbook",
      "file": "/data/manual-blog/chatgpt-apps-playbook.json",
      "category": "insights",
      "hashtags": "#AIMarketplace #ChatGPT #MCP #AppsSDK"
    },
    {
      "slug": "2025/10/inside-wordpress-wp-class",
      "title": "Inside WordPress WP Class",
      "publishedAt": "2025-10-23T12:56:25+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4a516926-727c-4c8f-8085-5de355778630.png",
      "socialMediaPost": "Curious about WordPress internals? Inside WordPress WP Class gives engineers a clear look at the core class so you can reason about how it works.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-wordpress-wp-class",
      "file": "/data/automated-blog/2025/10/inside-wordpress-wp-class.json",
      "hashtags": "#Internals #WebDev #PHP"
    },
    {
      "slug": "2025/10/inside-laravel-application-kernel",
      "title": "Inside Laravel\u0019s Application Kernel",
      "publishedAt": "2025-10-20T09:48:44+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-f0c9c7dd-a935-4223-9a9e-12a2c5ba7711.png",
      "socialMediaPost": "Get a clear tour of Laravel's Application Kernel — understand its purpose, the responsibilities it centralizes, and why developers should care when working on Laravel apps.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-laravel-application-kernel",
      "file": "/data/automated-blog/2025/10/inside-laravel-application-kernel.json",
      "hashtags": "#FrameworkInternals #PHPFrameworks #WebDev"
    },
    {
      "slug": "2025/10/inside-llamas-transformer-core",
      "title": "Inside Llama’s Transformer Core",
      "publishedAt": "2025-10-17T06:49:39+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-c337d88b-ab23-4dbf-b84e-b4cca6b0d2fd.png",
      "socialMediaPost": "Want a clear look inside Llama's Transformer core? A concise, engineer-focused tour of the model internals that explains how the core is structured and why those choices matter.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-llamas-transformer-core",
      "file": "/data/automated-blog/2025/10/inside-llamas-transformer-core.json",
      "hashtags": "#LLMs #Transformers #MLSystems"
    },
    {
      "slug": "2025/10/ai-history-timeline",
      "title": "The History of AI in One Timeline",
      "publishedAt": "2025-10-15T19:00:00+02:00",
      "featured": true,
      "imageUrl": "/images-optimized/blog/blog-1-2-medium.webp",
      "socialMediaPost": "So who invented AI? Maybe we all did. Human survival drove farming → farming needed counting → counting birthed math → math built machines → machines created computers → computers generated data → data trained AI → AI got transformers → transformers power AI. </br> Call it the longest relay race in tech, passed hand-to-hand for thousands of years.",
      "readingTime": "1h 5m",
      "url": "https://zalt.me/blog/2025/10/ai-history-timeline",
      "file": "/data/manual-blog/ai-history-timeline.json",
      "category": "insights",
      "template": "timeline",
      "hashtags": "#TechHistory #AI #Innovation #Timeline"
    },
    {
      "slug": "2025/10/inside-gits-front-controller",
      "title": "Inside Git’s Front Controller",
      "publishedAt": "2025-10-14T03:50:18+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-949d7436-a12e-4110-8013-46b5fad64ebe.png",
      "socialMediaPost": "Understand Git's front controller to see how the top-level dispatcher turns raw input into the correct subcommand and environment for engineers building or debugging CLIs.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-gits-front-controller",
      "file": "/data/automated-blog/2025/10/inside-gits-front-controller.json",
      "hashtags": "#Git #CLI #DevTools"
    },
    {
      "slug": "2025/10/bootstrapping-curls-cli-safely",
      "title": "Bootstrapping curl’s CLI Safely",
      "publishedAt": "2025-10-11T00:50:37+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-cdda8d00-8da0-407a-8b8c-3c3ef35e8bdb.png",
      "socialMediaPost": "Make the CLI entry safe: Bootstrapping curl’s CLI safely aims to keep startup logic small and predictable so engineers can reason about early failures with far fewer surprises.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/bootstrapping-curls-cli-safely",
      "file": "/data/automated-blog/2025/10/bootstrapping-curls-cli-safely.json",
      "hashtags": "#reliability #devtools #bootstrap"
    },
    {
      "slug": "2025/10/inside-polars-lazyframe",
      "title": "Inside Polars LazyFrame",
      "publishedAt": "2025-10-07T21:50:06+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-8d9262fb-23b4-464d-9421-92a5e59b37b8.png",
      "socialMediaPost": "Curious what's inside Polars LazyFrame? Engineers get a clear tour of its internals to better reason about lazy execution and spot refactors.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-polars-lazyframe",
      "file": "/data/automated-blog/2025/10/inside-polars-lazyframe.json",
      "hashtags": "#DataEngineering #Python #QueryEngine"
    },
    {
      "slug": "2025/10/inside-redis-server-c-orchestrator",
      "title": "Inside Redis server.c Orchestrator",
      "publishedAt": "2025-10-04T18:47:49+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b5fd6ab8-239a-4cce-a595-1d0c80ec3fd5.png",
      "socialMediaPost": "Inside Redis server.c Orchestrator peels back server.c to show how Redis coordinates its runtime — a concise look engineers can use to understand core orchestration and patterns to borrow.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/10/inside-redis-server-c-orchestrator",
      "file": "/data/automated-blog/2025/10/inside-redis-server-c-orchestrator.json",
      "hashtags": "#InMemoryDB #SystemsEngineering #CProgramming"
    },
    {
      "slug": "2025/09/inside-etcds-bootstrap-brain",
      "title": "Inside etcd’s Bootstrap Brain",
      "publishedAt": "2025-09-28T12:50:02+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0267727c-2ca2-47aa-86f6-2015237c2dbc.png",
      "socialMediaPost": "See inside etcd's bootstrap brain to learn what governs startup decisions—ideal for engineers who need clarity on config checks, disk classification, and readiness signaling.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/09/inside-etcds-bootstrap-brain",
      "file": "/data/automated-blog/2025/09/inside-etcds-bootstrap-brain.json",
      "hashtags": "#DistributedSystems #ControlPlanes #DevOps"
    },
    {
      "slug": "2025/09/demystifying-terraform-cli-bootstrap",
      "title": "Demystifying Terraform CLI Bootstrap",
      "publishedAt": "2025-09-25T09:49:23+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-32e38c14-a294-4251-a2d5-ea7207161777.png",
      "socialMediaPost": "Understand Terraform CLI bootstrap end to end: a clear look at the bootstrap sequence so engineers can read the entrypoint and reason about initialization, with clear steps.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/demystifying-terraform-cli-bootstrap",
      "file": "/data/automated-blog/2025/09/demystifying-terraform-cli-bootstrap.json",
      "hashtags": "#DevTools #CommandLine #Observability"
    },
    {
      "slug": "2025/09/inside-fastapi-routing-core",
      "title": "Inside FastAPI’s Routing Core",
      "publishedAt": "2025-09-22T06:43:11+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4fd78844-54e7-4d21-88d5-808323c93d69.png",
      "socialMediaPost": "Understand FastAPI routing internals: Inside FastAPI’s Routing Core explains how the router and request handler wire requests, dependencies, and responses — useful for backend engineers.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-fastapi-routing-core",
      "file": "/data/automated-blog/2025/09/inside-fastapi-routing-core.json",
      "hashtags": "#Python #WebFrameworks #APIDesign"
    },
    {
      "slug": "2025/09/inside-celerys-app-core",
      "title": "Inside Celery\u0019s App Core",
      "publishedAt": "2025-09-19T03:43:53+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-36ad1d87-4a67-40a3-aace-7f2e29305a82.png",
      "socialMediaPost": "Want to see what's under the hood of Celery's App Core? A practical tour for engineers to understand the app lifecycle, key seams, and where to start when debugging or extending it.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-celerys-app-core",
      "file": "/data/automated-blog/2025/09/inside-celerys-app-core.json",
      "hashtags": "#TaskQueue #Internals #DevOps"
    },
    {
      "slug": "2025/09/inside-flasks-request-engine",
      "title": "Inside Flask’s Request Engine",
      "publishedAt": "2025-09-16T00:44:25+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-9123c905-aab0-4c2a-ac76-4f575f33dd4b.png",
      "socialMediaPost": "Inside Flask's Request Engine: a clear, engineer-focused walk through the app's lifecycle so you can reason about how requests flow, where hooks run, and what to test or refactor.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/09/inside-flasks-request-engine",
      "file": "/data/automated-blog/2025/09/inside-flasks-request-engine.json",
      "hashtags": "#WebInternals #Python #WSGI"
    },
    {
      "slug": "2025/09/inside-djangos-basehandler",
      "title": "Inside Django\u00199s BaseHandler",
      "publishedAt": "2025-09-12T21:43:39+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-f6a6f440-df5b-4532-b5c8-59bd00062b5f.png",
      "socialMediaPost": "Curious what's under the hood of Django? Inside Django's BaseHandler walks engineers through the handler's internals so you can better understand how the framework processes requests.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-djangos-basehandler",
      "file": "/data/automated-blog/2025/09/inside-djangos-basehandler.json",
      "hashtags": "#Python #WebFramework #WebDev"
    },
    {
      "slug": "2025/09/inside-vites-dev-server",
      "title": "Inside Vite’s Dev Server Orchestrator",
      "publishedAt": "2025-09-09T18:37:12+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-fefc0fc7-b24a-412b-ac6a-33c2f329df2e.png",
      "socialMediaPost": "See inside Vite’s Dev Server Orchestrator: a concise view for engineers of the orchestrator’s role in managing the dev server and keeping its components coordinated.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-vites-dev-server",
      "file": "/data/automated-blog/2025/09/inside-vites-dev-server.json",
      "hashtags": "#Frontend #BuildTools #ViteJS"
    },
    {
      "slug": "2025/09/decoding-torch-init-py",
      "title": "Decoding torch/__init__.py: Design Lessons",
      "publishedAt": "2025-09-09T09:34:17+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4d620d96-4f28-4fcd-a9ee-f0b20a9099a6.png",
      "socialMediaPost": "Get design lessons by decoding torch/__init__.py - practical insights into the initializer that engineers can use to improve API clarity, module responsibilities, and long-term maintenance.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/decoding-torch-init-py",
      "file": "/data/automated-blog/2025/09/decoding-torch-init-py.json",
      "hashtags": "#PyTorch #SoftwareArchitecture #PythonDev"
    },
    {
      "slug": "2025/09/inside-the-piece-executor",
      "title": "Inside the Piece Executor",
      "publishedAt": "2025-09-08T08:34:43+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-391718aa-5610-4e79-9c14-33320e2522f6.png",
      "socialMediaPost": "Peek inside the Piece Executor — a compact tour of its internals and design intent for engineers who maintain or extend execution code, so you can reason clearly about runtime behavior.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-the-piece-executor",
      "file": "/data/automated-blog/2025/09/inside-the-piece-executor.json",
      "hashtags": "#Architecture #Runtime #Engineering"
    },
    {
      "slug": "2025/09/inside-nextjs-base-server",
      "title": "Inside Next.js Base Server",
      "publishedAt": "2025-09-07T11:47:23+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-3cbb120b-e392-4028-bf01-69715c7c9d72.png",
      "socialMediaPost": "Curious what runs at the heart of Next.js? Inside Next.js Base Server explores the server core so engineers can understand its internals, key design trade‑offs, and practical patterns to borrow.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/09/inside-nextjs-base-server",
      "file": "/data/automated-blog/2025/09/inside-nextjs-base-server.json",
      "hashtags": "#WebDev #Backend #Frameworks"
    },
    {
      "slug": "2025/09/deconstructing-nestfactory-nestjs",
      "title": "Deconstructing NestFactory in NestJS",
      "publishedAt": "2025-09-07T08:28:45+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-919019dd-7c92-4d1a-9812-8313bb00820d.png",
      "socialMediaPost": "NestFactory (nestjs/nest): how create(), microservices and app context wire DI, UuidFactory and ExceptionsZone — 3 fixes: stronger adapter guard, warn on UUID mode, flush logs before abort.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/deconstructing-nestfactory-nestjs",
      "file": "/data/automated-blog/2025/09/deconstructing-nestfactory-nestjs.json",
      "hashtags": "#NestJS #NodeJS #Observability"
    },
    {
      "slug": "2025/09/inside-fastify-factory-core",
      "title": "Inside Fastify’s Factory Core",
      "publishedAt": "2025-09-07T07:33:52+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-75455879-7e86-4ede-8eaa-88aacefd86be.png",
      "socialMediaPost": "Stared at a framework's big factory file and felt lost? I walk Fastify's core to show the tiny guards that keep requests fast, where bugs hide, and a one-line fix that fixes multibyte responses. 🔍",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2025/09/inside-fastify-factory-core",
      "file": "/data/automated-blog/2025/09/inside-fastify-factory-core.json",
      "hashtags": "#nodejs #fastify #architecture #Zalt"
    },
    {
      "slug": "2025/09/inside-n8n-workflow-engine",
      "title": "Inside n8n’s Workflow Engine",
      "publishedAt": "2025-09-07T07:07:53+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-83711de2-272d-407a-9d0e-ced7ec9793e6.png",
      "socialMediaPost": "Ever wondered how n8n runs workflows? I unpack the orchestrator that schedules nodes, syncs multi-input joins, keeps runs cancelable — plus 3 practical refactors to scale 🚀",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/inside-n8n-workflow-engine",
      "file": "/data/automated-blog/2025/09/inside-n8n-workflow-engine.json",
      "hashtags": "#n8n #automation #architecture #Zalt"
    },
    {
      "slug": "2025/09/inside-llama-transformer-core",
      "title": "Inside Llama Transformer Core",
      "publishedAt": "2025-09-07T05:45:15+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-434ea093-e55b-4e0a-b8fe-87c423d75a52.png",
      "socialMediaPost": "Ever stared at a transformer file and wondered how it works? I unpack Llama's compact core: embeddings, rotary encoding, KV cache for fast generation, plus tiny refactors and tests to make it reliable. 🔧",
      "readingTime": "10m",
      "url": "https://zalt.me/blog/2025/09/inside-llama-transformer-core",
      "file": "/data/automated-blog/2025/09/inside-llama-transformer-core.json",
      "hashtags": "#programming #transformers #ml #Zalt"
    },
    {
      "slug": "2025/09/taming-giant-registries-safely",
      "title": "Taming Giant Registries Safely",
      "publishedAt": "2025-09-06T15:13:15+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e6d82059-e36a-464a-8187-6fa9bb24d66a.png",
      "socialMediaPost": "Ever had a huge plugin table go wrong in production? I dug into how to keep giant registries safe — lazy loading, tiny validation tests, and simple doc fixes that stop subtle breakage 🚨🧰",
      "readingTime": "10m",
      "url": "https://zalt.me/blog/2025/09/taming-giant-registries-safely",
      "file": "/data/automated-blog/2025/09/taming-giant-registries-safely.json",
      "hashtags": "#programming #architecture #devops #Zalt"
    },
    {
      "slug": "2025/09/trust-your-timeouts-less",
      "title": "Trust Your Timeouts Less",
      "publishedAt": "2025-09-06T06:38:55+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-ecfb4361-1a26-4960-8158-a5a24d9d7917.png",
      "socialMediaPost": "Ever had an env var silently disable a safety check? I found NaN timeouts can turn pause limits into no-ops—clamp and validate env-derived timeouts to keep long-lived flows from blowing up. 🔧",
      "readingTime": "10m",
      "url": "https://zalt.me/blog/2025/09/trust-your-timeouts-less",
      "file": "/data/automated-blog/2025/09/trust-your-timeouts-less.json",
      "hashtags": "#programming #devops #Zalt"
    },
    {
      "slug": "2025/09/why-transformers-imports-feel-fast",
      "title": "Why Transformers Imports Feel Fast",
      "publishedAt": "2025-09-06T06:18:05+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-58e3d8a6-d6ad-4620-92fa-68242cfd1038.png",
      "socialMediaPost": "Slow imports killing your flow? I explain why transformers feels fast: it exposes names quickly but only loads heavy backends when used, keeps IDEs happy, and shows clear error messages ⚡",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/why-transformers-imports-feel-fast",
      "file": "/data/automated-blog/2025/09/why-transformers-imports-feel-fast.json",
      "hashtags": "#ML #Python #performance #Zalt"
    },
    {
      "slug": "2025/09/why-pydantic-models-feel-fast",
      "title": "Why Pydantic Models Feel Fast",
      "publishedAt": "2025-09-05T11:32:50+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4235b195-1acb-48c2-bd87-62ded5ad8dc7.png",
      "socialMediaPost": "",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2025/09/why-pydantic-models-feel-fast",
      "file": "/data/automated-blog/2025/09/why-pydantic-models-feel-fast.json"
    },
    {
      "slug": "2025/09/the-router-factory-pattern",
      "title": "The Router Factory Pattern",
      "publishedAt": "2025-09-05T11:14:24+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-66eabd2d-c02b-4b9a-ace4-2445e7bd1bb8.png",
      "socialMediaPost": "",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2025/09/the-router-factory-pattern",
      "file": "/data/automated-blog/2025/09/the-router-factory-pattern.json"
    },
    {
      "slug": "2025/09/torch-init-lesson-learned",
      "title": "Torch init! The 2,000-Line Bootstrap That Powers AI",
      "publishedAt": "2025-09-05T10:47:04+02:00",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-75b95531-d69d-42d8-9db7-18b93d82a069.png",
      "socialMediaPost": "",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2025/09/torch-init-lesson-learned",
      "file": "/data/automated-blog/2025/09/torch-init-lesson-learned.json"
    }
  ],
  "totalPosts": 98,
  "generatedAt": "2026-04-10T06:07:12.773Z"
}