Implement retry wrapper and interdependent validators

Q: Implement retry wrapper and interdependent validators

This question evaluates a candidate's competence in building robust asynchronous utilities and form validation logic, covering retry/backoff strategies, error classification, per-attempt and overall timeouts, cancellation via AbortSignal, observable retry hooks, cross-field validators, state management, and accessibility considerations in JavaScript/TypeScript web applications. Category: Other / Miscellaneous; domain: web development and systems reliability in JavaScript/TypeScript; it is commonly asked because it probes both conceptual understanding of retry semantics, cancellation and validation constraints and practical implementation skills related to API ergonomics, error propagation, composable validators, and performance trade-offs.

Q: How do I approach Software Engineering Fundamentals interview questions?

Software Engineering Fundamentals questions require understanding of core concepts and practice. PracHub provides solutions with explanations to help you master software engineering fundamentals interviews.

Q: What difficulty level is this interview question?

This is a hard difficulty Software Engineering Fundamentals question, commonly asked during Onsite rounds at Airbnb.

Q: What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Airbnb during technical interviews.

Question

Context

You are implementing reusable utilities that are commonly needed in modern web apps:

a robust retry wrapper for functions that can fail synchronously or asynchronously, and
a small validation framework for interdependent form inputs.

The environment is JavaScript/TypeScript. You may assume access to standard Web APIs (e.g., AbortController), and you should design APIs that are ergonomic for both browser and Node runtimes.

Part A — Retry higher-order function

Implement a higher-order utility wrapWithRetry(fn, options) that wraps a JavaScript/TypeScript function which may throw synchronously or return a rejected Promise.

Requirements:

Retry policies:
1. Retry once.
2. Retry N times.
3. Exponential backoff with configurable base/initial delay, factor, cap, and optional jitter.
Control which failures are retryable:
- Allow specifying retryable error types and/or predicate functions (e.g., network errors, HTTP 5xx).
Timeouts:
- Per-attempt timeout.
- Overall timeout across all attempts.
Cancellation:
- Support cancellation with AbortController / AbortSignal so the entire retrying operation can be aborted.
- If the underlying function supports cancellation via AbortSignal , allow passing a per-attempt signal into the function.
Behavior and ergonomics:
- The wrapper must handle both synchronous throws and asynchronous rejections uniformly.
- Provide hooks to observe retries (e.g., onRetry ).
- Return or throw the final error with meaningful context.
Deliverables:
- Implementation in JS/TS.
- Usage examples.
- Discussion of edge cases: synchronous throw vs. asynchronous rejection, non-idempotent operations, retries outliving the caller, and error propagation.

Part B — Interdependent input validators

Build a small form component with three text inputs and a tiny validation framework.

Requirements:

A per-field validator that checks value length against configurable min/max.
A cross-field validator that errors when any two inputs have identical values.
When any input changes, revalidate other inputs as needed to keep cross-field constraints correct.
Describe and demonstrate:
- State management for values, errors, and touched/dirty state.
- Composing per-field and cross-field validators.
- Event triggers (onChange, onBlur, onSubmit).
- Error display and accessibility (e.g., aria-invalid , aria-describedby ).
- Performance considerations (e.g., avoiding unnecessary revalidations, debouncing costly checks).

Provide a working example (TypeScript + React preferred) and explain your design choices and trade-offs.

Implement retry wrapper and interdependent validators

Quick Overview

Implement retry wrapper and interdependent validators

Context

Part A — Retry higher-order function

Part B — Interdependent input validators

Write your answer