<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>HexGigs Backend Labs — Updates</title>
    <link>https://blog.hexgigs.com/</link>
    <description>Latest posts from HexGigs Backend Labs (.NET, SQL, RabbitMQ, Background Services, AI).</description>
    <language>en-us</language>
    <item>
    <title>AI Can Write the Code. You Still Own the Architecture.</title>

    <link>https://blog.hexgigs.com/posts/ai-code-engineering-judgment.html</link>

    <guid>https://omarr-backend-lab.netlify.app/posts/ai-code-engineering-judgment.html</guid>

    <pubDate>Tue, 08 Sep 2026 12:00:00 -0500</pubDate>

    <description>
        AI can generate impressive code, but architecture, trade-offs,
        failure handling, and production ownership still require
        engineering judgment.
    </description>
</item>
    <item>
<title>Caching in .NET: The Fastest Code Is the Code You Never Execute</title>
<link>https://blog.hexgigs.com/posts/dotnet-caching-production.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/dotnet-caching-production.html</guid>
<pubDate>Sat, 11 Jul 2026 12:00:00 -0500</pubDate>
<description>
Practical caching strategies for .NET applications, covering memory caching, distributed caching, expiration policies, cache stampedes, and performance monitoring.
</description>
</item>
    <item>
<title>Designing Event-Driven Systems That Survive Production</title>
<link>https://blog.hexgigs.com/posts/designing-event-driven-systems-production.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/designing-event-driven-systems-production.html</guid>
<pubDate>Wed, 08 Jul 2026 12:00:00 -0500</pubDate>
<description>
Lessons learned from building resilient event-driven systems with .NET, RabbitMQ, retries, idempotency, and observability.
</description>
</item>
    <item>
<title>How I Use AI Daily as a Senior Software Engineer (.NET Edition)</title>
<link>https://blog.hexgigs.com/posts/how-i-use-ai-daily-senior-dotnet-engineer.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/how-i-use-ai-daily-senior-dotnet-engineer.html</guid>
<pubDate>Mon, 25 May 2026 12:00:00 -0500</pubDate>
<description>
How I practically use AI every day as a senior .NET engineer across architecture, debugging, SQL, APIs, and documentation.
</description>
</item>
    <item>
<title>AI in Real Backend Systems: Where It Actually Creates Value</title>
<link>https://blog.hexgigs.com/posts/ai-real-backend-systems-where-it-creates-value.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/ai-real-backend-systems-where-it-creates-value.html</guid>
<pubDate>Wed, 22 Apr 2026 12:00:00 -0500</pubDate>
<description>
A practical backend-engineer view of where AI creates real business value inside production systems.
</description>
</item>
    <item>
<title>Integration Testing in .NET: What Unit Tests Don’t Catch</title>
<link>https://blog.hexgigs.com/posts/dotnet-integration-testing-what-unit-tests-miss.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/dotnet-integration-testing-what-unit-tests-miss.html</guid>
<pubDate>Wed, 06 Apr 2026 12:00:00 -0500</pubDate>
<description>
Why integration testing matters in .NET systems and what unit tests fail to catch in real production code.
</description>
</item>
    <item>
<title>Unit Testing in .NET 10: What Actually Matters in Real Systems</title>
<link>https://blog.hexgigs.com/posts/dotnet10-unit-testing-real-world.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/dotnet10-unit-testing-real-world.html</guid>
<pubDate>Wed, 01 Apr 2026 12:00:00 -0500</pubDate>
<description>
A practical guide to unit testing in .NET 10 focusing on real-world backend systems.
</description>
</item>
    <item>
<title>C# and .NET 10: Small Things That Make a Big Difference</title>
<link>https://blog.hexgigs.com/posts/dotnet10-csharp-quick-tips.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/dotnet10-csharp-quick-tips.html</guid>
<pubDate>Wed, 18 Mar 2026 12:00:00 -0600</pubDate>
<description>
Practical C# and .NET 10 tips for building clean and maintainable backend systems.
</description>
</item>
    <item>
<title>Why Python Became the Language of AI</title>
<link>https://blog.hexgigs.com/posts/python-ai-importance.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/python-ai-importance.html</guid>
<pubDate>Sun, 15 Mar 2026 12:00:00 -0600</pubDate>
<description>
Why Python became the dominant language for machine learning and AI development.
</description>
</item>
    <item>
<title>RabbitMQ Patterns Every Backend Engineer Should Know</title>
<link>https://blog.hexgigs.com/posts/rabbitmq-patterns-backend-systems.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/rabbitmq-patterns-backend-systems.html</guid>
<pubDate>Sun, 08 Mar 2026 12:00:00 -0600</pubDate>
<description>
Common RabbitMQ messaging patterns used in production backend systems.
</description>
</item>
    <item>
<title>Data Science vs Software Engineering: Where AI Systems Actually Meet</title>
<link>https://blog.hexgigs.com/posts/data-science-ai-engineering-boundary.html</link>
<guid>https://omarr-backend-lab.netlify.app/posts/data-science-ai-engineering-boundary.html</guid>
<pubDate>Fri, 06 Mar 2026 12:00:00 -0600</pubDate>
<description>
Understanding how data science and software engineering intersect in real AI systems.
</description>
</item>
        <item>
  <title>Probability, Uncertainty, and Why AI Outputs Are Never “Certain”</title>
  <link>https://blog.hexgigs.com/posts/ai-probability-uncertainty.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/ai-probability-uncertainty.html</guid>
  <pubDate>Fri, 20 Feb 2026 12:00:00 -0600</pubDate>
  <description>
    Understanding probability and uncertainty in AI systems — and why outputs are likelihoods, not truths.
  </description>
</item>

    <item>
  <title>Math, Statistics, and Why AI Is Not Magic</title>
  <link>https://blog.hexgigs.com/posts/ai-math-statistics-foundation.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/ai-math-statistics-foundation.html</guid>
  <pubDate>Fri, 06 Feb 2026 12:00:00 -0600</pubDate>
  <description>
    Why math and statistics are the real foundation of AI and ML — beyond the hype.
  </description>
</item>

    <item>
  <title>Designing Guardrails for AI in Production Backends</title>
  <link>https://blog.hexgigs.com/posts/ai-production-guardrails.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/ai-production-guardrails.html</guid>
  <pubDate>Wed, 21 Jan 2026 12:00:00 -0600</pubDate>
  <description>
    Practical guardrails for running AI safely in real backend systems: validation, limits, observability, and failure modes.
  </description>
</item>

    <item>
  <title>AI in backend systems: where automation ends and engineering still matters</title>
  <link>https://blog.hexgigs.com/posts/ai-backend-automation-vs-engineering.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/ai-backend-automation-vs-engineering.html</guid>
  <pubDate>Sun, 18 Jan 2026 00:00:00 +0000</pubDate>
  <description>
    A senior-level look at where AI genuinely helps backend systems and where engineering judgment still matters.
  </description>
</item>
<item>
  <title>Idempotency in backend systems</title>
  <link>https://blog.hexgigs.com/posts/backend-idempotency-patterns.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/backend-idempotency-patterns.html</guid>
  <pubDate>Thu, 08 Jan 2026 00:00:00 +0000</pubDate>
  <description>
    Why retries make idempotency mandatory in backend systems, especially for APIs and queue-driven workflows.
  </description>
</item>

    <!-- Agentic AI -->


    <item>
  <title>Why AI agents are becoming backend engineers' new teammates | HexGigs Backend Labs</title>
  <link>https://blog.hexgigs.com/posts/ai-backend-agents.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/ai-backend-agents.html</guid>
  <pubDate>Wed, 19 Nov 2025 00:00:00 +0000</pubDate>
  <description>
    How AI agents are evolving from code helpers into always-on backend teammates that triage incidents, steer background jobs, and operate inside your .NET and SQL stack.
  </description>
</item>

    <item>
      <title>Agentic AI vs "plain" generative AI for backend systems</title>
      <link>https://blog.hexgigs.com/posts/agentic-vs-generative-ai-backend.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/agentic-vs-generative-ai-backend.html</guid>
      <pubDate>Mon, 17 Nov 2025 10:05:00 -0600</pubDate>
      <description><![CDATA[
A backend-focused comparison of agentic AI and generative AI, with practical integration patterns for .NET backends.
      ]]></description>
    </item>

    <!-- JSON handling -->
    <item>
      <title>Pragmatic JSON handling in .NET</title>
      <link>https://blog.hexgigs.com/posts/dotnet-json-handling.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-json-handling.html</guid>
      <pubDate>Sun, 16 Nov 2025 16:20:00 -0600</pubDate>
      <description><![CDATA[
How to keep JSON contracts stable and predictable in .NET services using DTOs, versioning, and safe logging.
      ]]></description>
    </item>

    <!-- Blue/green deployments -->
    <item>
      <title>Blue/green deployments without drama</title>
      <link>https://blog.hexgigs.com/posts/blue-green-deployments.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/blue-green-deployments.html</guid>
      <pubDate>Fri, 14 Nov 2025 15:10:00 -0600</pubDate>
      <description><![CDATA[
Practical strategies for running two app stacks, switching traffic safely, and rolling back quickly.
      ]]></description>
    </item>
    <!-- .NET 10 -->
    <item>
  <title>.NET 10 for Backend Engineers: What’s Actually Worth Paying Attention To</title>
  <link>https://blog.hexgigs.com/posts/dotnet-10-backend-what-matters.html</link>
  <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-10-backend-what-matters.html</guid>
  <pubDate>Wed, 14 Jan 2026 12:00:00 -0600</pubDate>
  <description>
    A backend-focused look at .NET 10, covering performance, APIs, hosting, and what actually impacts production systems.
  </description>
</item>

    <!-- .NET 9 -->
    <item>
      <title>.NET 9 for backend services: what actually matters</title>
      <link>https://blog.hexgigs.com/posts/dotnet-9-backend-services.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-9-backend-services.html</guid>
      <pubDate>Mon, 10 Nov 2025 20:30:00 -0600</pubDate>
      <description><![CDATA[
An opinionated look at what .NET 9 changes for backend services and APIs: performance, Aspire, and C# features.
      ]]></description>
    </item>

    <!-- EF Core vs Dapper -->
    <item>
      <title>EF Core or Dapper? How I decide</title>
      <link>https://blog.hexgigs.com/posts/dotnet-efcore-dapper.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-efcore-dapper.html</guid>
      <pubDate>Sat, 08 Nov 2025 19:45:00 -0600</pubDate>
      <description><![CDATA[
A practical guide to choosing between EF Core and Dapper for different types of data access.
      ]]></description>
    </item>

    <!-- Record vs class vs struct -->
    <item>
      <title>Record vs class vs struct in C#</title>
      <link>https://blog.hexgigs.com/posts/dotnet-record-class-struct.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-record-class-struct.html</guid>
      <pubDate>Thu, 06 Nov 2025 21:30:00 -0600</pubDate>
      <description><![CDATA[
Simple heuristics I use to decide whether a type should be a record, a class, or a struct in backend code.
      ]]></description>
    </item>

    <!-- Threading -->
    <item>
      <title>Threading in .NET: the mental model</title>
      <link>https://blog.hexgigs.com/posts/dotnet-threading-basics.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-threading-basics.html</guid>
      <pubDate>Sat, 25 Oct 2025 14:15:00 -0600</pubDate>
      <description><![CDATA[
A backend-focused way to think about threads, tasks, and async/await so you can reason about throughput and bugs.
      ]]></description>
    </item>

    <!-- SQL: functions vs procs vs views vs CTE vs temp tables -->
    <item>
      <title>Functions vs stored procedures vs views vs CTEs vs temp tables</title>
      <link>https://blog.hexgigs.com/posts/sql-functions-vs-procs-vs-views.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/sql-functions-vs-procs-vs-views.html</guid>
      <pubDate>Sun, 05 Oct 2025 17:00:00 -0600</pubDate>
      <description><![CDATA[
How I choose the right SQL tool for the job instead of defaulting everything to stored procedures.
      ]]></description>
    </item>

    <!-- Resilient background services -->
    <item>
      <title>Designing resilient .NET 8 background services</title>
      <link>https://blog.hexgigs.com/posts/dotnet-resilient-background-services.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-resilient-background-services.html</guid>
      <pubDate>Fri, 02 May 2025 21:15:00 -0600</pubDate>
      <description><![CDATA[
Patterns for building resilient long-running BackgroundService implementations in .NET 8.
      ]]></description>
    </item>

    <!-- Splitting monolith -->
    <item>
      <title>Splitting a monolith into queue-driven microservices</title>
      <link>https://blog.hexgigs.com/posts/dotnet-splitting-monolith-queues.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/dotnet-splitting-monolith-queues.html</guid>
      <pubDate>Fri, 18 Apr 2025 20:40:00 -0600</pubDate>
      <description><![CDATA[
Lessons from carving out a high-throughput processor into smaller, queue-driven microservices.
      ]]></description>
    </item>

    <!-- Senior-level SQL -->
    <item>
      <title>From "it works" queries to senior-level SQL</title>
      <link>https://blog.hexgigs.com/posts/sql-senior-level-queries.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/sql-senior-level-queries.html</guid>
      <pubDate>Mon, 10 Mar 2025 19:05:00 -0600</pubDate>
      <description><![CDATA[
Taking SQL queries from "it works" to production-ready with plans, indexing, and better troubleshooting.
      ]]></description>
    </item>

    <!-- Event logs & replays -->
    <item>
      <title>Event logs, audit trails, and replays in SQL</title>
      <link>https://blog.hexgigs.com/posts/sql-event-logs-replays.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/sql-event-logs-replays.html</guid>
      <pubDate>Fri, 21 Feb 2025 09:55:00 -0600</pubDate>
      <description><![CDATA[
Designing SQL schemas that support audit trails, state replays, and easier debugging of production issues.
      ]]></description>
    </item>

    <!-- RabbitMQ channel best practices -->
    <item>
      <title>RabbitMQ channel and connection best practices</title>
      <link>https://blog.hexgigs.com/posts/rabbitmq-channel-best-practices.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/rabbitmq-channel-best-practices.html</guid>
      <pubDate>Thu, 30 Jan 2025 11:20:00 -0600</pubDate>
      <description><![CDATA[
Channel sharing, connection management, and prefetch tuning so one bad consumer does not bring everything down.
      ]]></description>
    </item>

    <!-- RabbitMQ DLQs -->
    <item>
      <title>Dead-letter queues and poison message handling</title>
      <link>https://blog.hexgigs.com/posts/rabbitmq-dead-letter-queues.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/rabbitmq-dead-letter-queues.html</guid>
      <pubDate>Sun, 05 Jan 2025 22:10:00 -0600</pubDate>
      <description><![CDATA[
Practical RabbitMQ patterns for DLQs, poison messages, and "at least once" delivery.
      ]]></description>
    </item>

    <!-- Cron-like scheduler -->
    <item>
      <title>Cron-like scheduling with .NET background workers</title>
      <link>https://blog.hexgigs.com/posts/background-cron-like-scheduler.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/background-cron-like-scheduler.html</guid>
      <pubDate>Sun, 15 Dec 2024 06:30:00 -0600</pubDate>
      <description><![CDATA[
Building a lightweight cron-style scheduler for recurring jobs using .NET background services.
      ]]></description>
    </item>

    <!-- Background observability -->
    <item>
      <title>Making invisible background jobs observable</title>
      <link>https://blog.hexgigs.com/posts/background-observability.html</link>
      <guid>https://omarr-backend-lab.netlify.app/posts/background-observability.html</guid>
      <pubDate>Thu, 28 Nov 2024 15:45:00 -0600</pubDate>
      <description><![CDATA[
Logging, metrics, and tracing strategies so your background workers stop being a black box.
      ]]></description>
    </item>
<!-- End of HexGigs Backend Labs posts -->

    <!-- Side projects -->
<item>
  <title>OMR Holiday Atlas — side project</title>
  <link>https://omr-holiday-atlas.netlify.app</link>
  <guid>https://omr-holiday-atlas.netlify.app</guid>
  <pubDate>Mon, 10 Nov 2025 00:00:00 +0000</pubDate>
  <description>
    A small travel-planning web app built by Omarr as a playground for frontend and API integration experiments.
  </description>
</item>
<item>
  <title>OMRCade — JavaScript mini arcade</title>
  <link>https://omrcade.netlify.app</link>
  <guid>https://omrcade.netlify.app</guid>
  <pubDate>Wed, 12 Nov 2025 00:00:00 +0000</pubDate>
  <description>
    A browser-based mini arcade of JavaScript games with a dark theme, used as a sandbox for UI and game loop experiments.
  </description>
</item>


  </channel>
</rss>
