All posts
Box vs Rc vs Arc: Rust Smart Pointers and When to Use Which
Collecting the IOU the basics course left to The Book. The three situations that need Box (recursive types, dyn traits, moving large values), Rc and reference counting for multiple owners, Arc for crossing threads, RefCell and interior mutability with runtime borrow checking, and the working idioms Rc<RefCell<T>> and Arc<Mutex<T>> — with the selection criteria as a decision sequence.
Entra ID Automation #2 The User Lifecycle: Creation, Disabling, and Lifecycle Workflows
Handling joiners, movers, and leavers in code: why attribute standardization matters when creating users through the Graph API, delivering initial credentials with a Temporary Access Pass, why offboarding starts with disabling rather than deletion and how the 30-day soft delete works, why group-based licensing beats per-user assignment, and the product features that package the whole flow — Entra lifecycle workflows and HR-driven provisioning.
pgvector in Practice: What to Know When Running Vector Search on PostgreSQL
A practical guide to running embedding search on PostgreSQL without a separate vector database. The vector type and distance operators, why HNSW is the default index and how it compares to IVFFlat, the underfetching problem when combined with filters and iterative index scans (0.8.0), halfvec for half the size and 4,000 dimensions, and the criteria for when a dedicated vector database actually becomes necessary.
Terraform in Practice #3 EC2 and Security Groups: SG Chaining Design and Booting with user_data
Instead of writing CIDR blocks, we connect security groups by security group reference — a chaining design across an ALB and EC2 two-tier layout. We then look up the latest AL2023 AMI with a data source and launch an EC2 instance into a private subnet that boots a web server via user_data. Also covered: why no SSH port is opened, and the plan to complete access with Session Manager.
Entra ID Automation #1 The Big Picture: Tenants, Directory Objects, and the JML Lifecycle
First post in a series on automating Microsoft Entra ID administration with code: where Entra ID (renamed from Azure AD) sits, the structure of a tenant and its directory objects — users, groups, apps, devices — the joiner-mover-leaver (JML) model that forms the backbone of account automation, the tooling landscape across Graph API, PowerShell, and IaC, and how features map to the Free, P1, P2, and Governance license tiers.
PostgreSQL vs MySQL: Which One for a New Project in 2026
Sorting out the choice between the two open-source RDBMSs. The conclusion: new projects default to PostgreSQL unless there is a specific reason not to, while teams already standing on the MySQL ecosystem usually have no reason to switch. Covers the timing of MySQL 8.0 end of support (April 2026) and the 8.4 LTS transition, the difference in feature breadth (JSONB, window functions, extensions), MVCC implementation differences, replication-ecosystem maturity, and the cases where either choice is fine.
Rust vs Go: How to Choose for Servers, CLIs, and Systems Programming
Both are statically typed, compiled languages producing single binaries — yet their design philosophies are close to opposites. Memory management (GC vs ownership), concurrency (built-in goroutines vs the async ecosystem), learning curve and team onboarding, latency characteristics, and which side wins for web APIs, CLI tools, infrastructure software, and embedded — the decision criteria, organized.
Terraform in Practice #2 VPC Network as Code: Subnets Across Two AZs, Routing, and the NAT Gateway
We build the VPC that the myapp infrastructure stands on. Public and private subnets go across two AZs with for_each, an internet gateway and route tables define the traffic paths, and a NAT gateway carries private outbound traffic with the cost trade-off made explicit. We wrap up by organizing the network outputs so the compute layer in the next part has everything it needs.
PostgreSQL in Practice #9 Backups, PITR, Upgrades: The Art of Rewinding to Just Before the Incident
The practice series closes with the last layer that protects data. Physical backups (pg_basebackup) combined with WAL archiving to get past pg_dump's limits, how PITR (Point-In-Time Recovery) rewinds to a chosen moment and setting the recovery target, the role split of "a delete accident cannot be undone by failover" between replication and backups, the three roads of a major version upgrade (pg_dump, pg_upgrade, logical replication), and a retrospective of the whole track.
Rust Borrow Checker Errors, Solved: value moved, cannot borrow, does not live long enough
The borrow checker errors Rust beginners meet most often, organized by error code: E0382 (use after move), E0502 (immutable/mutable borrow conflict), E0499 (two mutable borrows), E0506 (assigning to a borrowed value), E0597 (does not live long enough), and E0596 (closure capture) — each with its cause and standard fixes, in diagnose → cause → solution order.
Terraform in Practice #1 Project Design and Bootstrap: The Big Picture, Backend, and Common Tags
Before writing a single resource, we draw the full architecture of the web service infrastructure this ten-part series builds as code, and set down where lab costs arise and the principles for managing them. We bootstrap the state bucket and S3 backend, pin the provider version, and wire up default_tags so every resource gets common tags automatically — the groundwork that puts the practice series on its starting line.
PostgreSQL in Practice #8 Replication and High Availability: Streaming Replication, Read Scaling, Failover
Replication, the standard means of getting past a single server's limits. How streaming (physical) replication ships WAL as-is, replication lag under the asynchronous default and the read-your-writes problem, the trade-offs of synchronous replication, cautions when spreading read load to standbys, what automated failover actually requires (Patroni and friends) and split-brain, where logical replication fits with its per-table selection, and how it all maps onto managed services.