Softwareengineering Articles

Queueing theory for backend capacity

Why doubling traffic can quadruple tail latency, how to model each constrained resource as a queue, and how to measure utilisation before you hit the cliff.

14 min read · 8 November 2026

Async practices that reduce meeting load

Seven async practices that replace meetings rather than relocate them, with failure modes, prioritization guidance, and how to measure whether they work.

16 min read · 5 November 2026

Technical debt: defend priorities to stakeholders

A framework that turns technical debt into cost, risk, and timing arguments stakeholders can act on, with scoring, cost-of-delay arithmetic, and capacity rules.

13 min read · 4 November 2026

STRIDE is a checklist, not a threat model

STRIDE is a memory aid, not a threat model. Use attack trees to map paths to an asset and STRIDE to prompt each node, with a CI check that keeps trees current.

15 min read · 1 November 2026

Small language models: the classifier trap

Why compact classifiers fail on rare inputs, and how per-label thresholds, guardrails and score monitoring contain the damage.

15 min read · 31 October 2026

Dependency pinning: the lockfile lie

A lockfile records a resolution, not a guarantee. Learn where determinism breaks, how to enforce lockfiles in CI, and how pinning interacts with SCA.

16 min read · 31 October 2026

Node.js memory leak: find it in 10 min

Classify rising memory before profiling it: compare heapUsed and rss, take two heap snapshots, read retainer paths, and bound every in-memory structure.

14 min read · 29 October 2026

Multi-agent DX: LangGraph vs CrewAI gaps

Where LangGraph and CrewAI leave you on your own when debugging multi-agent systems, the failure modes that recur, and how to instrument for causal traces.

16 min read · 28 October 2026

When velocity is hard to measure: evaluating engineering…

Velocity measures capacity, not output. Build a three-layer evidence portfolio—delivery, stability, outcome—and compute it from data you already have.

14 min read · 25 October 2026

HTTP/3 changes less than the demos imply

HTTP/3 usually terminates at the CDN, so origin behavior barely changes. Here is where QUIC matters, where it does not, and how to measure a rollout.

13 min read · 24 October 2026

Remote premium rates: skills AI can't copy

Four drills for remote engineers: latency budgets, evidence-based diagnosis, decision records and handoff artifacts that outlast the work.

19 min read · 21 October 2026

Docs that survive: the bus factor fix

How to write runbooks and design docs that a new engineer can follow without asking the author: explicit audience, exact commands, expected output, and rollback.

15 min read · 21 October 2026

Property-based testing vs example tests: the bug gap

How example-based and property-based tests differ in what they catch, what each costs to maintain, and how to split work between them in financial code.

18 min read · 20 October 2026

7 IDP shifts for AI feature delivery

Seven platform shifts that let teams version prompts, pin models, run offline evals, attribute token cost, and roll out AI changes gradually.

15 min read · 10 October 2026

Deployment platforms: senior vs new hire

How to build a deployment platform that serves both senior engineers and new hires, with escape hatches, guardrails, and a decision checklist.

17 min read · 7 October 2026

Debugging techniques that outlast any framework

Framework-agnostic debugging methods: narrow hypotheses about state, time, concurrency, boundaries and data shape, with a worked race-condition example.

11 min read · 6 October 2026

Chaos engineering without an SRE team

How to run controlled fault injection in CI without a dedicated SRE team: scoping, kill switches, instrumentation, and failure modes to avoid.

14 min read · 30 September 2026

Settlement vs clearing: backend engineer's guide

Clearing produces obligations; settlement moves money. How to model both ledgers, reconcile them, and avoid the schema mistakes that break finance.

15 min read · 28 September 2026

Portfolio projects hiring managers skip

Portfolio projects often fail screening for legibility, not code quality. Here is how to restructure a repo so a reviewer understands it fast.

19 min read · 25 September 2026

Rust rewrites: where they pay off, where they don't

A practical framework for deciding whether a Rust backend rewrite is worth it, with code, failure modes, and measurement steps.

12 min read · 21 September 2026

Golden paths that don't handcuff

How to build internal scaffolds and CLIs that stay reversible: pinned versions, a compatibility contract, drift detection, and a tested eject path.

12 min read · 21 September 2026

Scope agent permissions per task

Most agent permission models fail because credentials are scoped to the agent, not the task. Here is how to issue short-lived, task-scoped tokens and what to measure.

20 min read · 19 September 2026

Platform engineering ROI: metrics that fund teams

How to connect platform work to business outcomes with flow metrics, honest attribution, and instrumentation you can build in an afternoon.

13 min read · 19 September 2026

Agent access for non-AI engineers

A backend-first guide to exposing internal tools to LLM agents: typed schemas, dry-run defaults, idempotency, budgets, and replayable traces.

16 min read · 17 September 2026

Which agent stack survives 3G?

How edge-deployed and centralised agent stacks behave on high-latency, lossy mobile links, and how to measure reconnection storms before choosing one.

13 min read · 16 September 2026

Agent platform abstractions: a case study

Why agent failures are platform failures: typed tool contracts, durable execution, and structured traces that make runs replayable and retries safe.

11 min read · 16 September 2026

Platform Teams: Agentic World Struggle

Platform teams must adapt identity, tooling, and observability for AI agents that call APIs instead of using dashboards, with concrete patterns and failure modes.

13 min read · 12 September 2026

Portfolio projects that hire remote senior devs

Build a portfolio that proves operational rigor: caching, rate limiting, observability, and load tests that survive a senior remote technical screen.

14 min read · 3 September 2026

Self-service is broken without AI ops

Self-service platforms fail on cognitive load, not RBAC. How to add pre-flight, mid-flight and post-flight guardrails with measurable results.

12 min read · 24 August 2026

AI tools won’t help if everyone writes the same code

AI coding assistants amplify existing team imbalances. Here is how to measure per-author incident rates and rebalance review load without policing.

14 min read · 29 July 2026

Designing AI-Assisted Sales for Developer Tools

How to build an AI-assisted sales pipeline for developer tools: intent routing, code generation, handoff rules, failure modes, and what to instrument.

16 min read · 14 July 2026

Designing Alert Triage That Suppresses Noise Safely

Classify alerts by shape and downstream impact, then suppress with evidence. Includes PromQL, SQL, breaker logic, and a 30-minute first step.

12 min read · 11 July 2026

Agent context: short-term vs long-term memory

Compare Redis-style short-term agent context with Postgres event logs: latency, durability, auditability, cost, and how to measure each.

15 min read · 9 July 2026

7 skills senior engineers need now agents are live

Long-running agents break assumptions built for short-lived processes. Seven skills, how to measure each one, and failure modes to watch for.

15 min read · 5 July 2026

Evaluate agents with Spark vs custom harness

A practical comparison of Spark-based and custom Python agent evaluation harnesses, with failure modes, cost arithmetic, and a decision checklist.

12 min read · 3 July 2026

Meter dev-tool pricing in 2026

Build usage-metered pricing for a dev tool: Stripe metered billing, Redis counters, idempotent usage events, and the edge cases that break first.

11 min read · 2 July 2026

AI agents killed dev tool sales cycles

How agent-driven evaluation changes integration design, onboarding, and pricing for developer tools, with concrete patterns and a 30-minute test.

10 min read · 2 July 2026

Double the price, double the revenue

How to design four-tier pricing for a developer tool: seat limits, usage counters, feature gates, plan enforcement, and how to measure whether it converts.

13 min read · 30 June 2026

When flags become experiments

How to run feature flags and A/B tests on a $5 VPS with no data warehouse, using offline-tolerant self-hosted tooling and SMS replies as conversions.

15 min read · 28 June 2026

Platform teams in 2026: Docs vs. production reality

Platform docs describe happy paths; production exposes the gaps. Covers cluster defaults, IDP design by company size, Helm guardrails, and policy enforcement.

18 min read · 27 June 2026

Store data once, serve everywhere: cheaper

How to serve reads from regional caches instead of replicating your database everywhere, with worked cost math, invalidation code, and failure modes.

12 min read · 25 June 2026

Alerts 2026: AI turns false alarms to silence

Build a webhook service that counts alert firings per fingerprint and demotes noisy alerts, plus how to measure whether it works.

15 min read · 24 June 2026

2026 alert triage: when Opsgenie slept for you

Build a scoring, deduplication and LLM-summary layer over PagerDuty or Opsgenie, plus how to measure whether it actually reduces wake-ups.

16 min read · 20 June 2026

Run APIs in 50 spots: what breaks first

Edge APIs fail at the data layer, not the network. Covers sharding, bounded staleness, cache invalidation, clock drift, and how to measure each.

12 min read · 19 June 2026

Build in public without burning out

A practical framework for controlled transparency: what to publish, what to withhold, how to measure the cost, and when the standard build-in-public advice fails.

11 min read · 16 June 2026

Portfolio that hires: show constraints, not code

A portfolio that proves engineering judgement: latency budgets, load tests, failure-mode notes and honest trade-offs recruiters can verify.

14 min read · 16 June 2026

Rebalance pay when AI fills half your role

Measure AI's share of your codebase, then renegotiate scope, level, and pay with evidence instead of anecdotes or cost-of-living framing.

13 min read · 15 June 2026

Found niche in 2026: SaaS that AI can’t copy

How to find defensible SaaS niches where AI struggles: deterministic rule engines, human-in-the-loop verification, and audit trails that satisfy regulators.

11 min read · 15 June 2026

Pricing SaaS tools by real cost, not seat count

A practical method for pricing usage-based SaaS: instrument cost per request, model support burden, guard free tiers, and replay traffic before publishing.