Loading
Interview concepts grouped by what the question is really testing.
Admin CRUD, permissions, audit, feature flags, bulk actions, and operational product controls.
SLOs, symptom alerts, burn rate, dashboards, release correlation, capacity signals, alert fatigue, and reliability feedback loops.
Allocation rate, large objects, hot paths, string usage, collections, buffers, and memory-aware performance trade-offs.
Login flows, password handling, identity providers, token validation, refresh tokens, session revocation, and authentication diagnostics.
Roles, permissions, capabilities, policy authorization, resource ownership, tenant membership, admin actions, and stale permission handling.
Status codes, ProblemDetails, validation, pagination, idempotency, cancellation, health, and release-safe smoke contracts.
Small coding exercises that mirror API helpers, validation, paging, filtering, and safe logging.
Audit logs, denied attempts, credential rotation, rate-limit observability, incident support, and security-focused diagnostics.
CORS, CSRF, rate limiting, overposting, safe errors, secrets, security headers, TLS, and browser/API hardening.
Practical software boundaries, dependency direction, domain modeling, modularity, and design-pattern decisions inside applications.
WebApplicationFactory, test authentication, isolated dependencies, relational test containers, and HTTP-boundary verification.
Coding exercises involving async operations, retry, cancellation, rate limiting, and production reliability.
C# async/await behavior, asynchronous control flow, and production pitfalls.
Background jobs, queues, retries, status models, idempotency, and long-running backend workflows.
App Service logs, diagnostics, startup failures, slot issues, performance degradation, and troubleshooting workflows.
WebJobs, Azure Functions, queues, workers, retries, poison messages, and background workload ownership.
Azure hosting choices, App Service runtime behavior, environment configuration, and production readiness for .NET apps.
Application Insights, Azure Monitor, OpenTelemetry, logs, metrics, traces, alerts, and production diagnosis.
Azure production debugging, impact mitigation, incident diagnosis, recovery, and runbook ownership for .NET services.
Managed identities, Key Vault references, secret rotation, and service-to-service access without embedded credentials.
Azure SQL connectivity, managed identity, transient faults, retries, migrations, and production database behavior.
Practical backend system design scenarios for product features, workflows, data boundaries, and operational behavior.
Invalidation after writes, versioned keys, stale data, event-driven invalidation, permission revocation, and derived cache freshness.
Cache hit rate, latency, misses, evictions, hot keys, invalidation failures, stale reads, source load, and degraded-mode monitoring.
Cache purpose, cache-aside, TTLs, stale data, cache keys, response caching, and source-of-truth boundaries.
CancellationToken usage, request cancellation, timeout boundaries, and cooperative cancellation.
Containers, infrastructure as code, progressive delivery, supply-chain security, and disaster recovery.
Code review, mentoring, stakeholder communication, disagreement, feedback, and team trust.
C# collection choice, hashing, set operations, enumeration, LINQ execution, grouping, materialization, and performance trade-offs.
Container packaging, runtime behavior, orchestration, networking, security, resource management, deployment, and production diagnosis.
Async, synchronization, database, and locking deadlock scenarios.
Scope, estimates, trade-offs, risk, deadlines, and choosing what matters first.
Azure App Service staging slots, slot settings, swaps, warm-up, rollback, and release safety.
Resource ownership, IDisposable, IAsyncDisposable, finalizers, dependency-injection lifetimes, and cleanup boundaries.
Application models, resource relationships, service discovery, local dependency orchestration, and portable environment composition.
Architecture decisions for system framing, service boundaries, communication, consistency, replication, partitioning, and distributed workflows.
Trace context, spans, correlation, service boundaries, dependency timing, queue propagation, and request-level diagnosis.
Transactions, concurrency tokens, unique constraints, migrations, bulk changes, tenant isolation, and database consistency boundaries in EF Core.
EF Core diagnostics, telemetry, query tags, retries, compiled queries, batch imports, and production performance behavior.
Generated SQL, projections, filters, pagination, query count, and translating API read needs into efficient EF Core queries.
Pragmatic decision-making, simplicity, risk control, and maintainable engineering choices.
Partitions, consumer groups, offsets, event replay, retention, compaction, schema evolution, and stream processing guarantees.
Uploads, downloads, metadata, scanning, storage lifecycle, secure access, and file processing.
Form UX, validation boundaries, field errors, submissions, stale edits, and recovery behavior.
React or Next.js UI integration with API contracts, auth, errors, validation, request state, and compatibility.
Client data fetching, request states, caching, refetching, stale data, and API integration.
Accessible forms, labels, validation messages, keyboard behavior, and custom controls.
Testing, performance, error boundaries, observability, bundle size, and user-facing quality.
Browser credential storage, XSS, CSRF, CORS, cookies, and frontend-to-API trust boundaries.
Client cache invalidation, optimistic UI, stale data, request cancellation, and mutation state.
End-to-end product feature work across frontend UI, API contracts, backend behavior, data state, and release quality.
Managed memory cleanup, generations, reachability, finalization, and runtime memory behavior.
Learning, feedback, process improvement, adaptability, and practical leadership.
HTTP method guarantees, status codes, representations, caching, conditional requests, CORS, streaming, and retry signaling for APIs.
Incident triage, mitigation, communication, ownership, rollback, degraded mode, runbooks, and post-incident learning.
External APIs, webhooks, third-party sync, signatures, retries, replay, and integration supportability.
ASP.NET Core hosts, databases, containers, isolation, contracts, and realistic test environments.
Filterable lists, search, pagination, empty states, loading states, and user-facing data workflows.
Production memory investigation using metrics, dumps, GC counters, heap comparison, and safe diagnostic handling.
Managed memory retention caused by roots, subscriptions, static state, service lifetimes, and unbounded references.
Commands, events, envelopes, schemas, compatibility, ownership, and event contract design.
Queue depth, consumer lag, dead-letter recovery, broker outages, replay, backpressure, and runbooks.
Queues, topics, commands, events, workers, delayed messages, payload boundaries, and basic message-driven architecture.
At-least-once delivery, idempotency, retries, dead letters, locks, ordering, inbox/outbox, and duplicate handling.
Runtime counters, EventPipe traces, stack snapshots, heap evidence, process dumps, profiling, and controlled production collection for .NET services.
xUnit structure, test doubles, async behavior, determinism, and maintainable .NET tests.
Server components, client components, rendering modes, route handlers, caching, and hydration.
Email, in-app notifications, mentions, user preferences, templates, retries, and delivery observability.
Object responsibilities, encapsulation, abstraction, inheritance, composition, polymorphism, construction, and maintainable C# type design.
Logs, metrics, traces, correlation IDs, dependency telemetry, health checks, sampling, and telemetry design for backend systems.
Parallel workloads, CPU-bound work, concurrency limits, and throughput trade-offs.
Hands-on C# interview coding problems focused on production-shaped data, APIs, and edge cases.
Executable reproductions and evidence for query regressions, failed requests, traces, connection pressure, and incident prevention.
Structured investigation paths for slow APIs, failed releases, dependency incidents, missing logs, queue backlogs, and auth failures.
Production bugs, incidents, mitigation, communication, and post-incident follow-up.
Feature workflows such as invitations, approvals, moderation, settings, entitlements, and live product behavior.
Owning real engineering work from problem discovery through delivery, release, and follow-up.
React rendering, props, state, keys, component boundaries, and everyday component design.
Effects, dependencies, cleanup, stale closures, request lifecycle, and hook behavior.
Redis connection management, serialization, stampedes, outages, locks, sessions, pub/sub, memory pressure, and production failure behavior.
Exports, dashboards, activity feeds, read models, aggregation, freshness, and reporting performance.
Search APIs, filtering, indexing, ranking, pagination, index freshness, and discovery workflows.
Authorization, audit logs, data retention, tenant isolation, sensitive workflows, and backend trust boundaries.
Relational modeling, normalization, denormalization, constraints, snapshots, and read-model design.
Index keys, included columns, covering indexes, selectivity, sort order, and index maintenance trade-offs.
Schema migrations, referential integrity, constraints, cascade behavior, safe backfills, and data-retention effects.
Joins, filtering, grouping, null semantics, pagination, projections, and practical SQL read queries.
Execution plans, statistics, SARGability, row estimates, workload tuning, and slow-query diagnosis.
Transactions, isolation, locking, blocking, deadlocks, optimistic concurrency, and race-condition prevention.
String normalization, parsing, tokenization, validation, and comparison problems.
Synchronization primitives, shared mutable state, locking, and coordination in .NET.
Task-based asynchronous programming in .NET.
Choosing unit, integration, contract, component, end-to-end, and release checks from the behavior and risk.
Flaky-test diagnosis, parallel isolation, external dependencies, and trustworthy CI feedback.
.NET thread pool behavior, starvation, blocking calls, and runtime throughput.
JWT validation, token lifetime, refresh rotation, revocation, token storage, reset tokens, and claim freshness.
Type safety at runtime boundaries, browser scheduling, responsive layout, and core web-platform behavior.
End-to-end tests, debugging, observability, supportability, and production confidence for product features.