Microsoft .NET Developer Interview Questions & Answers

At a high level, this gateway gives clients one controlled entry point to internal .NET services. The main challenge is keeping authentication, authorization, rate limits, and routing consistent while handling partial failures safely. I would explain the design in three parts: the synchronous request path, the shared platform services, and failure handling. Requests pass through Azure Front Door and six gateway stages before reaching a private backend service. The trade-off is stronger central control, but shared gateway dependencies must remain highly available.

The goal is to give different clients one safe way to reach internal .NET services. Every request must pass the right security checks, traffic limits, validation, and routing rules. The difficult part is keeping these rules consistent while still serving healthy routes during partial failures. The diagram solves this with one ordered gateway pipeline. It keeps shared policy, rate-limit state, monitoring, secrets, and background integration around that pipeline so the main request path stays clear.

1. Which clients need access, and do any require client certificates?
2. Should rate limits differ by user, route, or client type?
3. Which routes may return cached or predefined fallbacks during an outage?
4. Which operations may be accepted for background processing?

I would start with the normal request path. Web, mobile, partner, and IoT clients send HTTPS traffic to Azure Front Door. Front Door forwards the request to the internal Azure API Gateway. The response returns through Front Door to the client. The gateway is deployed as containerized .NET 8 or .NET 10 services on Azure Container Apps. It can scale out and use multiple zones.

The first stage is TLS Termination and WAF. It handles TLS offload, OWASP rules, IP filtering, and request-size limits. Authentication then validates JWT or OAuth2 credentials. It can use AAD or B2C, token introspection, and optional client-certificate or mTLS authentication.

Authorization checks scopes, roles, policies, and ABAC or RBAC rules. Validation checks the request schema, content type, and model binding. These checks happen before backend routing.

Rate Limiting and Throttling applies global, per-user, and per-route rules. It supports burst limits, sustained limits, and quotas. Shared rate-limit state is kept in Redis with a primary and replica.

After those checks pass, Routing selects the backend using path, host, method, headers, query values, versioning, and canary or weighted rules. The gateway then calls the selected private .NET service over HTTPS with mTLS.

Policy and Configuration includes Azure App Configuration, Key Vault, Feature Flags, and the Gateway Policy Store. These provide settings, secrets, certificates, and policy definitions. Cross-cutting concerns include correlation IDs, structured logging, metrics, tracing, audit information, caching, response shaping, and compression.

Observability uses Azure Monitor, Application Insights, Log Analytics, and Alerts. Azure Service Bus handles queued background work. Event Grid carries domain events. These asynchronous paths do not need to block the normal synchronous response.

I would finish with failure behavior. Timeouts, bounded retries with exponential backoff, circuit breakers, and bulkhead isolation limit the effect of failing services. The gateway continues serving requests when the dependencies needed by those requests are healthy. If required authentication or policy state cannot be checked, it rejects the request safely.

Safe routes may use cached responses or predefined fallbacks. Operations designed for background handling may enqueue accepted work to Service Bus. Gateway replicas stay stateless, while shared state remains in Redis and App Configuration. The main trade-off is central control versus dependency risk. Central rules are easier to keep consistent, but those shared services must be designed for high availability.

At a high level, the goal is to keep a reliable history of every change across decentralized services. The hard part is preserving event order while still supporting replication and recovery. I would explain this in three flows: writing events, publishing committed events, and rebuilding state. Commands append ordered events to the replicated event store. Background workers build read models, while replay restores state when needed. The main trade-off is stronger write consistency versus lower write availability when a quorum is unavailable.

The system must keep every important change as an event instead of storing only the latest state. Those events are copied across decentralized storage nodes, so their order must stay correct even when nodes fail or lose network access. The design separates the problem into a secure write path, a replicated event store, background processing, read models, and replay. The key rule is simple: first commit the event safely, then use that saved history to publish updates, build query views, or recover lost state.

1. Do we need strict ordering only inside each event stream?
2. Should writes stop when the replicated store cannot form a quorum?
3. How quickly must read models reflect newly committed events?

I would start by saying that client requests enter through the Security & Gateway layer. The gateway handles authentication, authorization, validation, rate limiting, and throttling. TLS protects communications shown in the design.

The request then moves to the Command API in the .NET Application Layer. The Domain Model & Aggregates apply the business rules. An aggregate is the business unit whose events must stay in the correct order.

For the write path, the Event Store Client appends the new event to the Decentralized Event Store. The store keeps append-only event streams. Each stream uses a sequence or version so events have a clear order inside that stream.

The event store is replicated across peers using consensus. Enough nodes must agree before the write is accepted. During a network partition, nodes without quorum cannot accept writes. This protects the ordered event history.

Each Event Record contains Stream Id, Event Type, JSON payload, metadata, Version or Sequence, Timestamp, Causation Id, and Correlation Id. These fields help preserve ordering and trace related work.

After an event is committed, the Integration Event Publisher reads committed events from the Event Store. It publishes integration events toward the Message Bus and external integrations. The Message Bus uses at-least-once delivery, so the same event may be delivered more than once.

The BackgroundService Projection Builder consumes events and builds the Read Models / Projections. These query stores include a Relational DB, Document DB, and Cache. Processing is idempotent, which means handling the same event again must not produce an incorrect duplicate result.

The Replay Service reads an ordered stream or range from the Decentralized Event Store. It replays those events over time to rebuild state or projections. Because the original event history is retained, a damaged projection can be recreated from the stored events.

Failed consumers can resume from their last processed sequence. This supports recovery after crashes or restarts without changing the stored event history.

The application services are stateless, so they can scale horizontally. Read models can scale separately for query workload. Observability & Diagnostics collects structured logs, metrics, traces, and alerts.

The main trade-off is consistency versus write availability. Consensus preserves correct ordering during failures, but nodes without quorum cannot accept writes. Read projections can also be slightly behind because they are updated in the background.

At a high level, I would separate accepting a task from doing the background work. The main challenge is keeping tasks moving when workers or processing steps fail. I would explain the design in three flows: accepting and publishing tasks, processing them with workers, and handling retries or failed tasks. A transactional outbox prevents a database and queue write gap. Partitioned queues and worker leases help the system scale. The trade-off is more moving parts and more operational complexity.

The goal is to accept work quickly, save it safely, and process it in the background. The difficult part is that machines can stop, messages can appear again, and some tasks can keep failing. The system must keep useful work moving without losing tasks or retrying bad tasks forever. The diagram separates this into task acceptance, safe queue publication, worker processing, retries, and failed-task handling. It also shows how partitions spread work and how monitoring helps operators find stalled or unhealthy parts of the system.

1. Do tasks need to stay ordered within the same partition?
2. How long should a task remain available before retention removes it?
3. How many retries should happen before a task goes to the Dead Letter Queue?
4. Can the same task be processed more than once?

For the request path, a client sends an HTTPS request through the API Gateway / Edge. The gateway handles authentication, authorization, validation, rate limiting, and the request ID.

The .NET 8/10 Web API accepts the enqueue request. It checks the idempotency key, which helps detect the same request being sent again. The service creates the task and writes an outbox record inside the same Relational DB transaction.

The service returns the enqueue response and task ID through the API Gateway / Edge. The gateway then returns the HTTP response to the client. The task itself is processed later in the background.

The Outbox Relay Process is a .NET BackgroundService. It polls pending outbox records from the Relational DB.

The relay is the normal publisher to the Task Queue. It publishes each pending task message and then marks the outbox record as published. This avoids the gap where the database write succeeds but a separate queue write is lost.

The Task Queue is split into partitions. Each partition is durable and append-only. The queue also shows retention, at-least-once delivery, and a visibility timeout or lease.

The .NET Worker Service uses BackgroundService consumers. A Partition Leases Manager coordinates worker ownership of partitions.

Concurrent Message Fetchers fetch leased messages. The Task Processor runs the business logic and may call External Services / APIs. The Result / State Updater saves success or failure information in the Relational DB.

At-least-once delivery means a message can appear again. The worker therefore needs safe repeated processing, so running the same task again does not create a wrong result.

If processing fails for a temporary reason, the Retry / Backoff Handler sends the task to the Retry Queue. Backoff means waiting before trying again.

When the delay expires, the Retry Queue requeues the task into the Task Queue. This prevents immediate retry loops and gives temporary problems time to recover.

If the task keeps failing or reaches the retry limit, it moves to the Dead Letter Queue. This isolates poison or failed tasks from normal work.

The Dead Letter Queue sends failed tasks to Manual / Automated Inspection & Reprocessing. After the problem is understood and fixed, that process can explicitly requeue the task.

Metrics, Structured Logs, Alerts, Dashboards, and Distributed Tracing show queue depth, failures, high retries, stalled partitions, system health, and request flow. These signals help operators find problems quickly.

Producer and worker replicas are stateless where possible, so they can scale horizontally. The broker and Relational DB remain stateful. Communication uses HTTPS, and secrets come from a configuration provider or Key Vault.

The main trade-off is complexity. Partitioning improves scale, while leases, retries, outbox processing, and failure recovery add more operational work.

At a high level, this system must deliver chat messages quickly while keeping messages ordered inside each conversation. The hard parts are real-time delivery, presence, and reconnecting without losing messages. I would explain three flows: sending a message, pushing live updates, and replaying missed messages. Stateless .NET services use SQL for stored chat data, Redis for presence and sequence state, and an Event Bus for background delivery. The trade-off is extra operational complexity for reliable real-time behavior.

The goal is to let many people chat at the same time and see new messages quickly. Messages inside each conversation must appear in the right order. The system must also show presence, such as whether someone is online. A phone or browser can lose its connection at any time, so reconnecting users must receive messages they missed. The diagram separates normal chat requests, live WebSocket delivery, and reliable background delivery. Stored chat history lets the system recover after temporary connection failures.

1. Should ordering be guaranteed only inside one conversation?
2. How quickly should presence changes appear to other users?
3. How long should missed messages remain available for replay?
4. Do attachments need the same delivery guarantees as text messages?

I would start with how users enter the system. Desktop, mobile, and web clients use HTTPS for normal requests. The web client also shows a WSS connection for live updates. Azure Front Door or Application Gateway is the entry point. WAF and DDoS protection filter harmful traffic. Microsoft Entra ID handles OAuth 2.0 or OIDC sign-in. JWT validation checks the signed user claims. Rate limiting controls excessive requests by IP, user, or tenant.

For a new message, the Chat REST API sends work to the Message Service. This service validates and enriches the message before saving it. The Conversation Service checks the conversation, members, and permissions. The Ordering Service assigns per-conversation sequence information. It also helps detect duplicate messages and sequence gaps. The SQL Database Primary stores conversations, messages, users, and memberships. Redis stores sequence counters and idempotency keys. An idempotency key lets the system recognize the same client request sent again.

For live updates, the Real-time Gateway manages WebSocket or SignalR connections. The Presence Service handles heartbeats and user status changes. Redis stores presence, user sessions, and connection-related state. The design also uses SignalR backplanes with Redis so horizontally scaled service replicas can reach connected users. The gateway then fans messages and presence updates out to the correct active connections.

Reliable delivery uses an Outbox Table in SQL. The message write saves durable delivery work there before background publishing happens. The Outbox Publisher polls the table and publishes events to the Event Bus. Fan-out Workers consume those events and deliver them through the Real-time Gateway. If processing keeps failing, poison work can move to the Dead Letter Queue. Retries use exponential backoff, which increases the delay between attempts. When a client reconnects, it sends its last-seen sequence. The server then replays missing messages from stored chat history.

The .NET services are stateless, so the system can add more replicas horizontally. Data is partitioned using tenant or conversation information. SQL read replicas support reporting or search reads. Blob or Object Storage holds attachments and media. The Search Index supports full-text search. Structured logs, metrics, distributed tracing, and alerts help operators find problems. TLS protects traffic. JWT tokens, RBAC, input validation, WAF rules, rate limits, and tenant isolation protect access. The main downside is complexity. Redis, WebSockets, background workers, retries, and event delivery all need careful operation.

At a high level, the system must score each transaction and quickly decide whether to approve, block, or review it. The main challenge is making that decision fast while using enough fraud signals to make a useful choice. I would explain three flows: secure transaction ingestion, real-time scoring and decisioning, and background review and learning. The .NET application coordinates the main path, while the event stream handles slower work. The trade-off is that richer fraud checks add processing and operational complexity.

The system must examine each transaction and decide whether it looks safe or suspicious. Normal transactions should move forward quickly. High-risk transactions should be blocked, while uncertain transactions should be sent for human review. The hard part is making a useful fraud decision without slowing every request too much. The diagram solves this with a secure ingestion path, a real-time scoring and decision path, and background work for feature updates, model training, alerts, auditing, and analyst review.

1. Which transaction sources must the system support first?
2. How should the business choose thresholds for approve, block, and review?
3. Which fraud signals are available when the transaction arrives?
4. How quickly must an escalated case reach an analyst?

I would first make sure every transaction enters through a controlled path. Mobile apps, web apps, and partner services send an HTTPS transaction request to Security & Edge. This layer provides WAF and DDoS protection, OAuth 2.0 or JWT authentication, validation, rate limiting, and idempotency checks. A validated request then reaches the Transaction API inside the ASP.NET Core application. The API accepts the transaction, adds a correlation ID, performs basic validation, and records request logs.

Next, the Transaction API sends a transaction command to the Fraud Orchestrator. The orchestrator builds the features needed for fraud detection and calls the Scoring Engine. The Scoring Engine combines rules evaluation with ML model inference. It returns a risk score from 0 to 1000 together with explanation factors. The scoring path can read the features, profiles, rules, recent transactions, and model information shown in the diagram. Redis holds fast-changing profile, device, velocity, and recent-transaction data.

The Fraud Orchestrator passes the result into the Decision Service. The Decision Service applies thresholds and policies and produces reason codes. A high-risk transaction follows the Block path and becomes declined. A low-risk transaction follows the Approve path and becomes approved. An uncertain transaction follows the Escalate path and enters Queue for Review. The application then returns an approved, declined, or escalated response through Security & Edge to the original client.

For an escalated transaction, the system creates a case event for the Fraud Analyst Console. The analyst can inspect case details, timeline, evidence, and notes, then approve or decline the case. That analyst decision reaches Final Decision Applied, which updates the database and sends notifications. Transaction and decision events also flow through the Event Stream using Kafka or Azure Event Hubs. Background consumers update the Feature Store, retrain and validate models, send alerts and notifications, and create audit and compliance reports.

The Operational DB stores transactions, decisions, users, and rules. The Historical Data Store keeps data for analytics and model training. The Model Registry stores model versions and metadata. Observability includes structured logging, metrics, distributed tracing, dashboards, and alerts. Cross-cutting controls include configuration, secrets management, resilience policies, and caching. The main trade-off is simple: using rules, ML, several stores, and human review can improve fraud decisions, but it creates more services and dependencies to operate reliably.

At a high level, the goal is to build a newsfeed that feels live while keeping normal feed reads fast. The main challenge is combining fresh posts, user relationships, ranking signals, and real-time updates at scale. I would explain it through the feed read path, the write and background update path, and live delivery. Redis keeps common feed reads fast, a durable Message Queue supports background fan-out, and SignalR pushes live updates. The trade-off is more complexity and a small delay for some background updates.

The goal is to show each user a useful newsfeed and make new activity appear quickly. The difficult part is that many users may read feeds while posts, reactions, follows, mutes, and blocks keep changing. The system must find suitable items, rank them, remove unwanted items, and deliver fresh changes without making normal reads slow. The diagram separates this work into a fast feed-read path, a durable background processing path, and a real-time delivery path. Redis helps with fast reads, while background workers handle work that does not need to block the user request.

1. How quickly should a new post appear in followers' feeds?
2. Should ranking favor freshness, engagement, relationships, or user preferences?
3. How much delay is acceptable during heavy traffic?
4. Which clients need live SignalR updates and push notifications?

I would first explain how requests enter the system safely. Mobile apps, the Web SPA, and desktop apps are the clients. The CDN or Edge layer serves static content such as images and video thumbnails. Requests that reach the API Gateway pass through TLS, authentication, authorization, validation, rate limiting, and request routing before entering the .NET newsfeed service.

For a feed read, the Feed Read API works with the Feed Orchestrator. The orchestrator coordinates candidate fetching, ranking, filtering, enrichment, and fallback behavior. The Candidate Fetcher gets possible items from the Cache Layer or stores. The Ranking Engine scores and sorts them using signals such as recency, engagement, relationships, content relevance, and user preferences. The Deduplicator / Filter removes repeated or unwanted items. The Enricher adds related user, media, or ad information. Redis keeps per-user or home timeline data and item data close to the service for fast access.

For writes, the Feed Write API handles actions such as creating posts and reactions. The User Graph API handles follow, unfollow, mute, and block changes. Change Capture uses an Outbox Pattern to write domain events. These events go to the durable Message Queue. Feed Builder Workers consume them, fan out updates to followers, update user timelines, and make incremental changes. The Timeline Store keeps per-user timelines using a NoSQL or wide-column style store.

Indexing Workers update the Search Index, trending data, aggregates, and counters. Push Notification Workers batch and send push notifications to devices. Background failures can retry, and failed work can move to a dead-letter path instead of blocking the main request. The Real-time Hub uses SignalR or WebSockets for live updates. A Redis SignalR backplane helps multiple replicas coordinate those real-time messages. Media is kept in the Media Store, while events and metrics go to the Analytics Store.

The .NET services can scale horizontally across multiple replicas, zones, or regions. The Timeline Store can be partitioned, and caching reduces database reads. Durable messaging provides backpressure, which means work can wait when producers are temporarily faster than workers. The design accepts eventual consistency for fan-out, meaning some background updates may appear a little later. Consumers should handle repeated events safely. TLS, authentication, authorization, data minimization, user controls, and compliance protect the system. Structured logs, metrics, distributed tracing, alerts, and dashboards help operators find problems. The main trade-off is that fast reads and live updates require more infrastructure and operational work.

At a high level, the goal is to keep the same files synchronized across many devices, even when users work offline or edit the same file at the same time. The hard part is sending only changed data while keeping file versions correct. I would explain three flows: delta upload and download, version and conflict handling, and background storage and notifications. The design uses stateless .NET services, versioned storage, and a version graph. The trade-off is extra version logic for lower bandwidth and better offline support.

The system must keep a user’s files synchronized across Windows, macOS, mobile, and the web. A device may lose its connection, change a file, and reconnect later. Two devices may also change the same file before either device receives the other change. The design handles this by transferring only changed data, keeping old file versions, and preserving conflicting edits when an automatic merge is unsafe. I would explain the client sync path first, then version handling, then the background work that stores changes and notifies devices.

1. How large can files become, and how often are they changed?
2. Should automatic merging be allowed for every file type or only safe cases?
3. How long should old versions and deleted data be retained?
4. How quickly should a committed change appear on another device?

I would start with the Local Sync Engine because it knows what changed on each device. It uses a File System Watcher, Change Journal, File Chunking, and rolling-hash Delta Detection. It also keeps a Local Cache and Offline Store, so work can continue while the device is disconnected.

For an upload, the client sends delta data and metadata over HTTPS. For a download, it requests changed data and metadata instead of downloading every file again. Backoff and Retry help when a request temporarily fails.

The request passes through the CDN, WAF and DDoS Protection, and API Gateway. The gateway applies rate limiting, throttling, authentication, and authorization. A validated request then reaches the .NET 8 backend services.

The Sync API Service handles delta upload and download. The Metadata Service handles file and folder metadata, permissions, sharing, and quotas. The Auth Service validates tokens and delegated access.

The Versioning Service maintains the Version Graph and detects conflicts. Blob Storage keeps file chunks, versioned blobs, and version history. The Version Index stores the Version Graph and reconciliation state, which means information used to compare competing file histories.

When two devices create divergent edits, both branches are preserved. The Conflict Resolution Service can auto-merge safe cases. Otherwise, the Conflict UI shows the versions and choices to the user. After the user selects or manually merges them, a new unified version is committed and devices can be updated.

Background work goes through the Ingestion Queue. The Delta Processor BackgroundService deduplicates, validates, and normalizes work. The Reconciliation Worker BackgroundService builds the version graph, detects conflicts, and applies safe merge strategies.

The Storage Writer BackgroundService stores chunks, updates metadata, and indexes versions. The Notifier Worker BackgroundService sends web push, optional email, or in-app alerts. These are hosted background workers. Task-based async I/O is different: it lets a .NET process wait for network or storage operations without treating each Task as a durable queue item.

The .NET services run as multiple stateless instances in Azure App Service or Container Apps. Managed threads and the ThreadPool belong to each running process, while separate instances do not share ordinary process memory.

The Metadata DB stores users, files, folders, permissions, quotas, devices, and sync state. Redis caches hot metadata, session data, and throttling counters. Key Vault stores keys, secrets, and certificates.

Application Insights, Log Analytics, dashboards, Distributed Tracing, Synthetic Tests, and SLOs monitor the system. Security includes TLS 1.2 or later, encryption at rest, RBAC, audit logs, data residency, retention, and legal hold. The main trade-off is lower bandwidth and stronger offline support at the cost of more client, version, and conflict-handling complexity.

At a high level, I would build one shared ticket system for agents and customers. The main challenge is keeping ticket state correct while notifications, search, SLA checks, and audit work happen efficiently. I would explain three flows: the secure ticket request, fast reads and search, and background processing. Stateless .NET services use a primary database, Redis, a message broker, workers, a read replica, and a search index. The trade-off is that background views can briefly lag behind the main ticket data.

The system must help support teams create, triage, assign, update, and resolve customer tickets. Everyone involved should see important changes without making the main ticket action slow. The hard part is keeping the ticket record correct while also handling search, notifications, SLA checks, attachments, reporting, and audit work. The diagram organizes this into a secure entry path, stateless .NET services, persistent stores, and background workers. The main database keeps ticket data, while slower side work can happen separately.

1. Which ticket states and assignment rules are required?
2. How quickly should status changes become visible to participants?
3. What attachment sizes and file types must we support?
4. Which email, chat, identity, or CRM systems must connect?

I would first explain how requests enter the system safely. Web agents, mobile agents, inbound email, live chat, and customer self-service all reach the Edge & Security layer. The API Gateway accepts HTTPS traffic. Authentication and authorization use OIDC or OAuth2. Rate limiting and the WAF protect the service from abusive or unwanted traffic.

After these checks, the request enters the stateless .NET application layer. Stateless means one service instance does not depend on local user state. That makes horizontal scaling easier because several instances can sit behind a load balancer.

For ticket work, the Ticket API handles create, update, read, comments, and attachments. The Triage Service categorizes tickets, sets priority, detects duplicates, and adds tags. The Assignment Service can use skills, round-robin, or workload rules. The Workflow Service controls status transitions, SLA rules, escalations, and approvals. The Notification Service handles email, in-app messages, mentions, status updates, and subscriptions.

The Primary Database stores tickets, users, organizations, SLA data, comments, and audit data. It is the main stored record for ticket state. Redis is a performance layer for lookups, sessions, rate counters, and search cache. It does not replace the Primary Database.

For search, the Search API supports full-text search, filters, saved views, and pagination. The Search Index stores ticket content in a form optimized for full-text queries. A Read Replica supports reporting and scale. It can be slightly behind the Primary Database, so reports may briefly show older data. Attachments are kept in Blob Storage instead of placing large files in the ticket database.

After ticket activity, the application can publish events to the Message Broker. The diagram shows RabbitMQ or Azure Service Bus as examples. Background services run as .NET hosted workers and consume that work asynchronously, which means it happens separately from the main request.

The Email Dispatcher Worker sends notifications and replies. The SLA Monitor Worker checks SLAs and creates escalations. The Reindex Worker updates the Search Index. The Audit Logger Worker writes audit records. Keeping this work in the background reduces work on the main request path.

The system integrates with email, chat, an identity provider, file storage, and optional CRM or asset systems. Observability includes structured logging, metrics, tracing, alerts, and dashboards. Multiple service instances, backups, retries, and health monitoring improve availability.

The main trade-off is simple. Ticket transactions stay correct in the Primary Database, but reporting, search results, and other background updates may appear a little later.

At a high level, this system lets people publish short posts and quickly read a current home feed. The main challenge is keeping reads fast while fan-out work grows with the number of followers. I would explain the write path, the home-feed read path, and the background processing path. Stateless .NET services handle requests, Redis and read-optimized storage speed reads, and background workers build timelines. The trade-off is that timeline updates can appear a little later.

The goal is to let people publish short posts and see fresh posts from people they follow. Publishing should feel quick, even when one post must reach many followers. Reading the home feed should also stay fast. The design separates normal user requests from work that can happen in the background. I would explain it through the request entry path, publishing and fan-out, the home-feed read path, and the supporting failure and scaling choices.

1. How fresh must the home timeline be after someone publishes a post?
2. Do we expect some users to have much larger follower counts than others?
3. How much delay is acceptable for timeline updates and notifications?

I would start with the common request path. Mobile, web, and third-party clients send HTTPS requests through DNS and the Global Load Balancer. The edge also provides WAF and DDoS protection. The CDN serves static assets and media delivery.

Inside Security & Access, the Auth Service uses OAuth 2.1 or OIDC. The API Gateway handles routing and TLS termination. The Rate Limiter applies per-user or per-IP limits. Request Validation and Anti-Abuse checks reject unsafe requests before they reach the application services.

For the write path, the validated request reaches the Tweet Service. The diagram shows the write flow as create tweet, save it, and then publish an event. Tweet data and metadata go to the Tweet Store Write DB, shown as Cassandra or ScyllaDB.

The User Service handles profile and follow operations. User information, profiles, and follow relationships are stored in the PostgreSQL User Store. Keeping these responsibilities separate lets the stateless services scale independently.

After a tweet is saved, its event goes through the Message Broker, shown as Azure Service Bus or Kafka. The Fan-out Worker Service processes that work in the background and updates followers' timelines using the push model shown in the diagram.

The Timeline Worker Service handles timeline work. The Notification Worker Service handles notification work. These workers run as BackgroundService consumers. The diagram also shows events such as TweetCreated, Followed, Mentioned, Liked, and Retweeted. Retries and idempotent jobs make repeated processing safe when temporary failures occur.

For reads, the Feed Service handles the read API, while the Timeline Service represents the home feed. Redis caches timelines and also supports counters and rate-limit data. The read path can use cached data or the Tweet Store Read DB for speed.

The read database uses Cassandra or ScyllaDB and is denormalized for reads. Search requests go through the Search Service to the OpenSearch Search Index for full-text and hashtag search. Media and attachments use Blob Storage and can be delivered through the CDN.

The .NET application services are stateless and can scale horizontally. The diagram shows .NET 8 or .NET 10 services using C# 12 or C# 14, Kestrel, managed threads, and Task-based asynchronous operations.

Health checks, retries, timeouts, and circuit breakers help with temporary failures. Logging, Prometheus metrics, OpenTelemetry tracing, alerting, Grafana dashboards, and audit logs support operations. Timeline updates use eventual consistency, which means followers may see a new post after a small delay. That delay is the main trade-off of background fan-out.