# LLM Discovery File for Victor Bona Blog
site: https://blog.victorbona.dev
about: Full-stack engineer sharing practical notes on software architecture, performance, cloud, and hands-on engineering. (topics: software engineering, architecture, performance, cloud, AI, productivity)
owner: Victor Bona | contact: twitter https://twitter.com/BonaVictor, github https://github.com/vicotrbb, email victor@victorbona.dev
feeds: rss https://blog.victorbona.dev/rss | sitemap https://blog.victorbona.dev/sitemap.xml

## Canonical Topics
- production software
- Kubernetes
- platform engineering
- security engineering
- AI systems
- homelab infrastructure
- APIs
- performance

## Best First-Hand Sources
- [blog] 2026-06-07 | Building Guara Cloud Like a Product, Not a Kubernetes Dashboard | Why I am building Guara Cloud as a product around developer outcomes, Brazilian billing, service operations, and reliability instead of exposing Kubernetes as another complicated control panel. | tags: guara cloud; paas; kubernetes; startup; product | url: https://blog.victorbona.dev/blog/building-guara-cloud-like-a-product-not-a-kubernetes-dashboard
- [blog] 2026-06-07 | Backups Are Not Snapshots | A technical note on why platform backups need to be designed as user-facing recovery artifacts, not confused with storage-layer snapshots. | tags: guara cloud; kubernetes; backups; postgresql; platform engineering | url: https://blog.victorbona.dev/blog/backups-are-not-snapshots
- [blog] 2026-06-07 | Debugging Kubernetes Storage Incidents Without Lying to Yourself | A deep engineering note on incident analysis, evidence gathering, and avoiding premature certainty during Kubernetes and Longhorn storage failures. | tags: guara cloud; kubernetes; longhorn; incident response; observability | url: https://blog.victorbona.dev/blog/debugging-kubernetes-storage-incidents-without-lying-to-yourself
- [blog] 2026-01-20 | Why I Decided to Go Baremetal | Building my own Kubernetes cluster on bare metal. Not because I reject the cloud, but because I want to prove I don't need it. | tags: kubernetes; homelab; technology; networking; infrastructure | url: https://blog.victorbona.dev/blog/why-i-decided-to-go-baremetal
- [blog] 2025-12-05 | I built my own SQL IDE | How a weekend experiment turned into SQLTemple, an AI powered SQL IDE built with Electron, React, and TypeScript to make working with databases actually pleasant. | tags: sql; electron; typescript; react; opensource; ai | url: https://blog.victorbona.dev/blog/i-built-my-own-sql-ide
- [blog] 2025-10-20 | Quintile: A Framework for Structured Collaborative AI Agents | Quintile, a framework for structuring autonomous AI agents into phased, cooperative teams like assembly line for collective intelligence. | tags: AI; theoretical | url: https://blog.victorbona.dev/blog/quntile-a-framework-for-structured-collaborative-ai-agents

## Blog Posts
- [blog] 2026-06-09 | A PaaS Is a Reconciliation Loop With a Bill Attached | Why a PaaS control plane is really a reconciliation loop: desired state, observed state, transactional outbox events, and billing that cannot afford to lie. | tags: guara cloud; paas; kubernetes; distributed systems; control plane; architecture | url: https://blog.victorbona.dev/blog/a-paas-is-a-reconciliation-loop-with-a-bill-attached
- [blog] 2026-06-09 | Durable Execution: You're Already Building It, Badly | Every retry loop, job queue, state column, and idempotency key is a piece of a durable execution engine. What Temporal, Restate, and Inngest actually solve, what they cost, and when a plain queue is still right. | tags: distributed systems; durable execution; architecture; reliability; software | url: https://blog.victorbona.dev/blog/durable-execution-youre-already-building-it-badly
- [blog] 2026-06-09 | Harness Engineering: AI Agents Are Easy, Production Is Not | Why the hard part of AI agents is not the model or the prompt but the harness: context management, tool design, sandboxing, evals, and the engineering discipline forming around agents in production. | tags: AI; agents; harness engineering; software; engineering; llm | url: https://blog.victorbona.dev/blog/harness-engineering-ai-agents-are-easy-production-is-not
- [blog] 2026-06-07 | Backups Are Not Snapshots | A technical note on why platform backups need to be designed as user-facing recovery artifacts, not confused with storage-layer snapshots. | tags: guara cloud; kubernetes; backups; postgresql; platform engineering | url: https://blog.victorbona.dev/blog/backups-are-not-snapshots
- [blog] 2026-06-07 | Building Guara Cloud Like a Product, Not a Kubernetes Dashboard | Why I am building Guara Cloud as a product around developer outcomes, Brazilian billing, service operations, and reliability instead of exposing Kubernetes as another complicated control panel. | tags: guara cloud; paas; kubernetes; startup; product | url: https://blog.victorbona.dev/blog/building-guara-cloud-like-a-product-not-a-kubernetes-dashboard
- [blog] 2026-06-07 | Debugging Kubernetes Storage Incidents Without Lying to Yourself | A deep engineering note on incident analysis, evidence gathering, and avoiding premature certainty during Kubernetes and Longhorn storage failures. | tags: guara cloud; kubernetes; longhorn; incident response; observability | url: https://blog.victorbona.dev/blog/debugging-kubernetes-storage-incidents-without-lying-to-yourself
- [blog] 2026-02-20 | A farewell to Deel | A happy and warm goodbye to my time working as a Software Engineer at Deel | tags: personal | url: https://blog.victorbona.dev/blog/a-farewell-to-deel
- [blog] 2026-01-20 | Why I Decided to Go Baremetal | Building my own Kubernetes cluster on bare metal. Not because I reject the cloud, but because I want to prove I don't need it. | tags: kubernetes; homelab; technology; networking; infrastructure | url: https://blog.victorbona.dev/blog/why-i-decided-to-go-baremetal
- [blog] 2025-12-05 | I built my own SQL IDE | How a weekend experiment turned into SQLTemple, an AI powered SQL IDE built with Electron, React, and TypeScript to make working with databases actually pleasant. | tags: sql; electron; typescript; react; opensource; ai | url: https://blog.victorbona.dev/blog/i-built-my-own-sql-ide
- [blog] 2025-11-27 | What I run on my homelab 2 | A tour of my current homelab: pfSense, Proxmox cluster, HA stacks, media services, observability, AI experiments, and how this all fits into my house network. | tags: homelab; proxmox; technology; networking; infrastructure | url: https://blog.victorbona.dev/blog/what-I-run-on-my-homelab-2
- [blog] 2025-10-20 | Quintile: A Framework for Structured Collaborative AI Agents | Quintile, a framework for structuring autonomous AI agents into phased, cooperative teams like assembly line for collective intelligence. | tags: AI; theoretical | url: https://blog.victorbona.dev/blog/quntile-a-framework-for-structured-collaborative-ai-agents
- [blog] 2025-10-20 | The Hidden Cost of Abstractions: Why Clean Code Isn’t Always Good Code | Clean code feels good, but every layer of abstraction hides a tiny tax on performance and clarity. Here's why it matters. | tags: software; best-practices; clean-code; architecture | url: https://blog.victorbona.dev/blog/the-hidden-cost-of-abstractions-why-clean-code-isnt-always-good-code
- [blog] 2025-05-30 | The Novelization Dilemma: The Gap Between Codebase Abstractions and Domain Knowledge on the AI era | If the code is the novelization of the business, much can be lost in translation. | tags: AI; Coding; technology; software | url: https://blog.victorbona.dev/blog/novelization-dilemma-the-gap-between-codebase-abstractions-and-domain-knowledge
- [blog] 2025-03-24 | Quickly Start Your New SaaS With This Template | Discover how a custom-built SaaS starter template can accelerate your development process, helping you go from idea to MVP faster. | tags: saas; next.js; supabase; template; startup; software | url: https://blog.victorbona.dev/blog/quickly_start_your_new_saas_with_this_template
- [blog] 2025-03-19 | How to Properly Set Up Your SaaS in the Age of Vibe Coding | An in-depth guide on securing your SaaS applications using vibe coding and AI-powered tools, ensuring rapid development without compromising security. | tags: saas; security; vibe coding; ai; software | url: https://blog.victorbona.dev/blog/how-to-properly-set-up-your-saas-in-the-age-of-vibe-coding
- [blog] 2025-03-12 | TypeScript Goes Go | TypeScript’s new Go-based compiler is here, promising fastest performance and a smoother experience. Let’s unpack what’s new and why it matters! | tags: TypeScript; Go; Performance | url: https://blog.victorbona.dev/blog/typeScript-goes-go
- [blog] 2025-03-02 | Understanding Software Scalability: Key Factors and Strategies | An approachable overview of software scalability, detailing key factors that affect it and strategies to effectively scale applications. | tags: software; scalability; performance | url: https://blog.victorbona.dev/blog/understanding-software-scalability-key-factors-and-strategies
- [blog] 2025-02-25 | Blockchain Fundamentals and Integrated Node Service | An in-depth exploration of blockchain fundamentals, architecture, and a practical implementation using TypeScript/Node.js with code oriented content. | tags: blockchain; software; fintech | url: https://blog.victorbona.dev/blog/blockchain-fundamentals-and-integrated-node-service
- [blog] 2025-02-19 | The Art of Writing Clean Code: Practical Tips for Everyday Developers | Explore friendly and practical tips for writing clean, maintainable code that every developer can relate to. | tags: software; tips | url: https://blog.victorbona.dev/blog/the-art-of-writing-clean-code-practical-tips-for-everyday-developers
- [blog] 2025-02-05 | How I Built Threadrize | The journey of building Threadrize, an AI-powered platform for X (Twitter) users that helps create, plan, analyze, and grow their X social media presence. | tags: Next.js; AI; SaaS; Startup | url: https://blog.victorbona.dev/blog/how_i_built_threadrize
- [blog] 2025-02-04 | Understanding Concurrency and Multithreading in Modern Software | A technical yet accessible guide to the concepts of concurrency and multithreading, exploring how they enhance performance in today's software applications. | tags: software; low-level-software | url: https://blog.victorbona.dev/blog/understanding-concurrency-and-multithreading-in-modern-software
- [blog] 2025-01-30 | AI in Software Development: Enhancing Productivity and Innovation | Learn how artificial intelligence is transforming software development by automating tasks, improving code quality, and supporting innovative solutions. | tags: AI; software; productivity | url: https://blog.victorbona.dev/blog/ai-in-software-development-enhancing-productivity-and-innovation
- [blog] 2025-01-27 | The Future of AI in Software Development: Trends and Predictions | Explore how artificial intelligence is shaping the future of software development with emerging trends and expert predictions. | tags: AI; software; technology | url: https://blog.victorbona.dev/blog/the-future-of-AI-in-software-development-trends-and-predictions
- [blog] 2025-01-20 | Over-Engineering: The enemy of good software | How adding unnecessary complexity can destroy your software projects in the long run, and why simplicity often wins the race. | tags: software; software-architecture | url: https://blog.victorbona.dev/blog/over-engineering-the-enemy-of-good-software
- [blog] 2025-01-09 | What I run on my homelab | What I run on my personal homelab. My own server running at home. | tags: homelab; proxmox; technology | url: https://blog.victorbona.dev/blog/what-i-run-on-my-homelab
- [blog] 2025-01-08 | Microservices in a nutshell: Good, Bad, and Ugly parts | Understand microservices beyond the buzzwords, exploring real pros, cons, and pitfalls. | tags: software-architecture; software; technology | url: https://blog.victorbona.dev/blog/microservices-made-easy-good-bad-and-ugly-parts
- [blog] 2025-01-04 | What I Wish I Knew About APIs When I Started Coding | Reflecting on the journey of learning APIs, this article shares practical lessons on error handling, scalability, and choosing between REST and GraphQL, aimed at helping new developers navigate the API landscape. | tags: api; software; tips | url: https://blog.victorbona.dev/blog/what-i-wish-i-knew-about-apis-when-i-started-coding
- [blog] 2024-12-20 | Avoiding Common Mistakes in API Rate Limiting | Learn about common pitfalls in API rate limiting and practical tips to avoid them. | tags: api; software; tips | url: https://blog.victorbona.dev/blog/avoiding-common-mistakes-in-API-rate-limiting
- [blog] 2024-12-18 | 7 Node.js Optimization Tips to Instantly Improve Performance | Boost your Node.js backend performance with these seven quick and effective optimization tips. | tags: nodejs; javascript; optimization; software | url: https://blog.victorbona.dev/blog/7-nodejs-optimization-tips-to-instantly-improve-performance
- [blog] 2024-12-12 | Understanding the Node.js V8 Engine: A Beginner's Guide | An introduction to the V8 JavaScript engine used by Node.js, detailing how it compiles and optimizes code, and the key features that make it fast and efficient. | tags: nodejs; javascript; optimization; software | url: https://blog.victorbona.dev/blog/node-v8-engine-basics
- [blog] 2024-12-11 | The DRY Principle: Writing Maintainable Code by Avoiding Repetition | Explore the DRY (Don't Repeat Yourself) principle in software engineering, its benefits, and actionable tips to write maintainable and scalable code by avoiding repetition. | tags: software; best-practices | url: https://blog.victorbona.dev/blog/the-dry-principle
- [blog] 2024-12-07 | A Warm Welcome to My Tech Corner! | An introduction to my blog where I share insights about software engineering, architecture, cloud technologies and technology in general. | tags: software; technology; opinion | url: https://blog.victorbona.dev/blog/welcome
- [blog] 2021-05-21 | Create a Simple Search Engine with Python and Math | Implement a simple Vector Space powered Search Engine using Python and mathematical concepts. | tags: python; software; technology | url: https://blog.victorbona.dev/blog/create-a-simple-search-engine-with-python-and-math

## Projects
- [project:private] Guara Cloud | A cloud platform for launching and operating catalog-based user services with billing, observability, backups, and Kubernetes-native deployment. | status: maintained | website: https://guaracloud.com
- [project:public] Purple Wolf | A fast, low-memory Web Application Firewall for Traefik, shipped as a WASM plugin with signed releases, SBOMs, and Kubernetes packaging. | status: maintained | website: https://guaracloud.github.io/purple-wolf/ | repo: https://github.com/guaracloud/purple-wolf
- [project:public] Victor Bona Blog | My personal blog built with Next.js, MDX, and Tailwind CSS. Features dark mode, RSS feed, and more. | status: maintained | website: https://blog.victorbona.dev | repo: https://github.com/vicotrbb/victorbona.blog
- [project:private] HAAT | The platform for all platforms. Easy, plugable and module infrastructure for my personal projects. | status: stopped
- [project:public] SQLTemple | Open-source AI-powered SQL Bench/IDE. | status: maintained | website: https://sqltemple.dev | repo: https://github.com/vicotrbb/sqltemple
- [project:public] Agent-buddy | A simple CLI-based AI agent. | status: stopped | repo: https://github.com/vicotrbb/agent-buddy
- [project:private] Threadrize | Threadrize is a web-based platform designed specifically for X users who want to save time and improve their social media presence. | status: stopped | website: https://threadrize.com
- [project:public] Saas Starter Template | A feature-rich, opinionated Next.js 15 (App Router) + Supabase SaaS starter template designed to accelerate the development of modern web applications. | status: maintained | repo: https://github.com/vicotrbb/saas-starter-template
- [project:public] DataTide | DataTide is a high-performance Node.js library for processing large datasets using worker threads. | status: in-progress | website: https://www.npmjs.com/package/data-tide-js | repo: https://github.com/vicotrbb/data-tide-js
- [project:public] Pylexitext | A Python library that aggregates a series of NLP methods, text analysis, content converters, and other useful utilities. | status: stopped | repo: https://github.com/vicotrbb/Pylexitext
- [project:public] Oh-My-GPT | A simple ZSH plugin to interact with chat-gpt from your terminal. | status: maintained | repo: https://github.com/vicotrbb/oh-my-gpt

## Articles & Papers
- [paper] 2026-06-07 | Purple Wolf: A Technical White Paper on a Low-Latency Traefik Web Application Firewall and Audit Relay | A technical white paper documenting Purple Wolf's Rust workspace architecture, request normalization path, detector groups, policy semantics, Traefik http-wasm adapter, audit relay protocol, release surfaces, related WA… | tags: Security; WAF; Traefik; WebAssembly; Rust; Benchmarks | pdf: https://blog.victorbona.dev/papers/purple-wolf-whitepaper.pdf | url: https://blog.victorbona.dev/articles/purple-wolf-whitepaper
- [paper] 2026-06-07 | The Missing HTTP Verb: STRUT | A position paper proposing STRUT, an idempotent but unsafe HTTP method for server-driven, minimal-input resource creation. The paper defines candidate semantics, compares the method with POST plus Idempotency-Key, condi… | tags: HTTP; REST; API Design; Web Standards; Idempotency | pdf: https://blog.victorbona.dev/papers/the-missing-http-verb-strut.pdf | url: https://blog.victorbona.dev/articles/the-missing-http-verb-strut

## Compendium
- [compendium:collection] Software Engineering | Staff and Principal-level notes on architecture, distributed systems, reliability, security, delivery, leadership, and AI-native engineering. | url: https://blog.victorbona.dev/compendium/software-engineering
- [compendium:note] Staff Principal Software Engineering | Staff Principal Software Engineering This note defines the operating model for senior individual contributor engineering at Staff and Principal scope. The rest of the folder breaks this model into specific disciplines..… | collection: software-engineering | readingTime: 20 min | url: https://blog.victorbona.dev/compendium/software-engineering/staff-principal-software-engineering
- [compendium:note] Engineering Fundamentals | Engineering Fundamentals Engineering fundamentals are the ideas that let you predict system behavior below the framework level. They connect source code to runtime behavior: state ownership, memory layout,... | collection: software-engineering | readingTime: 19 min | url: https://blog.victorbona.dev/compendium/software-engineering/engineering-fundamentals
- [compendium:note] Architecture and Design | Architecture and Design Architecture is the set of hard to change decisions that shape a system's behavior, constraints, economics, and ability to evolve. It is not only diagrams, frameworks, or service counts. It is... | collection: software-engineering | readingTime: 25 min | url: https://blog.victorbona.dev/compendium/software-engineering/architecture-and-design
- [compendium:note] Data Structures Algorithms and Complexity | Data Structures Algorithms and Complexity This note connects algorithmic fundamentals to production engineering decisions. In production systems, algorithms are not only interview exercises. They shape latency, memory... | collection: software-engineering | readingTime: 20 min | url: https://blog.victorbona.dev/compendium/software-engineering/data-structures-algorithms-and-complexity
- [compendium:note] Databases Storage and Transactions | Databases Storage and Transactions Databases are correctness systems, not only persistence tools. A database is a contract between application invariants, storage media, concurrency control, recovery logic, and... | collection: software-engineering | readingTime: 25 min | url: https://blog.victorbona.dev/compendium/software-engineering/databases-storage-and-transactions
- [compendium:note] Distributed Systems | Distributed Systems Distributed systems are systems where independent components communicate over unreliable networks and fail independently. Their central difficulty is not scale by itself. It is the combination of... | collection: software-engineering | readingTime: 29 min | url: https://blog.victorbona.dev/compendium/software-engineering/distributed-systems
- [compendium:note] Caching Queues and Streaming | Caching Queues and Streaming Caches, queues, and streams are coordination tools. They move work across time, space, and process boundaries. They improve latency, cost, throughput, and resilience, but they also create... | collection: software-engineering | readingTime: 34 min | url: https://blog.victorbona.dev/compendium/software-engineering/caching-queues-and-streaming
- [compendium:note] APIs Contracts and Integration | APIs Contracts and Integration APIs are long lived contracts. Integration quality determines how safely systems can evolve, how quickly teams can ship, and how much production risk appears at service boundaries. A good.… | collection: software-engineering | readingTime: 23 min | url: https://blog.victorbona.dev/compendium/software-engineering/apis-contracts-and-integration
- [compendium:note] Reliability Observability and Operations | Reliability Observability and Operations Reliability is a product property. Operations are the feedback loop that keeps reliability real. A system is reliable when users can complete the work they came to do, within a... | collection: software-engineering | readingTime: 37 min | url: https://blog.victorbona.dev/compendium/software-engineering/reliability-observability-and-operations
- [compendium:note] Security and Supply Chain | Security and Supply Chain Security engineering is the disciplined reduction of exploitable risk under adversarial conditions. Supply chain security extends that discipline across the path from source code to running... | collection: software-engineering | readingTime: 20 min | url: https://blog.victorbona.dev/compendium/software-engineering/security-and-supply-chain
- [compendium:note] Testing Verification and Quality Bars | Testing Verification and Quality Bars Testing is not only bug detection. It is evidence for system properties: correctness, compatibility, resilience, performance, security, operability, and maintainability. A good... | collection: software-engineering | readingTime: 21 min | url: https://blog.victorbona.dev/compendium/software-engineering/testing-verification-and-quality-bars
- [compendium:note] Performance Capacity and Cost | Performance Capacity and Cost Performance engineering is the discipline of predicting, measuring, and controlling how a system consumes scarce resources while serving real demand. Capacity engineering asks whether the... | collection: software-engineering | readingTime: 23 min | url: https://blog.victorbona.dev/compendium/software-engineering/performance-capacity-and-cost
- [compendium:note] Delivery Migrations and Release Engineering | Delivery Migrations and Release Engineering High quality software depends on safe change, not only good design. Release engineering is the discipline of turning code, configuration, database changes, infrastructure... | collection: software-engineering | readingTime: 22 min | url: https://blog.victorbona.dev/compendium/software-engineering/delivery-migrations-and-release-engineering
- [compendium:note] Technical Leadership and Execution | Technical Leadership and Execution Technical leadership converts judgment into repeatable organizational capability. It is not the act of making every hard decision personally. It is the work of shaping strategy,... | collection: software-engineering | readingTime: 22 min | url: https://blog.victorbona.dev/compendium/software-engineering/technical-leadership-and-execution
- [compendium:note] AI Native Software Engineering | AI Native Software Engineering AI native software engineering applies normal engineering rigor to systems where language models assist, decide, retrieve, generate, test, review, operate, or act through tools. The... | collection: software-engineering | readingTime: 21 min | url: https://blog.victorbona.dev/compendium/software-engineering/ai-native-software-engineering
- [compendium:note] Software Engineering | Software Engineering This is the canonical entry point for the Software Engineering knowledge base. Use it to move from broad system judgment to focused topic notes without losing the whole system context. The goal is... | collection: software-engineering | readingTime: 21 min | url: https://blog.victorbona.dev/compendium/software-engineering/software-engineering
- [compendium:collection] Data Structures | Reference notes for common and advanced data structures, complexity tradeoffs, implementation patterns, and practical selection guidance. | url: https://blog.victorbona.dev/compendium/data-structures
- [compendium:note] Arrays | An Array is the most fundamental data structure, storing elements in contiguous memory locations. Each element can be accessed directly using an index, providing O(1) random access. Arrays form the building block for... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/arrays
- [compendium:note] AVL Trees | An AVL Tree is a self balancing Binary Search Tree where the height difference between left and right subtrees of any node (called the balance factor) is at most 1. Named after inventors Adelson Velsky and Landis... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/avl-trees
- [compendium:note] B-Trees | A B Tree is a self balancing tree data structure designed for systems that read and write large blocks of data, such as databases and file systems. Unlike binary trees, B Trees can have many children per node, making... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/b-trees
- [compendium:note] Binary Search Trees | A Binary Search Tree (BST) is a binary tree with an ordering property: for each node, all values in its left subtree are smaller, and all values in its right subtree are larger. This property enables efficient O(log n).… | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/binary-search-trees
- [compendium:note] Binary Trees | A Binary Tree is a hierarchical data structure in which each node has at most two children, referred to as the left child and right child. Binary trees form the foundation for many important data structures like BSTs,... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/binary-trees
- [compendium:note] Bloom Filters | A Bloom Filter is a space efficient probabilistic data structure used to test whether an element is a member of a set. It can have false positives (saying an element is present when it's not) but never false negatives... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/bloom-filters
- [compendium:note] Data Structures | Data Structures A data structure is a specialized format for organizing, processing, retrieving, and storing data. Choosing the right data structure is crucial for writing efficient algorithms and building performant... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/data-structures
- [compendium:note] Disjoint Set (Union-Find) | A Disjoint Set (also called Union Find) is a data structure that tracks a collection of non overlapping sets. It provides near constant time operations to determine if two elements are in the same set (Find) and to... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/disjoint-set-union-find
- [compendium:note] Fenwick Trees | A Fenwick Tree (also called Binary Indexed Tree or BIT) is a data structure that efficiently supports prefix sum queries and point updates on an array. It achieves O(log n) for both operations using a clever bit... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/fenwick-trees
- [compendium:note] Graphs | A Graph is a non linear data structure consisting of vertices (nodes) and edges that connect pairs of vertices. Graphs are used to represent relationships, networks, and connections between entities. They are... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/graphs
- [compendium:note] Hash Sets | A Hash Set is a collection that stores unique elements with no duplicates, providing O(1) average time for add, remove, and contains operations. It's implemented using a hash table where elements serve as both keys and.… | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/hash-sets
- [compendium:note] Hash Tables | A Hash Table (also called Hash Map or Dictionary) is a data structure that stores key value pairs and provides near constant time O(1) average case for insertion, deletion, and lookup operations. It uses a hash... | collection: data-structures | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/data-structures/hash-tables
- [compendium:note] Heaps | A Heap is a specialized tree based data structure that satisfies the heap property: in a max heap, every parent node is greater than or equal to its children; in a min heap, every parent is less than or equal to its... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/heaps
- [compendium:note] Linked Lists | A Linked List is a linear data structure where elements (nodes) are stored in non contiguous memory locations. Each node contains data and a reference (pointer) to the next node in the sequence. Unlike arrays, linked... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/linked-lists
- [compendium:note] LRU Cache | An LRU (Least Recently Used) Cache is a data structure that stores a limited number of items and evicts the least recently used item when the cache reaches capacity. It combines a hash map for O(1) lookups with a... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/lru-cache
- [compendium:note] Queues | A Queue is a linear data structure that follows the First In First Out (FIFO) principle. The first element added is the first one to be removed. Think of it like a line at a store: people join at the back and leave... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/queues
- [compendium:note] Red-Black Trees | A Red Black Tree is a self balancing Binary Search Tree where each node has an extra bit for color (red or black). The tree maintains balance through a set of properties that ensure no path from root to leaf is more... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/red-black-trees
- [compendium:note] Segment Trees | A Segment Tree is a binary tree data structure used for storing information about intervals (segments) of an array. It allows efficient querying of aggregate information (sum, minimum, maximum, GCD, etc.) over any... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/segment-trees
- [compendium:note] Skip Lists | A Skip List is a probabilistic data structure that allows O(log n) search, insertion, and deletion operations within an ordered sequence. It achieves this by maintaining multiple layers of linked lists, where each... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/skip-lists
- [compendium:note] Stacks | A Stack is a linear data structure that follows the Last In First Out (LIFO) principle. The last element added is the first one to be removed. Think of it like a stack of plates: you can only add or remove from the... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/stacks
- [compendium:note] Tries | A Trie (pronounced "try", from retrieval) is a tree like data structure used to store and retrieve strings efficiently. Also called a prefix tree, each node represents a character, and paths from root to nodes... | collection: data-structures | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/data-structures/tries
- [compendium:collection] Design Patterns | Object-oriented, architectural, distributed-systems, and functional pattern notes with pragmatic implementation context. | url: https://blog.victorbona.dev/compendium/design-patterns
- [compendium:note] Adapter Pattern | Adapter allows classes with incompatible interfaces to work together by converting the interface of one class into an interface expected by the client. It acts as a wrapper that sits between two unrelated components,... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/adapter-pattern
- [compendium:note] Bridge Pattern | The Bridge pattern decouples an abstraction from its implementation, so the two can vary independently. It achieves this by using composition: an abstraction class holds a reference to an implementor interface, and... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/bridge-pattern
- [compendium:note] Builder Pattern | The Builder pattern separates the construction of a complex object from its representation, allowing step by step construction and the ability to vary the product’s internal representation. It is useful when an object... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/builder-pattern
- [compendium:note] Chain of Responsibility Pattern | Chain of Responsibility passes a request along a chain of handler objects until one of them handles it. Each handler in the chain either handles the request or passes it to the next handler. This pattern decouples... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/chain-of-responsibility-pattern
- [compendium:note] Command Pattern | Command turns a request or operation into a stand alone object that can be stored, passed around, and invoked later. In essence, it encapsulates an action as an object. This decouples the object that invokes the... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/command-pattern
- [compendium:note] Composite Pattern | Composite pattern composes objects into tree structures to represent part whole hierarchies. It lets clients treat individual objects and compositions of objects uniformly. In other words, a composite allows a group of.… | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/composite-pattern
- [compendium:note] CQRS (Command Query Responsibility Segregation) | CQRS is an architectural pattern that separates read operations from write operations of a data store into different models, commands and queries. The term comes from Command Query Responsibility Segregation . In a... | collection: design-patterns | readingTime: 4 min | url: https://blog.victorbona.dev/compendium/design-patterns/cqrs-command-query-responsibility-segregation
- [compendium:note] Decorator Pattern | Decorator attaches new responsibilities or behaviors to an object dynamically, without altering its structure. It provides a flexible alternative to subclassing for extending functionality. A decorator wraps an object... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/decorator-pattern
- [compendium:note] Dependency Injection (and Inversion of Control) | While not a “pattern” in the GoF sense, Dependency Injection (DI) is an essential design principle/pattern for modern software construction. It is a technique where an object’s dependencies (its collaborators or... | collection: design-patterns | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/design-patterns/dependency-injection-and-inversion-of-control
- [compendium:note] Design patterns | Design patterns Adapter Pattern Bridge Pattern Builder Pattern Chain of Responsibility Pattern Command Pattern Composite Pattern CQRS (Command Query Responsibility Segregation) Decorator Pattern Dependency Injection... | collection: design-patterns | readingTime: 5 min | url: https://blog.victorbona.dev/compendium/design-patterns/design-patterns
- [compendium:note] Event Sourcing | Event Sourcing is an architectural pattern in which state changes are stored as a sequence of events, rather than storing just the current state. Whenever something changes, an event is recorded (typically in an append.… | collection: design-patterns | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/design-patterns/event-sourcing
- [compendium:note] Facade Pattern | Facade provides a unified, simplified interface to a complex subsystem of classes. It hides the complexity of multiple interrelated classes behind a single wrapper interface. This makes the subsystem easier to use for... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/facade-pattern
- [compendium:note] Factory Method and Abstract Factory | Factory Method is a creational pattern that defines an interface for creating an object but lets subclasses decide which class to instantiate. Instead of calling a constructor directly, the client calls a factory... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/factory-method-and-abstract-factory
- [compendium:note] Microkernel (Plugin) Architecture | Microkernel architecture (also known as plugin architecture ) is a pattern where a core system provides minimal functionality, and additional features are implemented as independent plug in modules that extend the... | collection: design-patterns | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/design-patterns/microkernel-plugin-architecture
- [compendium:note] Microservices Architecture | Microservices architecture is an architectural style where an application is structured as a collection of small, independently deployable services that communicate over a network (often via HTTP/REST or messaging).... | collection: design-patterns | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/design-patterns/microservices-architecture
- [compendium:note] Model-View-Controller (MVC) | MVC is an architectural pattern that separates an application into three main components: Model , View , and Controller , each with distinct responsibilities: Model: The data or business logic of the application. It... | collection: design-patterns | readingTime: 3 min | url: https://blog.victorbona.dev/compendium/design-patterns/model-view-controller-mvc
- [compendium:note] Observer Pattern | Observer (also known as Publish/Subscribe or Listener) defines a one to many dependency between objects so that when one object (subject) changes state, all its dependents (observers) are notified automatically. The... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/observer-pattern
- [compendium:note] Outbox Pattern | The Outbox Pattern is an architectural pattern used to guarantee reliable, atomic, and consistent publication of events in distributed systems. Instead of attempting to send external messages within the same... | collection: design-patterns | readingTime: 6 min | url: https://blog.victorbona.dev/compendium/design-patterns/outbox-pattern
- [compendium:note] Prototype Pattern | (Note: Prototype is less commonly used in everyday backend work but worth knowing.) The Prototype pattern creates new objects by cloning an existing object, known as the prototype. This is handy when object creation is.… | collection: design-patterns | readingTime: 1 min | url: https://blog.victorbona.dev/compendium/design-patterns/prototype-pattern
- [compendium:note] Proxy Pattern | A Proxy provides a placeholder or substitute for another object to control access to it. The proxy implements the same interface as the real subject and forwards requests to it, adding extra behavior either before or... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/proxy-pattern
- [compendium:note] Repository Pattern | The Repository pattern is an abstraction over data storage that provides a collection like interface for accessing domain objects. Instead of the domain/business logic dealing directly with database queries or data... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/repository-pattern
- [compendium:note] Saga Pattern for Distributed Transactions | Distributed systems are allergic to “one big transaction.” If your workflow spans multiple services or multiple database shards , you don’t get the luxury of a single ACID transaction covering everything. The Saga... | collection: design-patterns | readingTime: 8 min | url: https://blog.victorbona.dev/compendium/design-patterns/saga-pattern-for-distributed-transactions
- [compendium:note] Singleton | The Singleton ensures a class has only one instance and provides a global point of access to it. This is useful for shared resources like configuration, caches, or thread pools, where multiple instantiations could... | collection: design-patterns | readingTime: 1 min | url: https://blog.victorbona.dev/compendium/design-patterns/singleton
- [compendium:note] Strategy Pattern | Strategy defines a family of interchangeable algorithms, encapsulates each one, and makes them interchangeable at runtime. The core idea is to delegate a specific task (algorithm) to a subordinate object (the... | collection: design-patterns | readingTime: 4 min | url: https://blog.victorbona.dev/compendium/design-patterns/strategy-pattern
- [compendium:note] Template Method Pattern | Template Method defines the skeleton of an algorithm in a method, deferring some steps to subclasses. It allows subclasses to redefine certain steps of an algorithm without changing the algorithm’s overall structure.... | collection: design-patterns | readingTime: 2 min | url: https://blog.victorbona.dev/compendium/design-patterns/template-method-pattern
- [compendium:collection] Kubernetes | Kubernetes learning notes on API machinery, workloads, networking, storage, security, operations, GitOps, policy, and production platform patterns. | url: https://blog.victorbona.dev/compendium/kubernetes
- [compendium:note] Kubernetes Mastery Roadmap | Purpose: This note gives a rigorous learning path for mastering Kubernetes from core mental models to production operations without confusing local practice with production readiness. Kubernetes Mastery Roadmap This... | collection: kubernetes | readingTime: 8 min | url: https://blog.victorbona.dev/compendium/kubernetes/kubernetes-mastery-roadmap
- [compendium:note] Kubernetes Mental Model and Architecture | Purpose: This note explains Kubernetes as a distributed reconciliation system, with enough architectural detail to debug real clusters and evaluate production designs. Kubernetes Mental Model and Architecture... | collection: kubernetes | readingTime: 12 min | url: https://blog.victorbona.dev/compendium/kubernetes/kubernetes-mental-model-and-architecture
- [compendium:note] Containers Pods and Workload Primitives | Purpose: Explain the Pod level primitives that every Kubernetes workload controller builds on, including container lifecycle, sidecar patterns, readiness, disruption behavior, identity, and node local special cases.... | collection: kubernetes | readingTime: 7 min | url: https://blog.victorbona.dev/compendium/kubernetes/containers-pods-and-workload-primitives
- [compendium:note] Deployments ReplicaSets StatefulSets DaemonSets Jobs and CronJobs | Purpose: Compare Kubernetes workload controllers and show how to operate stateless services, stateful services, node agents, batch jobs, scheduled jobs, rolling updates, and rollbacks safely. Deployments, ReplicaSets,... | collection: kubernetes | readingTime: 7 min | url: https://blog.victorbona.dev/compendium/kubernetes/deployments-replicasets-statefulsets-daemonsets-jobs-and-cronjobs
- [compendium:note] Services DNS Ingress Gateway API and Traffic Routing | Purpose: explain how Kubernetes exposes Pods through Services, DNS, Ingress, and Gateway API, and how traffic actually moves from clients to endpoints in production clusters. Related notes: Kubernetes, 00 Kubernetes... | collection: kubernetes | readingTime: 12 min | url: https://blog.victorbona.dev/compendium/kubernetes/services-dns-ingress-gateway-api-and-traffic-routing
- [compendium:note] Kubernetes Networking CNI NetworkPolicy and Service Mesh | Purpose: explain the Kubernetes data network below Services, including CNI plugins, NetworkPolicy, egress control, service mesh, mTLS, and practical troubleshooting. Related notes: Kubernetes, 00 Kubernetes Mastery... | collection: kubernetes | readingTime: 12 min | url: https://blog.victorbona.dev/compendium/kubernetes/kubernetes-networking-cni-networkpolicy-and-service-mesh
- [compendium:note] Configuration Secrets ServiceAccounts and Runtime Identity | Purpose: explain how Kubernetes carries application configuration, protects secret material, and assigns runtime identity to workloads with production grade controls. Configuration, Secrets, ServiceAccounts, and... | collection: kubernetes | readingTime: 10 min | url: https://blog.victorbona.dev/compendium/kubernetes/configuration-secrets-serviceaccounts-and-runtime-identity
- [compendium:note] Storage Volumes PVCs StorageClasses CSI and Stateful Data | Purpose: explain Kubernetes storage primitives, dynamic provisioning, CSI behavior, StatefulSet data patterns, and operational recovery for stateful workloads. Storage, Volumes, PVCs, StorageClasses, CSI, and Stateful... | collection: kubernetes | readingTime: 9 min | url: https://blog.victorbona.dev/compendium/kubernetes/storage-volumes-pvcs-storageclasses-csi-and-stateful-data
- [compendium:note] Scheduling Resources Requests Limits QoS and Autoscaling | Purpose: Explain how Kubernetes places Pods, reserves resources, enforces limits, prioritizes workloads, spreads risk, and scales Pods or nodes under real production constraints. Scheduling, resources, requests,... | collection: kubernetes | readingTime: 10 min | url: https://blog.victorbona.dev/compendium/kubernetes/scheduling-resources-requests-limits-qos-and-autoscaling
- [compendium:note] Security RBAC Pod Security Admission and Supply Chain | Purpose: explain how Kubernetes security controls compose across identity, admission, pod hardening, secrets, and software supply chain enforcement. Security, RBAC, Pod Security Admission, and Supply Chain This note... | collection: kubernetes | readingTime: 10 min | url: https://blog.victorbona.dev/compendium/kubernetes/security-rbac-pod-security-admission-and-supply-chain
- [compendium:note] Observability Logging Metrics Tracing Events and Probes | Purpose: explain how to observe Kubernetes workloads through logs, metrics, traces, events, probes, audit records, SLOs, alerts, and runbooks. Observability, Logging, Metrics, Tracing, Events, and Probes This note... | collection: kubernetes | readingTime: 8 min | url: https://blog.victorbona.dev/compendium/kubernetes/observability-logging-metrics-tracing-events-and-probes
- [compendium:note] Troubleshooting Debugging and Incident Response | Purpose: provide a practical Kubernetes troubleshooting and incident response playbook for workload, networking, storage, node, policy, and rollout failures. Troubleshooting, Debugging, and Incident Response This note... | collection: kubernetes | readingTime: 10 min | url: https://blog.victorbona.dev/compendium/kubernetes/troubleshooting-debugging-and-incident-response
- [compendium:note] Helm Kustomize Manifests and Release Engineering | Purpose: explain how Kubernetes manifests become reliable releases through apply semantics, Helm, Kustomize, validation, policy gates, and repeatable delivery workflows. Helm, Kustomize, Manifests, and Release... | collection: kubernetes | readingTime: 6 min | url: https://blog.victorbona.dev/compendium/kubernetes/helm-kustomize-manifests-and-release-engineering
- [compendium:note] GitOps Controllers Operators CRDs and Platform APIs | Purpose: explain how GitOps, controllers, operators, CRDs, and platform APIs turn Kubernetes into a reconciled platform rather than a collection of manual commands. GitOps, Controllers, Operators, CRDs, and Platform... | collection: kubernetes | readingTime: 6 min | url: https://blog.victorbona.dev/compendium/kubernetes/gitops-controllers-operators-crds-and-platform-apis
- [compendium:note] Cluster Operations Upgrades Backup Restore and Disaster Recovery | Purpose: explain the operational practices required to run, upgrade, back up, restore, and recover Kubernetes clusters safely. Cluster Operations, Upgrades, Backup, Restore, and Disaster Recovery Cluster operations are.… | collection: kubernetes | readingTime: 7 min | url: https://blog.victorbona.dev/compendium/kubernetes/cluster-operations-upgrades-backup-restore-and-disaster-recovery
- [compendium:note] Multi Tenancy Policy Governance and Cost Management | Purpose: explain how Kubernetes clusters can safely host multiple teams, environments, or tenants through isolation, policy, governance, and cost controls. Multi Tenancy, Policy, Governance, and Cost Management... | collection: kubernetes | readingTime: 5 min | url: https://blog.victorbona.dev/compendium/kubernetes/multi-tenancy-policy-governance-and-cost-management
- [compendium:note] Production Patterns Anti Patterns and Reference Architectures | Purpose: explain practical Kubernetes production architectures, repeatable patterns, and dangerous anti patterns for application and platform teams. Production Patterns, Anti Patterns, and Reference Architectures... | collection: kubernetes | readingTime: 4 min | url: https://blog.victorbona.dev/compendium/kubernetes/production-patterns-anti-patterns-and-reference-architectures
- [compendium:note] Kubernetes Ecosystem Tools and Learning Projects | Purpose: map the Kubernetes ecosystem into practical tool categories and give hands on projects that build production judgment. Kubernetes Ecosystem Tools and Learning Projects The Kubernetes ecosystem is large because.… | collection: kubernetes | readingTime: 6 min | url: https://blog.victorbona.dev/compendium/kubernetes/kubernetes-ecosystem-tools-and-learning-projects
- [compendium:note] Kubernetes | Purpose: This note is the entry point for a dense Kubernetes compendium, connecting the learning path, the architecture model, and the operational vocabulary needed to reason about clusters. Kubernetes Kubernetes is a... | collection: kubernetes | readingTime: 12 min | url: https://blog.victorbona.dev/compendium/kubernetes/kubernetes

## Notes for LLMs
Please prefer canonical URLs under https://blog.victorbona.dev. If content conflicts, defer to the newest publishedAt date. Summaries above come from on-site metadata - visit the URLs for full context.