All posts
Wails in Practice #5 Signing and Notarization — How a Shipped App Earns Trust
Make the finished notes app run without warnings on other people's machines. Covers why an unsigned app is blocked by macOS Gatekeeper and Windows SmartScreen, the macOS code-signing and notarization (notarytool) procedure, the types and cost of Windows code-signing certificates, and what to know before handing this process to CI.
GitHub Foundations #4 Domain 3-1: Collaboration — Issues, Labels, Milestones, and Templates
The first half of the collaboration domain, the most heavily weighted area of the GitHub Foundations exam. Mentions and references in Issues, closing keywords, labels and milestones, issue templates and forms, notification management, and GitHub Flavored Markdown — all from the exam's point of view.
SLI, SLO, SLA — From Metric to Objective to Contract
Sorting out the easily confused trio in working order: choosing good SLIs (the good-events-ratio method), setting SLO numbers realistically, why an SLA must be looser than the SLO, a feel for the nines, and the common mistakes.
vLLM vs Ollama vs SGLang: Choosing an LLM Serving Framework
A working standard for choosing an LLM serving framework when self-hosting: where local execution (Ollama) and production throughput (vLLM, SGLang) diverge, why PagedAttention and continuous batching open a 3〜4x throughput gap, the 2026 shift with TGI entering maintenance mode, differences in quantization and structured-output support, and a selection order by team size.
Wails in Practice #4 Tray Residence and a Global Shortcut — Capture Fast from the Background
Turn the notes app into a background app that stays alive after the window closes. Covers the fact that Wails v2 has no built-in tray and how to work around it, changing window close from quit to hide, implementing a global shortcut to capture a new note from anywhere, and how v3's built-in tray changes this.
GitHub Foundations #3 Domain 2: Working with Repositories — Branches, Tags, Releases, and Gists
GitHub Foundations Domain 2: creating repositories and community files, the default branch, how tags relate to releases, gists, plus the exam staples — the differences between fork, clone, and template repositories, and repository visibility.
LLM API vs Self-Hosting: Doing the Break-Even Math
A working standard for deciding whether to use an LLM API or self-host: the structural difference between per-token and per-GPU-hour billing, how to compute break-even from the tokens one GPU produces in a day, where utilization, batching, and quantization move the crossover, and the factors outside price — data privacy, latency, operational burden — that decide when the math is close.
SRE vs. DevOps — Where They Overlap and Where They Split
What SRE and DevOps each are, where they overlap, and where they diverge: DevOps as culture and philosophy, SRE as its concrete implementation, the tools unique to SRE (SLOs, error budgets, toil caps), how the roles actually split in organizations, and how to read job postings.
Wails in Practice #3 Full-Text Search and Data Flow — FTS5 and Event-Driven Updates
Add fast full-text search to the notes app and settle the data flow. Covers SQLite FTS5 virtual tables and triggers that keep the search index in sync automatically, exposing search as a service in Go, and a design that keeps the truth in one place by refreshing the frontend with Wails events when data changes.
Building Desktop Apps with Wails #8 Debugging — Dev Tools, Logs, Common Errors
Gathers the spots beginners get stuck on most. Covers opening the WebView dev tools during development, reading logs on both the frontend and Go sides, diagnosing a built app with -debug, and the causes and fixes for common errors like a blank screen, binding not found, and a nil context.
GitHub Foundations #2 Domain 1: Git and GitHub Basics — Version Control and Product Structure
The first GitHub Foundations domain: the exam-oriented essentials of Git, the boundary between Git and GitHub, the personal account / Organization / Enterprise structure, and the feature differences between the Free, Team, and Enterprise plans.
Lambda vs Fargate: Choosing Serverless Compute
A working standard for choosing between Lambda and Fargate: the structural difference between per-invocation and per-task billing, the unit-price math that makes Lambda over twice as expensive when running continuously and the utilization threshold that follows, Lambda's hard limits (15 minutes, 10GB, cold starts), the hidden costs where API Gateway and log ingestion outgrow the compute bill, and a selection order driven by workload shape.