Runnable code, Bicep, KQL, and diagrams from the 45-post series. Clone a branch, dotnet run — $0 Azure spend to learn.
See what you get
Samples below are read from the vault ZIP on this server when available: KQL queries, Bicep modules, drill cards, ADRs, and architecture diagrams.
Loaded from your vault ZIP: 6 artifact folders detected on this server.
Post 45 · Production Readiness Review gate query
// All systems green = deployment ready
// This query is the final gate in the Azure DevOps pipeline
let sloLatencyP99Ms = 500.0;
let sloErrorRatePct = 1.0;
let sloDLQDepth = 100;
let sloEHLagSec = 30;
union
(requests | where timestamp > ago(1h)
| summarize P99=percentile(duration,99), ErrorRate=countif(success==false)*100.0/count()
by cloud_RoleName
| extend Component="API",
Status=iff(P99 < sloLatencyP99Ms and ErrorRate < sloErrorRatePct,"PASS","FAIL")
| project Component, Status, Detail=strcat("P99=",tostring(round(P99,0)),"ms ErrorRate=",tostring(round(ErrorRate,2)),"%")),
(customMetrics | where timestamp > ago(1h) and name == "ServiceBus.DLQMessages"
| summarize MaxDLQ=max(value)
| extend Component="ServiceBus.DLQ",
Status=iff(MaxDLQ < sloDLQDepth,"PASS","FAIL"),
Detail=strcat("DLQ=",tostring(MaxDLQ)," (limit=",tostring(sloDLQDepth),")")
| project Component, Status, Detail),
(customMetrics | where timestamp > ago(1h) and name == "EventHub.ConsumerGroupLag"
| summarize MaxLag=max(value)
| extend Component="EventHubs.Lag",
Status=iff(MaxLag < sloEHLagSec,"PASS","FAIL"),
Detail=strcat("Lag=",tostring(MaxLag),"s (limit=",tostring(sloEHLagSec),"s)")
| project Component, Status, Detail)
| order by Status asc // FAIL rows first
servicebus.bicep — parameterised module from the vault
// modules/servicebus.bicep — Azure Service Bus
// Distributed Systems with .NET · Vault Resource
// Production-ready module with Standard SKU, topics, subscriptions, DLQ settings
@description('Service Bus namespace name — must be globally unique')
param namespaceName string
@description('Azure region')
param location string = resourceGroup().location
@description('SKU: Basic (queues only), Standard (topics), Premium (VNet, sessions at scale)')
@allowed(['Basic','Standard','Premium'])
param sku string = 'Standard'
@description('Queue and topic names to create')
param queueNames array = ['orders-processing']
@description('Topic names to create')
param topicNames array = ['telemetry']
@description('Max delivery count before DLQ — lower = faster failure detection')
param maxDeliveryCount int = 3
@description('Environment tag')
param environmentName string = 'prod'
resource namespace 'Microsoft.ServiceBus/namespaces@2022-10-01-preview' = {
name: namespaceName
location: location
sku: { name: sku, tier: sku }
tags: { environment: environmentName, series: 'distributed-systems-dotnet' }
properties: {
minimumTlsVersion: '1.2'
publicNetworkAccess: 'Enabled'
disableLocalAuth: false
}
}
Sample layout from post-45-drill-card.pdf in your vault
Invoke-RestMethod http://localhost:8080/health -Headers @{ "X-Tenant-Id" = "tenant-a" }ServiceBusClient.CreateProcessor(queueName, options)union (requests | summarize P99=percentile(duration,99) by cloud_RoleName) …Stop the Service Bus emulator container — processor should surface DLQ growth within 60s.System overview style — 90 editable SVG diagrams in the full vault
Annotated Repository README — architectural decision record
Not ready yet? Read the free series on Substack
Who it's for
All three work on Windows, write C#, and deploy to Azure. What differs is where they are in their career and what they need most.
You are 3–6 months into a new Azure project. You have the services running but the distributed parts — async messaging, multi-tenant routing, KQL dashboards, KEDA autoscaling — are ahead of you. You want working code to learn from, not documentation to read through.
→ Gets most value from: Complete source repository + drill cards + KQL library
Your team is adopting Azure Service Bus, debating Bicep versus Terraform, or choosing between Application Insights and Loki. You need the trade-off tables, the ADRs, and the architecture diagrams already drawn — ready to drop into a Confluence page or present in a design review.
→ Gets most value from: Decision guide + Bicep modules + architecture diagrams + annotated README
The AZ-305 Azure Solutions Architect Expert exam is heavy on selecting the right Azure service, understanding resilience patterns, and designing multi-tier data storage. This series maps directly to those domains. The AZ-305 alignment map tells you which posts cover which exam skills and how heavily.
→ Gets most value from: AZ-305 alignment map + all 45 posts + decision guide
Vault contents
Every item listed individually below with its own price. Buy separately or get everything in the bundle for $149.
The complete Hyperscale Log Monitoring Masterclass series in searchable, printable PDFs organised by phase. No 7-day subscriber delay, no paywall.
Phase 1–9 · Substack-quality layoutSingle-page A4 per post: PowerShell 7 commands, Azure SDK method signature, KQL snippet, decision rule, verify command, and a "break it deliberately" one-liner.
PDF · A4 light version · 90-page compiled masterOne production-ready KQL query per post, annotated inline. Organised by post number and by Azure service. Works in ADX, Azure Monitor, App Insights, and Sentinel. Plus a 2-page printable cheatsheet of all KQL operators.
2× .kql files + PDF cheatsheetParameterised Bicep modules for every Azure service in the series: Service Bus, Event Hubs, App Insights, Blob Storage, ADX, AKS, ACR, Key Vault, DAPR components. One command deploys the full stack.
11 .bicep files + parameters.prod.jsonAzure-native vs open-source decision tables (6 technology pairs), Azure SDK .NET patterns (5 recurring patterns), complete Windows developer machine setup guide, and Azure emulator quick-start.
4 printable PDFsEvery post mapped to the AZ-305 Azure Solutions Architect Expert exam domain with a 1–4 weight score and the recommended study sequence. Use it alongside official Microsoft Learn modules.
PDF · 45 posts × 5 exam domainsThe architectural decision record for the entire system. Why Aspire over Docker Compose, why per-event checkpointing, why KQL is the universal language, why KEDA ties to Event Hubs lag not CPU. The document a new engineer reads before their first sprint.
Markdown + PDF · 258 linesPrivate GitHub repository. One branch per post — the complete running system at that point. git checkout post/09 and dotnet run --project src/AppHost and the system for Post 9 starts. No pseudocode, no exercises left for the reader.
Two diagrams per post: the full 45-post system with that post's components highlighted, and the internal data-flow diagram for that post's primary component. Microsoft Fluent color palette. Editable SVG — drop into Figma, PowerPoint, or Confluence.
SVG (editable) + PNG exports · 2× per postIndividual vs Bundle
| Resource | Individual | Vault Bundle |
|---|---|---|
|
All 45 Posts (PDF collection)
45 PDFs · searchable · organised by phase |
$49 | ✓ included |
|
Drill Card Pack
45 cards + 90-page compiled PDF |
$29 | ✓ included |
|
KQL Query Library
45 queries · 2× .kql files + cheatsheet PDF |
$19 | ✓ included |
|
Bicep Module Library
9 modules + main.bicep + parameters.prod.json |
$39 | ✓ included |
|
Reference Guides Pack
4 PDFs — decision guide, SDK patterns, Windows setup, emulators |
$19 | ✓ included |
|
AZ-305 Alignment Map
All 45 posts mapped to exam domains |
$9 | ✓ included |
|
Annotated Repository README
10 architectural decisions with full reasoning |
$9 | ✓ included |
|
Complete .NET Aspire Source Repository
Private GitHub · 45 branches · all runnable |
$79 | ✓ included |
|
Architecture Diagrams
90 SVGs + PNGs · editable · Microsoft Fluent palette |
$19 | ✓ included |
| Total | $271 | $149 |
Pre-order at $99 until Post 45 publishes. Full price $149 after that date.
The bundle
The complete Hyperscale Log Monitoring Masterclass in one download. Every post, every drill card, every KQL query, every Bicep module, every diagram, and the complete working source repository. No subscription. No recurring payment.
All on Windows · All using official free Microsoft local emulators · No Azure subscription required for any resource
Vault Bundle
$271 individually
You save $122 — 45% off individual prices
Pre-order at $99 — available until Post 45 publishes.
All resources delivered immediately as they are completed.
Need just one item? Every resource is also available individually above. Prices range from $9 (AZ-305 map) to $79 (complete source repository).
Individual resources
Each item is available separately — or save $122 with the complete bundle.
45 GitHub branches · .NET 8 · Aspire 8.3.0
For engineers who learn by reading and running code — not by following along.
45 PDFs · organised by phase · searchable
For engineers who want the full series without the Substack reading interface.
9 modules + main.bicep + parameters.prod.json
For Azure engineers who deploy with Bicep and want production-parameterised modules.
45 cards · A4 · 90-page compiled master
For engineers who want a one-page reference per post on their monitor.
45 queries · 2 .kql files · cheatsheet PDF
For engineers who query Azure Monitor, App Insights, ADX, or Sentinel daily.
4 PDFs · printable
For teams onboarding developers or preparing architecture reviews.
90 SVGs + PNG · 2 per post
For architects who need diagrams for design reviews and Confluence.
3-page PDF · 45 posts × 5 domains
For engineers preparing for AZ-305 certification.
10 ADRs · Markdown + PDF
For senior engineers documenting and defending architectural decisions.
FAQ
No. Every Azure service in the series — Service Bus, Event Hubs, Blob Storage, Application Insights, Azure Data Explorer — runs on official free Microsoft local Docker containers. The Bicep modules are designed so you can deploy to real Azure, but nothing in the vault requires it.
.NET 8 LTS. .NET Aspire 8.3.0. All NuGet versions are pinned in every .csproj file — no floating * references. Runs on Windows 11 with Docker Desktop 4.x and PowerShell 7.4.x.
You receive a GitHub invitation to a private repository. All 45 branches are available immediately. You can also download a ZIP of any branch directly from GitHub if you prefer not to clone.
Yes. The Bicep modules are yours to use, adapt, and extend in any project. They are not licensed for redistribution or resale as a standalone product, but using them in your own Azure infrastructure is exactly what they are designed for.
All 45 posts in the newsletter go free to all subscribers after 7 days. The Vault includes the same posts as PDFs — the value is having them searchable and downloadable in a single package, not exclusive content.
14-day no-questions refund on any purchase, as long as the private repository has not been accessed and the downloadable files have not been downloaded. Contact the newsletter directly via Substack after purchase.
Both. Every query is written in standard KQL and tested against the Kusto Emulator (ADX local). The same queries run in Azure Monitor Logs, Application Insights, and Microsoft Sentinel with zero or minimal changes — the service-specific table names are called out in each query's comments.
The series is Windows-first by design — PowerShell 7 is the primary scripting language, .NET Aspire's Dashboard and Docker Desktop are the assumed tools. The verify.sh scripts and Docker Compose files work on macOS and Linux, but the series makes no guarantees outside Windows 11 with Docker Desktop.
Everything from the Hyperscale Log Monitoring Masterclass — the code, the queries, the diagrams, the modules, and the decisions behind all of it — in a single purchase.
One-time payment · No subscription · No Azure subscription required · 14-day refund policy