Posts

Warehouse Picker Routing Optimization (GraphHopper & OR-Tools) Answer-first: Minimizing walking distance for warehouse pickers requires solving the Traveling Salesperson Problem (TSP) inside a physical building. The 2026 standard architecture uses a Java-based Indoor GraphHopper instance to generate a 100x100 Distance Matrix from custom OpenStreetMap (OSM) data, which is then fed into a C++ Google OR-Tools gRPC Microservice to calculate the absolute optimal pick sequence in under 15 milliseconds. The S-Shape Trap in Warehouse Picking In legacy Warehouse Management Systems (WMS), workers are directed to pick items using heuristic patterns like the S-Shape (Z-pattern) or Largest Gap. These heuristics force the worker to walk down every aisle that contains an item, traversing the aisle from end to end. ...

Order Splitting at Scale: Graph Coloring, Bin Packing, and OPA in Go Answer-first: Real-time e-commerce order splitting is a Constraint Satisfaction Problem (CSP). To determine the absolute minimum number of cardboard boxes required for a complex cart without violating safety rules or physical dimensions, the 2026 standard pipeline relies on Open Policy Agent (OPA) for dynamic business rules, Golang (gonum) for Graph Coloring (Welsh-Powell) to resolve logical conflicts, and First-Fit Decreasing Bin Packing to resolve physical constraints. This pipeline executes in under 50ms during synchronous checkout, deferring heavy Multi-Warehouse routing to async workers. ...

Building a Custom Golang Vector Database Engine with HNSW Building a custom Go vector database engine with HNSW combines 256-bit SIMD AVX2 loop unrolling, off-heap mmap zero-GC slab memory, and Product Quantization (PQ-32) to get high recall at low latency while cutting vector RAM footprint dramatically. This post covers: How to bypass Go bounds checking and force AVX2 vectorization in pure Go using unsafe.Pointer loop unrolling without assembly maintenance overhead. Why naive Go pointer-based graph data structures trigger catastrophic GC pause spikes at 1M+ vectors—and how mmap off-heap slab allocation solves it. How to implement Asymmetric Distance Computation (ADC) lookup tables for Product Quantization to evaluate distance in $O(m)$ byte additions instead of $O(d)$ floating-point multiplications. Fine-grained lockless graph traversal strategies using atomic.Pointer to achieve concurrent write/read throughput without lock contention on high-degree node layers. 1. Vector Search Mathematics & Why Go Needs a Native Engine Modern Artificial Intelligence applications—from retrieval-augmented generation (RAG) to multimodal recommendation systems—depend fundamentally on high-dimensional vector search. Vectors represent semantic embeddings generated by neural networks (e.g., OpenAI text-embedding-3-large at 1,536 dimensions or Cohere embed-v3 at 768 dimensions). Searching for contextually relevant data requires discovering the $k$-Nearest Neighbors ($k$-NN) of a target query vector $\mathbf{q}$ within a dataset $S$ of $N$ vectors. ...

Distributed Transactions in Go with Temporal Saga Pattern Distributed transactions in Go microservices are commonly implemented using the Temporal Saga pattern: replacing blocking Two-Phase Commit (2PC) locks with imperative workflow orchestration, dynamic reverse compensations (saga.AddCompensation), and PostgreSQL idempotency tables to keep financial event consistency during network partitions. This guide covers: The Zombie Activity Pitfall: Why setting StartToCloseTimeout without database-level idempotency locks causes phantom debits during prolonged TCP network partitions. Dynamic Compensation Registration: How to structure workflow.NewSaga in Go so that partial failures (e.g., debit succeeds, fraud check passes, but ledger credit fails) only execute compensation for steps that actually mutated state. Handling Non-Compensable External Side-Effects: Practical design patterns for handling third-party banking APIs (e.g., SWIFT/ACH wires) that cannot be programmatically rolled back. Workflow Determinism Invariants: How to write Go workflows that use Temporal signals and queries without triggering fatal non-deterministic replay panic errors. Section 1: FinTech Distributed Transaction Mechanics: 2PC vs Saga & Dual-Entry Accounting Invariants In modern distributed financial systems, microservice architectures decompose monoliths into autonomous domains: Account Management, Fraud Detection, Core Ledger, Payment Gateway Integration, and Customer Notifications. While this decomposition provides organizational velocity and independent database scaling, it shatters the traditional ACID guarantees provided by single-instance relational databases. ...

Zero-Trust Service Mesh Security in Go: SPIFFE/SPIRE & Istio Introduction: The Zero-Trust Imperative in Modern Financial Microservices Traditional perimeter security models relying on firewalls, Virtual Private Clouds, and static IP addresses fail to protect modern microservices processing sensitive payment data. Container IP addresses are ephemeral and static Kubernetes secrets risk exposure, so enterprise financial architectures need Zero-Trust models that cryptographically authenticate every inter-service communication. The Payment Card Industry Data Security Standard version 4.0 (PCI-DSS 4.0) explicitly mandates stricter access controls, continuous identity attestation, automated key rotation, and cryptographic verification of all system components accessing the Cardholder Data Environment (CDE). Meeting these requirements demands a shift to a Zero-Trust Architecture (ZTA), where network locality confers zero trust: every service request must be explicitly authenticated, authorized based on strong workload identity, and encrypted in transit using short-lived cryptographic credentials. ...

High-Throughput Event-Driven Microservices in Go with NATS JetStream & CQRS Section 1: Architectural Rationale: Why Go + NATS JetStream for Event-Driven Microservices Beyond tens of thousands of transactions per second, synchronous request-response designs start hitting database write contention and cascading latency spikes. Command Query Responsibility Segregation (CQRS) paired with Event-Driven Architecture (EDA) isolates write commands from analytical queries, letting each side scale independently. To overcome these structural boundaries, high-scale engineering organizations adopt Command Query Responsibility Segregation (CQRS) paired with Event-Driven Architecture (EDA). By explicitly separating the write path (commands) from the read path (queries), CQRS allows each side to scale independently according to its access patterns. Commands execute lightweight state mutations against write-optimized engines, emitting immutable domain events into a high-performance message broker. Decoupled consumer workers asynchronously consume these events to populate specialized, read-optimized views (such as Redis key-value pairs, Elasticsearch documents, or PostgreSQL materialized read tables). ...

Laravel vs Golang: When to Add Features in Each? This post is part of the Magento to Go Migration series — a CTO playbook for migrating with a Vietnam engineering team. The Real Question Every Tech Lead eventually faces a pivotal architectural dilemma: “Do we add this new feature directly to Laravel, or is this the right moment to introduce a dedicated Golang microservice?” The answer is rarely a simple choice between “Laravel is better” or “Go is better.” Instead, making the right engineering decision requires evaluating the specific operational profile of the feature you are building. High-velocity CRUD features, admin tools, and complex business workflows belong in Laravel. Conversely, real-time WebSocket feeds, high-throughput auth validation, and compute-heavy pipelines belong in Go. ...

Magento Migration: Shared DB, CDC, or Event Bus? Why Go running against Magento’s MySQL is faster at the compute layer but still bottlenecked at the EAV query layer — and what actually fixes it. The single deciding factor between CDC (Option B) and Event Bus (Option C): who owns the PHP Magento codebase. This post is part of the Composable Commerce Migration series — a step-by-step playbook for migrating Magento 2 to Go microservices. For the full migration execution guide, see Part 6: Phase 1 Strangler Fig. ...

OSRM vs GraphHopper: Routing Engine Architecture Comparison Introduction: When Do You Outgrow Cloud Route APIs? Building early-stage logistics applications with cloud routing APIs provides immediate reliability, accurate ETAs, and zero infrastructure maintenance. However, when daily traffic exceeds 100,000 requests or requires massive distance matrices for vehicle route optimization, proprietary API costs explode while rigid routing profiles prevent injecting custom fleet constraints. Not only are they prohibitively expensive at scale, but these proprietary APIs also lack the flexibility required to inject custom routing rules. For instance, if your logistics fleet consists of 5-ton trucks that cannot enter certain city districts between 6 AM and 8 AM, or if you need to strictly penalize left turns at specific intersections to optimize fuel consumption, standard APIs fall short. They offer generic profiles for ‘driving’ or ‘bicycling’, but they do not allow you to define the exact physics and legal constraints of your unique vehicles. ...

High-throughput Go Framework Benchmarks: Gin, Fiber, Kratos The Testing Methodology (Beyond Hello World) We set up our benchmark tests on standard AWS hardware using a c6i.2xlarge instance (8 vCPUs, 16 GiB RAM) running Ubuntu 22.04 LTS. Both the testing client and the server running the Go application were placed in the same VPC to completely minimize any margin of error caused by physical network latency. In this testing scenario, each framework will process a GET request directed to the /ping endpoint. This endpoint does not merely return a static JSON response; it is forced to execute a middleware to extract (or generate) a Request ID from the HTTP Header (X-Request-ID), attach that information to the processing context, and execute a simulated query against a PostgreSQL database via a database connection retrieved from an optimized connection pool. Utilizing a simulated database query allows us to accurately measure the framework’s asynchronous interaction capabilities during an I/O block, while also evaluating its resource deallocation mechanisms and its ability to propagate Context Cancelation signals down the stack. ...

Multi-region Geo-distributed API Routing Architecture The Need for Geo-Distributed APIs In the era of global digitization, user experience is directly determined by application response speed. When a business scales to serve customers across multiple countries and continents, a single-region central server architectural model quickly reveals severe physical limitations. The nature of network communication involves the movement of data packets through fiber optic cables, which is ultimately bounded by the speed of light. A request traveling from Vietnam to a server located in the US East region (us-east-1) must traverse tens of thousands of kilometers and numerous transit hops, resulting in a minimum Round Trip Time (RTT) of 200ms to 300ms. For applications requiring real-time interaction or financial transactions, this latency is unacceptable. ...

Build Production Go MCP Servers: The Definitive Guide Introduction: The Rise of Agentic Infrastructures The ecosystem of AI is shifting from passive chat boxes to autonomous agents. Building a Go MCP server allows developers to safely connect AI models with databases and APIs. Anthropic’s Model Context Protocol (MCP) establishes this secure, bidirectional communication between AI client environments and backend service APIs. When we deployed our first suite of agentic tools, our Claude desktop client crashed immediately due to a single un-routed fmt.Println statement. We quickly realized that while spinning up a simple Python-based calculator running over standard I/O is trivial, building a highly resilient MCP server in an enterprise environment requires a completely different level of engineering rigor. ...

Composable E-Commerce Migration: Overcoming Tech Debt See the 21-service e-commerce architecture blueprint for the domain boundaries this migration targets. In theory, MACH (Microservices, API-first, Cloud-native, Headless) and Composable Commerce are the “holy grail” of the e-commerce industry. However, when systems scale to process millions of transactions, issues regarding data consistency, domain decomposition, and observability costs surface. This guide details the lessons and architectural patterns from migrating a monolithic Magento application into a 21-service Go microservices platform. ...

AWS EKS vs ECS: Architecture, Cost & Use Cases (2026) Answer-first: When deciding between AWS ECS and EKS, choose ECS Fargate for speed and zero control plane costs if you lack Kubernetes expertise. Choose EKS if you require the CNCF ecosystem (ArgoCD, Dapr, KEDA) and have dedicated DevOps engineers to manage the $73/month control plane fee. Feature AWS ECS (Elastic Container Service) AWS EKS (Elastic Kubernetes Service) Control Plane Cost $0 (Free) $73/month (~$876/year) Scalability Good (ASG-based) Excellent (Karpenter ~45s provisioning) Complexity Low (AWS-native) High (Requires Kubernetes expertise) I’ve run both in production. At Vigo Retail, I architected a 21-service Go microservices platform on EKS handling 8,000 RPS peak and 25M+ requests/month. I’ve also managed ECS clusters for smaller AWS-native projects. This guide is what I wish existed before I made those decisions. ...

Zero DevOps E-commerce with Cloudflare Workers & Turborepo For a stateful edge checkout pattern, pair it with Cloudflare D1 and Durable Objects for real-time carts. Tired of maintaining expensive Kubernetes clusters, fine-tuning Auto-scaling groups on AWS, or wiring together complex CI/CD pipelines just to keep an e-commerce store alive? Welcome to the Zero DevOps era. This guide we dissect Aura Store — a production-grade Cloudflare Workers E-commerce platform built entirely on Edge infrastructure, powered by a Turborepo Monorepo. Everything you see below is drawn directly from the running codebase. ...

Kubernetes In-Place Pod Resizing: No-Restart Scaling Before this feature, changing a container’s resource allocation required deleting and recreating the pod. For a stateful database holding connections, an AI model with 30GB of weights loaded in memory, or a long-running batch job — that restart is catastrophic. In-Place Pod Resize finally decouples resource management from pod lifecycle. This post is the production guide: what it is, how to use it, and where the sharp edges are. For the broader Kubernetes deployment context, see our GitOps at Scale guide. If you’re also upgrading your Go services, the Go 1.26 Green Tea GC improvements pair well with in-place resizing for memory-efficient workloads. ...

Go 1.26: Green Tea GC, Faster CGO & Goroutine Leak Detection Released in February 2026, Go 1.26 is not a routine patch release. It fundamentally changes how the Go runtime manages memory, interacts with C code, and surfaces concurrency bugs. For teams running Golang microservices at scale, these improvements compound across a fleet — zero code changes required. This post covers what changed, why it matters for production systems, how to adopt it, and what to watch out for during migration. ...

Go microservices from domain design to Kubernetes deployment — gRPC, Dapr, OpenTelemetry, and GitOps patterns with explicit operational trade-offs.

Vietnam’s Magento talent pool runs deep — but finding engineers who can handle production architecture is harder. Cost tiers, vetting signals, hiring models, and when to migrate.

Golang gRPC Microservices: Protobuf, TLS & Middleware Why gRPC for Go Microservices? gRPC over HTTP/2 with binary Protobuf serialization reduces payload sizes and lowers latency compared to REST/JSON: gRPC REST/JSON Serialization Protobuf (binary, schema-enforced) JSON (text, schema-optional) Payload size 3–10× smaller Baseline Streaming Unary, Client, Server, Bidirectional HTTP/2 SSE (server-only), WebSocket (separate) Contract .proto file (language-agnostic codegen) OpenAPI (opt-in, often stale) Latency ~0.5ms p50 inter-service ~2–5ms p50 inter-service Browser support gRPC-Web (needs proxy) Native Best for Internal microservices, streaming Public APIs, browser clients Step 1: Define Your Service with Protobuf Contract-first API design with Protocol Buffers guarantees strict schema enforcement and language-agnostic code generation: ...

GraphHopper Distance Matrix: Production Self-Hosting & API Guide How to Call the GraphHopper Matrix API (/matrix Endpoint) Running GraphHopper distance matrix in production requires configuring Docker deployment, the /matrix API endpoint, Custom Models for vehicle-specific routing (truck/motorcycle), H3-based Redis caching, and evaluating performance tradeoffs against OSRM, Valhalla, and Google Maps (for an in-depth analysis of routing engine selection, see our OSRM vs GraphHopper Architecture Comparison). The /matrix endpoint evaluates element-by-element matrix calculations between sets of origin and destination coordinates. When issuing requests, callers specify input point arrays along with requested output arrays such as times (travel duration in seconds) and distances (road distance in meters). Depending on graph preparation, GraphHopper can evaluate matrix queries using speed-optimized Contraction Hierarchies (CH) or flexible Landmark-based (LM) routing models. ...

Composable Banking Architecture: Monolith to Modular Answer-first: The composable banking architecture pattern replaces monolithic core banking systems with modular, independent Packaged Business Capabilities (PBCs). By leveraging Go microservices, Saga orchestration, and the Strangler Fig migration pattern, banks can decouple their legacy ledgers without risky “Big Bang” cutovers. Migration Path from Monolith to Composable Transitioning to a composable core requires a phased approach to mitigate operational risk: API Gateway & Anti-Corruption Layer (ACL): Shield the legacy core behind a gateway and translate modern API requests into legacy formats using an ACL. Shadow Routing: Deploy the new composable service (e.g., a new Go-based ledger) in parallel. Mirror live traffic to it and reconcile the outputs without affecting actual customer balances. Incremental Cutover (Strangler Fig): Once reconciliation achieves 100% parity, route read traffic to the new service, followed by write traffic, effectively “strangling” that specific domain out of the monolith. Legacy core banking systems were designed in a different era. Temenos T24, Finacle, and Flexcube shared one defining assumption: the bank’s entire product catalogue — deposits, lending, payments, trade finance — would live inside a single, tightly coupled application and a single, shared database. That assumption held when banking moved at human speed. It breaks completely when product releases need to go from months to days, when a single fraud engine update must not risk a payments outage, and when engineers on a COBOL codebase are retiring faster than they can be replaced. ...

MySQL Scalability Guide: Read Replicas, Sharding, and Distributed SQL MySQL scalability is the ability to increase database throughput — reads per second, writes per second, or data volume — without rewriting your application. The critical distinction: read scaling (adding replicas) and write scaling (sharding or distributed SQL) require completely different architectural approaches. Choosing the wrong path creates technical debt that takes months to unwind. This guide walks through every stage of the MySQL scaling ladder — InnoDB buffer pool tuning, ProxySQL pooling, async read replicas, Vitess/GORM sharding for write-heavy data, and TiDB migration — with Go-specific implementation patterns at each step. ...

Real-Time Inventory Topology: CDC, Kafka, and Redis Real-time inventory synchronization is the process of propagating stock count changes from the system of record (database) to all sales channels — web storefront, mobile app, WMS, ERP — in sub-second time. Instead of batch ETL jobs that run every hour, a CDC + Kafka pipeline streams every committed stock change as an event, eliminating overselling and stale stock displays. Handling this during a flash sale — where thousands of users attempt to purchase a highly contested SKU simultaneously — is a pinnacle architectural challenge. Traditional synchronous database updates collapse under lock contention. ...

Go Microservices Distributed Tracing Architecture (2026) Monitoring complex Go microservices requires more than isolated logs. When a request traverses HTTP APIs, Kafka event streams, and asynchronous worker pools, you need absolute visibility to pinpoint latency bottlenecks and failures. By 2026, OpenTelemetry (OTel) has cemented itself as the vendor-neutral standard for telemetry. This guide explores the architecture of distributed tracing in Go, from SDK context propagation to advanced Collector Gateway configurations. ...

Go pprof CPU & Memory Profiling: Production Tutorial Prerequisite: This guide covers how to profile and diagnose complex performance issues in production. If you are specifically dealing with unbounded goroutine growth, ensure you first understand the foundational concepts in Goroutine Leak Detection and Fix in Production Go Services. Performance degradation in production is inevitable. When a Go microservice suddenly spikes to 90% CPU utilization or triggers an Out-Of-Memory (OOM) kill in Kubernetes, guessing the root cause by staring at the code is rarely effective. You need data. ...

Banking Microservices in Go: Saga & Event Sourcing 1. Introduction: Deconstructing the Legacy Core Legacy banking platforms like Temenos T24 and Oracle FLEXCUBE were designed as rigid transactional monoliths for batch processing. Digital banking now requires decomposing these into event-driven microservices capable of real-time payments with sub-10ms latency. Migrating to a microservices architecture means dismantling these bottlenecks: Scaling limitations: Monoliths scale vertically (costly hardware), while microservices scale horizontally. Release cycles: Legacy cores require massive, risky quarterly releases. Microservices enable independent deployments. Data locking: Central databases in monoliths create severe lock contention during high-velocity events (like payday processing). By leveraging Go’s highly concurrent runtime and a distributed event-driven architecture, we optimize the system for <10ms database writes at 10,000 TPS, ensuring scalability and fault tolerance. ...

Vitess vs GORM Sharding: MySQL Write Scaling in Go When your application reaches millions of users, a single database instance will inevitably become the biggest bottleneck in your entire architecture. To solve this, MySQL database scaling becomes mandatory. You must Scale DB for Microservices using Horizontal Scaling techniques. This article examines the differences between scaling methods and compares the two most popular Sharding architectures today: Middleware-level Sharding (Vitess) and Application-level Sharding in Go (GORM Sharding plugin). ...

Alipay Double 11: 544,000 TPS Architecture Explained Research Baseline Two different Double 11 peak figures circulate widely, and they measure different layers of the stack — conflating them is the most common error in write-ups on this topic: Figure What it actually measures Layer Source 544,000 TPS Alipay payment transactions per second (2019) Payment / ledger OceanBase engineering 61 million QPS Database queries per second at the same 2019 peak Database OceanBase engineering 583,000 orders/sec Order creation on Alibaba’s e-commerce platform (2020) Commerce / order intake Alibaba Group press release [!IMPORTANT] The widely-quoted 583,000 figure is order creation throughput on Alibaba’s commerce platform, not Alipay’s payment TPS. Alipay’s reported payment peak is 544,000 TPS. This article is about the payment-side architecture, so 544,000 TPS is the relevant number. ...

Cloudflare D1 + Durable Objects: Building a Real-Time Cart The traditional shopping cart architecture is a familiar set of tradeoffs: Redis for session storage, PostgreSQL for order data, and a backend API tier that coordinates between them. It works, but it introduces latency proportional to the distance between the user and your datacenter, requires operational overhead for Redis cluster management, and struggles with globally concurrent cart edits from the same user across multiple devices. ...