Amazon .NET Developer Interview Questions & Answers

At a high level, this system places lockers across many locations and safely moves each package from assignment to pickup. The main challenge is keeping capacity correct while locker state changes in real time. I would explain three flows: finding and reserving capacity, assigning and delivering a package, and authenticating the customer for pickup. The design uses strongly consistent reservation and pickup records, device heartbeats, and background events. The trade-off is better capacity control at the cost of more coordination.

The goal is to operate package lockers across many locations and make sure each package gets a suitable available space. Customers need nearby lockers, delivery partners need reliable assignments, and the system must know when each locker is free, occupied, or offline. The hard part is keeping capacity correct while many customers, packages, and physical lockers change state. The diagram separates this into location and capacity management, package reservation and assignment, physical locker communication, customer pickup, and background operational work.

1. How should we choose between several nearby lockers with available capacity?
2. How long should a reservation stay active before unused capacity is released?
3. What should happen when a locker temporarily loses network connectivity?

I would start with the customer request. The Customer Mobile App or Amazon Website sends HTTPS requests through the Amazon API Gateway. The gateway provides WAF and DDoS protection before the request reaches the .NET service layer.

Amazon Cognito handles OAuth2 or OIDC authentication. IAM Policies provide RBAC or ABAC authorization. Rate Limiting & Throttling protects the services from excessive requests.

The Locker Location Service manages locations, geofencing, and availability. The Locker Inventory Service tracks door state, temperature, capacity, and heartbeat information.

After a locker is selected, the Reservation Service holds capacity. It also handles reservation expiration, release, and concurrency control so conflicting requests do not consume the same space.

The Package Assignment Service chooses the best locker, checks capacity fit, and creates the reservation. Important locations, lockers, reservations, and pickup records are stored in the Primary DB using Aurora or PostgreSQL. Reservations and pickups use strong consistency because capacity must remain correct.

The Cache keeps locker state and other hot data for faster lookups. The Primary DB remains the durable store for the important reservation and pickup records.

The .NET services send locker commands through HTTPS or MQTT. Locker hardware contains a controller, sensors, connectivity, secure boot, firmware, and a local state buffer.

The lockers send heartbeat and status updates back to the service layer. These updates help the Locker Inventory Service know whether a locker is healthy and available.

Amazon Order Management and Delivery Partner Systems exchange order or status updates with the service layer. The pickup flow then moves from locker selection to assignment and reservation. The customer receives a PIN or QR notification.

At the locker, the Pickup Service verifies the PIN or OTP. It sends the command to open the correct door and completes the pickup. The API Gateway returns the JSON response to the client.

Services publish asynchronous events to the Message Queue and EventBridge. The Notification Service uses email, SMS, or push providers for pickup and expiry alerts. BackgroundService workers handle background work without turning Tasks into a durable queue.

Object Storage keeps audit logs, receipts, and locker firmware. The system also connects to the Payment Service shown in the diagram.

Containerized .NET services run on Kubernetes across multiple availability zones. Health checks support recovery. Metrics, logs, and OpenTelemetry tracing provide observability. Retries use backoff, circuit breakers, and idempotent consumers. The main trade-off is that real-time capacity reduces overbooking, but requires more coordination and operational work.

At a high level, this service turns long URLs into short links and redirects them quickly. The main challenge is keeping generated codes unique while making repeated lookups fast. I would explain three flows: creating a link, redirecting a link, and processing click data in the background. The ASP.NET Core API stores mappings in PostgreSQL and caches hot mappings in Redis. A reliable queue handles background events. The trade-off is using more cache memory to reduce database reads.

The goal is to turn a long web address into a short link and later send people back to the original address. The hard part is making each short code safe to use while keeping redirects fast. The diagram solves this with three paths. One creates links. One resolves links through Redis or PostgreSQL. One sends events to background workers so analytics and cleanup do not slow normal requests.

1. Should short links expire, or should they normally stay available?
2. Is authentication required for all users, or only for protected operations?
3. How important are click statistics compared with redirect speed?

I would start with the client request path. Web browsers, mobile apps, and other clients send HTTPS requests to the Edge / API Gateway. It handles TLS termination, rate limiting, IP filtering, optional API key or OAuth authentication, and input validation.

Valid traffic reaches TinyLink.API, an ASP.NET Core service. Kestrel serves HTTP requests. Managed ThreadPool threads run application work, while Task-based asynchronous I/O avoids holding a worker thread during Redis or PostgreSQL waits. The API runs as container replicas behind a load balancer. Singleton state, such as IMemoryCache, belongs to one application process and is not shared across replicas.

For the create path, the client sends POST /shorten. The Shorten Link Controller passes the request to the Link Service. Validation and Business Rules check the input before a candidate code is generated.

The service checks whether the code already exists. PostgreSQL stores the short_links table and enforces a UNIQUE constraint on code. If a collision appears, the service generates another code and retries with backoff or radix increment. After PostgreSQL saves the mapping, the caching abstraction updates Redis. The API then returns the short link.

For the read path, the client sends GET /{code}. The Redirect Controller asks the Link Service to resolve the code. Redis is checked first because it stores hot code-to-link mappings.

On a cache hit, the original URL is available immediately. On a cache miss, the Data Access Repository reads PostgreSQL and the result can be cached. The API returns a 301 or 302 redirect to the original URL. Redis uses TTL and eviction to remove entries when needed.

The API can enqueue Link Created and Click Events into the reliable Message Queue. BackgroundService consumers process them outside the main request path.

The Click Event Consumer handles click information. Other workers clean expired links and aggregate analytics. Aggregated results can go to the optional Analytics Store. This keeps that work from delaying redirects.

The API and background workers scale horizontally by adding replicas. Redis reduces repeated PostgreSQL reads, while PostgreSQL remains the stored source for link mappings.

The design includes structured logging, Prometheus metrics, OpenTelemetry tracing, threshold alerts, Grafana dashboards, and protected secrets. More cache memory can improve the hit rate. Longer codes lower collision risk but make short URLs longer. Background analytics keeps requests fast, but reports may appear later.

At a high level, the warehouse system must move inventory safely from receiving to storage, fulfillment, and shipping. The main challenge is keeping inventory and reservations correct while many warehouse activities happen at once. I would explain three main flows: inbound storage, fulfillment, and shipping with routing. .NET microservices coordinate the work, while the SQS/SNS event backbone connects background updates. The design scales well, but the trade-off is more operational complexity and delayed consistency for less critical data.

The warehouse system must receive goods, store them in the right place, fulfill customer orders, and route packed orders to carriers. The hard part is coordinating many activities without losing track of inventory. Receiving teams, workers, robots, services, sellers, and carriers may all act at the same time. The design handles this by separating inbound storage, fulfillment, and shipping responsibilities. Shared events and data stores connect those flows while reservations receive stronger consistency than less critical updates.

1. Should the design focus on one warehouse or many warehouse locations?
2. How quickly must inventory reservations become visible to other requests?
3. Should shipping routing favor cost, speed, or the delivery promise?

I would start with the safe entry path. Web, mobile, and seller or vendor systems reach Edge & Security first. Amazon Route 53 provides DNS, Amazon CloudFront provides CDN behavior, and AWS WAF applies rate limiting. The API Gateway then handles AuthN and AuthZ using OAuth2 or OIDC and performs request validation.

Requests reach the .NET microservices. The diagram shows Inventory Service, Inbound Service, Fulfillment Service, Warehouse Management Service, Shipping & Routing Service, and Notification Service. Shared infrastructure includes an Event Publisher, Idempotency Store, Distributed Cache, and Configuration Service.

For inbound work, the physical flow starts with Inbound Scheduling. Goods then pass through Dock Check-in, Receiving & QC, Putaway Planning, and Putaway Execution. The result is an inventory update.

Storage infrastructure includes shelving and bins, robotics and automation, barcode or RFID identification, and environmental monitoring. These capabilities help the warehouse place goods correctly and keep inventory visible.

For fulfillment, the system creates a Wave or Task Plan and sends work through Task Dispatch. An associate or robot performs the Pick. The item then moves through Pack & Label and Staging & Sortation.

Support systems improve this flow with Slotting Optimization, Demand Forecasting, Workforce Management, and Real-time Reoptimization. Reservations need strong consistency because two orders must not claim the same available inventory.

Important changes are published through the Amazon SQS/SNS Event Backbone. The diagram shows Inbound Received, Inventory Updated, Reservation Created, Pick Task Created, Pick Completed, Pack Completed, Ship Requested, and Order Completed. These asynchronous events let later work happen without turning the full warehouse journey into one long request.

Shipping continues through Carrier Selection, Rate Shop & Labeling, Manifest & Handover, and Tracking & Delivery Events. Routing uses Zone Optimization, Carrier Performance, Cost vs Speed Trade-off, and Delivery Promise Estimation.

Amazon Aurora stores orders, inventory, and warehouse data. Amazon DynamoDB stores reservations and idempotency data. Amazon ElastiCache with Redis provides caching. Amazon S3 stores documents, labels, images, and audit logs. Amazon OpenSearch supports search and analytics, while Amazon QLDB provides an audit or ledger store.

External systems include carriers, a payment gateway, third-party sellers or vendors, and tax and compliance services. Observability uses structured logs, OpenTelemetry metrics and tracing, dashboards, alerts, and audit logs. Security uses least-privilege IAM roles, TLS in transit, encryption at rest, audit logging, and network segmentation. The main trade-off is strong consistency for reservations while other updates may become consistent a little later.

At a high level, the goal is to let Amazon.com handle ten times more traffic without becoming slow or unreliable. The main challenge is that hot paths like catalog, search, cart, checkout, payment, recommendations, and inventory can grow much faster than other traffic. I would explain the design in three parts: absorb traffic at the global edge, scale stateless .NET services horizontally, and scale data plus background work separately. The trade-off is higher cost and more operational complexity.

The goal is to let Amazon.com serve ten times more traffic while keeping normal customer actions fast and reliable. The hard part is that traffic will not grow evenly. Catalog, search, cart, checkout, payment, recommendations, and inventory can become hot spots first. The diagram handles this in layers. The global edge removes work before it reaches the application. Stateless .NET services scale separately. Cache and several data stores protect the data layer. Queues and background workers move slower work away from the main request path.

1. Which customer paths are expected to grow the most?
2. Do we need active traffic in multiple regions at the same time?
3. Which operations need the newest data immediately?
4. Which background tasks may finish a little later?

I would first keep repeated work away from the application servers. Clients send HTTPS requests through Route 53 DNS, CloudFront CDN, AWS WAF, and edge locations. Static images, CSS, JavaScript, videos, and downloads can come from S3 and CloudFront. This reduces the amount of traffic reaching the .NET service layer.

The security layer applies WAF rules and bot control. It also performs rate limiting, AWS Cognito authentication and authorization, and request validation. These checks stop bad or excessive traffic early.

The API Gateway, shown as YARP or Envoy, routes requests into the application layer. The main services are Catalog, Pricing, Cart, Order, User, Inventory, Payment, and Notification. They use the service-to-service communication path shown in the diagram, including gRPC, HTTP, and JSON.

The runtime layer uses ASP.NET Core and Kestrel. It also shows dependency injection, middleware, logging, and health checks. The important scaling decision is to keep services small and stateless. That lets ECS or EKS add more replicas horizontally when traffic rises.

For repeated reads, services can use ElastiCache for Redis. A cache hit avoids unnecessary database work. A cache miss sends the request to the appropriate data store.

Aurora PostgreSQL provides relational storage and reader replicas. DynamoDB handles high-scale key-value access. OpenSearch Service supports logs, search, and analytics. As traffic grows, the diagram also calls for read replicas, sharding, and partitioning so one data path does not become the bottleneck.

Not every task should block the customer request. Event producers publish work to Amazon SQS queues. .NET BackgroundService consumers process that work separately.

Amazon SNS topics support asynchronous or deferred delivery to external integrations. Those integrations include payment gateways, shipping providers, email, SMS, and third-party APIs. Failed background work uses retry with backoff, and the diagram includes a DLQ path for work that keeps failing.

The deployment layer uses ECS or EKS containers, horizontal auto scaling, blue-green deployments, Multi-AZ availability, and active-active Multi-Region deployment. CloudWatch, X-Ray, OpenSearch dashboards, health checks, alerts, and reports show where pressure is building.

I would watch queue depth, error rates, tail latency, and overloaded services. I would also revisit database queries, indexes, read replicas, sharding, and partitioning. The main trade-off is cost versus performance. More caches, replicas, regions, and capacity improve reliability, but they also make the system more expensive and harder to operate.

At a high level, search autocomplete must return useful suggestions while the user is still typing. The main challenge is keeping prefix lookups extremely fast while suggestion data keeps changing. I would split the design into the online lookup path, ranking and caching, and the background index-update path. Stateless .NET services, two cache levels, and a sharded Trie or FST keep reads fast. Versioned background updates improve freshness, but new suggestions can appear with a small delay.

The goal is to show useful search suggestions while a person is still typing. A prefix such as "app" may create a request after each keystroke. This makes response time very important. The diagram targets roughly p50 below 20 ms, p95 below 50 ms, and p99 below 100 ms. At the same time, popular searches and other signals keep changing. The design therefore separates the fast online lookup path from the slower background work that builds new versions of the autocomplete index.

1. How many suggestions should we return for each prefix?
2. How quickly must new trending queries appear?
3. Should ranking use recent searches and locale?
4. Which latency percentile is the most important target?

I would start with the path used for every typed prefix. Web, mobile, or SDK clients send the prefix over HTTPS. Edge / Front Door provides Anycast DNS, geo routing, and DDoS protection. The request then reaches the API Gateway.

The gateway handles authentication, authorization, quotas, rate limiting, request validation, and prefix normalization. Normalization includes operations such as lowercase conversion and trimming. These checks protect the service before expensive lookup work begins.

The request reaches the .NET 8/10 Autocomplete API Service. The service is stateless, so replicas can scale horizontally. Its Request Pipeline records logging, metrics, and tracing. The Suggestion Orchestrator coordinates fan-out, timeouts, and fallbacks.

The diagram uses ASP.NET Core for the API layer. Stateless replicas also make autoscaling and multi-AZ deployment easier because requests do not depend on one specific process.

Hot results can use the In-Memory Hot Cache as L1. A Redis Cluster provides the shared L2 Distributed Cache. A cache hit avoids repeating more expensive lookup work.

On a miss, the service uses the Sharded Prefix Index Store. The diagram represents it as a compressed Trie or FST. Prefix traversal takes O(k), where k is the prefix length. Ranked Top-N completions can be stored or retrieved at the matched prefix state. The design returns about five to ten suggestions.

Ranking & Filtering applies score, deduplication, personalization, and SafeSearch. The service may fetch top-query metadata from the Document Store. It may also read recent searches and locale from the User Context Store.

The update path does not block user requests. Query Sources include search logs, web-crawl queries, trending queries, and other signals. The Stream Ingestor validates, normalizes, deduplicates, and enriches this input.

Events are appended to the partitioned Event Stream. Aggregator Workers consume them, count activity, aggregate signals, and compute scores. The Index Builder then creates versioned Trie or FST snapshots. It publishes the result to the Distributed Index Store, and a new index version is rolled into the read-path prefix index atomically.

The diagram uses multi-AZ deployment, autoscaling, circuit breakers, timeouts, retries with backoff, graceful degradation, and health checks. HTTPS, authentication, authorization, quotas, validation, abuse protection, encryption, and data minimization protect the system.

The main trade-off is freshness. New queries are not visible instantly because the background pipeline needs time to create and roll out a new version. The diagram accepts a delay of seconds to minutes so the online lookup path can remain fast and predictable.

At a high level, the goal is to keep Fortnite rankings fresh while players are still active. The hard part is handling many score changes without making leaderboard reads slow. I would split the design into event ingestion, ranking updates, and real-time delivery. Game events flow through the event bus into the .NET ranking services. Redis keeps hot leaderboard data fast, while databases store longer-lived state. The trade-off is that some ranking views may briefly lag behind the newest gameplay event.

The system must keep player rankings updated while matches are still happening. Players can earn eliminations, placements, victories, and other score changes very quickly. The difficult part is processing those changes fast while keeping leaderboard reads responsive. The diagram separates the solution into three main ideas. First, gameplay events enter through a high-throughput event pipeline. Second, stateless .NET services calculate and apply ranking changes. Third, the live delivery layer pushes fresh rank information back to players, parties, and leaderboard viewers.

1. Should rankings be global, per region, per playlist, or all three?
2. How fresh must a leaderboard be during active gameplay?
3. Can a player briefly see an older rank while new events are processing?
4. How should corrected or replayed match events affect an existing rank?

I would first protect and validate traffic before it reaches the ranking services. Fortnite game clients can use WSS or HTTPS for real-time updates and subscriptions. Web and companion apps use HTTPS REST requests. Global DNS and the CDN or Anycast Edge help route traffic. WAF / DDoS Protection blocks abusive traffic. Rate Limiting & Throttling control request volume. AuthN / AuthZ checks identity and permissions. Request Validation & Abuse Detection rejects invalid or suspicious requests.

For active gameplay, score changes arrive as Game Events such as elimination, placement, victory, and time events. They enter the Event Bus, shown as Apache Kafka or Pulsar. Stream Processing, shown as Flink or .NET Stream, processes this event flow. Inside the stateless .NET 8/10 Ranking Service, the Scoring Orchestrator runs as hosted background services. Its Event Ingest Consumer sends work to the Score Calculator & Rules Engine. The Rank Updater then applies the score delta, meaning only the required ranking change is processed.

The Domain Services support this path. They include Player Profile Service, Season / Playlist Service, Anti-Cheat Adapter, and Notification Service.

For ranking reads, the API Gateway sends requests into the stateless .NET services. The Match & Player Service, Ranking Query Service, and Leaderboard Service handle the needed views. Internal Contracts use gRPC or REST between services. The Redis Cluster caches hot leaderboard data, player ranks, and session state so common reads stay fast.

The WebSocket Gateway uses .NET SignalR for live delivery. The Presence & Channel Manager helps route updates to active users and channels. The delivery side supports Live Leaderboards, Player Rank Updates, Party / Friends Rank Changes, and Season / Reward Progress.

The Player DB stores player data. The Ranking DB uses a wide-column design such as ScyllaDB or Cassandra for ranking state. The Time-Series DB stores match metrics. Object Storage keeps match logs and snapshots.

Background work handles Match Reconciliation, Cheat Detection & Analytics, and Seasonal Rollups & Snapshots. Match Reconciliation can validate, correct, and replay data. This work is asynchronous, so it does not need to block the live ranking path.

The .NET ranking services are stateless, so the system can add replicas horizontally. Ranking data is partitioned by playlist and region. The diagram also shows shard leaders in ScyllaDB. Retries, backoff, and idempotency help when processing must be attempted again. Dead-letter queues hold events that cannot be processed normally.

Metrics & Monitoring, Distributed Tracing, Centralized Logs, and Alerting & On-call help operators find problems. The main trade-off is freshness versus scale. Per-playlist ranking uses eventual consistency, which means some reads may briefly show older ranking data. Player profile data keeps stronger consistency.

At a high level, I would separate accepting product batches from storing them. The main challenge is handling millions of writes when some duplicates cannot be identified safely. I would explain the request path, the background worker path, and duplicate handling. A stateless ingestion service validates batches and sends them to a durable partitioned queue. Parallel workers write to partitioned storage. We use best-effort duplicate checks, but we accept possible duplicates instead of blocking large-scale ingestion.

The system must accept a very large number of product records and save them reliably. The difficult part is that two records may describe the same product, but their data may not give us a safe way to prove that. We therefore should not promise perfect duplicate removal. The diagram separates fast request acceptance from slower background storage. It also keeps raw input for recovery and uses fingerprints to remove duplicates when there is enough information to recognize them.

1. Can producers send products in batches, or only one at a time?
2. Is it acceptable to store duplicates when we cannot identify them safely?
3. How quickly must an accepted product appear in the Persistent Store?
4. Do we need raw input for audit, recovery, and reprocessing?

I would start by saying this is mainly a very large write problem. Clients include an Admin Console, ERP or PIM systems, Bulk Import Jobs, and Third-party Feeds.

They send HTTPS JSON or NDJSON requests through the API Gateway. The gateway handles authentication, authorization, rate limiting, request validation, and payload-size limits. This keeps bad or excessive traffic away from the main ingestion service.

For the request path, the Product Ingestion Service is a stateless ASP.NET Core service using .NET 8 and C# 12. Because it keeps no required local request state, several service instances can run in parallel.

The service parses each batch and checks its schema. It then normalizes and enriches the product data. It also computes an idempotency fingerprint, which is a content hash of a standard product representation.

The Short-term Dedupe Cache stores recent fingerprints for a limited time. The service can also use the Persistent Store when checking known fingerprints. If a duplicate is recognized, it can be dropped. If duplicates cannot be distinguished safely, the system accepts that both records may remain.

After validation, the Product Ingestion Service appends product batches to the Durable Queue / Stream. The queue is partitioned by a key such as a hash. This lets different partitions be processed in parallel.

Once the batch is accepted, the service can return Accepted 202 with a request ID. The queue provides buffering and backpressure, which means a traffic spike does not send unlimited writes directly to storage.

The Ingestion Workers run as .NET 8 BackgroundService processes. Multiple worker instances consume queue partitions in parallel. They retry temporary failures with backoff and make idempotent writes when a reliable product identity exists.

The workers write products to the Persistent Store. The Products table has no unique constraint because some duplicates cannot be identified. Writes are append-oriented, and the data can be partitioned or sharded for larger scale.

Raw payloads are also kept in the Data Lake for audit, recovery, and reprocessing. Poison messages or work that exceeds the retry limit goes to the Dead Letter Queue.

The durable queue keeps accepted work while workers recover from temporary failures. Failed items can be retried or replayed. Operators use structured logging, metrics, distributed tracing, dashboards, and alerts to watch ingestion rate, failures, and delays.

The API path uses TLS, authentication, authorization, rate limits, and audit logging. The main trade-off is higher insert capacity instead of strict duplicate elimination. Storage is updated in the background, so reads may see data later. We also use extra storage for raw payloads and duplicate-check information.