Part 1: HTTP/REST vs. gRPC Protobuf: Architectural Trade-offs in High-Concurrency Distributed Systems

← Series hub | Next Chapter: Part 2 — Golang vs. PHP/Laravel → Answer-first: For internal East-West microservices operating at scale, gRPC over HTTP/2 with Protobuf is non-negotiable, delivering 31x faster serialization, 68.8% lower egress bandwidth, and zero-allocation memory pooling. For external North-South traffic, deploy Go Kratos v2.9.1 dual-protocol servers to expose REST/JSON to web browsers while preserving high-throughput gRPC internally without intermediate proxy network hops. Prerequisite: General understanding of TCP/IP networking, OSI Layer 7 transport, HTTP/2 multiplexing streams, and binary Protocol Buffers serialization. ...

Chapter 1: Shopee Microservices — Golang, gRPC & API Gateway Foundation

Series Hub: Shopee Architecture Masterclass | Next Chapter: Chapter 2 — Flash Sale Engine & Zero Overselling Answer-first: Shopee replaced its legacy Python monolith with high-performance Golang microservices orchestrated via ByteDance Kitex and Netpoll IPC to eliminate Global Interpreter Lock contention and slash memory overhead. Integrating zero-copy Protobuf serialization, partitioned Consul discovery with local DaemonSet caching, and bounded worker pools dropped internal p99 RPC latency below three milliseconds under 500,000 requests per second. ...

Part 2: Rush Monorepo — Managing 21 Go & 2 Next.js Apps

← Previous Chapter: Part 1: Decomposing Magento into 21 Services with DDD | Series Hub | Next Chapter: Part 3: Go + Kratos v2 Framework Deep Dive → Answer-first: Governing a polyglot monorepo (21 Go microservices and 2 Next.js frontends) with Microsoft Rush delivers strict dependency control, incremental builds, and automatic generation of TypeScript SDKs from proto files — all without version conflicts. When you own 21 Go microservices and 2 frontend applications, the first infrastructure question is not Kubernetes or CI/CD — it is how do you manage the source code itself? ...

Part 4: gRPC Internal + REST Gateway — API Contracts

← Previous Chapter: Part 3: Go + Kratos v2 Framework Deep Dive | Series Hub | Next Chapter: Part 5: Migrating the Magento EAV Schema → Answer-first: Every API in the Composable Commerce system starts from a Protocol Buffers (.proto) contract, using gRPC for high-speed internal communication between services and gRPC-Gateway to automatically expose JSON REST endpoints for Web and Mobile applications. Every public-facing API in the Composable Commerce platform starts from a .proto file. The code — including the gRPC handler functions written in Go, the TypeScript SDK, the HTTP routes, request validation, and the error codes — is all automatically generated from that contract. This article documents the conventions behind the scenes that keep the whole system running smoothly. ...

Part 6: Building a Mini-Allocation Engine in Go (Production Prototype)

← Previous Chapter: Part 5: Split Shipments & Consolidation | Series Hub | Next Chapter: Part 7: Distance Matrix Engines & Transit Routing → Prerequisite: Advanced Go (concurrency patterns, channels, sync primitives, CGo basics), gRPC/Protobuf protocols, and relational data modeling. Answer-first: Building a production-grade order allocation engine in Go requires combining high-throughput concurrency patterns with native mathematical solver bindings. By encapsulating Google OR-Tools within isolated CGo worker pools, implementing zero-allocation Protobuf gRPC interfaces, and providing deterministic circuit-breaker fallbacks, engineering teams can achieve resilient sub-50ms order allocation capable of processing over 10,000 requests per second. ...

Deconstructing the E-Commerce Ecosystem: Services by Domain

Deconstructing the Ecosystem: 21 Microservices Across 6 DDD Domains “Why does an e-commerce system need as many as 21 independent microservices? Isn’t that overkill — making the problem more complicated than it needs to be?” This is the familiar question every Lead Architect faces when proposing to restructure a monolith that is collapsing under its own load. The answer, a law of software engineering, is Conway’s Law — Systems designed by organizations inevitably mirror the communication structure of the organizations that built them. ...

Golang gRPC Microservices: Protobuf, TLS & Middleware

Golang gRPC Microservices: Protobuf, TLS & Middleware Answer-first: Production Go gRPC microservices combine Protobuf binary serialization, mTLS transport encryption, interceptor middleware logging, and gRPC-Health checking for high-throughput RPC performance. 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: ...