Aloknecessary – Architecture Blog 2026-08-04T07:28:00+00:00 https://aloknecessary.in/ Multi-Cluster ArgoCD Architecture: Hub-and-Spoke vs. Per-Cluster, Done Right https://aloknecessary.in/blogs/multi-cluster-argocd-architecture/ 2026-07-31T00:00:00+00:00 Where does ArgoCD live when you go from 1 cluster to 15? Hub-and-spoke vs. ArgoCD-per-cluster, EKS and AKS cluster registration mechanics, and a decision framework tied to team topology and compliance boundaries. GitHub Actions OIDC: Eliminating Long-Lived Credentials from Your CI/CD Pipeline https://aloknecessary.in/blogs/github-actions-oidc/ 2026-07-27T00:00:00+00:00 OpenID Connect eliminates long-lived CI/CD credentials at the architectural level. This post covers the full implementation for AWS and Azure - OIDC provider setup, trust policy scoping, per-job role architecture, reusable workflow federation, the migration path from static secrets, and the audit trail that stored credentials structurally cannot provide. Cloud Security Architecture: From Shared Responsibility to Zero Trust https://aloknecessary.in/blogs/cloud-security-architecture/ 2026-07-21T00:00:00+00:00 Cloud security is not a layer you add after the architecture is designed — it is a set of architectural decisions made at the same time as resilience, cost, and modernisation. This post covers shared responsibility boundaries, IAM least-privilege at scale, secrets management, network segmentation, and zero-trust for Kubernetes workloads. Embedding Model Selection for Production: The Decision Nobody Documents https://aloknecessary.in/blogs/embedding-model-selection/ 2026-07-17T00:00:00+00:00 Every RAG architecture diagram has a box labeled 'embed.' Almost nobody documents how that box's contents got chosen, and almost everybody regrets the choice within eighteen months. This post is the decision framework that choice deserves. Cloud Cost Architecture: Engineering FinOps Into the System, Not Onto It https://aloknecessary.in/blogs/cloud-cost-architecture/ 2026-07-13T00:00:00+00:00 Cost is an architectural concern, not a finance concern. This post covers the decisions that determine your cloud bill before it arrives. Multi-AZ by Default: When High Availability Costs More Than the Downtime It Prevents https://aloknecessary.in/blogs/multi-az-by-default/ 2026-07-08T00:00:00+00:00 Multi-AZ doubles your database cost. That premium requires a business case, not a default. This post covers what Multi-AZ actually protects against, when Single-AZ with fast restore is the right answer, and a decision framework that ties availability investment to actual downtime cost. Modernising the Lifted Workload: The Architectural Decisions That Separate Cloud-Native from Cloud-Hosted https://aloknecessary.in/blogs/modernising-the-lifted-workload/ 2026-07-03T00:00:00+00:00 Kubernetes does not make your architecture better automatically. This post covers the graduation path from 'it's running on VMs' to genuinely cloud-native. GraphRAG vs. RAG: When Knowledge Graphs Earn Their Complexity https://aloknecessary.in/blogs/graph-rag-vs-rag/ 2026-06-29T00:00:00+00:00 Vector search tells you which chunks are similar to your query. GraphRAG tells you how entities in your corpus relate to each other. This post covers when that distinction matters, the benchmark evidence, how the 2024 cost problem got solved, and a decision framework for choosing between flat retrieval and graph retrieval. Context Engineering: The Discipline That Determines What Your LLM Actually Sees https://aloknecessary.in/blogs/discipline-that-determines-what-your-llm-actually-sees/ 2026-06-23T00:00:00+00:00 Prompt engineering asks how to phrase an instruction. Context engineering asks what information the model needs, in what form, in what order, and how much of it. This post covers token budgeting, four-type memory architecture, structured injection patterns, conversation compression, lost-in-the-middle mitigation, contradiction detection, and testing context assembly as a first-class system. Agentic RAG: Designing Self-Correcting Retrieval Loops for Production https://aloknecessary.in/blogs/designing-self-correcting-retrieval-loops-for-production/ 2026-06-17T00:00:00+00:00 Standard RAG retrieves once and hopes for the best. Agentic RAG retrieves, reflects, decides it was wrong, and tries again. This post covers the full architecture — query planning, iterative retrieval loops, reflection agents, multi-tool orchestration, routing, loop bounding, cost modeling, and the observability that makes agentic systems accountable. I Almost Lost an Entire Blog with git reset --hard (And Git Saved Me) https://aloknecessary.in/blogs/i-almost-lost-an-entire-blog-with-git-reset-hard/ 2026-06-14T00:00:00+00:00 I ran git reset --hard on autopilot and watched my blog post vanish. Fortunately, Git is far more resilient than most developers realize. This post covers the recovery, the mental model behind commits and references, and the commands every developer should know before they need them. LLM Evaluation in Production: Building the Eval Pipeline That Runs on Every Deploy https://aloknecessary.in/blogs/llm-evaluation-in-production/ 2026-06-11T00:00:00+00:00 Everyone ships the RAG system. Almost nobody ships the eval system that tells them when the RAG system starts lying. This post covers the four metrics that matter, LLM-as-Judge calibration, RAGAS integration, golden dataset management, GitHub Actions eval pipeline, and production sampling for continuous quality monitoring. Building Reliable RAG Pipelines: From Prototype to Production https://aloknecessary.in/blogs/rag_prototype_to_production/ 2026-06-04T00:00:00+00:00 Most teams get RAG working in a notebook over a weekend. Very few get it working reliably in production. This post covers the full pipeline — chunking strategy, hybrid retrieval, re-ranking, context assembly, prompt construction, retrieval evaluation, production observability, and graceful degradation. Event-Driven Architecture: The Dual Write Problem and How to Solve It https://aloknecessary.in/blogs/dual-write-problem-in-event-driven-architecture/ 2026-05-29T00:00:00+00:00 Writing to a database and publishing an event in the same operation without a transaction boundary is one of the most common correctness bugs in microservices. This post covers why it happens, the three solutions (Outbox Pattern, CDC with Debezium, Event Sourcing), and the operational concerns that determine which to choose. AI-Assisted Data Reconciliation at Scale: Patterns for Distributed Systems https://aloknecessary.in/blogs/ai_assisted_data_reconciliation/ 2026-05-20T00:00:00+00:00 Traditional reconciliation breaks at the seams of distributed ownership. This post covers where rule-based reconciliation fails, how embedding similarity and LLM classification fill the gap, the observation window pattern for eventual consistency, and the hard boundaries where AI should never be trusted to auto-resolve. Why Lift-and-Shift Fails Quietly: Architectural Smells That Appear After Migration https://aloknecessary.in/blogs/lift-and-shift-fails-quietly/ 2026-05-14T00:00:00+00:00 Lift-and-shift leaves on-premises assumptions baked into a system operating in a fundamentally different environment. This post covers the six architectural smells that surface after migration — latency amplification, chatty services, cost surprises, stateful assumptions, observability voids, and distributed monoliths — with diagnostics and mitigations for each. Designing Cloud-Native Systems That Survive Region-Level Failures https://aloknecessary.in/blogs/cloud_native_region_failure_architecture/ 2026-05-04T00:00:00+00:00 Most teams design for instance and zone failures but treat region-level outages as someone else's problem. This post covers the real architecture decisions behind multi-region resilience — active-passive vs active-active patterns, data replication trade-offs, failover automation, and a cost-aware framework for deciding how much resilience your system actually needs. Designing for Partial Failure: Why 'Everything is Highly Available' Is a Myth https://aloknecessary.in/blogs/designing_for_partial_failure/ 2026-04-17T00:00:00+00:00 High availability is not a property you buy — it is a discipline you build. This post covers how partial failures propagate into full outages, the concrete patterns that prevent cascading collapse (circuit breakers, bulkheads, timeout hierarchies, fallbacks), and the observability signals that make degraded states visible before they become incidents. Platform Engineering: Building the Internal Developer Platform Your Teams Actually Need https://aloknecessary.in/blogs/platform-engineering/ 2026-04-08T00:00:00+00:00 Platform Engineering is the architectural response to infrastructure tax at scale. This post covers the four pillars of a production-grade IDP — self-service provisioning, golden path CI/CD, centralized observability, and policy enforcement — along with team structure, implementation sequence, and the metrics that actually matter. BM25 vs. Vector Search: Choosing the Right Retrieval Strategy for Production Systems https://aloknecessary.in/blogs/bm25_vs_vector_search/ 2026-03-31T00:00:00+00:00 Keyword relevance or semantic understanding — the answer is rarely one or the other. This deep dive covers BM25 mechanics, vector search with embeddings, hybrid retrieval via Reciprocal Rank Fusion, re-ranking with cross-encoders, chunking strategies, and the architecture mistakes teams make when building search and RAG pipelines. The CAP Theorem in Practice: Making the Right Trade-offs at Scale https://aloknecessary.in/blogs/cap_theorem_architecture/ 2026-03-24T00:00:00+00:00 Every distributed system you build is already taking a side in the CAP trade-off. This post covers CP vs AP in practice, the PACELC model that actually matches production, architectural patterns shaped by CAP including sagas and CQRS, and a decision framework for making the trade-off deliberately. Saga Orchestration vs. Choreography: Making the Right Trade-off in Event-Driven Systems https://aloknecessary.in/blogs/saga-orchestration-vs-choreography/ 2026-03-16T00:00:00+00:00 The saga pattern looks straightforward in diagrams and becomes genuinely complex in production. This post compares orchestration and choreography — central control vs. decentralized reactions — covering failure modes, compensation correctness, and the baseline requirements most teams underestimate. Idempotency in Distributed Systems: Design Patterns Beyond 'Retry Safely' https://aloknecessary.in/blogs/idempotency-distributed-systems/ 2026-03-11T00:00:00+00:00 Idempotency is more than 'retry safely' — it's a system-wide property requiring deliberate design. This deep dive covers idempotency key semantics, deduplication store architecture, two-phase reservation patterns, API gateway vs application-layer handling, and the failure scenarios most teams miss until production breaks. Fresh VM to Dev Infra: The Complete Setup Guide https://aloknecessary.in/blogs/fresh-vm-dev-infra-setup/ 2026-03-04T00:00:00+00:00 Bootstrap a production-ready dev infrastructure VM with Docker, GitHub Actions runner, SQL, Redis, Portainer and Adminer — from zero to running in under an hour. Self-Hosted Runners on Kubernetes: Architecture, Security, and Cost Analysis https://aloknecessary.in/blogs/self-hosted-runners-kubernetes/ 2026-02-26T00:00:00+00:00 Running GitHub Actions self-hosted runners on Kubernetes at scale requires careful architectural decisions around isolation, security, and cost. This deep dive covers Actions Runner Controller (ARC) deployment patterns, namespace vs node-level isolation models, blast radius analysis, security hardening strategies, and realistic cost comparisons against GitHub-managed runners. Learn when self-hosted makes sense and how to implement it safely.