norbix.dev - The log of my journey through code & software systems architecture

Best Practices for Software Development in Go

Tue, 08 Apr 2025 19:10:10 +0200

A collection of real-world Go best practices from years of building backend systems, APIs, and cloud-native services.

Keywords in Software Architecture

Sun, 13 Apr 2025 14:44:44 +0200

A visual exploration of the core keywords and concepts in modern software architecture.

Diagrams: Mermaid Syntax Highlights

Tue, 15 Apr 2025 16:11:36 +0200

A quick reference guide to using Mermaid syntax for creating various types of diagrams, including flowcharts, graphs, and more.

Breaking the Chain: Dependency Inversion, Interfaces, and Testable Go Code

Mon, 14 Apr 2025 18:00:00 +0200

A deep dive into the Dependency Inversion Principle, its implementation with interfaces and dependency injection, and how it unlocks clean, testable Go code.

GoF Design Patterns in Go: Practical Examples

Tue, 15 Apr 2025 12:43:02 +0200

Explore the 23 Gang of Four (GoF) design patterns in Go with clear explanations and code snippets, grouped into creational, structural, and behavioral categories.

DSA - Data Structures and Algorithms

Thu, 24 Jul 2025 18:10:25 +0200

A deep dive into Data Structures and Algorithms (DSA) using Go and its Python counterpart, covering essential concepts, implementations, and best practices.

Graph Theory Algorithms 4 Competitive Programming

Sat, 19 Apr 2025 15:34:33 +0200

A comprehensive guide to graph theory algorithms in Go, covering essential concepts, implementations, and best practices for competitive programming.

Concurrency in Go

Sat, 19 Apr 2025 15:52:47 +0200

A deep dive into concurrency in Go, covering goroutines, channels, and real-world patterns.

Demystifying Big-O Notation in Software Engineering

Wed, 23 Apr 2025 10:00:00 +0200

Understand Big-O notation through real-world Go examples and discover how algorithmic complexity impacts code scalability, performance, and design choices.

Debugging Go Code: Techniques, Tools, and IDE Support

Tue, 22 Apr 2025 18:00:00 +0200

Learn effective debugging techniques for Go code using tools like Delve, and how to leverage modern IDEs such as VSCode and IntelliJ IDEA for faster diagnosis and fixes.

Profiling Go Applications: CPU, Memory, and Concurrency Insights

Tue, 22 Apr 2025 19:00:00 +0200

Learn how to profile Go applications using pprof, trace, and runtime tools to uncover bottlenecks, memory leaks, and concurrency issues in production and development.

Extreme Programming (XP): Engineering Excellence on Speed

Tue, 22 Apr 2025 20:00:00 +0200

What is Extreme Programming (XP)? Explore its core practices, values, and how it helps teams deliver high-quality software with speed, feedback, and sustainability.

DevOps Deployment

Sat, 19 Apr 2025 15:53:01 +0200

A complete DevOps walkthrough — from Docker and Helm deployment to managing CA certificates and end-to-end TLS trust in Kubernetes.

Engineering for Reliability: What SRE Is Really About

Tue, 22 Apr 2025 12:00:00 +0200

An in-depth look into Site Reliability Engineering (SRE): its core principles, how it’s different from DevOps, and how teams can adopt SRE to build reliable, scalable systems.

Platform Engineering: The DevOps You Productize

Tue, 22 Apr 2025 16:00:00 +0200

What is Platform Engineering? How is it different from DevOps or SRE? This article unpacks the role of platform teams, why they’re critical in modern software delivery, and how they bring together cloud, automation, and developer experience.

Building SaaS Microservices in Go: REST, gRPC, GraphQL, and WebSocket APIs

Tue, 22 Apr 2025 21:00:00 +0200

Explore how to build SaaS-ready microservices in Go using REST, gRPC, GraphQL, and WebSockets. Learn the trade-offs, use cases, and tooling for each API style.

Understanding Databases: B-Trees, SQL, NoSQL, ACID, and Normalization

Mon, 28 Apr 2025 18:00:00 +0200

Learn the key database concepts every software engineer should know: B-Trees, SQL, NoSQL, ACID properties, and database normalization principles.

Movement Patterns & Logical Thinking in Software Engineering

Fri, 25 Apr 2025 10:00:00 +0200

Exploring the intersection of movement patterns and logical thinking in software engineering, with a focus on algorithms and design.

The Generic Protocol Pattern in Go: Designing Extensible CLI Interfaces

Tue, 24 Jun 2025 12:00:00 +0200

Learn how to implement a flexible and extensible protocol pattern in Go for building structured CLI interfaces and stream-based IPC communication.

Demystifying Artificial Intelligence: AI, Machine Learning, and Deep Learning

Thu, 04 Sep 2025 18:00:00 +0200

Understand the difference between Artificial Intelligence, Machine Learning, and Deep Learning. Learn how these concepts fit together and power modern software systems.

Architectural Patterns in Go: MVC, Hexagonal, CQRS, and Microservices

Sat, 06 Sep 2025 12:00:00 +0200

Understand the difference between design patterns and architectural patterns. Explore how MVC, Hexagonal, CQRS, and Microservices can be applied in Go projects with practical insights and examples.

REST vs GraphQL vs WebSocket vs gRPC: API Styles and Contracts in Go

Sun, 07 Sep 2025 12:00:00 +0200

From REST to GraphQL, WebSocket, and gRPC — explore API communication patterns and how contracts like OpenAPI, Swagger, and Protobuf shape modern Go systems.

Concurrency in Python

Tue, 09 Sep 2025 16:00:00 +0200

Learn how Python handles concurrency and parallelism using threads, processes, and async with asyncio.

Humble Consulting: How Curiosity Creates Real Business Value

Wed, 17 Sep 2025 10:00:00 +0200

Exploring Edgar H. Schein’s idea of Humble Consulting and how curiosity, empathy, and co-creation lead to measurable business value—earning more, saving more, and reaching hidden gatekeepers.

Enterprise Integration Patterns in Go: Practical Examples

Mon, 22 Sep 2025 10:00:00 +0200

Explore key Enterprise Integration Patterns (EIP) with practical Go examples, covering point-to-point, pub/sub, queues, and event-driven design for distributed systems.

API-First Approach: Design Before You Code

Thu, 25 Sep 2025 09:00:00 +0200

Explore the API-first approach: why defining contracts before implementation accelerates development, reduces integration bugs, and enables parallel workflows across teams.

Kubernetes Operators in Go

Tue, 07 Oct 2025 10:00:00 +0200

Learn how to build and understand Kubernetes Operators in Go — from controllers and reconciliation loops to the Operator SDK.

The Twelve-Factor App — Timeless Principles for Modern Software

Mon, 03 Nov 2025 00:00:00 +0000

Revisiting the Twelve-Factor App principles in the context of modern Go, Docker, and Kubernetes setups.

SBOM Generation for Security and Compliance

Wed, 05 Nov 2025 00:00:00 +0000

Learn how to generate and integrate Software Bill of Materials (SBOM) into your build pipelines to achieve visibility, compliance, and trust in your software supply chain.

WIP vs VIP in Load Balancing: Understanding Global vs Local Traffic Routing

Wed, 26 Nov 2025 10:00:00 +0200

A clear explanation of the difference between Wide IP (WIP) and Virtual IP (VIP) in modern load balancing, using F5 and NGINX as real-world examples for high-SLA architectures.

Testing Strategy in Modern DevOps

Sat, 21 Feb 2026 17:30:00 +0200

A practical testing overview for modern DevOps teams — from static analysis and unit tests to E2E, performance, and operational readiness.

JSON Schema in Modern Microservices: Contract-First Validation Strategy

Wed, 25 Feb 2026 10:00:00 +0200

A practical guide to JSON Schema in modern microservices — API-first design, OpenAPI contracts, DTO generation, and runtime validation in Go systems.

Vanilla vs Frameworks in Software Engineering: Control, Speed, and Trade-offs

Thu, 26 Mar 2026 20:00:00 +0200

Should you build software using frameworks or go vanilla? Explore trade-offs, real-world scenarios, and how experienced engineers make the right choice.

The Boy Scout Rule in Software Engineering: Leave It Better Than You Found It

Fri, 10 Apr 2026 20:00:00 +0200

Small improvements compound. Learn how the Boy Scout Rule transforms messy codebases into maintainable systems—without big rewrites.

About

Sat, 05 Apr 2025 00:00:00 +0000

Hi, I’m Norbert Jakubczak — aka Norbix 👋

Building scalable systems where engineering meets real-world delivery. 🚀

Software Engineer | Technology Partner | Distributed Systems (Go, Python, TypeScript) | AWS & K8s

I help companies design and build scalable distributed systems, Internal Developer Platforms (IDP), and cloud-native SaaS solutions.

I work hands-on across the stack — from backend services in Go & Python, through cloud infrastructure (AWS, Kubernetes), to developer tooling and system design.