Abhishek Rai

ASP.NET Core is a cross-platform, high-performance framework for building modern web applications. Learn the fundamentals of the request pipeline, middleware, and configuration system.

Build RESTful APIs using controllers. Understand routing, model binding, validation, and response formatting with ActionResult.

A streamlined approach to building APIs in .NET 6+. MapGet, MapPost, parameter binding, and structured responses.

Every ASP.NET Core request flows through a pipeline of middleware components. Learn to build custom middleware for cross-cutting concerns.

Built-in DI container. Register services with AddScoped, AddTransient, AddSingleton. Constructor injection pattern.

JWT authentication setup, policy-based authorization, role management, and Azure AD integration.

Build real-time web functionality with SignalR. WebSocket-based communication for live dashboards and notifications.

ORM for .NET. DbContext, migrations, LINQ queries, change tracking, and performance optimization.

Schedule and process background tasks using Hangfire. Recurring jobs, fire-and-forget, and delayed jobs.

Unit testing with xUnit, integration testing with WebApplicationFactory, containerization with Docker.

JavaScript runtime built on Chrome's V8 engine. Event loop, non-blocking I/O, modules, and npm ecosystem.

Minimal and flexible Node.js web application framework. Routing, middleware, error handling, and template engines.

React framework for production. SSR, SSG, API routes, file-based routing, and middleware.

Principles of RESTful API design. Resource naming, status codes, versioning, pagination, and error handling.

JWT, OAuth 2.0, session-based auth, cookies, and Passport.js middleware for Node.js.

Mongoose for MongoDB, Sequelize for SQL. Connection pooling, migrations, and query optimization.

WebSockets, Socket.IO, and Server-Sent Events. Building real-time features like chat and notifications.

Jest, Mocha, Supertest for API testing. Debugging with Chrome DevTools and VS Code.

Deploying Node.js apps to Azure, Docker, and cloud platforms. PM2 process management, environment configuration.

Distributed event streaming platform. Topics, partitions, producers, consumers, and brokers. Kafka's log-based storage.

Publishing and subscribing to records. Serialization (Avro, JSON), partitioning strategies, and consumer groups.

Using Confluent.Kafka client in .NET. Producing and consuming messages with async/await, error handling, and idempotence.

Stream processing with Kafka Streams API and KSQL. Stateless and stateful operations, windowing, and joins.

Building microservices that communicate through events. Event sourcing, CQRS, and eventual consistency patterns.

Import/export data from external systems using Kafka Connect. Source and sink connectors for databases and cloud services.

Monitoring Kafka clusters. Metrics, logging, Cruise Control for rebalancing, and disaster recovery strategies.

Tuning producers, consumers, and brokers for throughput and latency. Batch size, compression, acks, and buffer memory.

MongoDB stores data as BSON documents. Collections, documents, _id field, dynamic schema, and embedded vs referenced data.

Insert, find, update, and delete operations. Query operators ($gt, $in, $regex), projection, sorting, and pagination.

Powerful data processing pipeline. $match, $group, $sort, $lookup, $unwind, $project stages. Complex analytics.

Single field, compound, multikey, text, and geospatial indexes. Index intersection, covered queries, and explain() analysis.

MongoDB schema design patterns. One-to-one, one-to-many, many-to-many. Bucketing, polymorphism, and time series patterns.

Multi-document ACID transactions in MongoDB. Transaction API, retry logic, and when to use vs when to avoid transactions.

Replica sets for high availability. Primary/secondary/arbiter nodes. Sharding for horizontal scaling, shard keys, and balancers.

Query profiling, slow query logging, memory management. Authentication, authorization, encryption, and auditing.

Query language for APIs. Schema definition, type system, queries, mutations, subscriptions. Comparison with REST.

Object types, scalar types, enums, interfaces, unions, and input types. Non-null and list modifiers.

Resolver functions that fetch data for each field. DataLoader for batching and caching, solving N+1 problem.

Real-time GraphQL with subscriptions. WebSocket-based event streaming. Integration with Kafka and SignalR.

Depth limiting, query complexity analysis, rate limiting, authentication middleware, persisted queries.

Apollo Server, GraphQL Yoga, Hot Chocolate (.NET). GraphiQL, Apollo Studio, code generation.

In-memory data structure store. Strings, hashes, lists, sets, sorted sets. Expiration, persistence, and eviction policies.

Cache-aside, read-through, write-through, write-behind. Cache invalidation strategies. Distributed caching with Redis.

Redis Pub/Sub for message broadcasting. Redis Streams for persistent, consumer-group-based message processing.

Token bucket and sliding window rate limiting. Distributed locks with Redlock algorithm. Leaderboards and counters.

StackExchange.Redis client. Connection multiplexing, async operations, serialization, and health checks.

Docker architecture. Images, containers, layers, Dockerfile, and Docker Compose for multi-container apps.

Multi-stage builds, layer caching, minimal base images, security scanning, and health checks.

Orchestrating multi-service applications. Networks, volumes, environment variables, and service dependencies.

Azure App Service, Azure Functions, Azure Container Instances, AKS, and Azure DevOps pipelines.

GitHub Actions, Azure DevOps. Build, test, and deploy automation. Container registries and deployment strategies.

Application Insights, Serilog, structured logging. Metrics, traces, alerts, and dashboards for production systems.

Identity as a Service. Tenants, directories, applications, service principals, and managed identities.

Authorization code flow, client credentials, PKCE. Access tokens, refresh tokens, ID tokens. Scopes and claims.

JSON Web Token structure (header, payload, signature). Signing algorithms (RS256, HS256), validation, and security considerations.

Role-based access control. Custom policies, claims-based authorization, and resource-based permissions in ASP.NET Core.

Securing APIs with Azure AD. Daemon apps, on-behalf-of flow, and multi-tenant application architecture.