Loading
Interview concepts grouped by what the question is really testing.
Admin CRUD, permissions, audit, feature flags, bulk actions, and operational product controls.
Tools, planning, state, memory, permissions, human approval, recovery, and agent evaluation.
Gateways, orchestration, deterministic boundaries, state, failures, fallbacks, and versioning.
Representative datasets, task metrics, graders, release comparisons, regressions, and feedback loops.
Deployment, tracing, model changes, capacity, spend, incidents, and production quality.
Prompt injection, data leakage, tool authorization, provenance, tenant isolation, and governance.
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.
Hands-on Angular exercises covering signals, RxJS, forms, routing, HTTP, testing, browser integrations, updates, and deployment verification.
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.
Python asyncio tasks, cancellation, synchronization, threads, processes, backpressure, and production concurrency.
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.
DOM and CSS processing, layout, paint, compositing, main-thread responsiveness, storage, and deployment 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.
Python caching, Redis coordination, background task delivery, retries, worker behavior, and stale-work protection.
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.
Collection contracts, generic type safety, functional transformations, stream execution, aggregation, and Optional boundaries.
Container packaging, runtime behavior, orchestration, networking, security, resource management, deployment, and production diagnosis.
Cascade order, specificity, inheritance, responsive layout, overflow, rendering cost, and systematic CSS debugging.
SQLAlchemy, Django ORM, transactions, relationship loading, connection pooling, migrations, and evidence-led SQL 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.
Django and Django REST Framework request flow, application boundaries, validation, permissions, migrations, and reliable API design.
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.
Vector representations, similarity, indexing, metadata, ranking, and retrieval evaluation.
Pragmatic decision-making, simplicity, risk control, and maintainable engineering choices.
Partitions, consumer groups, offsets, event replay, retention, compaction, schema evolution, and stream processing guarantees.
FastAPI request flow, Pydantic contracts, dependencies, errors, resource lifetimes, streaming, and reliable HTTP boundaries.
Uploads, downloads, metadata, scanning, storage lifecycle, secure access, and file processing.
Form UX, validation boundaries, field errors, submissions, stale edits, and recovery behavior.
HTTP clients, request state, authentication, errors, validation, cancellation, and API compatibility.
Component ownership, dependency boundaries, state placement, routing, and maintainable frontend composition.
Client data fetching, request states, caching, refetching, stale data, and API integration.
Accessible forms, validation, field state, server errors, keyboard behavior, and custom controls.
Testing, rendering performance, observability, error recovery, and user-facing production quality.
Template rendering, change detection, DOM identity, server rendering, hydration, and browser behavior.
Route composition, lazy loading, navigation state, guards, resolvers, and deep-link behavior.
Browser and server trust boundaries, authorization, input validation, sessions, and secure delivery.
Local and shared state, reactive derivation, request lifetime, freshness, and cache consistency.
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.
Spring Boot production endpoints, health, observability, resource capacity, async and scheduled work, caching, resilience, deployment, and incident diagnosis.
Lexical scope, declarations, references, receivers, prototypes, promises, modules, equality, and language-level debugging.
Worked Java and Spring implementation exercises covering language design, concurrency, APIs, JPA, security, testing, and production correctness.
JPA and Hibernate persistence contexts, entity state, fetching, mappings, transaction behavior, locking, query choices, batching, and schema evolution.
JVM memory, garbage collection, the Java Memory Model, synchronization, concurrent execution, virtual threads, and production diagnosis.
Filterable lists, search, pagination, empty states, loading states, and user-facing data workflows.
Model behavior, tokens, context, generation, limitations, and foundational applied-AI decisions.
Managed models, retrieval, agents, guardrails, regions, quotas, observability, cost, and portability.
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.
App Router composition, rendering, routing, request boundaries, caching, metadata, and production delivery.
Email, in-app notifications, mentions, user preferences, templates, retries, and delivery observability.
Object responsibilities, encapsulation, abstraction, inheritance, composition, polymorphism, construction, equality, and maintainable 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.
Python web-server deployment, process lifecycle, profiling, observability, rollout, and production incident judgment.
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.
Instruction boundaries, context construction, examples, trust, and token-budget decisions.
Worked Python backend exercises covering language design, asyncio, FastAPI, Django, SQLAlchemy, PostgreSQL, testing, and background-work correctness.
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.
Retrieval pipelines, grounding, citations, freshness, access control, and answer quality.
Search APIs, filtering, indexing, ranking, pagination, index freshness, and discovery workflows.
Authorization, audit logs, data retention, tenant isolation, sensitive workflows, and backend trust boundaries.
Python, FastAPI, and Django authentication, authorization, browser security, secrets, signed requests, and unsafe input boundaries.
Spring's application container, bean lifecycle and scopes, proxy boundaries, external configuration, Boot auto-configuration, and startup diagnosis.
Spring Security request flow, authentication, authorization, sessions, tokens, exploit protection, and practical Spring testing strategy.
Spring MVC request handling, API contracts, binding, validation, error responses, cross-cutting web behavior, async processing, and HTTP clients.
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.
Schemas, validation, tool contracts, repair, execution boundaries, and safe integration.
Synchronization primitives, shared mutable state, locking, and coordination in .NET.
Task-based asynchronous programming in .NET.
Pytest fixtures, parametrization, mocking, async tests, framework integration, database isolation, and trustworthy test suites.
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.
Structural typing, generics, contracts, nullability, checking tools, and proportional type design.
End-to-end tests, debugging, observability, supportability, and production confidence for product features.