Backend Development with .NET
Session 01
Introduction to
Backend Development
Eng. Seif Mansour  ·  Andalusia Academy
Week 1  ·  2 hours
Session Goals

By the end of this session, you will be able to:

  • Explain the difference between frontend and backend responsibilities
  • Describe the client-server model and how HTTP connects them
  • Identify the key API paradigms — REST, GraphQL, gRPC — and explain why REST is the right starting point
  • Understand where .NET and ASP.NET Core sit in the backend ecosystem
  • Have a clear picture of the Task Management API you will build throughout the course
Session Agenda
Time Segment Type Duration
0:00What is a backend?Theory20 min
0:20Client-server model & HTTP overviewTheory20 min
0:40REST vs other paradigmsTheory + Discussion20 min
1:00Where .NET fits inDemo15 min
1:15Course project introductionDiscussion20 min
1:35Q&A and wrap-upDiscussion25 min
Section 1 of 5
What is a Backend?
Everything the user never sees — and why it matters most
In this section
  • The role of the backend
  • Frontend vs backend responsibilities
  • Why the backend cannot be bypassed
The Backend's Role
  • Everything the user never sees: business logic, data storage, authentication, inter-service communication
  • You already know the frontend — React renders UI and makes HTTP calls
  • The backend is what answers those calls
  • The backend enforces rules the frontend cannot be trusted to enforce
Browser / Mobile / Postman HTTP Request ASP.NET Core Server Query Database HTTP Response
Backend Responsibilities
  • Handle incoming requests — routing, parsing, authentication checks
  • Validate data — enforce constraints the frontend cannot guarantee
  • Execute business logic — rules, calculations, workflows
  • Query and persist data — read and write to a database
  • Return structured responses — JSON, status codes, headers
  • Communicate with other services — email providers, payment APIs, message queues
Think about this
Every fetch() call you wrote in React assumed something was running on the other end. That something is the backend.
Key Concept
"The backend is the enforcer of rules — the frontend can be bypassed; the backend cannot afford to be."
— Session 01
Section 2 of 5
Client-Server Model & HTTP
The fundamental protocol powering every web application
In this section
  • The request-response cycle
  • HTTP methods
  • Status codes
  • Headers and body
The Request-Response Cycle
  • Every web interaction is a request-response cycle
  • The client (browser, mobile app, Postman) sends an HTTP request to a server URL
  • The server processes it and returns an HTTP response
  • HTTP is stateless — each request is independent; the server does not remember the previous one
  • The client must include all necessary context in every request (tokens, parameters, body)
Note
Statelessness is a constraint, not a limitation — it is what makes HTTP servers straightforward to scale horizontally.
HTTP Methods
MethodPurposeExample in our API
GETRetrieve a resourceFetch a task by ID
POSTCreate a new resourceCreate a new task
PUTReplace a resource entirelyUpdate a task's full data
PATCHPartially update a resourceMark a task as complete
DELETERemove a resourceDelete a task
Coming up
Session 04 covers HTTP methods and status codes in full depth with hands-on exercises.
HTTP Status Codes
CodeMeaning
200OK
201Created
400Bad Request
401Unauthorized
404Not Found
500Internal Server Error

Grouped by first digit:

  • 2xx — Success
  • 3xx — Redirection
  • 4xx — Client error (caller's fault)
  • 5xx — Server error (our fault)
Common mistake
Never return 200 OK with an error message inside the body. Use the correct status code.
Section 3 of 5
REST vs Other Paradigms
Why REST is the right starting point — and what else is out there
In this section
  • REST and its constraints
  • GraphQL, gRPC, WebSockets
  • Choosing the right paradigm
What is REST?

Representational State Transfer — an architectural style, not a protocol

  • Stateless — every request contains all information needed to process it
  • Resource-oriented — everything is a resource, identified by a URI: /tasks/42
  • Uses HTTP natively — methods map to operations (GET = read, POST = create, DELETE = remove)
  • Uniform interface — consistent structure and conventions across all endpoints
  • Client-server separation — frontend and backend are independently deployable
API Paradigms Compared
ParadigmStyleBest for
REST Resource-based, HTTP verbs General-purpose APIs, most web and mobile apps
GraphQL Query-based, single endpoint Complex UIs with flexible, nested data needs
gRPC Binary, contract-first (protobuf) High-performance microservice-to-microservice calls
WebSockets Persistent bidirectional connection Real-time: chat, live dashboards, multiplayer
Why REST first
REST maps directly onto HTTP, dominates the job market, and its principles transfer to every other paradigm.
Section 4 of 5
Where .NET Fits In
A cross-platform, strongly typed, enterprise-grade backend platform
In this section
  • .NET runtime overview
  • ASP.NET Core
  • Comparison with other frameworks
  • .NET strengths
.NET & ASP.NET Core
  • .NET is a free, cross-platform runtime from Microsoft — runs on Windows, Linux, and macOS
  • Not Windows-only: that was the old .NET Framework. Since .NET Core (2016), it runs everywhere
  • ASP.NET Core is the web framework on top of .NET — handles routing, middleware, and dependency injection
  • Current LTS version: .NET 8 (what we use in this course)
  • C# is the language — statically typed, modern, and expressive
Terminology
".NET" = the runtime. "ASP.NET Core" = the web layer. "C#" = the language. All three are used together.
Backend Frameworks at a Glance
Node.js / Express
JavaScript, lightweight, non-blocking I/O. Fast to start but weak typing at scale.
Django (Python)
Batteries-included, rapid development, strong ORM. Less control over the stack.
Spring (Java)
Enterprise-grade, very mature. Verbose configuration and steep learning curve.
ASP.NET Core (.NET)
Strong typing, top-tier performance, excellent tooling, massive enterprise adoption. Our choice.
.NET Strengths
  • Strong typing — catch errors at compile time, not in production
  • Excellent tooling — Visual Studio, VS Code, JetBrains Rider; powerful debugger and IntelliSense
  • Top-tier performance — ASP.NET Core consistently ranks among the fastest web frameworks in TechEmpower benchmarks
  • Large enterprise adoption — banks, healthcare systems, government, and Microsoft itself
  • First-class dependency injection — built in, no extra libraries needed
  • Great for teams — interfaces and strong conventions make large codebases navigable
Section 5 of 5
Course Project
The Task Management API you will build session by session
What you will build

A production-style RESTful API with authentication, filtering, versioning, and integration tests — built incrementally across all 20 sessions.

Task Management API — Session by Session
  • Sessions 3–4: Basic CRUD endpoints — create, read, update, delete tasks
  • Session 5: Proper error handling and clean structured error responses
  • Session 6: API versioning
  • Session 7: Pagination, filtering, and sorting
  • Sessions 9–10: Database persistence with Entity Framework Core
  • Sessions 13–15: JWT authentication and role-based authorization
Task Management API — Final State

By Session 20, your API will have:

  • JWT authentication and role-based access control
  • Full CRUD with filtering, sorting, and pagination
  • API versioning with backward compatibility
  • Structured error responses
  • Integration tests with a real database
  • Deployment configuration for production environments
Goal
Every session adds one real feature. By Week 10 you have a portfolio-ready API.
Summary
  • The backend handles everything after the HTTP request leaves the browser — validation, logic, data, and responses
  • HTTP is stateless; each request must carry all context it needs
  • REST is resource-oriented and maps naturally onto HTTP verbs and status codes
  • GraphQL, gRPC, and WebSockets serve specific use cases — REST is the right foundation first
  • .NET and ASP.NET Core provide a strongly typed, high-performance, enterprise-grade backend platform
  • You will build a Task Management API incrementally — one real feature per session
What's Next

Session 02 — Environment Setup & Git

  • Install the .NET 8 SDK and configure your development environment
  • Set up Git and connect to a remote repository
  • Create your first .NET solution and project structure

Before next session:

  • Install the .NET 8 SDK — instructions covered in Session 02
  • Read "What is REST?" at restfulapi.net — first two sections only
  • Optional: explore httpbin.org — a live API that echoes back your requests
Questions?
Session 01 — Introduction to Backend Development
Andalusia Academy