Introduction
We've reached the final day of our 30-Day ASP.NET Core Web API series.
Over the last 30 days, we've progressed from understanding what a Web API is to building, securing, testing, Dockerizing, and deploying APIs. Today is the final recap: revisiting important concepts, reviewing interview questions, and understanding what to learn next.
Whether you're preparing for a .NET developer interview or building your own applications, this recap will help you connect the concepts.
What We Learned in 30 Days
Throughout this series, we covered the following topics:
| Day | Topic |
|---|---|
| 1 | What Is Web API? |
| 2 | How Web API Works |
| 3 | HTTP Methods |
| 4 | Minimal APIs vs. Controllers |
| 5 | Routing & Route Parameters |
| 6 | Build Your First Web API |
| 7 | Request & Response with JSON |
| 8 | Dependency Injection |
| 9 | DTOs & Model Validation |
| 10 | Entity Framework Core |
| 11 | Connect SQL Server |
| 12 | Code First vs. Database First |
| 13 | Global Exception Handling |
| 14 | Build CRUD API |
| 15 | Authentication vs. Authorization |
| 16 | JWT Authentication |
| 17 | Role-Based Authorization |
| 18 | CORS with Angular |
| 19 | HttpClientFactory & External APIs |
| 20 | Rate Limiting |
| 21 | Logging, Monitoring & Debugging |
| 22 | Clean Architecture |
| 23 | Repository Pattern |
| 24 | Unit Testing with xUnit |
| 25 | API Versioning |
| 26 | Pagination, Filtering & Sorting |
| 27 | Dockerize Web API |
| 28 | Deploy Web API to Azure |
| 29 | Build a Real-World Project |
| 30 | Interview Questions & Learning Roadmap |
Visual Recap – The Web API Journey
Level 1 – Basic Interview Questions
1. What is ASP.NET Core Web API?
ASP.NET Core Web API is a framework for building HTTP-based services that can be consumed by clients such as web applications, mobile applications, and other systems.
It is commonly used to build REST-style APIs.
2. What is REST?
REST stands for Representational State Transfer.
It is an architectural style for designing network-based services. REST-style APIs commonly use HTTP methods, resource-oriented URLs, and stateless communication.
3. What is the difference between GET and POST?
| GET | POST |
|---|---|
| Retrieves data | Usually creates or submits data |
| Parameters may be in the URL | Data commonly sent in request body |
| Intended to be safe | Not inherently safe |
| Generally cacheable under HTTP rules | Generally not cacheable by default |
4. What is the difference between PUT and PATCH?
-
PUT generally replaces the resource representation at the target URI.
-
PATCH applies partial modifications to a resource.
PUT is generally idempotent. PATCH may or may not be idempotent, depending on the operation.
5. What is JSON?
JSON stands for JavaScript Object Notation.
It is a lightweight data format commonly used to exchange data between clients and Web APIs.
Example:
{
"id": 1,
"name": "Laptop",
"price": 75000
}
6. What is Routing?
Routing determines which endpoint or controller action should handle an incoming HTTP request.
Example:
[Route("api/products")]
7. What is a Controller?
A controller handles HTTP requests, coordinates application operations, and returns HTTP responses.
Example:
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
[HttpGet]
public IActionResult Get()
{
return Ok("Products");
}
}
8. What is IActionResult?
IActionResult represents an HTTP response result.
It allows an action to return different response types, such as:
-
Ok() -
NotFound() -
BadRequest() -
Created() -
NoContent()
9. What is ActionResult<T>?
ActionResult<T> allows an action to return either a
strongly typed response value or an HTTP action result.
Example:
public ActionResult<ProductDto> GetProduct(int id)
{
var product = GetProductFromService(id);
if (product == null)
return NotFound();
return Ok(product);
}
10. What is Middleware?
Middleware is software that is assembled into the HTTP request pipeline.
Each middleware component can:
Process an incoming request
Call the next middleware
Process the outgoing response
Short-circuit the pipeline
Level 2 – Intermediate Interview Questions
11. What is Dependency Injection?
Dependency Injection is a design technique in which an object receives its dependencies from an external source instead of creating them directly.
ASP.NET Core provides a built-in dependency injection container.
Example:
builder.Services.AddScoped<IProductService, ProductService>();
12. What are DI service lifetimes?
ASP.NET Core supports three common service lifetimes.
| Lifetime | Behavior |
|---|---|
| Transient | New instance each time requested |
| Scoped | One instance per scope, commonly per HTTP request |
| Singleton | One instance for the application's lifetime |
13. What is Entity Framework Core?
Entity Framework Core is an object-relational mapper (ORM) that allows .NET applications to work with databases using .NET objects and LINQ.
It supports querying, inserting, updating, deleting, and tracking data.
14. What is a DTO?
DTO stands for Data Transfer Object.
DTOs are used to transfer data between application boundaries.
They help control API request and response structures and avoid directly exposing database entities.
15. What is Model Validation?
Model validation checks whether incoming data satisfies defined rules.
Example:
public class CreateProductDto
{
[Required]
public string Name { get; set; } = string.Empty;
[Range(1, 100000)]
public decimal Price { get; set; }
}
16. What is the Repository Pattern?
The Repository Pattern provides an abstraction over data access.
It separates database operations from the business logic or application services that use them.
17. What is the difference between Authentication and Authorization?
-
Authentication determines who the user is.
-
Authorization determines what the user is allowed to do.
18. What is JWT?
JWT stands for JSON Web Token.
It is a compact token format commonly used to transmit claims between parties and is frequently used in token-based authentication systems.
19. What is CORS?
CORS stands for Cross-Origin Resource Sharing.
It is a browser-enforced mechanism that allows a server to specify which cross-origin browser requests are permitted.
20. What is HttpClientFactory?
IHttpClientFactory provides a way to create and manage
HttpClient instances.
It supports configuration, logging, delegating handlers, and named or typed clients.
Example:
builder.Services.AddHttpClient();
21. What is Rate Limiting?
Rate limiting controls how many requests a client can make within a specified time period or policy.
It helps protect services from excessive requests and supports resource management.
22. What is Logging?
Logging records information about application execution.
ASP.NET Core uses ILogger<T> for structured logging.
Example:
_logger.LogInformation(
"Product {ProductId} retrieved",
productId);
23. What is API Versioning?
API versioning allows an API to evolve while supporting different versions of its contract.
For example:
/api/v1/products
/api/v2/products
24. What is Pagination?
Pagination divides a large dataset into smaller result sets.
Instead of returning thousands of records at once, an API returns a selected page of results.
25. What is Clean Architecture?
Clean Architecture organizes an application so that business rules and application logic are independent of infrastructure details.
The goal is to make the system easier to maintain, test, and change.
Level 3 – Advanced Interview Questions
26. What is the difference between Middleware and Filters?
Middleware operates in the overall HTTP request pipeline.
Filters operate within the MVC or endpoint execution lifecycle, depending on the filter type.
Middleware is commonly used for:
Request logging
Exception handling
Authentication
CORS
Request/response pipeline operations
Filters are commonly used for:
Action-specific logic
Authorization
Validation-related behavior
Result processing
27. What is the difference between IEnumerable and
IQueryable?
| IEnumerable | IQueryable |
|---|---|
| Represents an enumerable sequence | Represents a queryable sequence |
| Typically executes iteration in memory | Can translate expression trees to a provider-specific query |
| Uses delegates for many operations | Uses expression trees for query operations |
| Common for in-memory collections | Common with EF Core |
With EF Core, IQueryable can allow LINQ expressions to be
translated into SQL before results are retrieved.
28. What is AsNoTracking()?
AsNoTracking() tells EF Core not to track the returned entities
in its change tracker.
It is useful for read-only queries where we don't intend to update the retrieved entities through that DbContext.
Example:
var products = await _context.Products
.AsNoTracking()
.ToListAsync();
29. What is the difference between eager, lazy, and explicit loading?
-
Eager loading: Related data is loaded as part of the query, often using
Include. -
Lazy loading: Related data is loaded automatically when accessed, if configured.
-
Explicit loading: Related data is loaded later through an explicit EF Core operation.
30. What is async/await in ASP.NET Core?
async and await allow asynchronous operations to be
expressed in a readable way.
They are especially useful for I/O-bound operations such as:
Database calls
HTTP requests
File operations
Asynchronous code can help improve server scalability by avoiding blocking threads while waiting for I/O operations to complete.
31. What is the difference between Unit Testing and Integration Testing?
Unit testing tests an individual component in isolation, often using test doubles for its dependencies.
Integration testing tests how multiple components work together, such as an API endpoint with its middleware, database, and services.
32. What is a Mock?
A mock is a test double that allows a test to control dependency behavior and verify interactions.
Mocks are useful when testing services without depending on actual databases or external systems.
33. What is Idempotency?
An operation is idempotent if performing it multiple times has the same intended effect as performing it once.
HTTP PUT and DELETE are defined as idempotent methods, although the actual implementation should respect those semantics.
POST is not generally idempotent by default.
34. How do you handle exceptions globally?
ASP.NET Core supports centralized exception handling using exception-handling middleware.
This avoids duplicating try/catch blocks throughout every controller.
Example:
app.UseExceptionHandler();
A proper exception-handling configuration should return consistent error responses without exposing sensitive internal details.
35. How do you improve Web API performance?
Common approaches include:
Pagination
Efficient database queries
Database indexes
Asynchronous I/O
Caching
Avoiding unnecessary data retrieval
Optimizing serialization
Monitoring slow endpoints
Rate limiting
Appropriate resource management
36. How do you secure a Web API?
Security can include:
Authentication
Authorization
HTTPS
Input validation
Secure secret management
CORS configuration
Rate limiting
Safe error responses
Dependency updates
Logging and monitoring
Protection against common application vulnerabilities
37. What is the difference between 401 and 403?
| 401 Unauthorized | 403 Forbidden |
|---|---|
| Authentication is missing or invalid | Server understands the request but refuses access |
| Client may need to authenticate | Client generally lacks required permission |
Despite its name, HTTP 401 is specifically an authentication-related status.
38. What is the difference between 400 and 422?
-
400 Bad Request: The server cannot or will not process the request because of a client error.
-
422 Unprocessable Content: The request content is syntactically valid but its instructions or content cannot be processed.
Many ASP.NET Core APIs commonly use 400 for model validation failures.
39. What is a Health Check?
A health check exposes information about whether an application or one of its dependencies is functioning.
Health checks can be used by monitoring systems, orchestrators, and hosting platforms to determine service health.
40. How do you deploy a Web API?
A typical deployment workflow may include:
Build the application.
Run automated tests.
Publish the application.
Configure production settings.
Deploy to a hosting platform.
Configure database connectivity.
Verify endpoints.
Monitor the application.
Deployment options include cloud services, containers, virtual machines, and managed application hosting.
HTTP Status Codes – Quick Revision
| Code | Meaning |
|---|---|
| 200 | OK |
| 201 | Created |
| 202 | Accepted |
| 204 | No Content |
| 301 | Moved Permanently |
| 302 | Found |
| 304 | Not Modified |
| 400 | Bad Request |
| 401 | Unauthorized |
| 403 | Forbidden |
| 404 | Not Found |
| 405 | Method Not Allowed |
| 409 | Conflict |
| 415 | Unsupported Media Type |
| 422 | Unprocessable Content |
| 429 | Too Many Requests |
| 500 | Internal Server Error |
| 502 | Bad Gateway |
| 503 | Service Unavailable |
| 504 | Gateway Timeout |
Web API Request Lifecycle
Understanding the request lifecycle is one of the most important concepts for a .NET developer.
When a client sends an HTTP request:
The request enters the ASP.NET Core pipeline.
Middleware components process the request.
Routing identifies the matching endpoint.
The controller or endpoint executes.
Services and data access components perform operations.
A response is generated.
-
The response travels back through the middleware pipeline to the client.
Your Next Learning Roadmap
Completing this series is a starting point, not the end of your learning journey.
To become a stronger .NET backend developer, continue with the following topics.
1. Advanced C#
Generics
Delegates
Events
LINQ
Async/await
Collections
Reflection
Records
Pattern matching
2. Advanced ASP.NET Core
Middleware
Filters
Custom model binders
Minimal APIs
Background services
SignalR
OpenAPI
Performance optimization
3. Database & EF Core
Advanced SQL
Indexes
Query optimization
Transactions
Isolation levels
Stored procedures
EF Core performance
Concurrency handling
4. Architecture
SOLID principles
Clean Architecture
CQRS
Domain-Driven Design
Design Patterns
Microservices
5. Security
OAuth 2.0
OpenID Connect
JWT
Identity
Refresh tokens
Claims
Security best practices
6. DevOps & Cloud
Git
GitHub
CI/CD
Docker
Docker Compose
Azure
Monitoring
Kubernetes fundamentals
7. Frontend Integration
Angular
TypeScript
RxJS
HttpClient
Authentication integration
CORS
API error handling
Final Challenge – Build Your Own API
Now it's your turn to apply what you've learned.
Build a complete Employee Management API with the following requirements:
Features
Create employee
Get all employees
Get employee by ID
Update employee
Delete employee
Search employees by name
Filter by department
Pagination
Sorting
Technical Requirements
ASP.NET Core Web API
SQL Server
Entity Framework Core
DTOs
Dependency Injection
Service Layer
Repository Pattern, if justified
Model Validation
Global Exception Handling
JWT Authentication
Role-Based Authorization
Logging
Unit Testing with xUnit
Advanced Requirements
API Versioning
Rate Limiting
Docker
Health Checks
Azure Deployment
CI/CD Pipeline
Try to build this project without copying a complete solution. Start with the basic CRUD operations, then gradually add each feature.
🎉 Congratulations on Completing the 30-Day Series!
Learning Web API is not just about memorizing attributes, methods, or commands. It's about understanding how requests flow through an application, how data is processed, how systems communicate, how errors are handled, and how applications are secured and deployed.
Keep building projects. Keep solving problems. Keep revisiting concepts. The best way to become a better developer is to apply what you learn in real-world scenarios.
Your 30-day journey ends here, but your journey as a developer continues. 🎓
💙 Found This Series Helpful?
Share this 30-Day ASP.NET Core Web API series with your friends, colleagues, teammates, or fellow developers who are learning Web API or preparing for their next development challenge.
Your share could help someone discover a useful resource, understand a difficult concept, or take another step toward becoming a better developer.
🤝 Learn together. Build together. Grow together.
Thank you for learning with Skills Tutorials and being part of this journey!
Skills Tutorials | Learn • Build • Grow Together