All posts
Wails in Practice #8 A Testing Strategy — Verifying the Service and Repository
Actually write the tests promised back in #1 when we split the layers. Covers unit tests that verify service logic in pure Go without Wails, integration tests that verify the repository with a temporary SQLite, sweeping edge cases with table-driven tests, and wiring these into #6's CI so they run automatically before a release.
ALB vs NLB: Choosing a Load Balancer
A working standard for choosing between ALB and NLB: the layer difference between L7 routing and L4 forwarding, the things only NLB can do (static IPs, source IP preservation, PrivateLink), how bills diverge in LCU math even though the hourly rate is identical, hidden costs like cross-zone load balancing, and the chained NLB-to-ALB setup for when you need both.
GitHub Foundations #7 Domain 5: Project Management — Projects, Automation, and Insights
GitHub Projects with its table, board, and roadmap views, custom fields, built-in automation workflows, and the repository Insights tab. This post covers Domain 5, Project Management, of GitHub Foundations.
How Linux Came to Dominate Servers — Cost, Architecture, Ecosystem
How Linux became the default server OS, from both the technical and ecosystem sides: the zero-license, open-source starting point, the structural traits that fit server duty (headless, remote-managed, long-running), the lock-in effects of the cloud and container eras, and the territories Linux never took.
Wails in Practice #7 The Note Editor for Real — Markdown Preview and List UX
The first post of Part 2. We actually build the front half of the notes app, backend-heavy so far. Covers a preview that renders markdown safely, debounced autosave that fires when typing stops, keeping edits from shuffling the list order, and a list UX you can move through with the keyboard.
Choosing a GPU Cloud: Hyperscaler vs Specialist GPU Cloud vs Serverless Inference
A working standard for where to rent GPUs for AI workloads: why H100 hourly rates run 2〜5x apart between hyperscalers (AWS) and specialist GPU clouds (Lambda, RunPod), what you accept when spot drops below half, where serverless inference removes GPU management with per-token billing, and the integration, network, and regulatory requirements that flip the price difference.
GitHub Foundations #6 Domain 4: Modern Development — Actions, Codespaces, Copilot, and Packages
The features that turn GitHub into a development platform beyond a code host. The structure of Actions workflows, the difference between Codespaces and github.dev, Copilot plans, Packages and the Marketplace — all from the exam's point of view.
The Core of Incident Handling — What Matters Most When Things Break
Making incident response run on procedure instead of heroics: recovery before root cause, separating command, communications, and operations, severity levels and declaration criteria, writing blameless postmortems that still name causes, and the conditions that keep on-call sustainable.
Wails in Practice #6 CI/CD Automated Releases — Three-Platform Delivery with GitHub Actions
Close the series by making a single tag generate a three-platform release automatically. Covers why macOS cannot be cross-compiled and forces a matrix build, a GitHub Actions workflow that builds and signs on per-platform runners, where pure-Go SQLite keeps CI simple, an auto-update strategy, and a full recap of the six posts.
Error Budgets — The Concept and Math of a Failure Allowance
The error budget that falls out of any SLO: converting budget size into time and request counts, why burn-rate alerts beat threshold alerts, the policy that fires when the budget runs dry, and running the speed-versus-stability conflict by rule instead of by meeting.
GitHub Foundations #5 Domain 3-2: Collaboration — Pull Requests, Code Review, and Discussions
The second half of the collaboration domain. The Pull Request lifecycle and drafts, CODEOWNERS and the three review states, suggested changes, the split between Issues and Discussions, and GitHub Pages — all from the exam's point of view.
LLM Quantization Compared: FP16, INT8, INT4 and GGUF, AWQ, GPTQ
A working standard for choosing an LLM quantization method: how precision (FP16, INT8, INT4) halves VRAM, the math that takes a 70B model from 140GB to 35GB, where the three formats (GGUF, AWQ, GPTQ) diverge by use (local, GPU serving, accuracy), where INT4 degrades quality on reasoning and code tasks, and how to match the format to the serving framework.