.

NET FULL STACK

COMPLETE STUDY GUIDE
Crack 10+ LPA Interviews in 2026–2027

Prepared for: Srinithi Arulanandam

Target: Accenture / MNC .NET Developer Roles | 10–16 LPA
Timeline: March 2026 – January 2027

WHAT'S INSIDE

Chapter 1 → C# & OOP Fundamentals

Chapter 2 → [Link] Core & Web API
Chapter 3 → Entity Framework Core & SQL
Chapter 4 → Architecture & Design Patterns
Chapter 5 → Azure & Cloud
Chapter 6 → System Design Basics
Chapter 7 → Frontend: React Essentials
Chapter 8 → Interview Strategy & Study Plan

CHAPTER 1
C# & Object Oriented Programming
The foundation of every .NET interview — non-negotiable

Core C# Concepts You Must Know

Data Types & Variables
• Value types: int, float, double, bool, char, struct, enum — stored on stack
• Reference types: string, class, array, object — stored on heap
• Nullable types: int? x = null — allows null for value types
• var keyword: implicit typing, type inferred at compile time
• const vs readonly: const is compile-time, readonly is runtime

OOP Pillars — Must explain with examples

Pillar One-Line Definition

Encapsulation Hiding internal state, exposing only through

properties/methods

Inheritance Child class inherits fields and methods from parent class

Polymorphism Same method behaves differently — overloading &

overriding
 Abstraction Hiding complexity, showing only essential features via
abstract/interface

Abstract Class vs Interface — Most asked interview question

Abstract Class Interface

Can have implementation Only method signatures (C# 8+ allows default impl)

Single inheritance only Multiple interfaces allowed

Can have constructors Cannot have constructors

Use when: shared base logic Use when: defining a contract

Q: What is the difference between abstract class and interface?

A: Abstract class can have both implemented and abstract methods, supports single inheritance, and is used
when classes share common logic. Interface defines a contract with no implementation (pre C#8), supports
multiple implementation, and is used when unrelated classes need the same behavior. Example: IDisposable is
an interface because any class — FileStream, SqlConnection — needs to implement it regardless of hierarchy.

Collections — Critical for interviews

Collection Key Feature When to Use

List<T> Dynamic array, index access General purpose ordered list

Dictionary<K,V> Key-value, O(1) lookup Fast lookups by key

HashSet<T> Unique elements, no duplicates Distinct value checks

Queue<T> FIFO — First In First Out Task queues, BFS

Stack<T> LIFO — Last In First Out Undo operations, DFS

IEnumerable<T> Read-only iteration Deferred execution, LINQ

LINQ — Very commonly tested

LINQ (Language Integrated Query) lets you query collections using SQL-like syntax in C#.

// Method syntax (preferred in interviews)

var seniors = employees
.Where(e => [Link] > 30)
.OrderBy(e => [Link])
.Select(e => new { [Link], [Link] })
.ToList();

// Deferred execution — query runs only when iterated

var query = [Link](x => x > 5); // not executed yet
var result = [Link](); // executed here

Q: What is deferred execution in LINQ?

A: LINQ queries are not executed when defined — they execute only when iterated (ToList, foreach, First etc.).
This is deferred execution. It improves performance by not processing data until needed. Immediate execution
methods: ToList(), ToArray(), Count(), First().

Exception Handling
try {
// risky code
 } catch (SqlException ex) {
// specific exception first
[Link](ex, "DB error");
} catch (Exception ex) {
// generic last
throw; // re-throw preserves stack trace
} finally {
// always runs — close connections here
}

async / await — Essential for .NET APIs

async/await enables non-blocking I/O operations. Every database call, HTTP call, and file operation should be async in modern
.NET.

// Always use async all the way down

public async Task<User> GetUserAsync(int id) {
return await _dbContext.[Link](id);
}

//
❌✅
// Common mistakes to avoid:
// .Result or .Wait() — causes deadlocks
await all the way

Q: What is the difference between Task and Thread?

A: Thread is a low-level OS thread. Task is a higher-level abstraction over ThreadPool — lighter, supports
async/await, cancellation, and continuations. In .NET, always prefer Task over Thread for async operations.

CHAPTER 2
[Link] Core & Web API
The heart of every .NET Full Stack role — deepest interview focus

[Link] Core Request Pipeline

Understanding the middleware pipeline is critical — this is asked in almost every senior .NET interview.

// [Link] — Middleware order matters

var app = [Link]();

[Link](); // 1. Global error handling

[Link](); // 2. Force HTTPS
[Link](); // 3. Serve static files
[Link](); // 4. Match routes
[Link](); // 5. Who are you?
[Link](); // 6. What can you do?
[Link](); // 7. Execute controller

Q: What is middleware in [Link] Core?

A: Middleware is software assembled into a pipeline to handle HTTP requests and responses. Each component
can pass to the next or short-circuit. Order matters — authentication must come before authorization. Custom
middleware is created using IMiddleware or Use/Run/Map extension methods.

Dependency Injection — Most Important Topic

DI is built into [Link] Core. You MUST understand the three lifetime scopes — this is asked in every interview.
Lifetime How Long It Lives Use For

Transient New instance every injection Lightweight, stateless services

 Scoped One per HTTP request DbContext, business services

Singleton One for app lifetime Config, caching, logging

// Registering services in [Link]

[Link]<IEmailService, EmailService>();
[Link]<IUserService, UserService>();
[Link]<ICacheService, CacheService>();

// Constructor injection in controller

public class UserController : ControllerBase {
private readonly IUserService _userService;
public UserController(IUserService userService) {
_userService = userService;
}
}

Q: What happens if you inject a Scoped service into a Singleton?

A: This is called a captive dependency problem. The Scoped service gets captured by the Singleton and lives as
long as the Singleton (app lifetime), not per-request. This causes data leaks between requests. [Link] Core
throws an InvalidOperationException at runtime if you do this with scope validation enabled.

REST API Best Practices

HTTP Method Action Example URL

GET Read resource GET /api/users/1

POST Create resource POST /api/users

PUT Replace resource PUT /api/users/1

PATCH Partial update PATCH /api/users/1

DELETE Delete resource DELETE /api/users/1

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase {

[HttpGet("{id}")]
public async Task<ActionResult<UserDto>> GetUser(int id) {
var user = await _userService.GetByIdAsync(id);
if (user == null) return NotFound();
return Ok(user);
}

[HttpPost]
public async Task<ActionResult<UserDto>> CreateUser(CreateUserDto dto) {
if (![Link]) return BadRequest(ModelState);
var user = await _userService.CreateAsync(dto);
return CreatedAtAction(nameof(GetUser), new { id = [Link] }, user);
}
}

JWT Authentication — Always Asked

JWT (JSON Web Token) is the standard authentication mechanism for REST APIs. Three parts: [Link]

// [Link] setup
[Link]([Link])
.AddJwtBearer(options => {
 [Link] = new TokenValidationParameters {
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = config["Jwt:Issuer"],
IssuerSigningKey = new SymmetricSecurityKey(
[Link](config["Jwt:Key"]))
};
});

// Protecting endpoints
[Authorize]
[HttpGet("profile")]
public IActionResult GetProfile() => Ok([Link]);

[Authorize(Roles = "Admin")]
[HttpDelete("{id}")]
public IActionResult DeleteUser(int id) { ... }

CHAPTER 3
Entity Framework Core & SQL Server
Data layer expertise — critical for enterprise roles

Entity Framework Core Essentials

DbContext & DbSet
public class AppDbContext : DbContext {
public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

public DbSet<User> Users { get; set; }

public DbSet<Order> Orders { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder) {

[Link]<User>()
.HasMany(u => [Link])
.WithOne(o => [Link])
.HasForeignKey(o => [Link]);
}
}

Code First Migrations — Must know commands

# Create migration
dotnet ef migrations add InitialCreate

# Apply to database
dotnet ef database update

# Rollback
dotnet ef database update PreviousMigrationName

# Remove last migration

dotnet ef migrations remove

Q: What is the difference between Code First and Database First?

A: Code First: you write C# classes (entities), EF generates database schema from them via migrations. Database
First: database already exists, EF scaffolds C# classes from it. In modern projects, Code First is preferred as it
keeps schema in source control and is version-controlled.
Tracking vs No-Tracking
Tracked Query (default) No-Tracking Query (AsNoTracking)

EF watches for changes EF ignores changes

Use for UPDATE/DELETE operations Use for READ-ONLY queries

Slightly slower Faster, less memory

var user = await [Link](id) var user = await [Link]().FirstAsync()

SQL Server — Interview Questions

Stored Procedures vs Functions
Stored Procedure Function

Can have side effects (INSERT/UPDATE) Cannot modify data (read-only)

Called with EXEC Used inside SELECT

Can return multiple result sets Returns single value or table

Supports transactions Cannot use transactions

-- Stored Procedure
CREATE PROCEDURE GetUserOrders @UserId INT AS
BEGIN
SELECT o.* FROM Orders o WHERE [Link] = @UserId
END

-- Call it
EXEC GetUserOrders @UserId = 5

-- Index for performance

CREATE INDEX IX_Orders_UserId ON Orders(UserId)
CREATE CLUSTERED INDEX IX_Users_Id ON Users(Id)

Q: What is the difference between clustered and non-clustered index?

A: Clustered index determines physical order of data in table — only one per table, usually primary key. Non-
clustered index is a separate structure pointing to data rows — multiple allowed per table. Clustered is faster for
range queries, non-clustered is faster for specific column lookups.

CHAPTER 4
Architecture & Design Patterns
What separates 6 LPA from 12 LPA candidates

Repository Pattern
Repository pattern abstracts data access logic, making code testable and decoupled from the database.

// Interface
public interface IUserRepository {
Task<User> GetByIdAsync(int id);
Task<IEnumerable<User>> GetAllAsync();
Task AddAsync(User user);
Task UpdateAsync(User user);
Task DeleteAsync(int id);
}
 // Implementation
public class UserRepository : IUserRepository {
private readonly AppDbContext _ctx;
public UserRepository(AppDbContext ctx) => _ctx = ctx;

public async Task<User> GetByIdAsync(int id) =>

await _ctx.[Link]().FirstOrDefaultAsync(u => [Link] == id);

public async Task AddAsync(User user) {

await _ctx.[Link](user);
await _ctx.SaveChangesAsync();
}
}

Unit of Work Pattern

Unit of Work coordinates multiple repository operations in a single transaction — either all succeed or all fail.

public interface IUnitOfWork : IDisposable {

IUserRepository Users { get; }
IOrderRepository Orders { get; }
Task<int> SaveChangesAsync();
}

// Usage in service
public async Task CreateOrderAsync(CreateOrderDto dto) {
var order = new Order { ... };
await _uow.[Link](order);

var user = await _uow.[Link]([Link]);

[Link]++;
await _uow.[Link](user);

await _uow.SaveChangesAsync(); // Single transaction

}

SOLID Principles — Define + Example Each

Principle One-Line Rule Violation Example

S — Single Responsibility One class, one reason to change UserService that also sends emails

O — Open/Closed Open for extension, closed for Adding if/else for each new payment
modification type

L — Liskov Substitution Subtypes must be substitutable for base Square extending Rectangle breaking
area calc

I — Interface Segregation Don't force classes to implement unused IWorker with Eat() forced on Robot class
methods

D — Dependency Inversion Depend on abstractions, not concretions new EmailService() inside a controller

Microservices — Awareness Level

You don't need to build microservices, but you must be able to explain the concept confidently in interviews.
• Microservices: application split into small, independently deployable services
• Each service owns its own database — no shared DB
• Services communicate via REST APIs or message queues (RabbitMQ, Azure Service Bus)
• Advantages: independent scaling, independent deployment, technology flexibility
• Disadvantages: network latency, distributed system complexity, harder debugging
 Q: When would you use microservices over monolith?
A: Monolith is better for small teams and early-stage products — simpler to develop and deploy. Microservices
make sense when different parts of the system have very different scaling needs, when teams are large and
need to work independently, or when parts need different technology stacks. Most enterprise projects start
monolithic and extract services as needed.

CHAPTER 5
Azure & Cloud
AZ-900 done — now go deeper for interviews

Azure Services You Must Know

Service What It Does When You Use It

Azure App Service Host web apps and APIs Deploy your [Link] Core API

Azure SQL Managed SQL Server in cloud Production database hosting

Azure Key Vault Store secrets, keys, certificates Connection strings, API keys

Application Insights Monitor app performance & errors Logging, alerts, telemetry

Azure Functions Serverless event-driven functions Background jobs, triggers

Azure Service Bus Message queue for async Microservices messaging

communication

Azure DevOps CI/CD pipelines, repos, boards Automated deployment

Azure Storage Blob, Queue, Table storage Files, images, logs

CI/CD with GitHub Actions

Know this — Accenture JD explicitly mentions it. Being able to explain your pipeline setup is a strong differentiator.

# .github/workflows/[Link]
name: Deploy to Azure

on:
push:
branches: [ main ]

jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Setup .NET
uses: actions/setup-dotnet@v3
with:
dotnet-version: '6.0.x'
- name: Build
run: dotnet build --configuration Release
- name: Test
run: dotnet test
- name: Deploy to Azure
uses: azure/webapps-deploy@v2
with:
app-name: 'your-app-name'
 CHAPTER 6
System Design Basics
For senior roles — know enough to not fail this round

Key Concepts to Know

Caching
• In-memory cache: IMemoryCache in [Link] Core — fast, single server
• Distributed cache: Redis — shared across multiple servers
• Cache-aside pattern: app checks cache, fetches from DB on miss, stores in cache
// In-memory cache
public async Task<User> GetUserAsync(int id) {
if (!_cache.TryGetValue($"user_{id}", out User user)) {
user = await _repo.GetByIdAsync(id);
_cache.Set($"user_{id}", user, [Link](10));
}
return user;
}

Load Balancing & Scaling

• Horizontal scaling: add more servers — stateless apps scale this way
• Vertical scaling: add more CPU/RAM to existing server — has limits
• Load balancer: distributes traffic across servers (Azure Load Balancer, Nginx)
• Stateless API: no server-side session — JWT tokens enable this

Database Optimization
• Indexing: add indexes on frequently queried columns — biggest performance win
• Pagination: never return all records — use Skip/Take in EF Core
• Connection pooling: reuse DB connections — EF Core does this by default
• N+1 problem: loading related data in a loop — fix with Include() in EF Core
// N+1 Problem — BAD
var users = await _ctx.[Link]();
foreach (var user in users) {
var orders = await _ctx.Orders // N extra queries!
.Where(o => [Link] == [Link]).ToListAsync();
}

// Fixed with Include — GOOD

var users = await _ctx.Users
.Include(u => [Link]) // Single JOIN query
.ToListAsync();

CHAPTER 7
React Essentials
Frontend layer — you already have this, just refresh

Core React Concepts for Interviews

Hooks — Most Asked
Hook Purpose Example Use

useState Local component state Form inputs, toggles

 useEffect Side effects (API calls, subscriptions) Fetch data on mount

useContext Share state without prop drilling User auth, theme

useRef Access DOM or persist value Focus input, store timer

useMemo Memoize expensive computation Filtered/sorted lists

useCallback Memoize function reference Prevent child re-renders

// Typical API call pattern

const [users, setUsers] = useState([]);
const [loading, setLoading] = useState(true);

useEffect(() => {
const fetchUsers = async () => {
try {
const res = await fetch('/api/users');
const data = await [Link]();
setUsers(data);
} catch (err) {
[Link](err);
} finally {
setLoading(false);
}
};
fetchUsers();
}, []); // empty array = run once on mount

Q: What is the difference between useMemo and useCallback?

A: useMemo memoizes a computed value — use when a calculation is expensive and inputs haven't changed.
useCallback memoizes a function reference — use when passing callbacks to child components to prevent
unnecessary re-renders. Both take a dependency array and only recalculate when dependencies change.

CHAPTER 8
Interview Strategy & Study Plan
How to actually get shortlisted and clear rounds

Accenture Interview Process

1. Round 1: Online Assessment — Coding + MCQ (C#, SQL, .NET concepts)
2. Round 2: Technical Interview 1 — Deep dive on C#, OOP, [Link] Core, EF Core, design patterns
3. Round 3: Technical Interview 2 — System design, Azure, project discussions, code walkthrough
4. Round 4: HR + Manager Round — Communication, team fit, salary discussion

Top 20 Interview Questions — .NET Full Stack

Q: What is Dependency Injection and why is it used?
A: DI is a design pattern where dependencies are provided to a class rather than created inside it. It promotes
loose coupling, testability, and follows the Dependency Inversion principle. [Link] Core has built-in DI
container. Instead of new EmailService() inside a class, you inject IEmailService through the constructor.

Q: Explain the Repository Pattern.

A: Repository pattern provides an abstraction layer between business logic and data access. It exposes data
operations (CRUD) through an interface, hiding EF Core details. Benefits: easier unit testing (mock the
repository), swap database without changing business logic, single place to manage queries.
 Q: What is the difference between IEnumerable and IQueryable?
A: IEnumerable executes query in memory — all data is fetched from DB first, then filtered in C#. IQueryable
executes query on the database — filters are translated to SQL. Always use IQueryable for database queries to
avoid loading unnecessary data.

Q: How does JWT authentication work?

A: Client sends credentials to /api/auth/login. Server validates and returns a signed JWT token. Client stores
token and sends it in every request header: Authorization: Bearer <token>. Server validates signature and expiry
on each request without hitting the database — stateless authentication.

Q: What is CORS and how do you enable it in [Link] Core?

A: CORS (Cross-Origin Resource Sharing) is a browser security feature blocking requests from different origins. In
[Link] Core, enable with [Link]() and [Link]() in [Link], specifying allowed
origins, methods, and headers. Required when React frontend runs on different port than API.

Q: What is the N+1 problem in EF Core?

A: N+1 occurs when you load N entities, then make 1 extra database query per entity to load related data. Fix
with .Include() to eager load related entities in a single JOIN query. Can also use explicit loading or projection
(Select) to load only required fields.

Q: What are action filters in [Link] Core?

A: Action filters run code before and after a controller action. Used for cross-cutting concerns: logging,
validation, exception handling, caching. Implement IActionFilter or IAsyncActionFilter. Can be applied at action,
controller, or global level.

Month-by-Month Study Plan

Period Focus Area Deliverable

March–April 2026 C# deep dive, OOP, Collections, LINQ, Solid answers to Chapter 1 questions
async/await

May–June 2026 [Link] Core, DI, JWT, REST API best GitHub Project 1: E-Commerce API
practices complete

July–Aug 2026 EF Core, SQL, Repository Pattern, Unit of GitHub Project 2: EMS with full patterns
Work

Sept–Oct 2026 Azure PaaS, CI/CD, System Design basics AZ-204 cleared, projects deployed on
Azure

Nov 2026 Full revision, mock interviews, LeetCode Interview-ready

easy-medium

Dec 2026–Jan 2027 Apply: Accenture, Capgemini, Wipro Target: 10–16 LPA offer
Digital, LTI

Resources Summary
Topic Resource Format

C# & .NET Core Kudvenkat YouTube Video — passive

[Link] Core deep [Link] Text — reference

Coding practice C# Academy Hands-on projects

System Design Gaurav Sen YouTube Video — passive

Backend concepts Hussein Nasser YouTube Video — passive

Azure Microsoft Learn (free) Text + labs

Interview prep InterviewBit .NET track Q&A format

Quick revisions Nick Chapsas YouTube Video — focused

💡 YOUR SECRET WEAPON

Your biggest advantage is the Deloitte brand. Every interview starts with 'tell me about your Deloitte project.' Prepare
a crisp 3-minute walkthrough of your multilingual notice platform — mention 5M+ notices, 30+ languages, SQL
pipelines, and OpenText. This shows real enterprise experience that freshers cannot compete with.

You don't need to know everything. You need to know these chapters well enough to speak confidently. That's the
difference between getting filtered and getting the offer.