Home/Courses/Software Development/.NET Core
Beginner No prior .NET experience needed

Introduction to .NET Core

Eleven hours from what .NET Core actually is to an ASP.NET Core application you built yourself - architecture, the CLI, MVC, dependency injection and middleware, each demonstrated on screen, then quizzed.

Enroll on Coursera
≈ 11 hours 3 modules · 40 lessons Beginner · start from zero English · 23 languages available
Want a mentor alongside the course? See 1:1 coaching
Introduction to the course · 0:57

Introduction to .NET Core

By Board Infinity · Offered on Coursera

  • 40 video lessons · 10 assignments
  • Cross-platform - Windows, macOS or Linux
  • Shareable certificate on completion
  • Flexible schedule - fully self-paced
Enroll on Coursera

Every concept on screen

40 short lessons, with demos built live in Visual Studio and VS Code

Certificate included

Shareable on LinkedIn the day you finish

Quizzed, not just watched

10 assignments across the three modules

6 Lakh+learners on our Coursera courses
10+domains covered
270+courses
57+specializations
01 About the course

One course that goes all the way to middleware.

Most .NET introductions stop once a project runs. This one keeps going - through ASP.NET Core and MVC into dependency injection, the middleware pipeline, configuration, debugging and testing.

3
Modules
Architecture to advanced
40
Video lessons
Including 7 live demos
10
Assignments
7 practice, 3 graded
11h
Total learning time
Self-paced, flexible deadlines

Introduction to .NET Core is designed to equip you with the skills to build web applications using the .NET Core framework. It starts with the things every tutorial skips - what .NET Core actually is, how its version history got here, how it differs from the .NET Framework, and what the CLR, CoreCLR and CoreFX are doing underneath - and does not stop until you are wiring up your own middleware.

The shape is consistent across all three modules: a short screen-recorded lesson, then a quiz on the same idea. There are 40 lessons and 10 assignments, seven of them practice quizzes that sit between the lessons and three graded quizzes that close each module.

It assumes no prior .NET background. Module one sets up your development environment in Visual Studio and VS Code on screen, introduces the .NET CLI, and gets a console app and a web app running before it introduces a single controller.

Inside the course
01Introduction to .Net Development≈ 4h 02Building Web Applications using ASP.NET Core≈ 3h 03.NET Core Advance Concepts≈ 4h
02 Who it's for

For anyone who keeps almost learning .NET.

If one of these is you, the course was built for exactly this starting point.

Beginners

New to .NET entirely

You have heard .NET Core, .NET Framework and ASP.NET used interchangeably and cannot tell them apart. Module one is exactly that: features, versions, and the differences, before any code.

Self-learners

Three tutorials in, still copying

You can scaffold a project but cannot say what the pipeline is doing. The 10 assignments are the difference - you find out what you actually know.

Developers

Coming from another stack

You already write code elsewhere and need the .NET way of doing it: the CLI, the MVC pattern, the IoC container, and how a request travels through middleware.

Students

Need .NET for the next thing

Full-stack .NET, backend and API courses all assume ASP.NET Core. This is that prerequisite, taught properly rather than skimmed.

03 What you'll learn

Four capabilities, in the order they build.

These are the four outcomes Coursera lists for this course - what you leave with is the ability to build these things yourself, from an empty project.

Module 1

Understand .NET Core's features, versions and setup

What .NET Core is and where it came from, its version history, and the differences between .NET Core and the .NET Framework - then a development environment set up on screen in Visual Studio and VS Code.

Module 1

Master the architecture, CLI and core components

The .NET Core platform - language compilers, CoreCLR and CoreFX - and the .NET CLI commands you use to develop, build, test and deploy an application from a terminal.

Module 2

Build web applications with ASP.NET Core and MVC

The MVC pattern and model-view-controller communication, handling requests, serving static files, session and state management, routing configuration and hosting environments.

Module 3

Work with DI, middleware, configuration and testing

Dependency injection and IoC containers, loosely- versus tightly-coupled architecture, the middleware request pipeline with built-in and custom middleware, exception handling, multi-targeting and code sharing.

Bhawna Gunwani Teaches this course

Bhawna Gunwani

Backend development specialist Works across C# .NET, Python, MEAN & MERN Instructor for this course with Board Infinity
C# & .NET Backend development Full-stack
View LinkedIn profile
04 Industry expertise

Taught by real industry expertise, not theory.

Bhawna Gunwani works in backend development, with hands-on experience across C# and .NET, Python, and the MEAN and MERN stacks. In this course she takes you from what .NET Core actually is to an ASP.NET Core application you build yourself - architecture, the CLI, MVC, dependency injection and middleware.

Meet your instructor · 1:07
1:1 coaching · optional add-on

Learn .NET Core with someone in your corner.

A dedicated coach who writes .NET for a living - someone who can look at the error you have stared at for an hour and tell you why.

Book a demo session
  • A coach matched to your goal in 24 hours
  • A written roadmap you keep
  • Weekly sessions for as long as you want them

60-minute demo session · 100% refundable · no obligation to continue

Get unstuck in minutes

The build error or unresolved service you have stared at for an hour, explained by someone who has seen it.

Your code read line by line

Not just whether the app runs - whether the controllers and services are ones you would want to maintain.

Practice beyond the quizzes

Problems set for you, then reviewed, so the framework turns into fluency.

Aim it at a role

Which .NET path fits you - backend, web or full-stack - and what to learn next.

2,000+Industry coaches
16Domains covered
4.8/5Average coach rating
48,000+Sessions delivered
05 Syllabus

Three modules, from what .NET Core is to your own middleware.

Eleven hours end to end, fully self-paced. Every module lists its learning objectives, exactly what is inside it, and what you leave with.

40 videos 9 readings 10 assignments ≈ 11 hours Download full syllabus
Learning objectives - by the end of this module you can:
  • Explain what .NET Core is, the features it introduced, and how its version history got here
  • Describe the differences between .NET Framework and .NET Core, and between ASP.NET and ASP.NET Core applications
  • Set up a development environment with Visual Studio and VS Code, and read an ASP.NET Core project folder structure
  • Use .NET CLI commands to build an application, and name the parts of the platform - language compilers, CoreCLR and CoreFX
What's inside
16 videos47 min
3 readings70 min
3 assignments90 min
1 plugin5 min
Topics covered
.NET Core features Version history .NET Framework vs .NET Core ASP.NET Core Project folder structure Visual Studio & VS Code .NET CLI
You leave with: a working .NET development environment, and your first console and ASP.NET Core web applications running.
Learning objectives - by the end of this module you can:
  • Explain the MVC pattern and how the model, the view and the controller communicate
  • Build a web application with ASP.NET Core and handle incoming requests in .NET Core MVC
  • Serve static files, and manage session and state across requests
  • Configure routing, and choose between the hosting environments .NET Core provides
What's inside
10 videos41 min
2 readings60 min
3 assignments90 min
Topics covered
MVC pattern Model-view-controller communication Handling requests Static files Session & state management Routing configuration Hosting environments
You leave with: an ASP.NET Core web application you routed and configured yourself, built the way the framework expects.
Learning objectives - by the end of this module you can:
  • Use ASP.NET Core environment variables to configure an application per environment
  • Apply dependency injection with the IoC container, and explain loosely-coupled versus tightly-coupled architecture
  • Trace the middleware request pipeline, and write custom middleware alongside the built-in ones
  • Handle exceptions, target multiple frameworks and share code across projects
What's inside
14 videos47 min
4 readings100 min
4 assignments105 min
Topics covered
Environment variables Dependency injection IoC containers Middleware pipeline Custom middleware Exception handling Multi-targeting & code sharing
You leave with: a .NET Core application built from scratch, with dependency injection and your own middleware wired into the pipeline.
06 Tools & skills

The tools you work in, and the skills you leave with.

Nothing to install before you start - module one sets all of it up on screen.

The framework
.NET logo

.NET Core

The whole course. Architecture, the platform, ASP.NET Core, dependency injection, middleware and deployment.

Where you write
Visual Studio logo

Visual Studio

Set up in a demo lesson in module one, so you are writing in a real IDE rather than a toy console.

The lighter option
Visual Studio Code logo

VS Code

Covered alongside Visual Studio in the same demo, so you can follow the course on Windows, macOS or Linux.

Where you build
.NET CLI logo

.NET CLI

Its own lessons in module one - the commands you use to create, build, test and deploy from a terminal.

Skills you leave with

The eleven capabilities Coursera lists for this course, grouped the way the work actually splits - building it, designing it, and shipping it.

Building applications

Getting a .NET Core application to exist and to run.

  • Application development
  • Web development
  • Cross platform development
  • Open source technology

Designing it

Structuring it so a second person can work on it.

  • Software architecture
  • Model view controller
  • Development environment
  • Microsoft development tools

Shipping it

Finding out what is wrong before your users do.

  • Software testing
  • Debugging
  • Application deployment
Certificate

Proof you can link to.

Finish the graded work and Board Infinity issues a certificate through Coursera - with a public verification link and a one-click path onto your LinkedIn profile.

Coursera lists a shareable certificate for this course, issued on completion of the graded work across the three modules.

On your profile in one click

Filed under Licenses & Certifications, where recruiters actually look.

Anyone can verify it

Its own verification link, so a hiring manager confirms it in seconds.

Earned, not attended

Awarded on the graded quizzes that close each module - it certifies what you can do.

Two names on it

Board Infinity as the provider, Coursera as the platform.

07 Career impact

.NET Core is the entry ticket - and then it keeps paying.

New .NET web work is written against ASP.NET Core. These are the roles that list it first.

Where this skill is the prerequisite

.NET Developer

The direct path. Everything after this course - APIs, data access, testing - assumes exactly what module three covers.

ASP.NET Developer

Module two is the job description: the MVC pattern, routing, static files, session and state, and hosting environments.

Backend Developer

Dependency injection, middleware and configuration are the vocabulary of every server-side .NET conversation.

Web Developer

Cross-platform by design - the same ASP.NET Core application runs on Windows, macOS or Linux.

Software Developer

Loosely-coupled architecture, multi-targeting and code sharing are transferable well past .NET itself.

Career switchers

The prerequisite that unlocks the rest of a catalogue. Do it once, properly, and stop restarting from module one elsewhere.

The honest comparison

.NET Core is free to learn. So what is this?

Every topic in this course exists free somewhere on the internet, including Microsoft's own docs. Nobody is pretending otherwise. What a course adds is the order you learn it in, the checking that makes it stick, and something to show at the end.

What you get
This course
Free videos and docs
A sequenced pathArchitecture → ASP.NET Core → advanced concepts
3 modules that build on each other
Whatever the algorithm shows you
Someone checkingLearning that sticks
10 assignments, 3 of them graded
You never find out what you missed
It goes far enoughMost tutorials stop once it runs
DI, middleware, debugging and testing
Usually ends at the scaffolded project
Nothing to set upThe usual first hurdle
Visual Studio and VS Code set up on screen
Where most beginners quit
Proof for recruitersVerifiable, on LinkedIn
Certificate with a verification link
Nothing to show
08 Where to go next

.NET Core is the base. Here is what it unlocks.

This course stands on its own. These are the Board Infinity courses that assume it and build straight on top.

Widen the stack

.Net Full Stack Foundation

The natural next step once ASP.NET Core makes sense: the foundation course of Board Infinity's .NET FullStack Developer specialization.

View course Go deeper server-side

Backend Development for .Net Full Stack

Take the controllers, dependency injection and middleware from module three and build a backend on top of them.

View course Add the interface

Frontend Development using React

The other half of a full-stack .NET application - a React front end talking to the ASP.NET Core back end you can now build.

View course

Board Infinity runs 270+ courses and 57 specializations on Coursera - browse the full catalogue.

Know exactly what you're signing up for.

3 modules · 40 lessons · 10 assignments · free PDF

09 FAQ

Common questions

Everything learners ask before enrolling, answered plainly.

About the course

You'll learn .NET Core end to end across three modules: its features, version history and the differences between .NET Framework and .NET Core, the .NET Core platform and architecture, and the .NET CLI; then ASP.NET Core web applications - the MVC pattern, model-view-controller communication, handling requests, serving static files, session and state management, routing configuration and hosting environments; then the advanced concepts - environment variables, dependency injection and IoC containers, middleware and the request pipeline, exception handling, multi-targeting and code sharing. That's 40 video lessons, 9 readings and 10 assignments.

No prior .NET experience is needed - Coursera lists the course at Beginner level. Module one starts at what .NET Core is, walks through its version history and its differences from the .NET Framework, and demonstrates setting up a development environment with Visual Studio and VS Code on screen before you build anything. Comfort with basic programming concepts helps you move faster, but the course does not assume you have written .NET before.

About 11 hours of learning across 3 modules - roughly 4 hours, 3 hours and 4 hours. Coursera's own guidance is 1 week at ten hours a week. It's fully self-paced with flexible deadlines, so evenings and weekends will stretch it out, and that's fine.

Nothing in advance. A dedicated demo lesson in module one covers setting up a development environment with Visual Studio and/or VS Code, and the .NET CLI lessons take it from there. Everything the course uses is free to download, and .NET Core runs on Windows, macOS and Linux.

Yes - this page is Board Infinity's own overview of our course. Enrollment, payment, video lessons, grading and the certificate all happen on Coursera, where the course is hosted. Think of this page as the detailed tour before you head there.

The price is shown at checkout on the Coursera course page and can vary by region. It's included at no extra cost with a Coursera Plus subscription, and Coursera's financial aid is available to eligible learners.

Career & certificate

Yes. Coursera lists a shareable certificate for this course. Complete the graded work across the three modules and Board Infinity issues a certificate through Coursera, with its own verification link. Coursera's one-click button adds it straight to the Licenses & Certifications section of your LinkedIn profile.

It's the foundation, not the finish line. This course takes you to the point where you can read and build an ASP.NET Core application, wire up dependency injection and middleware, and reason about configuration, debugging and deployment - which is the level most .NET roles and follow-on courses assume as their starting point. Roles will also want depth on top: data access and Entity Framework, APIs at scale, testing practice and cloud deployment.

Because they are how ASP.NET Core itself is built. Every request travels through a middleware pipeline, and almost every service an application uses is resolved by the built-in IoC container. Module three covers loosely-coupled versus tightly-coupled architecture, built-in and custom middleware, and the request pipeline - which is what separates following a tutorial from understanding the framework.

It depends where you're aiming. For a full-stack path, .Net Full Stack Foundation is the natural next step, followed by Backend Development for .Net Full Stack. If the interface side interests you more, Frontend Development using React pairs with the ASP.NET Core back end you can now build. The Where to go next section lists all three Board Infinity courses.

It's the cross-platform, open-source direction Microsoft took .NET in, and ASP.NET Core is what new .NET web applications are written against. The specific reason it's worth learning properly rather than partially is that everything downstream - APIs, microservices, full-stack .NET work - assumes you already understand the architecture, the CLI, the MVC pattern, dependency injection and middleware that this course covers.

Want someone building this with you?

Board Infinity 1:1 coaching pairs you with a practitioner while you take the course.

See 1:1 coaching
Introduction to .NET Core Enroll