SQL vs NoSQL vs Columnar: Choosing the Right Database for Your Go Service
Comparison of PostgreSQL, MongoDB, Cassandra, and ClickHouse. Performance metrics, cost analysis, and when to use each.
Serge Skoredin — IT Blog
Go, Backend, AI and Modern Technologies insights from Serge Skoredin.
Latest posts
Hexagonal Architecture in Go: Why Your "Clean" Code Is Actually a Mess
Everyone talks about clean architecture. Most get it wrong. Here's how to actually implement hexagonal architecture in Go without overengineering.
Finding and Fixing a 50,000 Goroutine Leak That Nearly Killed Production
Memory usage: 47GB. Response time: 32 seconds. Goroutines: 50,847. The story of debugging and fixing a massive goroutine leak in production.
gRPC Streaming: Real-Time Communication That Actually Works
Master all four gRPC streaming patterns. Production code handling 100K concurrent streams, reconnection logic, and backpressure.
Production GraphQL Server in Go: Complete Guide
Build production-ready GraphQL servers in Go. N+1 problem solutions, query complexity, caching strategies, security, and performance optimization techniques.
gRPC Gateway and REST API Bridge: Unified API Layer
Build production gRPC Gateway handling 100K+ requests/day. Bridge gRPC services to REST APIs with authentication, validation, and real implementation lessons.
Building a Plugin System in Go: Make Your Monolith Extensible Without Microservices
Microservices aren't your only option. Here's how to design a Go plugin architecture that lets customers run custom code without touching the core.
Go Memory Model Deep Dive: What Every Go Developer Must Know
Production bug from lost orders. One-line fix with atomic operations. Complete guide to Go's memory model without fluff.
Building Feature Flags System: From Simple Toggles to Complex Rules
Production feature flags system in Go handling 50M+ evaluations per day. Real implementation, performance metrics, and lessons learned.
Event Sourcing in Go: From Zero to Production
Event sourcing: append-only log as database. No UPDATE, no DELETE. Complete audit trail built-in. PostgreSQL event store with CQRS implementation.
eBPF and Go in Production: Network Monitoring and Security
Production eBPF programs in Go. Network monitoring, security filtering, performance tracing. Real implementations and lessons learned.
Docker for Go Developers: From Zero to Production
Everything Go developers actually need to know about Docker. Multi-stage builds, image optimization, security scanning, and production patterns.
Ring Cache for High-Frequency Trading in Go: Microsecond-Level Data Access
Ring cache (circular buffer) explained for HFT: lock-free implementation in Go that achieves sub-microsecond latency. From concept to production-ready code with benchmarks.
Distributed Tracing in Go: Finding the Needle in the Microservice Haystack
Real-world guide to rolling out distributed tracing in Go with OpenTelemetry and Grafana Tempo: why logs were not enough, how to instrument services, and what changed once the traces shipped.
ClickHouse Deduplication: Why ReplacingMergeTree is Pain and What to Do About It
Real-world experience with ClickHouse ReplacingMergeTree pain points and modern stream-based deduplication solutions that actually work in production.
Distributed Lock Manager in Go: Redis, etcd, and Custom Solutions
Production distributed lock manager in Go. Redis, etcd, PostgreSQL implementations. Preventing race conditions in distributed systems.
CPU Cache-Friendly Data Structures in Go: 10x Speed with Same Algorithm
False sharing killed our performance. Data-oriented design saved it. Learn cache lines, NUMA, and how to write Go code that CPUs love.
Change Data Capture with Debezium and Go
Building real-time data pipelines with Debezium CDC and Go. Production patterns, performance optimization, and handling millions of events per day.
Kubernetes for Go Developers: Just Enough to Be Dangerous
Skip the 500-page books. Here's what Go developers actually need to know about Kubernetes. Deploy, scale, debug, and survive production.
End-to-End Encryption: How Your Messages Stay Private
Complete guide to E2E encryption implementation. How WhatsApp, Signal, and modern apps protect your data. Real code examples and simple explanations.
Building a Web Application Firewall in Go
Building a production-grade WAF in Go. Real-time threat detection, rate limiting, and advanced security patterns that blocked 99.7% of attacks.
Building DSL in Go: From Simple Rules to Complex Workflows
Built a DSL in Go that handles 10M rule evaluations per day. Parser, interpreter, optimization, and why our first approach was 100x too slow.
Microservices in Go: From Idea to Deployment
Complete guide to building microservices in Go. gRPC, Docker, Kubernetes, and production best practices.
Building a CDN in Go: Edge Computing and Content Delivery
Build production CDN in Go handling 100GB+ daily traffic. Edge caching, origin shielding, and content delivery optimization with real implementation code.
Building a Blockchain in Go: From Basics to Production Performance
Everyone's building a blockchain. Most are garbage. Here's how to build one that actually works, handles real throughput, and doesn't melt your CPU.
API Gateway in Go: From Zero to Production
Built production API Gateway in Go handling 1M+ requests/day. Rate limiting, authentication, load balancing, and real implementation lessons.
AiBsCleaner: Fighting the Performance Crisis in Modern Go Code
Why your Go code is slow: AI writes over-engineered solutions, humans copy-paste without understanding. AiBsCleaner finds performance killers that standard linters miss - from O(n³) algorithms to goroutine leaks.
AI Coding Tools for Go in 2025: What Actually Works
Tested Claude, Copilot, Cursor, and Codeium on real Go tasks. No marketing fluff. Plus why AI can destroy junior developers.
GPT-4 in Production: Real Implementation Experience
Practical experience integrating GPT-4 into backend services. Rate limits, costs, caching and best practices for reliable OpenAI API operations.