Amazon Java Developer Interview Questions & Answers

At a high level, this service turns long URLs into short links and quickly redirects users to the original page. The main challenge is keeping every alias unique while making the read-heavy redirect path fast. I would explain it in two main flows: creating a short link and redirecting an existing one. Stateless Java replicas handle requests, the Primary Database stores the official mapping, and the Distributed Cache speeds up redirects. The trade-off is that cached or replicated reads can briefly be behind the primary data.

The goal is to turn a long web address into a short alias. Later, anyone opening that alias should reach the original address very quickly. The hard part is balancing correctness and speed. New aliases must not conflict with existing ones, while redirects happen often and should stay fast. The diagram separates these concerns into a create path and a redirect path. It also moves optional click analytics into background work, so recording clicks does not slow the main redirect response.

1. Should users be allowed to choose their own custom aliases?
2. How much larger do we expect redirect traffic to be than create traffic?
3. Do we need click analytics for every redirect?

I would start by saying both flows use the same entry layer. DNS resolves the service address, and clients connect using HTTPS. The Load Balancer / API Gateway then sends requests to the URL Service.

The Guardrails can apply API Key / Tenant Auth when needed. They also provide Rate Limiting, URL Validation, and Alias Validation. An invalid URL or alias returns 400. An existing custom alias returns 409. A request over the rate limit returns 429.

For the create path, the client sends POST /shorten. The request contains a long URL and may include a custom alias.

A stateless Java 21/25 URL Service handles the request. Inside a JVM replica, the REST Controller sends it to the Shorten Handler. If a custom alias was supplied, the Alias Generator validates its uniqueness. Otherwise, it generates a random Base62 token, checks whether that token already exists, and retries after a collision.

The Mapping Repository writes the alias and long URL to the Primary Database. The database has a UNIQUE(alias) index, which is the final collision protection. After the database write succeeds, the Cache Client updates the Distributed Cache. The service then returns a JSON response containing the short URL.

For the redirect path, the client sends GET /{alias}. The Redirect Handler asks the Distributed Cache for the long URL first.

On a cache hit, the long URL is returned quickly. The service then sends an HTTP 301 or 302 redirect to the client.

If the cache misses, the service performs a SQL read for the alias. The read can use the Primary Database or the optional Read Replica. When the mapping is found, the service puts it into the cache and returns the redirect. If the alias does not exist, the client receives 404.

The URL Service runs as multiple stateless JVM replicas. Separate JVM replicas do not share heap state. This lets the Load Balancer / API Gateway spread requests across more replicas as traffic grows.

The Primary Database remains the source of truth and handles all writes. The optional Read Replica receives data asynchronously from the primary and can serve extra lookup traffic. Because that copy happens later, it can be slightly behind the primary.

Click analytics is optional and stays outside the critical redirect path. The service can send a click event to the Event Queue / Stream. The event then goes to the Analytics / Metrics Sink in the background.

Redirect traffic is read-heavy, so the Distributed Cache removes many reads from the database. The cache can be repopulated after a miss, but it may briefly contain older data.

Random Base62 tokens are simple to generate, but collisions are still possible. The service therefore checks for an existing token and retries. The database unique index remains the final protection.

Metrics, Structured Logs, Distributed Tracing, and Alerts help operate the system. They show request rates, errors, cache behavior, database latency, JVM health, and other failures without changing the main request flow.

At a high level, I would separate accepting a notification from delivering it in the background. The main challenge is reliable fanout across many recipients and channels while handling provider failures. I would explain the design in three flows: request acceptance, fanout, and channel delivery. The API saves the request and an outbox record, workers publish it to a durable queue, and delivery workers call providers. Retries and a DLQ handle failures. The trade-off is eventual delivery and more operational complexity.

The system must accept a notification request, save it safely, and deliver it through email, SMS, push, or webhook. The hard part is that delivery happens outside our system, so providers can be slow or fail. One request may also become many delivery jobs for different people and channels. The design separates request acceptance from background delivery. It adds retries, a dead letter queue for failed work, status tracking, and monitoring. This lets the API respond quickly while the delivery pipeline handles slow providers and failures safely.

1. Which delivery channels are required?
2. Can one notification target many recipients?
3. How quickly should the API accept requests and delivery happen?
4. When a provider fails, should we retry only or use a secondary provider when configured?

“For the first step, I would make accepting the request fast and safe.”

Client Applications send an HTTPS notification request to the API Gateway. The gateway handles authentication, authorization, validation, rate limits, and an idempotency key. The idempotency key helps recognize the same request sent again.

The request reaches stateless Notification API Service replicas running in separate JVMs. The service validates the request, selects the template, looks up user preferences, and writes notification metadata plus an outbox record to the Notification DB. The client receives 202 Accepted + notificationId.

“Next, I would move delivery work out of the API request.”

The Outbox Publisher Worker polls the Outbox Table. It publishes a NotificationRequested event to the Message Queue / Event Bus and updates the outbox record state. Because the database write happens first, accepted work remains recorded if publishing has a problem.

“For fanout, one notification can become several smaller delivery jobs.”

The Fanout Processor consumes the event. It reads the User Profile & Preference Store for preferences, device tokens, and contact data. It creates jobs per recipient and channel.

Jobs go to the Email Queue, SMS Queue, Push Queue, or Webhook Queue. Separate queues let each channel handle its own load.

“For delivery, I would use separate worker replicas for each channel.”

Email, SMS, Push, and Webhook Workers consume their queues and call the matching provider or customer webhook endpoint. They update the Notification DB with delivery results.

Virtual threads can support many blocking provider calls. They are lightweight JVM threads, but the queues still provide backpressure when work arrives faster than providers can handle it.

“Finally, I would make failure handling explicit.”

Temporary failures go to the Retry Scheduler / Delayed Retry Queue. It uses exponential backoff, so each retry waits longer, up to a maximum number of attempts. Permanent failures or poison messages go to the DLQ for inspection and manual replay.

Delivery is at least once, so a job may appear again. Consumers and providers must handle duplicates safely. Status can be delivered, failed, or retrying. If configured, a secondary provider can be used when one is unavailable.

Metrics, logs, traces, alerts, and a dashboard provide visibility. Security includes authenticated access, encrypted transport, and protection of PII. We scale by adding API replicas and queue consumers. The trade-off is eventual delivery, added cost, and more complexity for better reliability and scale.

At a high level, the system helps customers find an open table and reserve it safely. The hardest part is stopping two customers from booking the same table and time. I would explain it in three flows: checking availability, creating a reservation, and doing background work. Stateless Spring Boot replicas handle requests, while the primary relational database is the source of truth. Booking uses a transaction, row locks, a conflict-prevention rule, and an idempotency key. The trade-off is stronger booking correctness with more database work.

The system must help a customer find a restaurant table for a chosen date, time, and party size, then reserve that table without another customer taking the same slot. The hard part is that availability can change between the search and the final booking. The diagram handles this by separating the availability lookup from the stricter booking path. It also keeps notifications and expired-hold cleanup outside the main customer response. The primary relational database stores the booking state and is the source of truth.

1. Can one restaurant have many tables with different capacities?
2. Can reservations overlap when they use different tables?
3. How long should a temporary table hold stay active?
4. Should restaurant staff be able to change tables, time slots, and reservations?

I would say that customer and staff requests enter through the API Gateway and Load Balancer. Customer requests search availability or submit a booking. Staff requests manage restaurants, tables, time slots, and reservations.

The gateway handles authentication, input validation, rate limiting, and TLS. These checks reject invalid or excessive requests before they reach the Reservation Platform.

For the read path, the Availability API receives the restaurant, date, time, and party size. It reads tables, time slots, and existing reservations from the Primary Relational Database. It returns the available slots through the gateway to the customer.

The Reservation Platform uses stateless Spring Boot application replicas. They scale horizontally behind the load balancer. Requests can be handled concurrently with virtual threads, which are lightweight Java threads suited to many blocking I/O tasks.

For booking, the customer sends the selected slot and an idempotency key. The Reservation API starts a database transaction, which groups the booking changes into one controlled operation.

Inside the transaction, it checks availability again. It locks the candidate table rows or time-slot records using SELECT FOR UPDATE. It creates a short hold, then inserts the reservation only if no conflicting active reservation exists.

The database also has a unique or exclusion rule that prevents overlapping active reservations for the same table and time. After the transaction commits, the Reservation API returns the reservation details. If a conflict happens, it returns "slot no longer available" and asks the client to refresh availability.

The idempotency key prevents the same client retry from creating multiple reservations. This is separate from the database rule that protects the table and time from competing bookings.

After a reservation is created, the Notification Worker sends confirmation and reminder work to External Services for email, SMS, or push delivery. The Scheduled Task or Cleanup Worker removes expired Table_Holds so those slots can be used again.

The Primary Relational Database stores Restaurants, Tables, Reservations, Table_Holds, and Time_Slots. Foreign keys protect relationships, while the overlap rule protects booking correctness.

Services send logs, metrics, and traces to Observability. The design also uses least-privilege access, input validation, rate limiting, and TLS. The main trade-off is that availability reads can scale across stateless application replicas, but confirmed bookings still depend on the primary transactional database and its locking rules.

At a high level, I would treat this as a system that records clicks quickly and keeps popular-item counts ready to read. The main challenge is that click events come in fast, but reports and top-item lookups still need to stay fast. I would explain it in three parts: the security and ingestion path, the background counting path, and the read path that serves counts and popular items from cache with a store fallback. The trade-off is that reports may lag a little because some work happens in the background.

The goal is to record every click on an item, keep a total count, and show which items are most popular. The hard part is that clicks can arrive very often, but people still expect quick responses when they ask for totals or top items. The diagram solves this by splitting the system into a fast request path, a background counting path, and a read path that can use saved results when they are already ready. That keeps the main request fast and moves heavier work out of the way.

1. How fresh do the counts need to be?
2. Do we need exact totals for every time window, or only top items?
3. Should click events be kept for audit and replay?

"At a high level, this is a system for recording clicks and ranking popular items." The key point is that writes are frequent, but reads must stay fast. I would say the design keeps the request path short and moves heavier counting work to the background. The diagram uses stateless Java 21/25 Spring Boot services, a raw event store, a queue, a cache, and a pre-aggregated popularity store.

"For the write path, the click first goes through Edge & Security." That layer does WAF and DDoS protection, rate limiting by IP, user, or item, AuthN/AuthZ with API key or OAuth, and request validation and normalization. The Click Ingestion Service then saves the raw click in the Raw Clicks Store, which is append-only and partitioned by date. It also publishes the event to the Message Queue / Stream. The service returns 202 Accepted with an eventId, so the user does not wait for the background work.

"For the read path, the Click Query Service handles click totals and top-N popular items." It first checks Cache (Read-Through), which is a Redis Cluster. On a cache hit, it returns fast. On a miss, it reads from the Popularity Store, which keeps pre-aggregated counts in a sharded key-value store. The Admin / Reporting API uses the same data for time-range reports, popularity trends, and exports. The cache is only a speed layer. The Popularity Store is the place where the counts live.

"The queue lets the system do counting in the background." The Aggregation Worker consumes events, micro-batches them, increments counters, updates time windows, and handles retries or a Dead Letter Queue when events keep failing. This work does not block the main request. That is the main reason the system can accept clicks quickly and still build good reports later. The Raw Clicks Store also gives an audit trail, so the data can be checked again if needed.

"The system scales by keeping services stateless and by partitioning data by key and time." That lets the design use horizontal scaling and replicas safely. Replication, backups, retries, and the DLQ help reliability. Observability is covered with metrics, tracing, logs, and alerts. The main trade-off is freshness versus speed. Counts may lag a little because some work happens after the click is accepted. I would accept that trade-off because it keeps the main request path fast and protects the main store.

At a high level, the goal is to let customers create product reviews safely and let other customers read them quickly. The main challenge is stopping duplicate reviews without making popular product pages slow. I would explain the design in three flows: writing a review, reading reviews, and updating summary data in the background. The reviews table stays the source of truth, while the Read Cache speeds up common reads. The trade-off is that rating summaries can lag slightly after a new review.

The system must let a customer submit a review for a product and let other customers read reviews quickly. The difficult part is making each write safe when the same request is retried, while also keeping product pages fast. A customer should not accidentally create two active reviews for the same product. The design uses three flows: create the review, read reviews through a cache when possible, and update rating summaries in the background.

1. Can one user have only one active review per product?
2. Is it acceptable if rating totals update a little after a review is created?
3. Which review sort orders should the API support?

I would start with how requests enter the system. The Customer / Product Page UI sends HTTPS requests through the API Gateway / Load Balancer. It handles TLS termination, routing, logging, and health checks. The Authentication + Rate Limit Boundary verifies the JWT or session, extracts userId, rate-limits users, and adds WAF or abuse protection. The request then reaches stateless Java Review Service replicas on Java 21/25.

For a write, the client sends POST /products/{productId}/reviews with rating, title, body, and idempotencyKey. Validation checks the payload, product, and authenticated user. The Duplicate-Review Guard uses the idempotency key so a retry does not create another review.

The Review DB also enforces one active review per user and product with a uniqueness rule. This protects against racing requests. The Review Write Logic saves the review and an outbox row in the same database transaction. The reviews table is the source of truth. Success returns 201 Created with reviewId and status. An existing review or conflict does not create a second active review.

For a read, the client sends GET /products/{productId}/reviews with cursor and sort values. The Cache-Aware Read Path checks the Read Cache first. On a cache hit, the service builds the JSON response from cached summary and review data.

On a cache miss, the Review Read Logic reads review_summary and paginated reviews from the Review DB. It applies sorting and cursor pagination, then returns summary, reviews, and nextCursor. If the cache is unavailable, the service falls back to database reads.

After the write transaction, new outbox events are polled and published to the Message Queue as ReviewCreated events. The Background Consumer / Summary Updater runs in a separate JVM process. It updates review_summary with average rating, rating counts, and total reviews, then invalidates or refreshes the Read Cache.

Failed processing uses exponential backoff. The consumer is idempotent, meaning replaying the same event should not apply the same update twice. Because this work happens later, aggregate counts may briefly trail a review.

Stateless JVM replicas scale horizontally behind the gateway. Virtual threads help with many blocking database, cache, or HTTP calls, but they do not replace the durable Message Queue. Logs, metrics, and traces track request errors, database time, cache hit rate, queue lag, and calls across the system.

The trade-off is clear. The reviews table stays correct and reads stay fast, while derived summaries and cached data may be briefly behind.

At a high level, this is a system for sending chats quickly and safely across phone, web, and desktop clients. The main challenge is that the send path must feel instant, but the message still has to be saved, delivered, and tracked correctly. I would explain it in three parts: the client entry path, the Java service and data layer, and the real-time plus background delivery paths. The trade-off is a little more moving parts for better speed and reliability.

This system lets people send messages from mobile, web, and desktop. They can chat in real time, see who is online, send media, and get delivery updates. The hard part is that sending must feel fast, but the app still has to save every message safely and keep delivery status correct. The diagram answers this by splitting the design into an entry layer, a stateless Java service layer, several data stores, a real-time WebSocket delivery path, and a background path for retries and push notifications. It also separates fast delivery from background work.

1. Do we need only one-to-one chat, or also large group chats?
2. Do you want read receipts and typing indicators to be shown immediately, or can they arrive a little later?

At a high level, this is a chat system that must feel instant. The send path must be correct, and delivery updates can wait a little. The diagram keeps the fast path small. It uses a public entry layer, stateless Java services, separate data stores, a WebSocket path for online users, and background work for slower tasks.

For the create path, the client first connects through HTTPS or WSS. The request passes DNS, CDN, and the global load balancer, then the security layer. The Auth Service checks JWT, the API Gateway validates the request and rate limits it, and WAF blocks bad traffic. After that, the Message Service handles the send request. If it needs profile or membership data, the User Service and Conversation Service provide it. The Media Service handles uploads and stores files in object storage. The message is saved in the Message Store, while user and conversation data live in their own PostgreSQL databases. The write order matters because the app should save the message before it tries to fan out delivery.

After the message is saved, the WebSocket Gateway Cluster pushes it to online users. The Presence Service keeps track of who is online or offline. The Fan-out Service sends the message to the right connected clients, and the connected client gets the inbox update right away. Redis is used as a cache for hot data like conversations and presence. That makes reads faster. The cache is only a speed layer. The Message Store is still the source of truth.

Not every action should block the send path. The app publishes events to Kafka or Pulsar, and Java consumers process them in the background. Those workers handle read receipts, typing indicators, offline push prep, and analytics events. The Notification Service can turn those events into push, email, or SMS messages. If something fails, bad messages go to the DLQ. The service layer is stateless, so replicas can scale horizontally. PostgreSQL, Cassandra or ScyllaDB, and object storage split the storage jobs. That helps scale, but it adds more moving parts. Kafka makes background work safe, but some updates appear later. Multi-AZ deployment improves reliability, but failover can briefly interrupt writes. Logs, metrics, tracing, alerting, and dashboards help the team watch the system. TLS, JWT, rate limits, encryption, and audit logs protect the system.

At a high level, the goal is to return useful search suggestions while the user is still typing. The main challenge is keeping this path very fast while ranking results well. I would split the design into the online lookup path, the background ranking path, and the snapshot update path. Stateless Java replicas use a Distributed Response Cache and a local weighted Trie or FST for fast lookups. Query and click data improves future rankings. The trade-off is that suggestions can be slightly stale between snapshot updates.

The goal is to predict useful search suggestions from a small prefix, such as "lap", before the user finishes typing. The difficult part is speed because every new keystroke may create another request. Ranking also matters because the most useful suggestions should appear first. The diagram separates this into a fast online path, background work that learns from queries and clicks, and snapshot updates that refresh the search data. Each Java replica keeps a local search index in memory, so most candidate lookups do not need a remote data store.

1. How many suggestions should we return for each prefix?
2. Should suggestions change by locale or signed-in user context?
3. How fresh must popularity and click signals be?
4. What should happen when there are no strong prefix matches?

I would start with the user-facing path because latency matters most there. The Browser / Mobile Search UI sends an HTTPS prefix request to CDN / Edge + API Gateway inside the Edge / Protection layer. This layer terminates HTTPS, validates prefix length and characters, and applies Rate Limiting / Abuse Control. Authentication is optional. When the user is signed in, the gateway can attach user context before forwarding the validated prefix.

The request reaches the Autocomplete Service Cluster running Java 21/25. Its replicas are stateless JVM processes, so separate JVMs do not share heap memory. Inside a replica, Request Handler receives the request and Prefix Normalizer cleans the prefix. Cache Check then checks the Distributed Response Cache for hot prefixes. On a cache hit, the service can use the stored Top N suggestions. On a cache miss, Candidate Generator reads the local read-only weighted Trie / FST snapshot stored in that replica's memory.

Ranker combines prefix relevance with popularity, recency, click feedback, locale, and optional user context. Response Builder then returns the Top N suggestions as JSON. Hot results can be written back to the Distributed Response Cache with a TTL, which means they expire after a set time. If the local snapshot has no strong matches or confidence is low, the service can use Popular Suggestions Fallback by locale. Virtual threads can help with concurrent I/O, but backpressure is still needed so outside resources are not overloaded.

Query impressions and clicks go to the Query & Click Event Log without slowing the main response. Suggestion Quality / Ranking Pipeline uses those events to compute popularity, recency, CTR, locale signals, freshness, and other ranking features. It also performs deduplication and unsafe-term filtering. The pipeline builds a validated weighted Trie / FST snapshot and stores it in the Versioned Snapshot Store. The Java replicas poll for newer versions and hot-swap their local snapshot when a valid version is available.

The service scales horizontally by adding more stateless Java replicas behind the gateway. Keeping the weighted Trie / FST in memory lowers lookup latency, but every replica needs memory for its own snapshot. If the Distributed Response Cache is unavailable, the service continues with its local snapshot. If a new snapshot fails validation, replicas keep serving the previous version. Suggestions may be slightly stale until the next snapshot publish. Observability / Monitoring collects metrics, logs, traces, alerts, latency, errors, and cache hit rate so operators can spot problems quickly.

At a high level, this system lets sellers create auctions, buyers place bids, and the platform choose one correct winner. The hardest part is handling competing bids without losing history or accepting the wrong highest bid. I would explain three flows: listing and reading auctions, accepting bids safely, and closing auctions with background notifications. The Relational Auction DB keeps the official state, Redis speeds reads, and the outbox handles reliable events. The trade-off is strong bid correctness with slightly delayed cached reads and notifications.

The goal is to run online auctions from listing creation through winner selection. Sellers create auctions, buyers read them and place bids, and the system closes each auction when its time ends. The difficult part is handling bids that arrive almost together. We must keep every accepted bid, maintain the correct highest bid, and choose only one winner. The diagram handles this with a transactional main database, a read cache, careful bid validation, an auction-closing worker, and background event delivery.

1. Can many bidders place bids on the same auction at nearly the same time?
2. Should a bid equal to the current highest bid be rejected?
3. How fresh must the displayed highest bid be?
4. Which notification channels are required for bid and auction events?

I would first explain how every client reaches the platform safely. Web App, Mobile App, and Seller / Admin UI send HTTPS requests through the Load Balancer / API Gateway. It handles routing, TLS termination, and request logging.

Auth & Rate Limits checks authentication, authorization, rate limits, and IP or device limits. Authorized requests then reach the Auction Platform. The platform runs as Java 21/25 JVM replicas, and each replica is a separate JVM process. Virtual threads help each replica handle many blocking database, cache, and HTTP calls efficiently.

For listing creation, the Listing API creates or updates the auction in the Relational Auction DB. It stores auction rules and the close time there. This database keeps the official auction state.

For reads, the Auction Query API checks Redis Cache for the listing and CurrentHighestBid. Redis stores this data by auction ID and uses a TTL. On a cache hit, the query can return quickly. On a cache miss, the system queries the Relational Auction DB and returns the database result. Cached data may be slightly behind, so Redis is a speed layer rather than the final source of truth.

For bidding, the Bid API sends the request to Bid Validation. It checks bid increments, auction state, and bidder eligibility.

The Relational Auction DB then performs one atomic transaction. This means the related changes succeed or fail together. It inserts the accepted bid into Bid history and uses a version-based compare-and-set on CurrentHighestBid. If another bid changed that version first, the update cannot silently overwrite it.

A bid at or below the current highest bid is rejected. Bid history is not updated or deleted after acceptance. The database returns an ACCEPTED or REJECTED transaction result to the Bid API. The highest bid wins, and the earliest accepted timestamp breaks a tie.

The Auction Close Scheduler / Worker finds auctions whose end time has passed. It closes each auction only once with a conditional database update. It then selects the highest valid bid at close time and saves the Winner.

This work is idempotent, which means retrying it does not create a second winner. The worker can safely retry after a temporary failure. A lease or transaction can prevent two workers from selecting duplicate winners.

The Relational Auction DB also stores Outbox records. The Outbox Publisher reads pending records and publishes BidAccepted, AuctionClosed, and Outbid events to the Message Broker.

The Notification Worker consumes those events and sends Email, SMS, or Push notifications. If the broker has a temporary failure, the producer retries from the outbox with exponential backoff. This keeps event publishing reliable without making notifications part of the bid transaction.

Observability collects logs, metrics, and traces from the platform and workers. The main trade-off is strong consistency for bids and winner selection, while cached reads and background notifications can be slightly delayed.

At a high level, this system must issue certificates safely and make lookup and delivery fast. The main challenge is keeping certificate status correct while serving common reads quickly. I would explain three flows: issuance, lookup, and delivery, with notifications handled in the background. Requests pass through the Edge/CDN and API Gateway to stateless Java services. PostgreSQL keeps the main records, Redis speeds lookups, and Object Storage keeps certificate files. The trade-off is faster reads with more cache and background-processing complexity.

The system needs to create certificates, let people find them later, and deliver the certificate file when requested. The difficult part is keeping certificate ownership, metadata, and revocation status correct while making frequent lookups fast. Delivery may also involve signing, rendering, email, or SMS. Those slower tasks should not make every user wait. The diagram separates the solution into issuance, lookup, delivery, and background work. PostgreSQL keeps the main certificate records, Redis speeds common reads, Object Storage keeps files, and Kafka carries work that can happen later.

1. How often are certificates issued compared with lookups?
2. How quickly must a revocation become visible to users?
3. Which certificate file formats must be delivered?
4. Are email and SMS notifications required for every issuance?

I would start by showing how a request safely reaches the certificate service. Web, mobile, partner, and admin clients send HTTPS requests through the Edge/CDN and API Gateway. The edge provides DNS, CDN, DDoS protection, and WAF filtering. The API Gateway handles routing, TLS termination, rate limiting, and authentication. Identity & Access Management validates OAuth2 or OIDC tokens, JWTs, API keys, and RBAC or ABAC permissions before protected operations continue.

For issuance, the Certificate Issuance API creates a certificate after validation and business-rule checks. The Application Services provide validation, templates, signing, notification support, and auditing. Certificate information is written to the Primary Data Store, which is the PostgreSQL cluster. Certificate files are written to S3-compatible Object Storage. After that main work, the service can publish events such as certificate.created, email.send, or audit.log to Kafka. This keeps later notification and audit work away from the main response.

For lookup, the Certificate Lookup API searches by ID or code and verifies status. It checks the Redis Cache Layer first. Redis stores certificate metadata, status or revocation information, templates, and short-lived tokens. On a cache hit, the service can answer without reading PostgreSQL. On a miss, it reads the needed record from the Primary Data Store and returns the result. PostgreSQL remains the main stored record. Redis is only the faster lookup layer, so cache invalidation must be handled carefully when certificate state changes.

For delivery, the Certificate Delivery API generates or renders the result, uses the signing service when needed, and reads the certificate file from Object Storage. It then returns the file or link to the client. The Java Certificate Service is stateless and runs as multiple replicas. Virtual threads inside each JVM support many I/O-bound tasks, but they do not replace Kafka. Kafka carries background events to separate JVM workers. Those workers send email or SMS, process audits, generate reports, and perform cleanup. Scheduled Jobs handle certificate expiry, old-data archiving, report recomputation, and cache warmup.

Stateless replicas make horizontal scaling easier. Redis and the CDN reduce repeated work on common reads and file delivery. Background workers can retry failed work and safely handle repeated events. Failed events can move to a dead-letter queue, which stores work that could not be processed normally. The Email / SMS Service also uses retry and backoff. Logs, metrics, tracing, and alerts show failures. Security includes TLS 1.3, encryption at rest, secrets in Vault or KMS, least privilege, and audit records. The main downside is more operational complexity from caches, queues, workers, and several storage systems.

At a high level, I would treat this as a read-heavy system. The main challenge is that crawlers and real users can look similar, so the detector must stay fast and accurate. I would explain the design in three parts: edge checks, the Java detection service, and the background scoring and training pipeline. The trade-off is that stronger detection can add a little latency and may challenge some good traffic.

This question asks how to tell whether incoming visits are from real people or from crawlers. A crawler can copy pages, scrape data, or hit the site too often. The hard part is that bad traffic and normal traffic can look alike at first. Some checks must happen right away so the site stays fast. Other checks can run later in the background. The diagram solves this by separating edge protection, the Java decision service, and the async learning pipeline.

1. Should suspicious traffic be blocked right away, or challenged first?
2. Do we want to protect every endpoint, or mainly pages that are easy to scrape?

At a high level, the goal is to tell crawlers from normal traffic quickly. The system does that by checking traffic at the edge, scoring it in the Java service, and then learning from new events in the background. The Java layer can run on Java 21 or Java 25 and stays stateless, so many replicas can make the same decision. Fast checks protect the site first. Deeper checks improve accuracy without slowing every request.

For the request path, traffic starts with clients such as web browsers, mobile apps, and bad bots or crawlers. It passes DNS, then WAF / DDoS protection, and then the CDN for static content. After that, the API Gateway / Reverse Proxy forwards allowed requests into the Java application layer. That layer does request validation, reputation checks, feature extraction, and risk scoring before it returns allow, challenge, or block.

The Crawler Detection Service is the part that makes the bot decision. It reads from the Feature Store / Cache, which is the fast place for recent counters and sketches. It also reads the Operational Database for IP, session, and user profile data. The service can call the ML Inference Service when a score needs a deeper check. This is where the system separates a normal user from a crawler in a simple and explainable way.

Not every check should block the request path. The diagram sends events to Kafka or Pulsar, then a stream processor like Flink or Kafka Streams enriches and aggregates them. The same flow also feeds offline analytics and model training. The Data Lake / Warehouse stores raw events and training data, while the Model Registry keeps trained models and versions. This background work helps the detector improve over time without slowing the live request.

The Java service uses virtual threads for many blocking requests, but it still keeps bounded thread pools where needed. That keeps the service responsive without pretending threads are free. Observability is also important here. Metrics, logs, traces, dashboards, and alerts show when a rule is too strict or too weak. The main trade-off is accuracy versus speed. More checks improve bot detection, but they can add latency and may challenge some real users.