Software Engineering
guides.

Software Engineering articles

45 guides

• API 429 vs 503: Build Safer Retry Behavior ↗

  Distinguish rate limiting from temporary service failure and design bounded retries with Retry-After, jitter and idempotency.

• GPU Inference OOM: Budget KV Cache and Concurrency After the Model Has Loaded ↗

  Diagnose LLM inference memory using model weights, KV cache, context length, concurrent sequences, runtime settings, and a workload-based latency and capacity test.

• RAG Prompt Injection: Keep Retrieved Documents From Authorizing Tool Actions ↗

  Design RAG applications with untrusted retrieval content, server-enforced tenant access, scoped tools, action validation, and tests that preserve useful answers.

• Cloudflare and Personalized Pages: Test Two Users Before Making HTML Cacheable ↗

  Review Cloudflare cache rules, origin headers, authentication cookies, cache keys, and two-user tests before caching HTML that can contain personalized information.

• AI Batch Inference: Reconcile Every Request Before Publishing the Results ↗

  Build AI batch processing with stable request identifiers, per-item outcome reconciliation, semantic validation, and selective retries before publication.

• Deleting Documents From RAG: Remove Retrieval Access Across Vectors, Caches, and Re-ingestion ↗

  Design RAG document removal with source identity, chunk inventory, retrieval gates, cache invalidation, and re-ingestion controls backed by verification.

• Accessible dialogs: manage focus through the full lifecycle ↗

  Build modal dialogs with deliberate initial focus, keyboard containment, close behavior and focus restoration, then test the real workflow with assistive technology.

• HTTP conditional writes: prevent silent lost updates ↗

  Protect concurrent edits with strong validators and atomic conditional writes, then give users a safe conflict-resolution path instead of silently overwriting newer work.

• OpenAPI changes: test consumer compatibility before release ↗

  Review API contract changes across requests, responses and error behavior, then exercise real consumer fixtures instead of assuming a valid OpenAPI document is compatible.

• Application uploads: quarantine before publication ↗

  Build an upload lifecycle with size limits, content validation, private quarantine and authorized release so a successful transfer does not mean a file is safe to publish.

• AI tool calls: enforce authorization outside retrieved text ↗

  Design AI-assisted tools with independent authorization, narrow capabilities and adversarial tests so instructions hidden in documents cannot grant system access.

• AI structured output: validate meaning after JSON shape ↗

  Use structured AI responses with explicit schema support, semantic validation and review boundaries so valid JSON cannot silently become an invalid business action.

• Embedding upgrades: migrate the retrieval contract with the index ↗

  Plan an embedding-model migration using versioned corpus and query pipelines, retrieval evaluation and a reversible index switch rather than dimensions alone.

• Shopify theme performance: inspect the real rendering path ↗

  Improve Shopify theme responsiveness by tracing critical images, app scripts and main-thread work, then verify checkout-related behavior and accessible motion.

• Shopify app scopes: compare requested and granted access ↗

  Diagnose Shopify permission failures by separating declared scopes, merchant-granted access, token identity and the supported installation or reauthorization flow.

• Magento queue backlog: verify consumers and business progress ↗

  Investigate Magento asynchronous backlogs through consumer ownership, scheduler behavior and durable task outcomes before adding workers or replaying queued work.

• ASP.NET Data Protection: keep a shared service consistent across nodes ↗

  Diagnose protected-cookie failures across ASP.NET Core instances by reviewing persistent key rings, application isolation and key-at-rest access without exposing secrets.

• EF Core DbContext: stop sharing one unit across parallel work ↗

  Diagnose EF Core parallel-operation errors by tracing DbContext ownership, awaited calls and background scopes while preserving explicit transaction boundaries.

• Spring JPA pagination: avoid collection-join page surprises ↗

  Review Hibernate collection fetching and pagination together so a faster Spring data endpoint preserves parent counts, ordering and bounded database work.

• FastAPI background work: distinguish accepted from durable ↗

  Choose between FastAPI in-process background tasks and durable workers by defining recovery, job identity and completion evidence before returning success.

• SQLAlchemy sessions: isolate concurrent units of work ↗

  Diagnose SQLAlchemy session errors and pool pressure by separating engine reuse from transaction ownership, task-local sessions and reliable cleanup.

• Python releases: rebuild the environment, pin the interpreter ↗

  Diagnose Python deployments that use the wrong environment by tracing interpreter paths, dependency installation and clean release reconstruction before promotion.

• JavaScript schedules: define daylight-saving behavior explicitly ↗

  Design recurring schedules around named time zones, missing or repeated local times and occurrence identity so daylight-saving changes do not create silent surprises.

• TypeScript and Node.js modules: align compile and runtime resolution ↗

  Diagnose imports that type-check but fail in Node.js by comparing package type, emitted extensions, module resolution and the actual production launch command.

• Next.js remote images: diagnose the optimizer boundary ↗

  Investigate Next.js image failures through remote-pattern matching, source authentication and optimizer responses while keeping external image access narrowly scoped.

• Next.js standalone releases: diagnose missing CSS and assets ↗

  Package a complete Next.js standalone release by tracing server output, static assets and release identity, then test real pages before switching production traffic.

• Laravel N+1 queries: measure relationship loading per page ↗

  Find Laravel N+1 queries by tracing relationship access, serializer behavior and query growth, then verify eager loading without fetching an unbounded object graph.

• Shopify bulk exports: completion is not import acceptance ↗

  Operate Shopify GraphQL bulk exports with explicit operation states, streamed JSONL parsing, parent reconciliation and safe handling of incomplete results.

• Magento stale catalog: inspect indexers before flushing caches ↗

  Trace Magento catalog freshness through saved data, scheduled indexers and storefront delivery, using targeted recovery rather than repeated global cache flushes.

• ASP.NET Core output caching: review the audience first ↗

  Review ASP.NET Core output-cache policies for public and authenticated endpoints, diagnose incorrect variants and verify isolation before optimizing cache hits.

• Spring transactions: diagnose self-invocation before changing isolation ↗

  Trace Spring transactional entry points and proxy boundaries when rollback tests fail, then verify the actual database result through the production call path.

• Python TaskGroup cancellation and reliable cleanup ↗

  Make Python asynchronous fan-out predictable with TaskGroup lifecycle ownership, cancellation propagation, resource cleanup and tests for partial failure.

• React Effect cleanup: prevent stale results and subscriptions ↗

  Diagnose stale React search results and duplicate subscriptions by tracing Effect lifecycles, cleanup, request identity and development Strict Mode behavior.

• TypeScript project references: why clean CI builds fail ↗

  Trace missing declarations and stale outputs in TypeScript project references, then establish a reproducible dependency build without relying on editor caches.

• Next.js cache revalidation with a clear privacy boundary ↗

  Separate public publishing from private data in Next.js, diagnose stale content across cache layers and verify authorized revalidation after a successful write.

• Node.js exports: backpressure before bigger memory limits ↗

  Build a bounded Node.js export path by tracing stream buffers, slow consumers, cancellation and completion evidence before increasing process memory limits.

• Generative AI Evaluation: Define the Business Acceptance Set ↗

  Build a generative AI evaluation set around real tasks, failure cases and human review. Track quality, safety and operational behavior before changing prompts or models.

• SaaS Billing Webhooks: Reconcile Entitlements Deliberately ↗

  Design SaaS billing webhook processing with signature checks, duplicate handling and entitlement reconciliation. Test delivery delays and operator recovery paths.

• Node.js Shutdown: Account for Requests and Background Work ↗

  Design Node.js shutdown behavior around active requests, background jobs and a bounded drain period. Verify restarts through the real deployment path.

• Application Testing: Choose Business Journeys That Matter ↗

  Choose end-to-end tests around critical business journeys, isolated test data and meaningful assertions. Keep a software release check understandable and repeatable.

• Spring Boot Actuator: Design a Safe Health Contract ↗

  Plan Spring Boot Actuator health endpoints around monitoring, access control and useful failure signals. Review exposed details before deploying Java services.

• FastAPI Request Design: Review Blocking Dependencies ↗

  Review FastAPI dependency behavior before choosing async endpoints. Measure slow I/O, define timeouts and keep expensive background work outside request paths.

• Shopify Webhooks: Build a Reliable Processing Workflow ↗

  Verify Shopify webhook deliveries, handle duplicates and reconcile business state. Plan useful operating checks for ecommerce integrations.

• Legacy Application Modernization: Choose the First Slice ↗

  Plan an incremental software modernization with a bounded first workflow, explicit data ownership and a reversible cutover.

• Node.js API Performance: Find CPU Work in the Request Path ↗

  Investigate slow Node.js requests by separating CPU work, I/O and dependency latency. Build a measured plan for background processing.