ASP.NET Core roadmap

The DotNet Software Development Kit is the primary toolset you need to write, build, and run C programs on your computer. It includes the compiler which translates your human-readable code into instructions the computer can execute, alongside the runtime that actually runs the application.

Think of it like a kitchen workspace that provides the oven, knives, and countertops required to cook any recipe you choose. Without it, you cannot compile or test your code locally.

Getting comfortable with the command line tools in this SDK is essential because every backend project you build will rely on these commands to restore packages, run tests, and start your web server.

• Includes compiler and runtime
• Operates via command line
• Required for local development

Language syntax refers to the strict grammar and spelling rules of C. It covers how you declare variables to hold data, use conditional statements like if-else to make decisions, and write loops to repeat actions.

Imagine writing a recipe where you must define your ingredients and steps in a precise order so the reader does not get confused. If you miss a semicolon, the compiler stops and points out the exact mistake.

Mastering syntax matters because it is the alphabet of programming. Without it, you cannot express logic or tell the computer what tasks you want your application to perform.

• Variables store different data types
• Conditional statements control logic flow
• Loops automate repetitive tasks

Object Oriented Programming is a style of writing code by grouping related data and actions together into blueprints called classes. You then create specific instances of those blueprints, known as objects, to run your program.

Think of a class as a blueprint for a car, defining properties like colour and speed, while an individual red sports car parked outside is the actual object created from that blueprint.

This approach matters because real-world software is large and complex. Organising your C code into logical classes helps you keep your projects tidy, maintainable, and easy to expand as requirements grow.

• Classes act as code blueprints
• Objects are individual instances
• Encapsulates data and behavior

Language Integrated Query, or LINQ, is a powerful feature in C that lets you filter, sort, and transform collections of data directly inside your code using a readable syntax.

Picture a librarian using an advanced catalog search system to quickly pull every history book published after the year two hundred from a massive warehouse.

This matters because web applications constantly handle lists of users, products, and messages. LINQ lets you query these lists safely and cleanly without writing messy, error-prone manual loops for every single filter.

• Queries lists and collections easily
• Uses familiar readable methods
• Reduces manual loop code

Minimal APIs are a streamlined feature in ASP.NET Core designed to let you build lightweight web endpoints with very little boilerplate code or complex setup.

Think of it like setting up a small pop-up coffee stall rather than opening a multi-storey restaurant; you serve customers quickly with just a table and a kettle.

This approach matters because modern web development often starts with small, focused services. Minimal APIs let you spin up functional web backends rapidly without getting bogged down in heavy configuration files.

• Requires minimal boilerplate code
• Ideal for lightweight services
• Fast setup for developers

Routing and parameters allow your web application to capture specific values from incoming URL paths and query strings so your endpoints can respond dynamically.

Consider an online shop where the URL changes based on the product ID you clicked, allowing the server to look up and display the correct item details.

This matters because web apps need to handle user-specific requests every second. Understanding routing ensures the right data gets sent to the right place every time a user clicks a link.

• Captures data from URL paths
• Handles query string parameters
• Enables dynamic web responses

API Controllers are structured classes that help you organise related web endpoints into logical groups when your application grows beyond a handful of simple routes.

Think of this like sorting a messy drawer of tools into labelled compartments, where all spanners go in one box and screwdrivers in another.

Organising your code with controllers matters because larger applications contain dozens of features. Structured groupings keep your codebase readable and help teams collaborate without stepping on each other's toes.

• Groups related endpoints together
• Improves large project structure
• Follows standard design patterns

Dependency Injection is a design pattern where required helper services are passed into your classes automatically by the framework rather than your code creating them manually.

Imagine a chef who does not grow their own vegetables or forge their own knives, but instead has fresh tools and ingredients delivered directly to their station.

This matters immensely for testability and modularity. By decoupling your classes from direct creation, you can easily swap out components or mock them during automated tests.

• Framework provides required services
• Reduces tight coupling in code
• Improves unit testing capability

The middleware pipeline is a sequence of components that process incoming HTTP requests and outgoing responses one after another in a defined order.

Picture airport security checkpoints where passengers pass through ticket checks, bag scans, and body scanners sequentially before reaching the departure gate.

This matters because cross-cutting concerns like logging, authentication, and error handling need to run consistently for every single request. Middleware lets you hook these tasks up cleanly in a predictable chain.

• Processes requests in sequence
• Handles cross-cutting tasks
• Order of components matters

App settings management involves storing configuration values, such as database connection strings and feature flags, securely outside your core source code.

Think of this like keeping your house keys in a designated key box rather than taped to the front door where anyone can grab them.

This matters because applications run in multiple environments like local development, testing, and cloud production. Separating settings prevents sensitive data leaks and lets you change app behaviour without rewriting code.

• Stores settings in JSON files
• Uses environment variables safely
• Separates code from configuration

Entity Framework Core is an Object Relational Mapper that allows you to interact with databases using ordinary C classes and LINQ instead of writing raw SQL strings.

Imagine an automated translator who listens to your English instructions and instantly converts them into fluent database commands without you needing to learn a foreign dialect.

This matters because it speeds up feature development significantly. You can focus entirely on your C domain models while the framework manages database communication behind the scenes.

• Maps C classes to tables
• Avoids writing raw SQL manually
• Simplifies data access logic

Database migrations are a safe way to track and apply changes to your database schema over time as your C data models evolve.

Think of this like architectural blueprints for a house renovation, detailing exactly which walls to add or remove without knocking the whole structure down.

This matters because applications change constantly. Migrations ensure your production and development databases stay perfectly synchronised with your code without losing valuable user data.

• Tracks schema changes safely
• Generates incremental update scripts
• Keeps code and database aligned

Querying databases with LINQ allows you to write standard C queries against your data models, which the framework then automatically translates into optimised SQL commands.

Picture speaking into a translation headset that listens to your native language and speaks the local dialect directly to a store clerk.

This matters because it keeps your data access logic consistent and type-safe. If you rename a C property, your compiler will warn you if a database query breaks, catching bugs early.

• C LINQ translates to SQL
• Type-safe database querying
• Catches property errors early

Authentication and authorisation work together to verify user identities and ensure they only access resources and endpoints they have permission to view.

Think of a nightclub bouncer checking your photo ID at the door to confirm who you are, and then checking if you have a VIP ticket to enter the backstage lounge.

This matters because web security is paramount. Proper identity verification protects sensitive user data and prevents unauthorised actors from tampering with your backend services.

• Authentication confirms identity
• Authorisation restricts permissions
• Protects sensitive API endpoints

Unit testing involves writing automated code using frameworks like xUnit to verify that individual pieces of your application logic work correctly in isolation.

Imagine an automotive engineer testing a single spark plug on a workbench before installing it into a complete car engine.

This matters because catching small logic bugs early saves hours of debugging later. Reliable unit tests ensure your core business rules behave exactly as expected under all conditions.

• Tests individual code units
• Uses frameworks like xUnit
• Catches logic bugs early

Integration testing checks how multiple parts of your application, such as routing, controllers, and databases, work together as a complete system.

Think of putting the fully assembled car onto a test track to verify that the steering, brakes, and engine operate harmoniously.

This matters because individual units might work fine in isolation, but fail when connected together. Integration testing ensures your web app runs reliably from the HTTP request down to the database.

• Tests complete request pipelines
• Verifies component integration
• Uses a test web server

Publishing for production involves compiling your C application into an optimized folder of self-contained files ready to run on a server.

Picture packing your belongings into sturdy travel boxes, stripping out all unnecessary clutter so everything is light and ready for transit.

This matters because development builds contain debugging tools and extra files that slow performance. Production publishing strips those away for maximum speed and security.

• Compiles optimized release files
• Removes heavy debug assets
• Prepares app for server hosting

Containerising with Docker packages your compiled web application and all its required runtime dependencies into a single portable container image.

Think of shipping goods inside a standardised metal freight container that can travel seamlessly by ship, train, or lorry without repacking.

This matters because it solves the classic problem of code working on your local laptop but failing on a server. A Docker container runs identically everywhere.

• Bundles app with dependencies
• Ensures consistent environment runs
• Portable across different servers

Cloud hosting is the practice of deploying your published web API onto remote cloud servers or platforms so it is accessible to users over the internet.

Imagine renting a dedicated shopfront in a bustling digital high street rather than hosting a market stall out of your garage.

This matters because your users need reliable access twenty-four hours a day. Cloud platforms handle hardware maintenance, security patches, and scaling effortlessly.

• Deploys API to remote servers
• Provides public internet access
• Handles uptime and scaling