Evidence and scope

The 5+ versus 7+ experience discrepancy is material. The CV says 6+ and lists June 2019 to present, which is over seven calendar years by October 2026, but the stated figure and dates differ. Reconcile the actual full-time dates and the summary wording before an interview; do not improvise. Likewise, distinguish an underwriting agent built and evaluated from one fully integrated into production: the CV says integration into the core platform is in progress.

Company and role brief

Gradion is a technology consulting and embedded engineering business serving clients in commerce, travel, fintech and other domains. Its public descriptions emphasize product delivery and recovery, full-stack work across several languages, and AI tied to measurable cost or revenue outcomes. The Shopware case study reports a 21-person embedded team and AI Co-pilot features; the HomeToGo case study reports a long-lived engineering partnership and many external integrations. These are public case-study claims, not a map of the team Tony would join. A strong interview answer moves from client problem to constraints, decision, evidence, rollout and measured result. Company sources.

Likely rounds, inferred rather than confirmed: recruiter and role fit; technical coding/debugging; system design; production/AI deep dive; stakeholder and peer discussion. Ask the recruiter for actual format, time, primary language, and whether a live codebase is used. The supplied JD does not require PHP, C/C++, AWS, Go, React or a specific LLM vendor. Use Go and TypeScript/React as Tony’s evidence-bearing languages while being ready to reason in an unfamiliar stack.

Requirement to preparation map

Quick diagnostic

Without notes, take 25 minutes to: (1) explain how a browser request reaches a Go or Node handler and a PostgreSQL row; (2) show how two concurrent requests can both issue the same order; (3) identify a slow endpoint using traces, pool metrics and an execution plan; (4) describe an AI golden set with false-approval costs; (5) narrate one user feedback loop and one technical disagreement. Score each from 0 absent, 1 fragmentary, 2 workable with gaps, 3 correct with trade-offs, 4 robust under follow-up. Any score under 3 becomes the first study block.

From click to result

A browser resolves a name, establishes a transport connection and TLS when applicable, sends an HTTP request, and may reuse the connection. A proxy routes it; the process parses headers and body, authenticates, authorizes, validates, calls domain code, obtains a database connection, runs a transaction or query, and serializes the response. Every queue and remote hop adds latency; network waits, lock waits and connection-pool waits do not necessarily consume CPU. Follow one trace across boundaries before blaming the framework. At the bottom, the runtime schedules work onto OS threads; syscalls cross into the kernel; cache locality, allocation and synchronization shape cost. HTTP overview; Node event loop; Go diagnostics.

Mental model: throughput is completed requests per second, latency is elapsed time for one request, and concurrency is work in flight. Little’s Law, L = lambda W, lets a team estimate average in-flight work from stable arrival rate and mean response time. At 200 requests/s and 0.5 s mean, about 100 requests are in flight. Averages hide tails: compare p50, p95 and p99 under load, and specify where they are measured. A faster CPU will not repair an exhausted connection pool or a slow external dependency.

Data structures: array/slice indexing is O(1) and tends to favor locality; linked traversal is O(n) and pointer-heavy; a hash table gives expected O(1) lookup with hashing and resizing costs; a balanced tree supports ordered O(log n) operations. Choose on access pattern, size, contention and measured memory, not notation alone. A DB B-tree has different storage and I/O behavior from an in-process tree. Practice bounded queues and two-pointer scans before esoteric puzzles.

Debug from evidence

Draw a latency budget across DNS/TLS, gateway, service CPU, pool wait, SQL, downstream calls and response. Use request ID/trace ID, dependency timings, error ratio, queue depth and saturation. Distinguish wall-clock profiles from CPU profiles: a CPU profile can be quiet when goroutines or callbacks are waiting on a pool. Reproduce with a controlled workload, state a hypothesis, change one variable, and compare a before/after distribution. The post-fix test must include the failure boundary that originally broke. OpenTelemetry signals; Go profiling.

Go depth

Go values have concrete representation and ownership conventions. Slices are descriptors over backing arrays: appending may allocate, while subslices can retain a large array. Maps are reference-like but not safe for unsynchronized concurrent writes. Goroutines are cheap relative to OS threads, never free; bound them by queue capacity, semaphores and cancellation. A channel coordinates data flow; a mutex protects shared state; neither should be chosen by slogan. Data-race freedom gives stronger reasoning about visibility under the Go memory model. Use go test -race on representative concurrent tests, then CPU/heap/block/mutex profiles as the symptom dictates. Pass context.Context down request lifetimes and honor deadlines; do not store request contexts for detached work. Race detector; Diagnostics.

TypeScript and Node depth

TypeScript checks source types; JSON and external inputs still require runtime validation. Node runs JavaScript callbacks on the event loop while I/O and some work are delegated; a long synchronous parse, regex or crypto operation can starve other requests. async creates a Promise-based flow, not a new CPU thread. Set bounded concurrency, cancellation and explicit error propagation for remote calls. A rejected Promise without correct handling can strand a request or create a process-level error depending on runtime and configuration. Know the deployed Node version; do not rely on one microtask/timer example as a universal event-loop explanation. Node guidance.

Choosing the tool

For a small product team, TypeScript end to end can reduce context switching; Go can suit a compact service with high concurrency and simple deployment; Java may suit an established transactional ecosystem; Python can accelerate data-adjacent work. Decide from workload, team expertise, ecosystem, operability and migration cost. Prove a bottleneck with a representative load test before a language rewrite. Gradion’s full-stack page names several languages and explicitly ties choice to the problem. That is a company position, not evidence that every client uses each language.

Transactions, invariants and indexes

Start with the business invariant, such as one accepted quote producing at most one active policy per insurer reference. Enforce the narrowest durable invariant with a unique constraint and a transaction; use a request idempotency key for replayed commands. PostgreSQL Read Committed uses a fresh snapshot per statement, so a check-then-insert can race. A unique constraint may suffice; more complex cross-row invariants may need a lock, careful update predicate, or Serializable plus whole-transaction retry. Retry serialization failures only when side effects are outside the transaction or safely idempotent. Transaction isolation.

Index columns matching filtering, joins and ordering, then inspect EXPLAIN (ANALYZE, BUFFERS) on realistic data. A composite index on (tenant_id, status, created_at DESC) can serve tenant/status filtering and recency, subject to query shape and selectivity. Indexes consume storage and slow writes. A sequential scan may be correct for a small table or broad filter. Pool size must reflect actual DB capacity across replicas and workers: 20 connections times 30 pods is 600 potential sessions, not 20. Pool wait, active/idle connections, DB CPU and lock waits tell different stories. Using EXPLAIN; Examining index usage.

Boundaries and delivery

Keep a modular monolith if a small team benefits from one transaction and deployment. Split when domain ownership, independent scaling or deployment pressure justifies the new failure modes. A synchronous API gives an immediate contract but couples latency and availability; a queue decouples work but creates backlog, ordering and duplicate-delivery concerns. The outbox stores business state and an event in the same database transaction; a publisher then delivers at least once, and consumers deduplicate by event or operation ID. An outbox is not atomic delivery to a broker. Cache only with a defined freshness contract and invalidation path. For tenant data, put tenant scope into authorization and query predicates; test cross-tenant access and avoid trusting a client-supplied tenant ID. AWS retry guidance.

Reliability and release discipline

Define an SLI from a user journey, not simply container health: e.g. eligible quote-to-policy completion without duplicate issuance within an agreed time. Set an SLO with a window and exclusions; the error budget makes release-versus-reliability choices explicit. Instrument traces, metrics and structured logs with stable identifiers but avoid recording sensitive policy data. During an incident, mitigate first, communicate impact and uncertainty, preserve evidence, then find the causal chain and write a durable action. A deployment should have small increments, feature flags or canaries, schema compatibility, and a rollback route. Google SRE error budgets; OpenTelemetry signals.

Review, tests and debt

Test pure domain invariants quickly, then exercise transaction boundaries and external contracts, plus a few end-to-end user journeys. A mock of a repository returning the expected row cannot prove that concurrent SQL writes are safe. Review risky assumptions, data flow, permissions, retries and migrations before style. For technical debt, name the user/business cost, collect a baseline, choose a small measurable slice and set a stop rule. For an unfamiliar codebase, trace one vertical user journey, run tests, inspect production signals and make a reversible change before proposing a rewrite.

The decision ladder

Begin with deterministic rules or search when the problem is well specified. Use an LLM when unstructured input or language variation creates real value. RAG retrieves authorized, versioned source chunks, then generates an answer with citations and abstention when evidence is missing. An agent adds tool selection and iteration; use a bounded workflow for known steps. Keep system instructions separate from retrieved text; treat documents and tool output as untrusted. Check tool arguments and resource authorization in code, not in a prompt. Gate consequential writes with a human or a narrow deterministic policy. Anthropic tool use; prompt injection guidance.

Evaluate from the failure cost

For underwriting, define cases by product, rule version, language, document quality, ambiguous exclusions and adversarial content. Freeze a golden set with expert adjudication and separate a held-out set. Measure retrieval recall and citation support separately from final decision correctness; report false approvals, false denials, abstention, latency, cost and escalation rate by slice. Use code grading for exact constraints, expert review for consequential judgments, and calibrated model grading only where reliable. Re-run after prompt, model, retrieval or policy changes; monitor drift and feedback in production. State the business cost of a false approval versus a manual review. Anthropic evaluation guidance; Anthropic agent evals.

Workflow and protocol boundaries

Temporal Workflow code must replay deterministically; LLM calls belong in retryable Activities, with idempotent external effects. LangGraph checkpoints agent state and supports human interrupts; choose it for agent orchestration when that state model helps, not as a replacement for all business transactions. MCP exposes tools/resources through a protocol; it does not make a tool authorized. Scope credentials and enforce per-tool, per-tenant policy server-side. The MCP specification changed in July 2026; confirm the deployed protocol and SDK version before naming transport details. Temporal workflow definition; LangGraph JavaScript; MCP 2026 release.

Computing and debugging Q01 to Q08

Go and TypeScript Q09 to Q18

Data and distributed systems Q19 to Q30

Frontend Q31 to Q38

Production Q39 to Q46

AI Q47 to Q56

Architecture and business Q57 to Q68

Prompts

Worked solutions

D01 Multi-tenant quote to policy platform

Actors and problem. Agents and brokers submit quotes across insurers; an end client accepts one; carrier integrations return decisions asynchronously. Support staff need a traceable lifecycle. Clarify insurer-specific rules, who can bind a policy, whether payment is required, whether one quote may be amended, and legal audit/retention with the client. Invariant: one acceptance command produces at most one active policy for a tenant/insurer reference, and unauthorized actors cannot see another tenant’s data.

Workload assumption. 200 tenants, 100,000 quote requests/day, a 20x peak over the daily mean, average payload 25 KB, and a 2 s user-visible quote response target for a synchronous carrier. That is roughly 1.16 requests/s average and 23/s peak before insurer fan-out. If each request fans out to three carriers, downstream peak is about 69 calls/s. Validate actual burst shape and carrier rate limits before sizing. At 2 s latency, about 46 peak quote requests could be in flight; pools, memory and in-flight carrier calls need more headroom than the daily average suggests.

API and model. POST /quotes uses a client-generated idempotency key; GET /quotes/{id} reports draft|submitted|quoted|declined|expired; POST /quotes/{id}/accept is a separately idempotent command; GET /policies/{id} exposes only authorized data. Model tenant, party, quote, quote_version, carrier_offer, acceptance, policy, idempotency_record and outbox_event. Use immutable quote/version identifiers so a late carrier response does not overwrite a newer request. A unique index enforces the policy invariant. Store price with currency and exact decimal representation; never use floating-point equality for money.

Flow. Authenticate actor, derive tenant, validate product/version, atomically record quote and command, then dispatch carrier calls with per-carrier deadlines and bounded concurrency. Return current state and a URL for progress if an insurer cannot answer within the interactive budget. Accept uses a transaction that checks version/state and writes acceptance, policy and outbox event under unique constraints. A publisher sends downstream events at least once; consumers dedupe. If an insurer’s bind API is an external side effect, coordinate with a durable workflow and insurer idempotency identifier, then reconcile ambiguous timeouts before marking the policy active. A browser can display pending state without promising issuance prematurely.

Reliability and security. Tenant scope applies in DB predicates, cache keys, logs and search. Authorize party/channel relationships at request and resource level. Timeouts and jittered retries honor carrier contracts; circuit-breaking or rate limiting isolates a sick carrier. Audit actor, rule version and decision reason while redacting sensitive documents. Instrument quote start-to-decision p95, bind success/duplicate prevention, carrier errors, pool wait, outbox age and tenant-isolation test failures. Use an SLO on the user journey and alert on error-budget burn, not only pod health.

Rollout and trade-off. Begin with a modular monolith and one transaction if one team owns the workflow; extract integration workers when carrier isolation or independent scaling merits it. Add schema fields compatibly, shadow old/new pricing for a subset, compare outcomes, then shift traffic per tenant or product. A queue improves resilience but adds lag and ordering complexity. At 10x volume, partition work by carrier/tenant and recheck DB locks, quotas and operational ownership. Interview follow-up: explain the failed response after commit and why the idempotency result must survive it. PostgreSQL isolation; AWS retry guidance.

D02 Underwriting AI assistant with human review

Actors and value. An underwriter needs policy-grounded evidence from changing product guidelines; a reviewer makes the final consequential decision. First establish the manual baseline: time per case, error and rework, document versioning, and how false approvals/denials affect customers. Test a narrow product and decision type. The assistant must never use a document from another tenant or invent a coverage rule. The CV reports an agent and eval harness but does not establish final production autonomy.

Workload assumption. A pilot has 500 cases/day with a 5x daytime peak, documents averaging ten pages, 100-case initial golden set and a manual review path. The average arrival rate is low; model latency, document parsing and review capacity dominate. Assume a 30 s assistant target and define which steps are asynchronous. Cost is model tokens plus embedding/index, storage, support and reviewer time per accepted case, not merely API calls.

Architecture. Ingestion validates file type and tenant, virus checks where appropriate, extracts page spans and metadata, versions the policy corpus, chunks by section, and indexes authorized text. Retrieval filters tenant/product/version before semantic ranking; it returns source references. A bounded orchestrator asks for missing facts and invokes read-only policy tools through server-side authorization. It produces structured proposed outcome, evidence spans, uncertainty and unresolved questions. A deterministic policy gate checks mandatory fields and routes uncertain/critical cases to human review. Store prompt/model/retrieval/tool versions, trace IDs and redacted artifacts for audit with appropriate retention.

Evaluation. Split retrieval quality from synthesis and action quality. Track coverage of authoritative passages, citation correctness, false approvals, false denials, abstention, tool permission violations, p95 latency, cost and human override by product/version. Test conflict between old and new guidelines, OCR errors and injected instructions. Use expert labels and held-out examples; compare to keyword search and a rules baseline. A green aggregate score is insufficient if a critical slice fails. Run offline eval, shadow mode, limited human-reviewed pilot and only then consider any bounded automation. The human keeps the final decision until evidence warrants a change.

Failure and rollout. If a new guideline is published, atomically mark its version and invalidate or re-index stale chunks; reject mixed-version evidence. If a tool times out, return an incomplete result and escalate. Treat retrieved text as data, block tool writes, and test adversarial PDF content. A model/version change triggers an eval run and canary. If the measured saving after reviewer corrections is negative, stop or narrow the feature. At 10x volume, batch ingestion, apply admission control to model calls and monitor queue age, while preserving tenant isolation. Anthropic evals; prompt injection; Temporal workflows.

D03 Commerce integration platform for a client

Provenance. Gradion’s public Shopware case reports an embedded AI product team and merchant features; its HomeToGo case reports 100+ third-party supply integrations. The design below is an authored hypothetical that combines the engineering concerns of multi-merchant commerce integrations. It is not a documented Shopware or HomeToGo architecture.

Actors and invariant. Merchants connect catalog/order systems, shoppers see current prices, and operators diagnose failures. Ask which platform owns inventory, how quickly price must refresh, how duplicate webhooks are identified, and how partial supplier outages affect checkout. Invariant: an order must not be charged twice, and a merchant must never see another merchant’s catalog or credentials.

Workload assumption. 1,000 merchants, 10,000 catalog updates/minute at peak (about 167/s), 100,000 shopper reads/minute (about 1,667/s), average update 2 KB. Change propagation within 60 s for most updates is a proposed target; checkout needs a stronger source-of-truth confirmation. Cardinality by merchant and supplier is skewed, so test hot merchants separately.

Model and flows. Use adapter interfaces with versioned canonical product/order schemas; keep raw source payload separately for forensic replay with retention limits. Webhook ingress authenticates/signature-checks the sender, records an idempotency key and event, then acknowledges quickly. A bounded queue drives validation, normalization, enrichment and upsert. Partition by merchant and item where order matters; dead-letter poison messages with a retry/replay tool. Read APIs serve an indexed materialized view or cache with freshness metadata. Checkout revalidates price/inventory with the authoritative supplier and uses a payment idempotency key; display a clear pending/failure state to the shopper.

Operations and trade-off. Measure ingestion lag, schema reject rate, per-supplier failure, item freshness, duplicate suppression, checkout success and p95 read latency. Limit per-merchant concurrency to prevent noisy neighbors. Deploy a new adapter behind shadow normalization and compare canonical records before promotion; keep a reversible mapping version. A universal connector abstraction can hide real supplier differences, so preserve explicit exceptions and contract tests. At 10x traffic, partition hot merchants, decouple read scaling, and check storage/index write amplification. Gradion integration description; HomeToGo case.

D04 Incident simulation and durable fix

Scenario. On Monday at 10:00 a release and scale-up coincide. Quote p95 moves from an illustrative 250 ms to 3 s, 5xx rises, carrier calls time out and users retry. The team initially suspects the new Go deployment. State what is known, what is suspected and what would falsify each hypothesis.

First 15 minutes. Declare user impact, freeze risky rollout, inspect error-budget burn and compare before/after traffic. Roll back or reduce concurrency if a safe mitigation exists. Trace the request: gateway wait, app CPU, DB pool acquire, SQL execution, lock wait and carrier span. Inspect pod count times pool size, active DB sessions, slow queries, retry volume and outbox age. Communicate a factual update with next checkpoint; keep a timeline. If retries are amplifying the outage, cap them and preserve idempotency. Avoid a DB restart merely because CPU is low.

Causal hypothesis and experiment. Suppose new replicas raise possible DB connections from 120 to 600 while a quote query also becomes slower on a skewed tenant. This is a hypothesis, not the revealed answer. Cap per-pod pool and concurrency, verify DB session/lock behavior, compare EXPLAIN (ANALYZE, BUFFERS) on representative data, and watch user journey p95 and error rate. If pool wait falls but query time remains, improve the specific query/index or restore the earlier plan. One change at a time makes attribution possible.

Aftercare. Add a capacity budget across replicas, alert on pool wait and queue age, integration-test duplicated acceptance, load-test a hot-tenant scenario, and add a staged rollout threshold tied to quote success. Document the actual contributing factors and why detection was late. The answer is strongest when the candidate distinguishes their real incident from this simulation. AWS reliability; PostgreSQL EXPLAIN.

A cautious 60-second introduction

“I’m Tony, a hands-on full-stack engineer who has worked across insurance, fintech and IoT products. My strongest work is at the boundary of domain rules, data integrity and production operations. At CoverGo, I worked on the multi-tenant distribution platform across backend and UI modules, including quote/policy and channel workflows. Earlier, I worked on transaction integrity and service migration at InvestaX and on legacy and real-time systems at Select Technology. I’ve also built an underwriting AI assistant and an evaluation harness; I’m careful to separate the parts already running from integration still in progress. I’m interested in this role because it asks for an individual contributor who can code, diagnose difficult failures, make architecture calls and help teams carry those decisions into production.”

Revise this script to match exact personal contributions and years. If the live 7+ threshold arises, explain the actual dated employment record and correct the CV summary rather than debating the number. Do not describe the AI agent as autonomous production underwriting unless that is true.

Project deep-dive card

For each of S01-S04, prepare one page with: user and business pain; topology and data flow; invariant; volume and scale source; your specific decision and rejected alternative; one failure; security/tenant boundary; instrumentation; release/migration; measured result; what changed from feedback. Draw it from memory in five minutes. If a figure is unknown, label it unknown and describe how you would measure it now.

Mock rubric

For each dimension, 0 = absent/incorrect; 1 = fragmentary; 2 = workable with gaps; 3 = correct with trade-offs; 4 = precise under follow-up. Dimensions: correctness, causal reasoning, implementation/design judgment, and communication. Record a quoted claim or behavior that justifies each score, one focused improvement, and a retest question. These are practice signals, not hiring predictions. To run a live mock later, ask one question, answer it aloud or in text, receive one probe, then see the model answer and score.