SDE 2 Backend and AI

Apply the Strategy pattern to make an algorithm interchangeable.

Apply the Factory pattern to separate object creation from object use.

Apply the Observer pattern to distribute event notifications.

Apply the State pattern to model behavior that varies by lifecycle state.

Apply the Decorator pattern to add behavior without changing a core class.

Apply the Adapter pattern to integrate an incompatible interface.

Apply the Command pattern to represent an operation as an object.

Choose between a simple object-oriented design and a named pattern, and justify the choice from the requirements.

Implement a typed Python domain model using classes, dataclasses, enums, and abstract interfaces.

Inject dependencies so that collaborators can be replaced without modifying domain logic.

Represent validation failures and domain errors with a consistent exception strategy.

Write focused unit tests for object behavior using fakes or mocks.

Identify a race condition in code that mutates shared state.

Protect a critical section using an appropriate Python synchronization mechanism.

Refactor an existing design to accommodate a new requirement while limiting changes to existing classes.

Design a parking-lot system with extensible vehicle, spot, ticket, and pricing rules.

Design a vending machine by modeling inventory, payments, and state transitions.

Design a multi-channel notification component with replaceable delivery providers.

Design an extensible logging framework with levels, formatters, and output destinations.

Design an in-memory LRU cache with constant-time get and put operations.

Design a ticket-booking component that prevents concurrent double booking.

Deliver a time-boxed, end-to-end LLD answer and critique it using an interview scoring rubric.

Convert an ambiguous HLD prompt into prioritized functional and non-functional requirements.

Estimate traffic, storage, bandwidth, and peak load from stated assumptions.

Define service APIs that support the system's principal user flows.

Create a logical data model from access patterns and consistency needs.

Draw a high-level architecture showing services, data stores, and communication paths.

Trace a critical request path through a proposed architecture.

Identify the first scaling bottleneck or single point of failure in an architecture.

Explain an architecture decision by comparing alternatives and trade-offs.

Choose between relational and non-relational storage for a specified workload.

Design an index for a query pattern and explain its write and storage costs.

Select a replication topology for a stated availability and read-scaling requirement.

Choose a partition key that limits hotspots and supports required queries.

Select an appropriate consistency level for a user-visible operation.

Choose message delivery and ordering guarantees for an asynchronous workflow.

Make a retried operation safe by designing an idempotency mechanism.

Choose between a local transaction and a cross-service saga for a business workflow.

Select a load-balancing strategy for a specified traffic pattern.

Design a stateless service tier that can scale horizontally.

Design a cache policy that addresses expiration, invalidation, and stale reads.

Design a token-bucket rate limiter for a public API.

Control backpressure when producers outpace asynchronous consumers.

Prevent a dependency failure from cascading by applying timeouts and circuit breakers.

Define a service-level objective and the signals needed to monitor it.

Threat-model a public API and select appropriate authentication, authorization, and data-protection controls.

Design a URL-shortening service for a stated traffic scale.

Design a real-time chat service with online delivery and offline message recovery.

Design a news-feed system that compares fan-out-on-write with fan-out-on-read.

Design a file-storage and sharing service for large objects.

Design an order and payment workflow that handles retries and partial failures.

Design a large-scale multi-channel notification platform.

Deliver and self-evaluate a time-boxed HLD answer using a requirements, data, scale, reliability, and trade-off rubric.

Trace the request lifecycle of a backend feature that calls a hosted language model.

Implement an asynchronous model API call with timeout, retry, and rate-limit handling.

Constrain a language model response to a validated structured schema.

Explain how embeddings support semantic retrieval and identify their principal limitations.

Choose a vector-search approach based on scale, filtering, latency, and operational constraints.

Design a retrieval-augmented generation pipeline for a document question-answering feature.

Define checks for AI output quality, safety, latency, and cost.

Design an LLM gateway endpoint that uses PII masking, prompt caching, and fallback providers.