Software Engineering, System Architecture & Code Debugging

Bring a hand-managed production database under version-controlled migration tooling

Reduce allocation churn causing frequent collection pauses during an interactive flow

Convert a slow synchronous write endpoint into a polled long-running operation with a status resource

Triage static-analysis findings on a pull request so reviewers spend time on real risk

Design a resumable data backfill that does not block schema deployment

Restructure a module without changing observable behaviour, protected by characterisation tests

Convert raw incident timeline data into a blameless write-up with contributing causes and prioritised follow-ups

Verify that personalised or authenticated responses cannot be stored or served to the wrong user

Specify a layered caching strategy with freshness, revalidation and invalidation rules per resource class

Cut wall-clock time and flake rate of a CI test suite without reducing coverage

Classify smells in a module and order the refactorings so each step keeps behaviour intact

Restructure a container build so layers cache well and the runtime image stays minimal

Audit container images for privilege, base-image provenance and dependency freshness

Design a multi-service business transaction using local transactions plus compensations

Replace broad shared-state reads between infrastructure stacks with least-privilege published values

Encode a project's own insecure coding patterns as automated static-analysis rules with tests

Trace a browser memory leak in a single-page application to the JavaScript reference retaining removed DOM nodes

Write end-to-end scenarios that assert user-visible outcomes with resilient locators

Split a capability out of a shared-database module into an independently deployed service

Expand a feature request into an implementation architecture spanning services, data, and failure handling

Turn real-user performance percentiles into a prioritised optimisation backlog

Design fixture scopes and teardown so tests stay isolated without redundant setup cost

Tune freshness lifetimes and validators to reduce repeat-visit network work without serving stale content

Separate under-provisioned heap from a genuine retention leak in a service that dies with out-of-memory errors

Plan a seam-by-seam replacement of a legacy subsystem while it keeps serving traffic

Check that error responses do not leak resource existence, internals or sensitive values

Improve a multi-join query by correcting cardinality estimates and enabling a better join strategy

Produce an ordered kubectl investigation runbook for a failing or crash-looping workload

Define a structured error payload whose codes clients can branch on safely across versions

Consolidate an unwieldy migration history without breaking partially upgraded environments

Review a change across design, functionality, complexity, tests, naming and documentation while separating blockers from nits

Define a forward-compatible list-endpoint contract with continuation tokens and query options

Consolidate duplicated deployment pipelines into one reusable, parameterised workflow with approval gates

Derive a parametrised test matrix with readable case identifiers from a written specification

Integrate automated code scanning into the pipeline with schedules, gating and alert ownership

Measure the runtime cost of migration-affected queries before the change reaches production

Review a module for readability, performance, security, concurrency and scalability before it ships

Turn a production bug report into ranked root-cause hypotheses with a staged investigation plan

Assess a proposed architecture for single points of failure, elasticity and change-safety before build starts

Encode the repository's testing conventions so agent-generated tests are mergeable without rework

Encode a codebase's architectural rules as scoped, machine-consumable instructions for coding agents

Choose and specify how a client learns the outcome of a workflow that completes after the request returns

Define a scoped automated reviewer persona that produces consistent first-pass review comments

Explain what unfamiliar inherited code does and where it is dangerous to change

Audit an application against recognised web risk categories and produce prioritised, evidence-based findings

Sequence a schema change and its code deployment so neither breaks the other

Diagnose a slow query by reading its execution plan and separating estimation errors from access-path problems

Review the tests inside a pull request for flakiness risk, locator fragility and assertion strength

Choose pipeline triggers and path filters so the right jobs run on the right events without waste

Establish a versioning policy that separates breaking releases from additive ones and defines client upgrade mechanics