Questions
Search, or browse in learning order. Priority tab: Must = asked most; "card →" = a card exists.
Trials: cards by other models → Today →
- Class vs object and constructors · DeepSeekCS · OOP foundations
- Static, sealed, partialCS · OOP foundations
- Four pillars of OOPCS · OOP foundations
- Abstract class vs interfaceCS · OOP foundations
- Value vs reference typesCS · .NET runtime and memory
- Garbage collection and memory leaks · DeepSeekCS · .NET runtime and memory
- .NET Framework vs .NET Core vs .NETCS · .NET runtime and memory
- CLR, JIT and ILCS · .NET runtime and memory
- Task vs Thread · DeepSeekCS · Async and threading
- async / awaitCS · Async and threading
- Array, List, interfaces, HashSet · DeepSeekCS · Collections, generics and delegates
- Delegates and eventsCS · Collections, generics and delegates
- SOLID principlesCS · SOLID, errors and code reading
- REST, HTTP verbs and status codesAPI · REST, MVC and controllers
- Model binding and validationAPI · REST, MVC and controllers
- MVC pattern and request lifecycleAPI · REST, MVC and controllers
- Dependency injection: what and whyAPI · DI and app startup
- DI service lifetimesAPI · DI and app startup
- Global exception handling and loggingAPI · Middleware, filters and error handling
- Middleware pipelineAPI · Middleware, filters and error handling
- Filters in ASP.NET CoreAPI · Middleware, filters and error handling
- Authentication vs authorizationAPI · Auth and API security
- Securing a Web APIAPI · Auth and API security
- JWT authenticationAPI · Auth and API security
- Unit testing basicsTEST · Unit tests and mocking
- How async/await works, and why use it in a web API · Gemini · Other
- Async and await in a web API · Luna · Other
- Constructors: types and order · Other
- EF Core vs Dapper vs ADO.NET · Other
- LINQ and deferred execution · Other
OOP foundations built 4 / 9
- Must77.5Explain the four pillars of OOP, with an example of each from your projectcard →
- Must31Abstract class vs interface: differences and when you choose eachcard →
- Must17Class vs object; constructors: types, static and private constructors, chaining, execution ordercard →
- Must13.5Abstraction vs encapsulation: what is the difference, with codenot built
- Must12Method overloading vs overriding (virtual, override, new)not built
- Must11.5static, sealed and partial classes: what each is forcard →
- Must10What is polymorphism? Compile-time vs runtime, with codenot built
- Should8.5Inheritance in C#: types, why C# has no multiple class inheritance, interfaces with the same default methodnot built
- Should3Access modifiers in C# (public, private, protected, internal, protected internal, private protected)not built
.NET runtime and memory built 4 / 13
- Must28.5.NET Framework vs .NET Core vs .NET 5+: what changed and why it matterscard →
- Must20.5CLR, JIT and IL: how .NET code is compiled and run; managed vs unmanaged codecard →
- Must14Value types vs reference types; stack vs heap; struct vs classcard →
- Must11How does garbage collection work in .NET (generations, LOH), and how do you find a memory leak?card →
- Should4.5const vs readonly vs static readonlynot built
- Should4Boxing and unboxing: what happens at runtime and why it costsnot built
- Should4ref vs out vs in parameters; returning multiple values (tuples)not built
- Should4String vs StringBuilder; why strings are immutablenot built
- Should3.5Nullable value types (int?) and nullable reference types; default valuesnot built
- Nice2.5IDisposable, using statement vs using declaration, Dispose vs Finalizenot built
- Nice1.5== vs Equals() vs ReferenceEquals; overriding Equals and GetHashCodenot built
- Nice1var vs object vs dynamicnot built
- Nice0Span<T>/Memory<T>, ValueTask and allocation-free code: when they matternot built
Async and threading built 2 / 6
- Must22How does async/await work, and why use it in a web API?card →
- Must14.5Task vs Thread; multithreading and the Task Parallel Library (Parallel.ForEach)card →
- Should6Thread safety: lock/Monitor vs Mutex vs SemaphoreSlim; are List and Dictionary thread-safe; concurrent collectionsnot built
- Should4ConfigureAwait(false), SynchronizationContext, sync-over-async deadlocks and thread-pool starvationnot built
- Should3Implement a thread-safe Singleton (lock, double-check, Lazy<T>); when a DI singleton is betternot built
- Nice1.5Make 100 independent API calls efficiently (Task.WhenAll, throttling with SemaphoreSlim)not built
Collections, generics and delegates built 2 / 9
- Must14Array vs ArrayList vs List<T>; IEnumerable vs ICollection vs IList; HashSet; which collection whencard →
- Must10.5Delegates, Func/Action and events: what they are and where you used themcard →
- Should7Generics: why use them, constraints, generic methodsnot built
- Should6How does Dictionary<TKey,TValue> work inside (hashing, buckets, collisions, GetHashCode/Equals)?not built
- Should4Small C# features: enums, indexers, namespaces, records, tuples, pattern matchingnot built
- Should3Extension methods: how they work and an examplenot built
- Should3Implement IEnumerator/IEnumerable by hand (or with yield return)not built
- Should0record vs class (and record struct); init-only properties; when you use recordsnot built
- Nice1Write code using delegates and events (publisher/subscriber in plain C#)not built
SOLID, errors and code reading built 1 / 6
- Must19.5Explain SOLID with a real example; which principle is violated in a given class?card →
- Must10Take over an unfamiliar (often AI-written) project: walk the code, find bugs and smells, propose improvementsnot built
- Should6Exception handling in C#: try/catch/finally, throw vs throw ex, custom exceptionsnot built
- Should5Predict the output of a C# snippet (casting, i++, value vs ref passing, constructor order)not built
- Nice2Reflection: what it is, creating instances and reading attributes at runtime, and its costnot built
- Nice1.5Review a small piece of C# code: find the obvious and non-obvious flaws and explain eachnot built
- Must0easyModel loans in code: abstract Loan, HomeLoan/CarLoan overriding CalculateEmi, encapsulated balancenot built
- Must10mediumTake over an unfamiliar (often AI-written) project: walk the code, find bugs and smells, propose improvementsnot built
- Must0mediumMake a blocking controller → service → HttpClient/EF chain async end to end; remove .Result/.Wait()not built
- Must0mediumFind and fix a memory leak (static event subscription, unbounded static cache): before/afternot built
- Must0mediumRefactor a God class (LoanService validating, saving and emailing) into SOLID pieces behind interfacesnot built
- Should5easyPredict the output of a C# snippet (casting, i++, value vs ref passing, constructor order)not built
- Should3easyImplement a thread-safe Singleton (lock, double-check, Lazy<T>); when a DI singleton is betternot built
- Should0easyWrite a custom exception; show how throw ex loses the stack trace and throw does notnot built
- Should0easyWrite an extension method, e.g. IQueryable<T>.Paginate(page, size)not built
- Should0easyWrite a generic Result<T> or Repository<T> with constraints (where T : class, IEntity)not built
- Should3mediumImplement IEnumerator/IEnumerable by hand (or with yield return)not built
- Should0mediumFix a race on a shared balance: lock, then Interlocked, then SemaphoreSlim for async codenot built
- Should0hardReproduce a sync-over-async deadlock, then fix itnot built
- Nice1.5easyReview a small piece of C# code: find the obvious and non-obvious flaws and explain eachnot built
- Nice1easyWrite code using delegates and events (publisher/subscriber in plain C#)not built
- Nice0mediumOverride Equals/GetHashCode for a key type; show the Dictionary lookup that fails without itnot built
- Nice0mediumCall 100 APIs concurrently with Task.WhenAll throttled by SemaphoreSlim (or Parallel.ForEachAsync)not built
- Nice1.5Make 100 independent API calls efficiently (Task.WhenAll, throttling with SemaphoreSlim)not built
REST, MVC and controllers built 3 / 8
- Must34MVC pattern and the ASP.NET MVC request lifecycle (routing → controller → action → view)card →
- Must20.5REST principles, HTTP verbs (PUT vs PATCH vs POST), idempotency and status codescard →
- Must16.5Build a CRUD Web API (controller → service → repository → EF Core) in the interviewnot built
- Must12.5Model binding ([FromBody], [FromQuery], [FromRoute]) and validation (data annotations, FluentValidation)card →
- Should8.5Routing and controllers: attribute routing, [ApiController], ControllerBase, action return types, minimal APIsnot built
- Should3ASP.NET MVC vs Web API vs Razor Pagesnot built
- Nice1DTOs vs entities, and mapping them (AutoMapper vs manual mapping)not built
- Nice1Swagger/OpenAPI: what it gives you and how you document and test an APInot built
DI and app startup built 2 / 5
- Must46.5What is dependency injection, what problem does it solve, and how do you register and inject a service?card →
- Must26.5Transient vs Scoped vs Singleton: differences, how you choose, and what goes wrong with a scoped service inside a singletoncard →
- Should6.5Program.cs/Startup and configuration: appsettings.json, environments, IOptions, where secrets gonot built
- Should0Two classes implement one interface: which is injected, IEnumerable<T>, keyed services (.NET 8)not built
- Nice0Circular dependency between services: what happens and what it says about the designnot built
Middleware, filters and error handling built 3 / 5
- Must32What is middleware, how does the request pipeline work, why does order matter, and how do you write custom middleware?card →
- Must21Filters in ASP.NET Core (authorization, resource, action, exception, result) and middleware vs filterscard →
- Must10.5Implement global exception handling and structured logging in a production APIcard →
- Must2.5Write a global exception handler (IExceptionHandler / middleware) returning ProblemDetails with a correlation IDnot built
- Nice0.5Write a middleware that counts every request to the backendnot built
Auth and API security built 3 / 6
- Must24How does JWT authentication work end to end between Angular and a .NET API (issue, validate, roles, expiry, refresh)?card →
- Must19Authentication vs authorization; role- and policy-based authorization in ASP.NET Corecard →
- Must15.5How do you secure a Web API (HTTPS, auth, CORS, input validation, rate limits, secrets, XSS/CSRF)?card →
- Must1Implement JWT login: issue access + refresh tokens, protect endpoints with [Authorize] and rolesnot built
- Should8What is CORS, and why does an API work in Postman but fail from Angular?not built
- Should3.5OAuth 2.0 vs OpenID Connect vs cookie auth; where Entra ID fitsnot built
Performance, resilience and operations built 0 / 10
- Must8An API is suddenly slow under load (or 10 s when the work takes 1 s): how do you find the bottleneck?not built
- Should8.5Calling external APIs: IHttpClientFactory, socket exhaustion, retries/timeouts with Pollynot built
- Should8Caching in ASP.NET Core: in-memory vs distributed (Redis) vs output caching, and cache invalidationnot built
- Should3.5Rate limiting an API (built-in RateLimiter middleware: fixed window, sliding, token bucket)not built
- Should3Return very large data from an API: pagination, streaming, compression, file downloadsnot built
- Should0Idempotent endpoints with idempotency keys (payments, retries, AI tool calls)not built
- Nice1.5API returns HTTP 500 only in production: how do you debug it?not built
- Nice1.5Write a production-grade API that sends templated emails with attachments and retry logicnot built
- Nice1.5API versioning: URL, header and query-string strategies, and how you retire a versionnot built
- Nice1Background and scheduled jobs in .NET: BackgroundService, Hangfire/Quartz, Azure Functions timer triggernot built
Legacy MVC and Web Forms (only if the JD names it) built 0 / 4
- Should13Legacy ASP.NET: Web Forms page lifecycle, ViewState, postback, Global.asax, WCFnot built
- Should13State management in ASP.NET: session, cookies, TempData, cache; where session data livesnot built
- Should6ViewBag vs ViewData vs TempData; passing data from controller to viewnot built
- Nice8MVC views: Razor, layout pages, partial views, _ViewStartnot built
- Must2.5easyWrite a global exception handler (IExceptionHandler / middleware) returning ProblemDetails with a correlation IDnot built
- Must0easyWrite an action filter (log execution time or validate the model) and register it globallynot built
- Must0easyWrite a request-timing middleware (Stopwatch, X-Response-Time header, warn on slow requests)not built
- Must0easyValidate a request DTO (data annotations or FluentValidation) and return 400 ProblemDetailsnot built
- Must16.5mediumBuild a CRUD Web API (controller → service → repository → EF Core) in the interviewnot built
- Must1mediumImplement JWT login: issue access + refresh tokens, protect endpoints with [Authorize] and rolesnot built
- Must0mediumRegister transient, scoped and singleton services, print their IDs per request, trigger the captive-dependency error, fix itnot built
- Must0mediumAdd a policy (CanApproveLoan: role + claim) with a custom requirement handlernot built
- Must0mediumBuild a GET endpoint with pagination, filtering and sorting (offset and keyset) that returns the total countnot built
- Should0easyAdd the built-in rate limiter (fixed window per user/IP) to an endpoint; return 429 with Retry-Afternot built
- Should0easyRegister two INotificationSender implementations; inject all of them, then pick one with keyed servicesnot built
- Should0easyBind a config section to IOptions<T> with ValidateDataAnnotations and ValidateOnStartnot built
- Should0mediumStream a large CSV export (IAsyncEnumerable / response stream) without loading it into memorynot built
- Should0mediumWrite a BackgroundService that drains a Channel<T> queue (scoped services, graceful shutdown) plus a scheduled jobnot built
- Should0mediumAdd cache-aside caching to a GET (IMemoryCache, then Redis/HybridCache) and invalidate it on updatenot built
- Should0mediumCall an external API with a typed HttpClient plus retry with backoff, timeout and circuit breakernot built
- Should0hardMake POST /payments idempotent with an Idempotency-Key header (store key + response, handle concurrent duplicates)not built
- Nice0.5easyWrite a middleware that counts every request to the backendnot built
- Nice0mediumUpload a file: streaming IFormFile, size and type checks, save to Blob Storage, return a SAS linknot built
- Nice0mediumPush real-time notifications from the API to Angular with SignalR (hub, per-user groups, auth)not built
- Nice1.5hardWrite a production-grade API that sends templated emails with attachments and retry logicnot built
- Must10.5Implement global exception handling and structured logging in a production APIcard →
- Must8An API is suddenly slow under load (or 10 s when the work takes 1 s): how do you find the bottleneck?not built
- Should3Return very large data from an API: pagination, streaming, compression, file downloadsnot built
- Nice1.5mediumAPI returns HTTP 500 only in production: how do you debug it?not built
SQL fundamentals built 0 / 8
- Must41SQL basics: DDL vs DML vs DCL, data types (CHAR vs VARCHAR vs NVARCHAR), NULL handling, LIKE/IN/BETWEEN, subqueriesnot built
- Must12Primary key vs unique key vs foreign key; constraintsnot built
- Must9.5DELETE vs TRUNCATE vs DROP (logging, identity reset, rollback)not built
- Must9GROUP BY, WHERE vs HAVING, and aggregate functionsnot built
- Should4UNION vs UNION ALL; JOIN vs UNIONnot built
- Should3SQL views: what they are, types, and can you update through onenot built
- Nice2Normalization (1NF–3NF) and when you denormalizenot built
- Nice2Relational vs NoSQL: when you would pick Cosmos DB or MongoDB over SQL Servernot built
Joins and query writing built 0 / 6
- Must48SQL joins: inner, left, right, full, self and cross join, with sample data and resultsnot built
- Must23Write SQL for employee/department/order tables: joins, group by, self-join for managers, top N, date rangesnot built
- Must21Find the 2nd/3rd/Nth highest salary (overall and per department)not built
- Must11.5CTEs and window functions: ROW_NUMBER, RANK vs DENSE_RANK, running totals, PIVOTnot built
- Must11Find and delete duplicate rows, keeping one (ROW_NUMBER/CTE)not built
- Should5.5Temp table vs table variable vs CTEnot built
Stored procedures, transactions and safety built 0 / 7
- Must17Stored procedures: write one, debug it, and optimise itnot built
- Must14.5Stored procedure vs function vs view: differences and when to use eachnot built
- Should8ACID and transactions: COMMIT/ROLLBACK, nested procedures, transactions in EF Corenot built
- Should5.5SQL triggers: when to use one and why teams avoid themnot built
- Should0Transaction isolation levels and the anomalies they prevent (dirty, non-repeatable, phantom reads)not built
- Should0SQL injection: parameterised queries, EF Core FromSql vs FromSqlRawnot built
- Nice1.5Two users update the same record at the same time: optimistic concurrency (rowversion) vs lockingnot built
Indexes, tuning and design built 0 / 6
- Must23Clustered vs non-clustered indexes; how an index speeds a query and when it hurtsnot built
- Must16A query is slow (fine at 1,000 rows, slow at millions): how do you investigate and fix it?not built
- Nice2.5Design a database schema for a feature (online test, booking app)not built
- Nice2.5Design pagination, filtering and sorting over millions of rows (offset vs keyset)not built
- Nice2Bulk-load large data into SQL Server (SqlBulkCopy, Excel import, batching)not built
- Nice0Modelling money in C# and SQL (decimal precision/scale, never float, rounding)not built
EF Core and LINQ built 0 / 13
- Must9.5EF Core vs Dapper vs ADO.NET (DataReader vs DataSet): trade-offsnot built
- Must9.5LINQ: deferred execution, First vs Single(OrDefault), Find, GroupBy, pagination with Skip/Takenot built
- Should8.5IEnumerable vs IQueryable: where the filter runs and why it matters with EF Corenot built
- Should7Repository (and Unit of Work) pattern: why use it, and do you need it on top of EF Core?not built
- Should7Change tracking and AsNoTracking: entity states and when to switch tracking offnot built
- Should6.5What is EF Core: DbContext, DbSet, how LINQ becomes SQL; ORM vs ADO.NETnot built
- Should6.5Write LINQ queries: join, left join, group by, ordering, paginationnot built
- Should5EF Core is slow on a large table: how do you investigate and optimise it?not built
- Should4Lazy vs eager vs explicit loading; Include vs projectionnot built
- Should3Write EF Core Fluent API configuration from memory (relationships, composite keys, global query filters)not built
- Nice2.5Code-first vs database-first; how EF Core migrations work and how you apply them in productionnot built
- Nice1.5The N+1 query problem in EF Core: how you spot it and fix itnot built
- Nice0.5DbContext lifetime: why scoped, what breaks if transient or singleton, thread safetynot built
- Must23easyWrite SQL for employee/department/order tables: joins, group by, self-join for managers, top N, date rangesnot built
- Must21mediumFind the 2nd/3rd/Nth highest salary (overall and per department)not built
- Must11mediumFind and delete duplicate rows, keeping one (ROW_NUMBER/CTE)not built
- Must0mediumAdd the right (covering) index for a slow query and prove it with the execution plannot built
- Must0mediumWrite a stored procedure with parameters, TRY/CATCH and a transaction; call it from EF Core or Dappernot built
- Must0mediumRunning total and rank per group with window functionsnot built
- Should6.5easyWrite LINQ queries: join, left join, group by, ordering, paginationnot built
- Should0easyShow a filter running in memory instead of SQL (IEnumerable vs IQueryable) and fix itnot built
- Should0easyFix an injectable query: string concatenation → parameters / FromSqlInterpolatednot built
- Should3mediumWrite EF Core Fluent API configuration from memory (relationships, composite keys, global query filters)not built
- Should0mediumTransfer money between two accounts in one EF Core transaction; roll back on failurenot built
- Should0mediumWrite a generic repository and unit of work over DbContext (and say when you would not)not built
- Should0mediumPrevent lost updates: rowversion concurrency token, catch DbUpdateConcurrencyException, return 409not built
- Should0hardImplement the transactional outbox: save the entity and an outbox message in one transaction, publish from a workernot built
- Nice0mediumInsert 100k rows: SaveChanges per row vs AddRange vs SqlBulkCopy / ExecuteUpdatenot built
- Nice0mediumReproduce the DbContext concurrency error from parallel tasks; fix with IDbContextFactorynot built
- Nice0mediumSpot an N+1 in EF Core from the logged SQL and fix it (Include vs projection)not built
- Nice0mediumWrite the DDL for a loan/customer/repayment schema with keys and constraintsnot built
- Must16A query is slow (fine at 1,000 rows, slow at millions): how do you investigate and fix it?not built
- Should5EF Core is slow on a large table: how do you investigate and optimise it?not built
- Nice2.5Design pagination, filtering and sorting over millions of rows (offset vs keyset)not built
- Nice2Bulk-load large data into SQL Server (SqlBulkCopy, Excel import, batching)not built
- Nice1.5Two users update the same record at the same time: optimistic concurrency (rowversion) vs lockingnot built
- Nice2.5Design a database schema for a feature (online test, booking app)not built
Unit tests and mocking built 1 / 2
- Must4.5How do you unit test .NET code (xUnit/NUnit, Arrange-Act-Assert, what to test)?card →
- Must2Mocking dependencies (Moq/NSubstitute, Jasmine spies): mocks vs stubs vs fakesnot built
Coverage, integration tests and TDD built 0 / 3
- Must3Code coverage and SonarQube: what you target, and why 100% coverage is not the goalnot built
- Should1.5Integration and regression tests for an API (WebApplicationFactory, test database, Testcontainers)not built
- Nice0TDD: where it helps and where it hurtsnot built
Angular tests built 0 / 3
- Should2.5Angular unit tests: TestBed, mocking a service via providers, testing a componentnot built
- Nice0.5Jasmine/Karma vs Jest (and why Karma is deprecated)not built
- Nice0.5Testing components that use signalsnot built
- Must0easyMock a repository with Moq/NSubstitute, stub a return value and verify a callnot built
- Must0easyWrite xUnit tests for a LoanService method (AAA, [Theory] with [InlineData])not built
- Should0mediumTest a component with a mocked service and an HTTP call with HttpTestingControllernot built
- Should0mediumIntegration-test an endpoint with WebApplicationFactory and a real test databasenot built
Git and Docker basics built 0 / 2
- Should1.5Docker basics for a .NET dev: image vs container, multi-stage Dockerfile; a container keeps restartingnot built
- Nice1Git: Git vs GitHub, branching strategy, merge vs rebase, resolving conflictsnot built
CI/CD and deployment built 0 / 5
- Must9.5Explain your CI/CD pipeline: what happens from commit to productionnot built
- Must7.5How is your Angular + .NET app deployed to production?not built
- Must6Write the Azure DevOps YAML pipeline you described (build, test, SonarQube, Docker image, deploy)not built
- Must5.5Manage per-environment config (Dev/QA/UAT/Prod URLs, keys) for Angular and .NETnot built
- Should0Zero-downtime deployments: slots, blue-green, canary, rollingnot built
Hosting and observability built 0 / 3
- Must5Kestrel vs IIS, application pools, reverse proxy; which portnot built
- Should3Observability: logs, metrics, distributed tracing (OpenTelemetry, correlation IDs, App Insights)not built
- Nice0Health checks: liveness vs readiness in ASP.NET Core and Azurenot built
- Must6mediumWrite the Azure DevOps YAML pipeline you described (build, test, SonarQube, Docker image, deploy)not built
- Should0easyWrite a multi-stage Dockerfile for the .NET API (and the Angular app on nginx)not built
- Should0mediumAdd structured logging (Serilog), a correlation-ID middleware and OpenTelemetry tracesnot built
- Nice0easyResolve a merge conflict, rebase a feature branch, revert a bad commit (live in a terminal)not built
- Nice0easyAdd liveness and readiness health checks (database, downstream API) to the APInot built
- Must7.5How is your Angular + .NET app deployed to production?not built
- Must5.5Manage per-environment config (Dev/QA/UAT/Prod URLs, keys) for Angular and .NETnot built
- Should3Observability: logs, metrics, distributed tracing (OpenTelemetry, correlation IDs, App Insights)not built
Your Azure story built 0 / 3
- Must11.5Which Azure services does your project use, and why each one (with a real example)?not built
- Should3Hosting a .NET API in Azure: App Service vs Functions vs Container Apps/AKS vs a VMnot built
- Should1.5Thousands of concurrent requests: how do you scale an ASP.NET Core app in Azure?not built
Functions and messaging built 0 / 4
- Must11Azure Functions: triggers and bindings, and how you integrated themnot built
- Must4.5Logic Apps vs Function Apps: when to use eachnot built
- Should2Azure Service Bus: queues vs topics, vs Storage Queue, sessions, dead-letter queue, max delivery countnot built
- Nice0Azure API Management and high availability across zones/regionsnot built
Storage and data built 0 / 2
- Should3Blob Storage: storing documents, SAS tokens, upload from Angular via the API or directlynot built
- Nice0Azure SQL vs SQL on VM vs Managed Instance; when Cosmos DBnot built
Secrets, identity and monitoring built 0 / 3
- Must10Managing secrets in Azure: Key Vault and managed identity instead of passwords in confignot built
- Should0Application Insights: what you monitor and alert on (failures, latency, dependencies, KQL)not built
- Should0Securing an API and Angular app with Microsoft Entra ID (app registrations, scopes, MSAL)not built
- Must0easyWrite an HTTP-triggered and a Service Bus-triggered Azure Function (isolated worker, C#)not built
- Must0easyRead a Key Vault secret with DefaultAzureCredential (managed identity in Azure, your login locally)not built
- Should0easyWrite KQL for failed requests and p95 latency per endpoint over the last 24 hoursnot built
- Should0mediumUpload to Blob Storage and return a short-lived read-only SAS URLnot built
- Should0mediumProtect the API with Microsoft.Identity.Web and call it from Angular with MSALnot built
- Should0mediumSend and receive Service Bus messages; retry, then dead-letter a poison messagenot built
- Should1.5Thousands of concurrent requests: how do you scale an ASP.NET Core app in Azure?not built
- Must11.5Which Azure services does your project use, and why each one (with a real example)?not built
Components and templates built 0 / 13
- Must23.5Component communication: @Input/@Output, parent-child-sibling, unrelated components via a service, ViewChildnot built
- Must15.5Pipes: pure vs impure, custom pipes, the async pipenot built
- Must15Angular components and decorators: structure, @Component/@Injectable, ng-content (content projection), NgModulenot built
- Must14.5Angular lifecycle hooks: order, what each is for, and where you call an APInot built
- Must13.5Data binding in Angular: interpolation, property, event and two-way bindingnot built
- Must12Directives: component vs structural vs attribute; writing a custom directive; HostListenernot built
- Must11.5Build small UI widgets live: traffic light, countdown timer, nested modal, transfer list, quiz/recipe appnot built
- Should9What is Angular, what is an SPA, and how is Angular different from plain JavaScript?not built
- Should5.5Built-in control flow (@if, @for with track) vs *ngIf/*ngFor; trackBynot built
- Should4Online Angular assessment (CodeSignal repo with unit tests; paper JS/HTML/CSS test)not built
- Should3.5JIT vs AOT compilation; how Angular bootstraps an appnot built
- Should3Render a file/folder tree with a recursive component, then add expand/collapsenot built
- Nice2Nested checkboxes: checking a parent updates all descendantsnot built
DI, services, state and architecture built 0 / 6
- Must19Angular DI and services: providedIn, hierarchical injectors, singleton vs component-level servicenot built
- Must12State management: services vs NgRx (store, actions, reducers, selectors, effects); handling lakhs of recordsnot built
- Must9.5Signals: signal(), computed(), effect(); signals vs RxJS/BehaviorSubjectnot built
- Should6What does a good Angular project architecture look like (core/shared/features, smart vs presentational, where logic lives)?not built
- Should5Plan and execute an Angular version upgrade; which version do you use and what changednot built
- Should3Standalone components and inject() vs NgModules and constructor DInot built
RxJS built 0 / 8
- Must12Subject vs BehaviorSubject vs ReplaySubject; multicastingnot built
- Must11switchMap vs mergeMap vs concatMap vs exhaustMap, and avoiding nested subscriptionsnot built
- Should4.5Promise vs Observablenot built
- Should4.5Hot vs cold observables; shareReplaynot built
- Should3Build an autocomplete/search box with debounced suggestions, caching and keyboard supportnot built
- Should3Preventing memory leaks from subscriptions (async pipe, takeUntilDestroyed, unsubscribe)not built
- Should3Typeahead search: debounceTime + distinctUntilChanged + switchMap to cancel stale callsnot built
- Should3What is RxJS: observables, operators, subscriptionsnot built
Change detection, performance and debugging built 0 / 7
- Must12The API returns 10,000 records: how do you render them without the UI lagging (paging, virtual scroll, trackBy, OnPush)?not built
- Must5.5OnPush vs Default change detection, and fixing unnecessary re-rendersnot built
- Should4.5How Angular change detection works; what Zone.js does; zonelessnot built
- Should3Debugging and error handling in Angular/JS: DevTools, source maps, global ErrorHandlernot built
- Should1.5Render 10,000 rows with CDK virtual scroll and @for track, without lagnot built
- Nice2.5How do you improve an Angular app's performance (bundle size, lazy loading, OnPush, images)?not built
- Nice2Web workers: when to move work off the main threadnot built
Routing and forms built 0 / 7
- Must11.5Angular routing: routes, ActivatedRoute, passing an id, child routes, forRoot vs forChildnot built
- Must10.5Template-driven vs reactive forms; validators and custom (cross-field) validatorsnot built
- Must10Lazy loading routes/modules, preloading, and restricting module download for unauthorized usersnot built
- Must9.5Route guards (CanActivate, CanActivateChild, CanDeactivate, functional guards) and protecting pages after loginnot built
- Should7Build forms live: login with validation, multi-step form, fields rendered from an objectnot built
- Should3Build a reactive form with CRUD, a cross-field validator and an async validator (username taken)not built
- Should1.5Write a functional route guard: redirect to login when signed out, block by rolenot built
HTTP, auth and security built 0 / 11
- Must9Calling APIs in Angular: HttpClient, typed responses, error handling, parallel calls (forkJoin)not built
- Should8.5Call an API and show employees in a table with filter (salary > 50k), search and paginationnot built
- Should7Implement login, token storage and role-based auth in Angular (with a JWT service that refreshes/retries)not built
- Should6.5Angular security: XSS and sanitization, DomSanitizer, CSRF, storing tokens safelynot built
- Should5.5Avoid duplicate API calls: cache responses in Angular (same id searched twice), shareReplaynot built
- Should5.5HTTP interceptors: attaching tokens, global error handling, retry, loadersnot built
- Should4.5The UI is done but the backend API is not ready: how do you keep developing and testing (mocks, interceptors, contracts)?not built
- Should4.5Show a dynamic menu based on user rolesnot built
- Should3Cache API responses in a service so the same id is fetched once (Map + shareReplay), with expirynot built
- Should1HTTP interceptor: attach the JWT, refresh once on 401 while parallel requests wait, then retrynot built
- Nice2.5localStorage vs sessionStorage vs cookies; where to keep a tokennot built
JavaScript, TypeScript, HTML and CSS basics built 0 / 22
- Must17.5Array methods: map vs forEach vs filter vs reduce vs findnot built
- Must11Promises, async/await and callbacks in JavaScript; sync vs asyncnot built
- Should20.5HTML basics: semantic and meta tags, DOCTYPE, attributes, linking scriptsnot built
- Should14CSS layout: Flexbox vs Grid, centering, position values, box modelnot built
- Should9DOM, window vs document, how the browser parses and paints a pagenot built
- Should8.5Closures and execution context in JavaScript, with a real usenot built
- Should8Implement debounce and throttle from scratchnot built
- Should7.5var vs let vs const, hoisting and the temporal dead zonenot built
- Should6Responsive design: media queries and doing it without themnot built
- Should6Plain-JS data utilities: group by, sum by keys, pick keys from an object, remove items found in another arraynot built
- Should5.5this, call/apply/bind and the prototype chainnot built
- Should5CSS specificity (id vs class) and display:none vs visibility:hidden vs overflow:hiddennot built
- Should5Event bubbling, capturing and delegationnot built
- Should4== vs ===, JavaScript data types, null vs undefined, empty-object checknot built
- Should3.5The JavaScript event loop: call stack, microtasks vs macrotasks, setTimeout output puzzlesnot built
- Should3Shallow vs deep copy; spread and rest operatorsnot built
- Should3ES6+ features you use daily (arrow functions, destructuring, modules, optional chaining)not built
- Nice2.5TypeScript essentials: why TypeScript, interfaces vs types, generics, ?? vs ?:, strict modenot built
- Nice2Implement memoize and curry functionsnot built
- Nice2Predict the output of JavaScript snippets (hoisting, closures, event loop)not built
- Nice2Implement a chainable calculator: cal.add(2).sub(3).mul(4).delay(2000).add(4)not built
- Nice1package.json: dependencies vs devDependencies, semver ranges, lock filesnot built
- Must0easyPolyfill Array.prototype.map, filter and reducenot built
- Must0easyWrite an attribute directive (highlight on hover) with @HostListener and an inputnot built
- Must0easyParent/child with input()/output(), siblings through a shared servicenot built
- Must0easyWrite a custom pure pipe (e.g. amount in lakhs/crores) and say why impure pipes are costlynot built
- Must0easySet up routes with an :id param, child routes and a lazy-loaded featurenot built
- Must0easyRewrite a BehaviorSubject-based component with signal, computed and effectnot built
- Must11.5mediumBuild small UI widgets live: traffic light, countdown timer, nested modal, transfer list, quiz/recipe appnot built
- Must0mediumFix a component that does not update under OnPush (mutation vs new reference, markForCheck)not built
- Must0mediumImplement Promise.all (and a retry-with-delay helper) from scratchnot built
- Must0mediumChain dependent HTTP calls without nested subscribes (switchMap / concatMap / forkJoin)not built
- Should6easyPlain-JS data utilities: group by, sum by keys, pick keys from an object, remove items found in another arraynot built
- Should1.5easyWrite a functional route guard: redirect to login when signed out, block by rolenot built
- Should0easyFind and fix a subscription leak (takeUntilDestroyed / async pipe)not built
- Should8.5mediumCall an API and show employees in a table with filter (salary > 50k), search and paginationnot built
- Should8mediumImplement debounce and throttle from scratchnot built
- Should7mediumBuild forms live: login with validation, multi-step form, fields rendered from an objectnot built
- Should3mediumCache API responses in a service so the same id is fetched once (Map + shareReplay), with expirynot built
- Should3mediumBuild a reactive form with CRUD, a cross-field validator and an async validator (username taken)not built
- Should3mediumRender a file/folder tree with a recursive component, then add expand/collapsenot built
- Should1.5mediumRender 10,000 rows with CDK virtual scroll and @for track, without lagnot built
- Should0mediumPolyfill Function.prototype.bind (and call/apply)not built
- Should0mediumWrite a deep clone (arrays, dates, nested objects, cycles)not built
- Should0mediumWrite a global ErrorHandler plus an HTTP error interceptor that shows a toast and logs to the servernot built
- Should0mediumWrite a state service with signals (or BehaviorSubject): load, select and update a list shared by componentsnot built
- Should3hardBuild an autocomplete/search box with debounced suggestions, caching and keyboard supportnot built
- Should1hardHTTP interceptor: attach the JWT, refresh once on 401 while parallel requests wait, then retrynot built
- Nice2easyPredict the output of JavaScript snippets (hoisting, closures, event loop)not built
- Nice2mediumImplement memoize and curry functionsnot built
- Nice2mediumNested checkboxes: checking a parent updates all descendantsnot built
- Nice0mediumUpload a file with a progress bar (reportProgress) and a cancel buttonnot built
- Nice2hardImplement a chainable calculator: cal.add(2).sub(3).mul(4).delay(2000).add(4)not built
- Must12The API returns 10,000 records: how do you render them without the UI lagging (paging, virtual scroll, trackBy, OnPush)?not built
- Should7Implement login, token storage and role-based auth in Angular (with a JWT service that refreshes/retries)not built
- Should5.5Avoid duplicate API calls: cache responses in Angular (same id searched twice), shareReplaynot built
- Should5Plan and execute an Angular version upgrade; which version do you use and what changednot built
- Should4.5The UI is done but the backend API is not ready: how do you keep developing and testing (mocks, interceptors, contracts)?not built
- Should4.5Show a dynamic menu based on user rolesnot built
- Nice2.5How do you improve an Angular app's performance (bundle size, lazy loading, OnPush, images)?not built
- Should6What does a good Angular project architecture look like (core/shared/features, smart vs presentational, where logic lives)?not built
- Should4mediumOnline Angular assessment (CodeSignal repo with unit tests; paper JS/HTML/CSS test)not built
Big-O and problem approach built 0 / 2
- Should0Big-O: time vs space complexity, and a trade-off where you spend memory to save timenot built
- Should0How do you approach a problem you have never seen (clarify, brute force, optimise, test aloud)?not built
Arrays and strings built 0 / 10
- Must14.5Array basics: rotate by k, move zeros to the end, merge sorted arrays, plus-one carry, missing numbernot built
- Must12Remove duplicates from an array and sort descending (with and without LINQ)not built
- Must11Palindrome and anagram checks; group anagramsnot built
- Must8.5Primes, factorial (with and without loops) and Fibonaccinot built
- Must6Find the largest, second largest or smallest element (and its count) without sortingnot built
- Must5.5Reverse a string / reverse the words in a sentence / reverse only lettersnot built
- Must5Count the occurrences of each character (or word) in a stringnot built
- Should6Print number/star patterns (pyramid, triangle) and simple seriesnot built
- Nice1.5Compress a string: "aabbccaaa" → "2a2b2c3a"not built
- Nice0Common array/string staples from prep lists (no 2026 report yet)not built
Hashing, two pointers and sliding window built 0 / 3
- Must10Longest substring without repeating characters (sliding window)not built
- Must4.5Two Sum (pairs that add up to a target), including in a 2D matrixnot built
- Nice0Two-pointer and hashing patterns (pair sums, dedupe in place, top-K frequent)not built
Sorting, searching, stacks, lists and trees built 0 / 3
- Must10.5Sort without built-ins (merge sort) and binary search, including rotated sorted arraysnot built
- Must4.5Linked list and tree basics: reverse a linked list, validate a BSTnot built
- Nice1Valid parentheses (stack)not built
Graphs, recursion and DP built 0 / 2
- Must12Graph problems: number of islands, BFS/DFS, Dijkstranot built
- Nice0Recursion vs iteration and DP basics (climbing stairs, coin change)not built
- Must8easyRemove duplicates from an integer array and sort descending (with and without LINQ)not built
- Must6.5easyCheck a prime / print primes up to Nnot built
- Must4.5easyBinary search on a sorted arraynot built
- Must4.5easyMove zeros to the end, keeping the order of the restnot built
- Must4.5easyPalindrome check (string and number)not built
- Must4easyFind all duplicate elements in an array or listnot built
- Must4easyMerge two sorted arraysnot built
- Must14.5Array basics: rotate by k, move zeros to the end, merge sorted arrays, plus-one carry, missing numbernot built
- Must12Graph problems: number of islands, BFS/DFS, Dijkstranot built
- Must12Remove duplicates from an array and sort descending (with and without LINQ)not built
- Must11Palindrome and anagram checks; group anagramsnot built
- Must10.5Sort without built-ins (merge sort) and binary search, including rotated sorted arraysnot built
- Must10Longest substring without repeating characters (sliding window)not built
- Must9mediumLongest substring without repeating charactersnot built
- Must8.5Primes, factorial (with and without loops) and Fibonaccinot built
- Must6Find the largest, second largest or smallest element (and its count) without sortingnot built
- Must5.5Reverse a string / reverse the words in a sentence / reverse only lettersnot built
- Must5Count the occurrences of each character (or word) in a stringnot built
- Must4.5Two Sum (pairs that add up to a target), including in a 2D matrixnot built
- Must4.5mediumBFS and DFS traversal of a graphnot built
- Must4.5mediumGroup anagramsnot built
- Must4.5Linked list and tree basics: reverse a linked list, validate a BSTnot built
- Must4mediumSearch in, or find the min/max of, a rotated sorted arraynot built
- Should3easyCount the occurrences of each character in a stringnot built
- Should3easyPrint a number series (100 to 1, evens, 99 96 … 3)not built
- Should3easyPrint a star triangle or pyramidnot built
- Should3easyTwo Sum: indices of two numbers that add up to a targetnot built
- Should2easyReverse a string or an array without built-insnot built
- Should2easySecond largest element without sorting (single pass)not built
- Should2easyCheck if two strings are anagramsnot built
- Should2easyCount the words in a sentence; find the longest namenot built
- Should6Print number/star patterns (pyramid, triangle) and simple seriesnot built
- Should3mediumRotate an array by k stepsnot built
- Should3mediumValidate a binary search treenot built
- Should2.5mediumSort without built-ins (merge sort)not built
- Should3hardSliding window maximum (monotonic deque)not built
- Should3hardConnected components with union-find (DSU)not built
- Nice1.5easyCompress a string: "aabbccaaa" → "2a2b2c3a"not built
- Nice1.5easyAdd two binary stringsnot built
- Nice1.5easyFibonacci: iterative, recursive, memoisednot built
- Nice1.5easyReverse a linked listnot built
- Nice1.5easyReverse only the letters, keep digits in placenot built
- Nice1.5easyInteger square root without Math.Sqrtnot built
- Nice1easyCustom sort: letters ascending, then digits descendingnot built
- Nice1easyFactorial with a loop and with recursionnot built
- Nice1easySmallest element and how many times it occursnot built
- Nice1easyFind the missing number in 1..nnot built
- Nice1easyPlus one: add 1 to a number stored as an array of digits (carry)not built
- Nice1easyReverse the vowels in a stringnot built
- Nice1easyReverse the words in a sentencenot built
- Nice1easySplit an array into two halves and sort each half in placenot built
- Nice1easyValid parentheses (stack)not built
- Nice1easySum of the digits of a numbernot built
- Nice0easyBest time to buy and sell a stocknot built
- Nice0easyClimbing stairsnot built
- Nice0easyFirst non-repeating character in a stringnot built
- Nice0easyDetect a cycle in a linked listnot built
- Nice0easyRemove duplicates from a sorted array in placenot built
- Nice1.5mediumNumber of islands in a gridnot built
- Nice1.5mediumUnique pairs in a 2D matrix that sum to a targetnot built
- Nice0mediumCoin change (fewest coins)not built
- Nice0Common array/string staples from prep lists (no 2026 report yet)not built
- Nice0mediumKth largest elementnot built
- Nice0mediumLevel-order traversal of a binary treenot built
- Nice0mediumMaximum subarray sum (Kadane)not built
- Nice0mediumMerge overlapping intervalsnot built
- Nice0mediumProduct of array except selfnot built
- Nice0Recursion vs iteration and DP basics (climbing stairs, coin change)not built
- Nice0mediumGenerate all subsets / permutationsnot built
- Nice0mediumThree Sum (triplets that add up to zero)not built
- Nice0mediumTop K frequent elementsnot built
- Nice0Two-pointer and hashing patterns (pair sums, dedupe in place, top-K frequent)not built
- Nice1.5hardShortest path with Dijkstranot built
Request flow and building blocks built 0 / 7
- Must13.5Explain the complete flow of a request from Angular to the API, business layer and databasenot built
- Must10.5System design building blocks: load balancer, reverse proxy, API gateway, CDN, Redis, message queuenot built
- Should4.5Write functional and non-functional requirements and draw the architecture for a given problemnot built
- Should3What to cache where: browser/Angular, CDN, API (Redis), database; invalidationnot built
- Should3Layered vs Clean Architecture (dependency rule, vertical slices): what goes in each layer and whynot built
- Should2.5A page takes too long to load: debug across browser, network, API and databasenot built
- Should2What happens when you type a URL and press Enter?not built
Microservices and messaging built 0 / 4
- Must19Microservices vs monolith: when to split, how services communicate, and how you migratenot built
- Must14.5Sync vs async communication; queues/Kafka; real-time with polling vs WebSocket vs SSE (SignalR)not built
- Must7.5Circuit breaker and cascading failures in microservicesnot built
- Must7.5Distributed transactions and the saga pattern (orchestration vs choreography)not built
Scalable back-end design cases built 0 / 6
- Must13Design a scalable ASP.NET Core + Angular system for high traffic (caching, DB, failure handling, logging, deployment)not built
- Must6.5Classic HLD prompts: Twitter feed (celebrity fan-out), notification feed, live streaming, quick-commerce surgenot built
- Should2Design a URL shortener with a rate limiter / a multi-tenant rate limiternot built
- Should0Design a loan application / repayment system with an audit trail (your own domain)not built
- Nice1.5Design a banking/payment API that stays consistent under concurrency (idempotency, no double charge)not built
- Nice1.5Upload a 500 MB file directly from the browser to storage (pre-signed/SAS URLs, chunking, resume)not built
Front-end system design built 0 / 8
- Must5Improve page load: code splitting, tree shaking, lazy loading, caching, CDNnot built
- Should4CSR vs SSR vs SSG (Angular SSR, hydration): when eachnot built
- Should4Front-end design: a real-time / analytics-heavy dashboard that still loads fastnot built
- Should3.5Micro-frontends and Module Federation: benefits, setup, Angular and React togethernot built
- Should3How a front-end system design round runs (RADIO: requirements, architecture, data model, interface, optimisations)not built
- Should2Front-end design: airports on a map where users log in and report incidentsnot built
- Should2Infinite scroll / update content on scroll in an e-commerce listnot built
- Nice1Show the live number of users viewing a pagenot built
- Must13.5Explain the complete flow of a request from Angular to the API, business layer and databasenot built
- Should2.5A page takes too long to load: debug across browser, network, API and databasenot built
- Must13Design a scalable ASP.NET Core + Angular system for high traffic (caching, DB, failure handling, logging, deployment)not built
- Must6.5Classic HLD prompts: Twitter feed (celebrity fan-out), notification feed, live streaming, quick-commerce surgenot built
- Should4.5Write functional and non-functional requirements and draw the architecture for a given problemnot built
- Should4Front-end design: a real-time / analytics-heavy dashboard that still loads fastnot built
- Should3What to cache where: browser/Angular, CDN, API (Redis), database; invalidationnot built
- Should3How a front-end system design round runs (RADIO: requirements, architecture, data model, interface, optimisations)not built
- Should2Design a URL shortener with a rate limiter / a multi-tenant rate limiternot built
- Should2Front-end design: airports on a map where users log in and report incidentsnot built
- Should2Infinite scroll / update content on scroll in an e-commerce listnot built
- Should0Design a loan application / repayment system with an audit trail (your own domain)not built
- Nice1.5Design a banking/payment API that stays consistent under concurrency (idempotency, no double charge)not built
- Nice1.5Upload a 500 MB file directly from the browser to storage (pre-signed/SAS URLs, chunking, resume)not built
- Nice1Show the live number of users viewing a pagenot built
Design patterns and principles built 0 / 6
- Must7.5LLD of a module from your own project (class diagram, patterns, concurrency)not built
- Must7Which design patterns have you used? Explain one with a real examplenot built
- Must5CQRS (with MediatR): what it is, when it is worth itnot built
- Must5Implement a thread-safe singleton; static class vs singletonnot built
- Should3Design a payment system (UML): Factory vs Strategynot built
- Nice1.5Write a calculator that applies all SOLID principlesnot built
Machine-coding classics built 0 / 7
- Should3.5Design and implement a publish-subscribe system (Observer pattern)not built
- Must9Machine coding: library / car rental / gym membership / parking lot (classes, relationships, race conditions)not built
- Must9Implement an LRU cache with O(1) operations (and per-item TTL, thread-safe)not built
- Must6Design a HashMap / a sharded map with iteratorsnot built
- Should3.5Implement a rate limiter (token bucket / sliding window)not built
- Should3Meeting rooms: book only if the room is free (interval overlap)not built
- Nice1.5Design a streaming error-log counter with a moving averagenot built
Concurrency designs built 0 / 2
- Must6Implement a thread-safe producer-consumer queue with a bounded buffernot built
- Must6Design a thread pool; analyse a huge file using multithreadingnot built
Front-end LLD built 0 / 2
- Should0Design a reusable Angular component API (data table, dropdown, modal): inputs, outputs, projection, statenot built
- Must4Front-end machine coding: build a chat UI (components, state, message list) in 90 minutesnot built
- Must9hardMachine coding: library / car rental / gym membership / parking lot (classes, relationships, race conditions)not built
- Must9hardImplement an LRU cache with O(1) operations (and per-item TTL, thread-safe)not built
- Must6hardImplement a thread-safe producer-consumer queue with a bounded buffernot built
- Must6hardDesign a HashMap / a sharded map with iteratorsnot built
- Must6hardDesign a thread pool; analyse a huge file using multithreadingnot built
- Must4hardFront-end machine coding: build a chat UI (components, state, message list) in 90 minutesnot built
- Should3.5mediumDesign and implement a publish-subscribe system (Observer pattern)not built
- Should3.5mediumImplement a rate limiter (token bucket / sliding window)not built
- Should3mediumMeeting rooms: book only if the room is free (interval overlap)not built
- Must7.5LLD of a module from your own project (class diagram, patterns, concurrency)not built
- Should3Design a payment system (UML): Factory vs Strategynot built
- Should0Design a reusable Angular component API (data table, dropdown, modal): inputs, outputs, projection, statenot built
- Nice1.5Write a calculator that applies all SOLID principlesnot built
- Nice1.5Design a streaming error-log counter with a moving averagenot built
LLM and prompt basics built 0 / 7
- Must9LLM fundamentals for app developers: tokens, transformer, temperature, context window, BERT vs GPTnot built
- Must6Prompt engineering that holds in production: system prompts, few-shot, structured (JSON) output, versioning promptsnot built
- Must5Azure OpenAI and Azure AI Foundry in a .NET app: projects, model deployments (standard vs provisioned), quotas/TPM, authnot built
- Should2Fine-tuning vs RAG vs prompting (and long context with caching): how you choosenot built
- Should1Semantic Kernel / Microsoft Agent Framework in C#: kernel, plugins, function calling, memorynot built
- Should1Stream LLM responses to the browser from ASP.NET Core (SSE / IAsyncEnumerable)not built
- Nice1Count tokens on the client in C# to stay inside context and budget limitsnot built
RAG core built 0 / 8
- Must22.5How does RAG work end to end (ingest, chunk, embed, retrieve, generate), and why not just prompt the model?not built
- Must16.5Embeddings and vector databases: semantic search, dimensions, updating documents, contextual embeddingsnot built
- Must13.5Build a small RAG over PDFs (or a LangChain chatbot) in the interview, explaining each choicenot built
- Must7.5Chunking: chunk size, overlap, structure-aware chunking, and what breaks when you raise knot built
- Must7.5Hybrid search (BM25 + vectors) and rerankingnot built
- Should5.5RAG variants: GraphRAG, multi-hop and cross-document retrieval, agentic RAGnot built
- Should3.5Azure AI Search for RAG: index design, indexers/skillsets, vector + hybrid + semantic ranker, security trimmingnot built
- Should3Ingesting PDFs/scans: Azure AI Document Intelligence / OCR before chunkingnot built
RAG quality and evals built 0 / 6
- Must12.5Reducing hallucinations: grounding, citations, contradictory or outdated sourcesnot built
- Must11.5How do you evaluate a RAG pipeline (golden set, retrieval vs answer metrics, RAGAS vs BLEU/ROUGE)?not built
- Must7.5The right document exists but the answer is wrong (or retrieval returns junk): how do you debug a RAG pipeline?not built
- Should4.5Eval score went up but user complaints rose (or golden set flat after a model upgrade): what now?not built
- Nice2LLM-as-judge: how you know the judge is good, and whether to use it as a live guardrailnot built
- Nice1Testing a non-deterministic LLM feature (temperature 0 is not deterministic)not built
Agents, tools and MCP built 0 / 5
- Must10.5Agent vs RAG vs fixed workflow: when you should NOT use an agent; single vs multi-agentnot built
- Must9LangChain vs LangGraph: chains vs stateful agent graphsnot built
- Must8.5Tool calling and MCP: what an MCP server is, and designing an agent that uses tools via MCPnot built
- Should4.5Agent failure modes: tool-call loops, wrong tool, agents ping-ponging, a retried payment tool (idempotency)not built
- Nice1MCP security: token passthrough, confused deputy, tool poisoningnot built
Guardrails, security and responsible AI built 0 / 6
- Should3Guardrails: stop the bot making commitments (₹1 sale, waived fee, wrong refund policy); Responsible AInot built
- Should1.5Prompt injection (direct and indirect) and the OWASP LLM Top 10; Azure Prompt Shields in a .NET pipelinenot built
- Should1.5Document-level access control in RAG (security trimming) and cross-tenant leaks via semantic cachenot built
- Should0.5Azure AI Content Safety and content filters; Responsible AI principles in a shipped featurenot built
- Nice1.5Securing a GenAI API: key management, authn/authz, per-user quotasnot built
- Nice0.5Customer PII shows up in App Insights traces: fix and preventnot built
Production design, cost and your project story built 0 / 7
- Must21Walk me through your GenAI project: architecture, why these choices, what broke, how you measured itnot built
- Must13Design a production (enterprise) RAG system, deploy it, and scale it from 10k to 1M documentsnot built
- Must7.5Design an LLM-backed feature: resume matching, Text-to-SQL, a support assistant you can prove helpsnot built
- Should3.5LLM cost and latency: bill tripled / $100→$700 a day, prompt caching at 0%, model routing, cost per resolved tasknot built
- Should1.5Monitoring an LLM feature in production: LLMOps, human review sampling, accuracy and hallucination detection on live trafficnot built
- Should1.5429s at peak: rate limits, retries with backoff, provider pool and fallbacknot built
- Should0You list AI-103: what did it cover, and what have you built with it?not built
- Must0easyWrite a chunker with size and overlap (token-aware)not built
- Must0easyEmbed texts and return the top-k by cosine similarity in C#not built
- Must0mediumWrite a tiny eval harness: golden set, hit-rate@k and an LLM-judge groundedness scorenot built
- Must0mediumGet JSON output from the model, validate it into a C# record, retry once on invalid outputnot built
- Must13.5hardBuild a small RAG over PDFs (or a LangChain chatbot) in the interview, explaining each choicenot built
- Must0hardBuild a minimal RAG endpoint in C#: chunk, embed, store, retrieve top-k, answer with citationsnot built
- Should0mediumAdd input and output guardrails (Prompt Shields / Content Safety) around a model callnot built
- Should0mediumWrap the chat client: retry 429 honouring Retry-After, then fall back to a second deploymentnot built
- Should0mediumGive the model a C# tool (Microsoft.Extensions.AI / Semantic Kernel function calling) and run the tool loopnot built
- Should0mediumStream an LLM answer from ASP.NET Core (IAsyncEnumerable / SSE) and render it token by token in Angular, with cancelnot built
- Nice0easyCount tokens (Microsoft.ML.Tokenizers) and trim chat history to a budgetnot built
- Nice0mediumRedact PII from prompts before they reach logs and App Insightsnot built
- Nice0hardWrite a minimal MCP server in C# exposing one tool, and call it from an agentnot built
- Must7.5mediumThe right document exists but the answer is wrong (or retrieval returns junk): how do you debug a RAG pipeline?not built
- Should4.5Eval score went up but user complaints rose (or golden set flat after a model upgrade): what now?not built
- Should3.5LLM cost and latency: bill tripled / $100→$700 a day, prompt caching at 0%, model routing, cost per resolved tasknot built
- Should3Guardrails: stop the bot making commitments (₹1 sale, waived fee, wrong refund policy); Responsible AInot built
- Should1.5Monitoring an LLM feature in production: LLMOps, human review sampling, accuracy and hallucination detection on live trafficnot built
- Should1.5429s at peak: rate limits, retries with backoff, provider pool and fallbacknot built
- Should1.5Document-level access control in RAG (security trimming) and cross-tenant leaks via semantic cachenot built
- Should4.5hardAgent failure modes: tool-call loops, wrong tool, agents ping-ponging, a retried payment tool (idempotency)not built
- Nice0.5Customer PII shows up in App Insights traces: fix and preventnot built
- Must21Walk me through your GenAI project: architecture, why these choices, what broke, how you measured itnot built
- Should0You list AI-103: what did it cover, and what have you built with it?not built
- Must13Design a production (enterprise) RAG system, deploy it, and scale it from 10k to 1M documentsnot built
- Must7.5Design an LLM-backed feature: resume matching, Text-to-SQL, a support assistant you can prove helpsnot built
- Must6.5mediumCode-review round: review an AI-generated PR with planted subtle bugsnot built
- Must15.5hardAI-enabled coding round: fix a bug, build a feature and optimise with an AI assistant while narratingnot built
- Should3Inherit a messy AI-generated codebase with no docs: how do you make sense of it and fix it?not built
- Must19AI-led screening interviews: what the bot asks (resume-based questions, basics, coding) and how to answer itnot built
- Must14.5How do you use AI tools in your work (which tools, how much, at which step), and how has your workflow changed?not built
- Must8How do you check AI-generated code is correct, safe and efficient before you merge it?not built
- Must5Working with coding agents: giving enough context, keeping changes reviewable, limited tokens, parallel sessionsnot built
- Should4Explain the code you (or the AI) just wrote; change it under a new constraint; give its complexitynot built
- Nice1AI policy: may proprietary code go into an AI tool, and is AI allowed in this interview?not built
- Nice1Does AI make you (or a teammate) faster, or just busier? How do you tell?not built
- Should4Tell me about a time an AI tool gave you a subtly wrong answernot built
- Must25.5Explain your current project: domain, architecture, your role, modules, one feature end to end, deploymentnot built
- Should0How does Agile/Scrum work in your team? Your part in each ceremony; a story spills over; how do you estimate, and what did you do when an estimate was wrong?not built
- Must12How comfortable are you with .NET / UI work / React? Your strongest skillsnot built
- Must9The most challenging problem you faced and how you overcame itnot built
- Must8Tell me about yourself (roles and responsibilities, in 90 seconds)not built
- Must6A difficult production issue you personally investigated and fixed (diagnosis, fix, follow-up)not built
- Should4.5A system or feature you designed and owned: trade-offs, what you would do differentlynot built
- Should4.5Amazon-style Leadership Principles questions with deep follow-upsnot built
- Should4How is your team structured; who owns contracts and deployments; working with another team you depend onnot built
- Should3.5How do you prioritise and handle pressure and tight deadlines?not built
- Should3How does code review work in your team; who reviews; what rules do you follow?not built
- Should3Dealing with ambiguous or changing requirementsnot built
- Should0A disagreement with a teammate or architect, or pushing back on scope/quality; influencing without authoritynot built
- Should0Improving a process or codebase; mentoring juniorsnot built
- Nice1Push back on an unrealistic AI ask (CFO wants the bot to replace support) without hurting the relationshipnot built
- Nice0Learning something new fast; receiving tough feedbacknot built
- Must22What is your notice period? Can it be bought out or reduced?not built
- Must12.5Why are you looking for a change? Explaining a layoff, short stint or career gapnot built
- Must12Current and expected CTC; handling a budget mismatchnot built
- Must6.5Relocation, commute, travel and preferred locationnot built
- Should4.5Background verification: letters, Form 16, PF must match your claimsnot built
- Should2.5Why should we hire you? Where do you see yourself in 5 years?not built
- Should0Why this company? (prepared per company)not built