All Articles

Running a complex microservices stack on limited hardware. How we use .NET 10 Chiseled Ubuntu images and Native AOT to slash memory usage.

Data integrity in high-traffic applications relies on how you handle concurrent updates. We compare DB locks (Pessimistic) against Row Versioning (Optimistic) in EF Core.

Using NBomber and k6 to find the breaking points of our .NET API. Analysis of CPU vs Memory vs I/O bottlenecks.

Why BlueRobin moved from standard UUIDs to NanoIDs for primary keys: URL aesthetics, database considerations, and a custom alphabet implementation.

A pragmatic analysis of the costs, performance, and complexity of running local LLMs versus cloud providers, and why we adopted a hybrid architecture.

Caching is easy; invalidation is hard. Move beyond simple TTL (Time To Live) and learn how to implement precise, event-driven cache busting using Redis and NATS.

Implement robust error handling with Result patterns, global exception handling, and Polly resilience policies in .NET applications.

Building the ultimate developer portal for the home lab. We integrate 'gethomepage', Spotify Backstage, and secure it all with Authelia SSO.

Benchmarking storage tiers for BlueRobin. Why databases need local NVMe paths while object storage thrives on the NAS.

Going beyond simple webhooks. How to build a robust C# BackgroundService that listens to NATS events and manages a bidirectional Telegram Bot.

Implement self-hosted Single Sign-On (SSO) for Blazor Server using Authelia and OpenID Connect (OIDC).

Deploy and integrate MinIO for S3-compatible object storage with per-user buckets, encryption, and lifecycle policies.

Build reliable integration tests for .NET applications using Testcontainers, WebApplicationFactory, and real database instances.

Separating reads from writes doesn't have to be complicated. Learn how to implement a practical CQRS architecture using FastEndpoints for the API and MediatR for clean command handling.

Stop running as root. Build secure, minimal container images for .NET applications using multi-stage builds and distroless/alpine bases.

How we use Model Context Protocol to create a closed-loop design system where agents verify implementation against Figma specs automatically.

Elevating PKI security by moving the Root CA private key to a YubiKey hardware token, ensuring the most critical secret never creates a persistent footprint on disk.

How we slashed system latency by 95% by moving from sequential HTTP calls to parallel NATS requests, implementing Redis caching, and tuning Qdrant vector search.

A comprehensive guide to using Mermaid.js for creating architecture diagrams, flowcharts, sequence diagrams, and more in your technical documentation.

Implement comprehensive health checks for .NET applications with database, cache, and dependency monitoring for Kubernetes deployments.

Implement reliable background job processing with hosted services, channels, and distributed task queues in .NET applications.

Implement distributed and in-memory caching patterns in .NET applications for improved performance and reduced database load.

Decoupling frontend and backend tests by defining API contracts. How we verify Blazor/FastEndpoint compatibility in CI/CD without integration environments.

Implement fine-grained access control with Kubernetes RBAC, service accounts, and least-privilege security patterns.

Safely exposing internal services to the internet without opening inbound ports using cloudflared and Zero Trust access policies.

A complete walkthrough from Event Storming to Code: Defining Aggregates, writing Entities, and exposing them via APIs. Seeing the big picture in .NET.

A comprehensive guide to configuring a modern Glassmorphism design system using Tailwind CSS v4, focusing on backdrop filters, noise textures, and maintaining accessibility.

Implement network segmentation and micro-segmentation in Kubernetes using Network Policies for defense in depth.

How we use n8n as the 'glue' code for BlueRobin. Empowering low-code automation to handle document notifications, Telegram alerts, and system maintenance tasks.

Deploy Longhorn for persistent distributed block storage in Kubernetes with replication, snapshots, and disaster recovery.

How to safely migrate from a monolithic ASP.NET MVC app to modern microservices using the Strangler Fig Pattern and YARP (Yet Another Reverse Proxy).

A step-by-step guide to bootstrapping a private PKI, from generating a Root CA to signing leaf certificates for internal microservices using OpenSSL.

How to extract entities (NER) from documents using LLMs and model them effectively in FalkorDB for knowledge graphs.

Deploy and configure MetalLB for load balancing in bare metal Kubernetes clusters with L2 and BGP modes.

Manage Kubernetes configurations across environments with Kustomize overlays, patches, and ConfigMap generators.

Build robust CI/CD pipelines with GitHub Actions for .NET applications including testing, Docker builds, and Kubernetes deployment.

A comprehensive guide to the hardware powering BlueRobin. From Ryzen processors and 128GB RAM to configuring TrueNAS Scale for Kubernetes storage via iSCSI and NFS.

Techniques for rewriting user queries (HyDE, Expansion) and reranking results to boost retrieval accuracy in Retrieval-Augmented Generation.

Why we chose the Document Model and RavenDB's impressive GUI, despite the challenges of a smaller ecosystem and specialized hosting requirements.

A comprehensive guide to hardening your homelab environment using ufw, network segmentation with VLANs, and SSH key-based authentication.

Implement effective text chunking strategies for RAG pipelines with semantic boundaries, overlap, and metadata preservation.

Extract named entities from documents using spaCy NLP service for building knowledge graphs and improving search relevance.

Manage database schema evolution with EF Core migrations, including multi-environment strategies and zero-downtime deployments.

Synchronize secrets from Infisical to Kubernetes using External Secrets Operator for GitOps-friendly secret management.

Why we abandoned the cloud for bare metal. A deep dive into the cost savings, performance gains of 10GbE, and total data sovereignty of running BlueRobin on-premise.

Achieve 100% reliable messaging by atomically committing state changes and events. A deep dive into the Outbox Pattern with EF Core and NATS utilizing background relay workers.

Exploring the highs of global distribution and the lows of execution limits. A candid look at when to embrace Cloudflare Workers and when to stick with containers.

Model and query entity relationships using FalkorDB (Redis Graph) for knowledge graphs and connected data in .NET applications.

A streamlined guide to setting up the full BlueRobin stack locally, from secret management with Infisical to running microservices with shared infrastructure.

A comprehensive guide to securing PostgreSQL in a production environment, covering pg_hba.conf, enforced SSL/TLS, RBAC, Row-Level Security (RLS), and credential management with Infisical.

Implementing 'Never Trust, Always Verify' in Kubernetes using Linkerd for mTLS, OIDC for user identity propagation, and Workload Identity for secure service communication.

Ditch bloated controllers. Build high-performance, maintainable APIs using the Request-Endpoint-Response (REPR) pattern with FastEndpoints.

Stop memory leaks and race conditions. Master Blazor Server's lifecycle events and build a robust BaseComponent.

A production blueprint for combining graph traversal and vector search to improve recall and precision in medical document retrieval.

How BlueRobin introduced a GraphRAG routing layer with health-aware fallback to keep agentic retrieval reliable in production.

A practical cluster setup guide for running BlueRobin-style agentic services with reliable data, messaging, and observability foundations.

How to run a full .NET + AI development environment remotely with VS Code, Kubernetes, and a persistent dev container pod.

Stop manually renewing certificates. Set up Cert-Manager to automate Let's Encrypt DNS-01 challenges with Cloudflare.

What happens when agent graph node names collide with state keys, and how to design LangGraph flows that remain safe under change.

Revolutionizing cluster operations by replacing kubectl with natural language interaction using the Kubernetes MCP Server.

How BlueRobin evolved entity extraction by combining deterministic and LLM-based providers with confidence-aware ensembling.

Configure Traefik as your Kubernetes ingress controller with TLS termination, middleware chains, and IngressRoutes for routing traffic.

How BlueRobin combines multiple retrieval strategies and uses reciprocal rank fusion to produce more stable, high-quality contexts for LLM responses.

Build intelligent AI agents using Microsoft Semantic Kernel with tool calling, memory, and multi-agent coordination in .NET.

Implementing model policy management and global token accounting so agentic features remain cost-aware and governable.

Deploy and configure Qdrant for production semantic search with collection management, filtering, and high availability on Kubernetes.

A practical strategy for evolving NATS subjects and event naming while keeping producers and consumers compatible during transition windows.

Deploy a production-ready MinIO cluster on Kubernetes with per-user encryption, bucket policies, and integration with your .NET applications.

How BlueRobin uses compare-and-swap semantics in NATS KV to prevent duplicate event processing across multiple worker instances.

Implement distributed tracing, metrics, and logging with OpenTelemetry in .NET applications for full observability.

Moving from local in-memory limits to cluster-aware NATS KV partitions for fair, durable API throttling in distributed deployments.

An end-to-end deployment walkthrough for introducing a new AI service with environment overlays, secret wiring, and production-safe defaults.

Implement a complete Retrieval-Augmented Generation pipeline that combines semantic search with local LLM inference for intelligent document Q&A.

Build a powerful hybrid search system that combines vector embeddings with traditional keyword search for comprehensive document retrieval.

Discover the hidden powers of NATS. Replace Redis and S3 for internal use cases using the built-in Key-Value Store and Object Store capabilities of JetStream.

Build robust forms in Blazor. Master FluentValidation integration, custom input components, and complex state management.

Bridging the gap between design and development by using the Model Context Protocol (MCP) to automate UI generation from Figma to Blazor.

Deep dive into NATS consumer configurations. Learn how to implement Load Balanced Work Queues for scaling background jobs and Fan-Out patterns for event-driven systems.

Set up comprehensive monitoring for NATS JetStream with Prometheus, Grafana dashboards, and alerting for production-ready messaging infrastructure.

A complete guide to replacing RabbitMQ/Kafka with NATS JetStream. Learn the core concepts of Streams, Subjects, and Consumers, and how to implement them in C#.

Decouple your domain logic from EF Core. Learn how to implement Repositories for DDD Aggregates with strict interface separation.

Mastering JavaScript Interop in Blazor: Efficiently calling JS from C# and vice-versa, managing object references, and ensuring type safety.

Master domain events in C# to build reactive systems with loose coupling, eventual consistency, and clean separation of concerns.

Learn how to design aggregates that enforce business invariants, manage consistency boundaries, and encapsulate complex domain logic in your C# applications.

Host your own OIDC/OAuth2 Identity Provider with Authelia on Kubernetes. Secure your apps with 2FA, SSO, and fine-grained access control.

Create a production-ready embedding pipeline in .NET that generates vector embeddings with Ollama and stores them in Qdrant for semantic search.

Implement real-time UI updates in Blazor Server using NATS JetStream instead of SignalR, with progress indicators and state management.

Learn how to implement value objects with built-in validation, equality semantics, and EF Core persistence for a cleaner, more expressive domain model.

Learn how to implement GitOps for your Kubernetes cluster using Flux CD, including repository structure, Kustomize overlays, and automated image updates.

Learn how to integrate Docling, an AI-powered document understanding library, into your .NET application for high-quality OCR with layout preservation.

Create a modern, translucent UI library with Blazor and Tailwind CSS 4. Master backdrop-filter, OKLCH colors, and reusable Razor components.

Visual architecture overview of the BlueRobin Telegram integration, showing the complete flow from mobile app to backend services, authentication, and notification pipelines.

A deep dive into creating a Telegram Mini App for BlueRobin that enables passkey authentication, leveraging Blazor Server, WebAuthn, and Telegram's native theming system.

Building a real-time notification pipeline from document processing events to Telegram messages using NATS Core, environment-prefixed subjects, and the publisher-subscriber pattern.

Complete guide to deploying the BlueRobin Telegram Bot on Kubernetes, covering Docker builds, Kustomize overlays, secrets management with Infisical, and GitOps with Flux CD.

Stop creating invalid objects. Learn how to use static factory methods and private constructors to ensure DDD entities are always in a valid state.

Implementation of the Shared Kernel pattern: A crucial library containing the base building blocks (Entity, AggregateRoot, ValueObject) for Domain-Driven Design.

A comprehensive guide to adopting Tailwind CSS 4 in Blazor, leveraging CSS-first configuration and the new JIT engine for a streamlined frontend workflow.

Securely exposing K8s services like API, MinIO, and databases using Tailscale sidecars and subnet routers for seamless access from anywhere.