Position Interviewed For: L4 Fullstack (Dotnet + React)

Estimated Level: L4 Fullstack (Dotnet + React)

Actual Level: L4 Fullstack (Dotnet + React)

Overall Personal Impression

The candidate demonstrated strong technical expertise across both
backend and frontend development areas. With over 10 years of
experience, the candidate showcased a solid understanding of complex
and advanced scenarios, providing practical examples to support their
answers. Their ability to clearly communicate complex concepts reflects
their depth of knowledge and hands-on experience.

Technical Skills Evaluation

Backend Skills (C# and .NET Core)
Strengths:Remarkable knowledge of backend technologies, particularly
in C#, .NET Core, and [Link] Core.
Able to handle advanced concepts effectively, such as generics with
constraints, middleware, and action filters.
Successfully demonstrated knowledge of REST API development,
including multi-model approaches and advanced features.
Provided comprehensive insights into practical backend scenarios and
wrote clean C# examples during the interview.
Level: Advanced
Feedback: Backend skills are one of the candidate's strongest areas. No
significant weaknesses observed.

Frontend Skills (React)

Strengths:Solid understanding of React concepts, able to articulate and
demonstrate their knowledge confidently.
Successfully wrote and explained simple but tricky React components,
showcasing creativity and proficiency in frontend development.
Managed to address questions related to React's lifecycle, state
management, and advanced component design.
Level: Good
Feedback: Strong knowledge of React with good practical
understanding. A noticeable strength, albeit backend appears slightly
stronger.

Database Skills
Strengths:Demonstrated advanced database skills, accurately
answering most database-related questions.
Practical understanding of core concepts such as query optimization,
indexing (including primary and clustered indexes), and relational
database design.
Improvement Opportunity:Slight improvement needed in non-clustered
index depth, where the candidate knew the concept but did not
articulate it exhaustively.
Level: Advanced
Feedback: Solid database skills with capacity for improvement in niche
advanced areas like index optimization.

C# Skills
Strengths:Clearly advanced skills in C#, showcasing knowledge through
examples.
Explained generics and constraints with a high level of detail, which
was a particularly strong demonstration of expertise.
Successfully wrote correct C# code during the interview without
mistakes.
Level: Advanced
Feedback: Demonstrated a strong command of C#, with no weaknesses
observed.

REST API Development

Strengths:Able to explain advanced REST API concepts such as
middleware, action filters, and endpoint mapping.
Demonstrated proficiency in designing APIs adhering to best practices
and multi-model approaches.
Level: Advanced
Feedback: Strong in REST API development, leveraging practical
experience to answer questions effectively.

Behavioral and Communication Skills

Strengths:Excellent communication skills; able to articulate complex
scenarios clearly and concisely.
Presented practical examples when answering questions, which added
credibility and demonstrated real-world expertise.
Showed enthusiasm and confidence throughout the interview, engaging
with both backend and frontend scenarios seamlessly.
Feedback: Communicates effectively and demonstrates professionalism.
A strong fit for collaborative team settings.

Overall Recommendation
The candidate showcases a rare balance of advanced skills in backend
(C#, .NET Core, [Link] Core) and frontend (React). Their database and
API development knowledge further reinforces their full-stack
expertise, making them highly capable for the L4 Fullstack role. Despite
minor room for improvement in some advanced database concepts, the
overall skill level and ability to deliver in practice make them a strong
hire.

I confirm that I verified the candidate’s face was clearly visible during
the interview:: Yes
I confirm that my camera was on throughout the entire interview:: Yes

L4 Fullstack (.NET + React) Interview Prep Guide

This guide covers backend (.NET Core, C#), frontend (React), database
design/optimization, REST APIs, and behavioral questions—aligned with your L4
feedback.

1. .NET Core & C# Backend

Q1. Generics with Constraints
Question: How do you enforce type constraints on a generic class or method in
C#? Provide an example.
Answer:
You apply the where keyword to restrict T to types implementing interfaces,
inheriting a base class, or having a parameterless constructor. This enables
compile-time safety and access to constrained members.
public interface IEntity { int Id { get; } }

public class Repository<T>

where T : class, IEntity, new()
{
public T Create() => new T(); // new() constraint
public void Save(T entity) { /*...*/ }
public int GetId(T entity) => [Link]; // IEntity constraint
}
 class: reference types only
 IEntity: ensures Id is available
 new(): allows instantiation

Q2. Custom Middleware

Question: Explain how [Link] Core middleware works. How would you write a
custom middleware to log request times?
Answer:
Middleware are delegates chained in [Link], each can inspect/modify
the HttpContext and call the next. Custom middleware typically measures
timings or injects headers.
public class RequestTimingMiddleware
{
private readonly RequestDelegate _next;
public RequestTimingMiddleware(RequestDelegate next) => _next = next;
 public async Task InvokeAsync(HttpContext context)
{
var sw = [Link]();
await _next(context);
[Link]();
var ms = [Link];
[Link]($"Request {[Link]} took {ms} ms");
}
}

// In [Link]
[Link]<RequestTimingMiddleware>();
 Register with UseMiddleware<T>()
 Ensures both pre- and post-processing

Q3. Action Filters

Question: What are action filters in [Link] Core MVC? When would you use
them?
Answer:
Action filters run before and/or after controller actions. Use them for cross-cutting
concerns like logging, authorization checks, or response wrapping.
public class LogActionFilter : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext ctx)
=> [Link]($"Executing {[Link]}");

public override void OnActionExecuted(ActionExecutedContext ctx)

=> [Link]($"Executed {[Link]}");
}

// In Controller
[LogActionFilter]
public IActionResult Get() => Ok();
 Apply at controller or action level
 Supports dependency injection

Q4. Multi-Model REST API (JSON & XML)

Question: How do you configure an [Link] Core API to support both JSON and
XML payloads?
Answer:
Install the XML formatter package, then add both formatters in
[Link]. The framework negotiates via Accept header.
public void ConfigureServices(IServiceCollection services)
{
services
.AddControllers(options => [Link] = true)
.AddNewtonsoftJson() // JSON
.AddXmlSerializerFormatters(); // XML
}
 Clients send Accept: application/xml or application/json
 Ensures backward compatibility for diverse consumers

Q5. Advanced REST API Features

Question: Describe advanced REST API features you’ve implemented.
Answer:
 HATEOAS: Embedding navigational links in responses
 API Versioning: Using URI or Header versioning
 Caching: Implemented ETag headers for conditional GETs
 Rate Limiting: Custom middleware to throttle IP addresses
 Content Negotiation: Configured custom media type formatters
[Link](opts =>
{
[Link] = new ApiVersion(1, 0);
[Link] = true;
[Link] = true;
});

2. Database Design & Optimization

Q6. Query Optimization Approach
Question: How do you identify and fix a slow SQL query?
Answer:
1. Capture the query via Profiler or Extended Events
2. Review execution plan for key warnings (table scans, missing indexes)
3. Add or adjust indexes, rewrite joins/subqueries, or consider indexed
views
4. Test with SET STATISTICS IO, TIME ON to compare improvements

Q7. Clustered vs. Non-Clustered Indexes

Question: Explain the internal structure of clustered and non-clustered indexes.
How do you optimize a non-clustered index?
Answer:

Physical
Index Type B-Tree Leaf Nodes Use Case
Order

Table rows Range queries, frequent

Clustered Data pages
ordered sorting

Non- Pointers to clustered Covering indexes, selective

Separate B-Tree
Clustered key lookups

Optimizing Non-Clustered Indexes:

 Include only necessary columns (use INCLUDE(...))
 Add filtered predicates (WHERE IsActive = 1)
 Monitor fragmentation and rebuild/reorganize as needed

3. React Frontend
Q8. React Component Lifecycle
Question: Compare class component lifecycle methods with Hooks equivalents.
Give an example where a specific hook is essential.
Answer:

Class Method Hook Equivalent Use Case

componentDidMount() useEffect(() => {}, []) Fetch data once on mount

Class Method Hook Equivalent Use Case

componentDidUpdate( Respond to dependency

useEffect(() => {}, [dep])
) changes

componentWillUnmou useEffect(() => return Cleanup subscriptions or

nt() cleanup, []) timers

useEffect(() => {
const id = setInterval(() => setTime([Link]()), 1000);
return () => clearInterval(id); // cleanup on unmount
}, []);

Q9. State Management Strategies

Question: When do you choose useState, useReducer, or Context API?
Answer:
 useState: Simple local state (booleans, strings)
 useReducer: Complex state logic or many state transitions
 Context API: Shared state across distant components without prop
drilling
const initialState = { count: 0 };
function reducer(state, action) {
return [Link] === 'increment'
? { count: [Link] + 1 }
: state;
}
const [state, dispatch] = useReducer(reducer, initialState);

Q10. Advanced Component Design

Question: Create a dynamic form builder component that accepts a schema and
validates inputs. Sketch your approach.
Answer:
1. Props: fields: Array<{ name, type, validators }>
2. State: formValues object and errors object
3. Render: Map fields to <input> or <select>
 4. Validation: On onChange, run each field’s validators and update errors
function DynamicForm({ fields, onSubmit }) {
const [values, setValues] = useState({});
const [errors, setErrors] = useState({});

const handleChange = (name, val) => {

setValues(v => ({ ...v, [name]: val }));
setErrors(e => ({ ...e, [name]: runValidators(name, val) }));
};

return (
<form onSubmit={() => onSubmit(values)}>
{[Link](f => (
<FormField key={[Link]}
{...f}
value={values[[Link]] || ''}
error={errors[[Link]]}
onChange={handleChange} />
))}
<button type="submit">Submit</button>
</form>
);
}

4. Behavioral & Collaboration

Q11. Explaining Complex Concepts
Question: Tell me about a time you explained a difficult technical concept to a
non-technical stakeholder. How did you ensure understanding?
Answer:
 Simplified jargon: “Indices are like a book’s index, pointing to pages.”
 Visual aids: Diagrams on a whiteboard
 Checked comprehension: Asked them to repeat the concept in their
own words
Q12. Cross-Functional Collaboration
Question: Describe a project where you collaborated closely with design, QA,
and DevOps. What was your role?
Answer:
 API Design: Gathered requirements from product and UI/UX
 QA Coordination: Created contract tests using Postman/Newman
 DevOps Handoff: Provided ARM templates and Helm charts for seamless
CI/CD

Q13. Handling Feedback & Growth

Question: You received feedback to deepen your understanding of non-
clustered indexes. What steps did you take to improve?
Answer:
 Studied internals: Read Microsoft docs on B-Tree architecture
 Hands-on labs: Created filtered/non-clustered indexes in demo DBs,
measured performance
 Shared learnings: Presented a brown-bag session to team

By mastering these questions and tailoring your examples to your experiences,

you’ll showcase both depth and breadth across .NET, React, databases, and
collaboration—cementing your fit for an L4 Fullstack role. Good luck!

Quiz: L4 Fullstack (.NET + React) Topics

Test your knowledge across backend, frontend, database, REST APIs, and
behavioral skills. Try to answer without looking up the solutions—then check
yourself afterwards!

1. .NET Core & C#

1. Generics with Constraints
Describe how you’d write a generic repository class that only works with
entities implementing an IEntity interface and having a parameterless
constructor. What keywords do you use and why?
2. Custom Middleware
Outline the steps to create and register a middleware that logs the HTTP
method and path of each request, along with its execution time.
3. Action Filters vs. Middleware
Given a cross-cutting concern like user activity logging, when would you
 implement it as middleware versus an action filter? Explain your
reasoning.
4. Multi-Model Support
How do you configure an [Link] Core API project to return JSON by
default but also support XML when clients request it? Mention the relevant
packages and startup configuration.

2. Database Design & Optimization

5. Slow Query Triage
You identify a slow-running SELECT statement in production. Walk through
the process—from capturing the query to verifying improvements—you’d
follow to optimize it.
6. Index Internals
Compare the physical structure of clustered and non-clustered indexes.
How would you tune a non-clustered index to improve lookup performance
without affecting insert speed?
7. Execution Plan Signals
Name three warning signs you’d look for in a SQL Server execution plan
that indicate missing or inefficient indexes.

3. Advanced REST API Features

8. HATEOAS Explained
What is HATEOAS, and how does it change the way clients interact with
your API? Give a simple JSON example illustrating an embedded link.
9. API Versioning
Two teams consume your API. One calls /v1/products, the other
/v2/products. Explain how you’d set up this versioning scheme in [Link]
Core so both endpoints route correctly.
[Link] Requests & Caching
How do you implement ETag-based conditional GET in [Link] Core?
Outline the steps to generate and validate ETags for a resource.

4. React & Frontend Architecture

[Link] vs. Hooks
For each of these class methods, name the equivalent Hook pattern:
o componentDidMount()

o componentDidUpdate(prevProps)

o componentWillUnmount()

[Link] Management Decision Tree

You have a form with complex nested state and many update actions.
 When would you pick useState, useReducer, or Context API? List at least
one scenario for each.
[Link] with Hooks
Explain the difference between useMemo and useCallback. Provide a code
snippet where each is critical to preventing unnecessary renders.
[Link] Form Builder
Sketch an outline (props, state shape, validation flow) for a React
component that takes a field schema array and renders a form with built-in
validation messages.

5. Behavioral & Collaboration

[Link] the Gap
Recall a time you explained a complex technical topic (e.g., generics,
indexing) to a non-technical stakeholder. How did you simplify it, and how
did you confirm they understood?
[Link] in Action
You received feedback to deepen your knowledge of non-clustered
indexes. What concrete steps did you take to learn and then share that
knowledge with your team?

Good luck! When you’ve answered, feel free to share your responses, and we can
review them together.

Based on the detailed feedback in your document for the L4 Fullstack (Dotnet
+ React) role, I’ve compiled a complete set of interview questions and
model answers covering all the assessed areas: backend (.NET Core/C#),
frontend (React), REST APIs, database (SQL), and behavioral skills.

✅ L4 Fullstack (.NET + React) Interview Questions & Answers

🔷 1. .NET Core & C# Backend

Q1. What are generics with constraints in C#? Provide an example.
A:
Generics with constraints enforce rules on type parameters.
public interface IEntity { int Id { get; } }

public class Repository<T> where T : class, IEntity, new()

{
public T Create() => new T();
 public int GetId(T entity) => [Link];
}
Constraints:
 class — reference type
 IEntity — interface implementation
 new() — must have parameterless constructor

Q2. Explain middleware in [Link] Core. Write a custom logging

middleware.
A: Middleware components intercept HTTP requests/responses.
public class LoggingMiddleware
{
private readonly RequestDelegate _next;
public LoggingMiddleware(RequestDelegate next) => _next = next;

public async Task InvokeAsync(HttpContext context)

{
var sw = [Link]();
await _next(context);
[Link]();
[Link]($"[{[Link]}] {[Link]} -
{[Link]} ms");
}
}
// In [Link]
[Link]<LoggingMiddleware>();

Q3. When would you use Action Filters instead of Middleware?

A:
 Use Action Filters for controller-specific logic (logging, model validation,
result wrapping).
 Use Middleware for global concerns (authentication, headers, CORS).
Q4. How to support both JSON and XML in [Link] Core APIs?
A:
Install the XML formatter:
dotnet add package [Link]
Then in [Link]:
[Link](options => [Link] =
true)
.AddXmlSerializerFormatters()
.AddNewtonsoftJson();

🌐 2. Advanced REST API Features

Q5. What is HATEOAS? Provide a simple JSON example.
A:
Hypermedia As The Engine Of Application State embeds navigational links in
responses.
{
"id": 123,
"name": "Product A",
"links": [
{ "rel": "self", "href": "/api/products/123" },
{ "rel": "update", "href": "/api/products/123" },
{ "rel": "delete", "href": "/api/products/123" }
]
}

Q6. Explain API versioning with [Link] Core.

A:
Install versioning package:
dotnet add package [Link]
In [Link]:
[Link](options =>
{
[Link] = new ApiVersion(1, 0);
[Link] = true;
 [Link] = true;
});

Q7. How do you implement ETag-based conditional GET?

A:
 Generate an ETag (e.g., from content hash or timestamp).
 Add header: [Link]["ETag"] = eTag;
 On GET, check If-None-Match and return 304 Not Modified if it matches.

🗃 3. Database Design & Optimization

Q8. How do you optimize a slow query?
A:
 Use SQL Profiler or Execution Plan.
 Look for table scans, missing indexes, high cost operations.
 Apply indexing (including filtered or covering indexes).
 Rewrite subqueries into joins.
 Use SET STATISTICS IO, TIME ON for tuning.

Q9. Compare clustered and non-clustered indexes. How do you tune

non-clustered ones?
A:

Index Type Stores Data Leaf Node Content Use Case

Actual data Sorting, range

Clustered Full row
rows queries

Non- Separate Pointers to data or CI Fast lookups,

Clustered structure key filters

Tuning Non-Clustered Indexes:

 Include only necessary columns using INCLUDE(...).
 Use filtered indexes (WHERE IsActive = 1).
 Monitor fragmentation; rebuild or reorganize.

Q10. Three red flags in SQL Execution Plans?

A:
 1. Table Scan — no index used
2. Key Lookup — frequent lookups from NCI to CI
3. Missing Index Suggestion — SQL suggests improvement

⚛️4. React Frontend

Q11. Match React Hooks to lifecycle methods.

Class Method Hook Equivalent

componentDidMount useEffect(() => {}, [])

componentDidUpdat
useEffect(() => {}, [dep])
e

componentWillUnmo useEffect(() => { return ()

unt => {} }, [])

Q12. When do you use useState, useReducer, or Context API?

 useState: Simple local values (e.g., input fields).
 useReducer: Complex state with multiple actions.
 Context: Shared global state (e.g., theme, user).

Q13. What’s the difference between useMemo and useCallback?

A:
 useMemo: Memoizes values
 useCallback: Memoizes functions
const memoizedValue = useMemo(() => expensiveCalc(num), [num]);
const memoizedFn = useCallback(() => doSomething(id), [id]);

Q14. Sketch a dynamic form builder in React.

A:
 Props: fields: [{ name, type, validators }]
 State: values, errors
 Render: Map fields to inputs
 Validation: On onChange, run validators
const [values, setValues] = useState({});
const [errors, setErrors] = useState({});

const handleChange = (name, value) => {

setValues(v => ({ ...v, [name]: value }));
setErrors(e => ({ ...e, [name]: validate(value) }));
};

💬 5. Behavioral & Communication

Q15. How do you explain technical topics to non-technical stakeholders?
A:
 Use analogies: “Indexing is like a book index.”
 Draw diagrams or workflows
 Ask them to repeat it in their own words

Q16. Describe cross-functional collaboration on a project.

A:
 Worked with designers to clarify component specs
 Created Postman tests for QA
 Provided deployment scripts (ARM, Helm) for DevOps
 Ensured smooth handoff across teams

Q17. How did you improve on non-clustered index knowledge after

receiving feedback?
A:
 Reviewed Microsoft Docs + B-Tree internals
 Created index scenarios and analyzed execution plans
 Shared results in a team knowledge session

🧠 Optional Practice Prompt (Quiz Style)

 What's the difference between action filters and middleware?
 When would you use a filtered non-clustered index?
 How would you prevent unnecessary re-renders in a React form?
Would you like this turned into flashcards, a PDF, or a practice test?

Great! Here's a Practice Test based on the topics in your interview feedback. It
includes multiple-choice, short answer, and code-writing questions across
.NET, React, SQL, REST APIs, and behavioral skills.

📝 L4 Fullstack (.NET + React) Practice Test

🔷 Section 1: .NET Core & C# (10 points)

1.1 [MCQ] What does the where T : class, new() constraint mean in
generics?
A. T must be a reference type and have a parameterless constructor
B. T must implement IDisposable
C. T must be a value type
D. T must be abstract

1.2 [Short Answer]

Describe a scenario where you would use middleware instead of an action filter.

1.3 [Code Writing]

Write a middleware class in [Link] Core that logs request paths and their
execution times.

🌐 Section 2: REST API Design (10 points)

2.1 [MCQ] Which of the following enables clients to navigate related
resources within a REST API?
A. JWT
B. ETag
C. HATEOAS
D. JSON Patch

2.2 [Short Answer]

Explain how to support both JSON and XML responses in an [Link] Core Web
API.

2.3 [Code Writing]

Write a snippet showing how to configure API versioning for /v1/products and
/v2/products.

🗃 Section 3: SQL & Indexing (10 points)

3.1 [MCQ] Which part of a non-clustered index contains the actual row
locator?
A. Root node
B. Intermediate node
C. Leaf node
D. Heap

3.2 [Short Answer]

What is a covering index and when would you use one?

3.3 [Short Answer]

List two common warning signs in a SQL execution plan that indicate poor
indexing.

⚛️Section 4: React (10 points)

4.1 [MCQ] What is the useReducer hook primarily used for?
A. Fetching data
B. Managing static configurations
C. Managing complex state logic
D. Setting global context

4.2 [Code Writing]

Write a React component that uses useEffect to start a timer on mount and clear
it on unmount.

4.3 [Short Answer]

Differentiate between useMemo and useCallback.

💬 Section 5: Behavioral (10 points)

5.1 [Short Answer]
Describe how you would explain the concept of database indexing to a non-
technical stakeholder.
5.2 [Short Answer]
How would you respond to feedback about improving your understanding of non-
clustered index depth?

✅ Bonus (Optional)
[Code Challenge]
Write a function in C# that uses generics with constraints to work only with types
implementing an IEntity interface.

Would you like me to generate the answer key now so you can self-evaluate?