Skip to content
ballmüllersolutions logo Send an email Call us

K2 Junior full stack with .NET and Blazor

Build, test and deliver a web application to Azure with ASP.NET Core, Blazor, SQL and EF Core – the craft for a first junior position.

Join the waiting list

Who it is for

For everyone after K1 who wants to start in web development with .NET as a junior.

Prerequisites

K1 or the placement test.

Afterward, you can

  • Build web pages with HTML and SCSS, accessible to WCAG
  • Develop web APIs with ASP.NET Core
  • Model and store data with SQL Server and EF Core
  • Build user interfaces with Blazor, static and with interactive islands
  • Add sign-in with Microsoft Entra ID and know the OWASP Top 10
  • Test web applications automatically, up to an end-to-end test
  • Build background work and integrations that hold up
  • Deliver an application to Azure as a container, with a Dockerfile and a registry of your own
  • Design and version APIs, with OpenAPI, gRPC and webhooks
  • Build live views with SignalR
  • Refactor code deliberately with SOLID and prove the gain with tests

Contents

  1. 2.1

    Web fundamentals

    HTTP, HTML, CSS and SCSS, accessibility (WCAG), browser tools

    35 h
  2. 2.2

    TypeScript, just what is needed

    strict mode, the DOM, one script per page, no framework

    15 h
  3. 2.3

    ASP.NET Core

    minimal APIs, routing, dependency injection, configuration and options, middleware, ProblemDetails, validation

    40 h
  4. 2.4

    Data

    SQL (SQL Server), modeling, indexes, EF Core, migrations, transactions

    45 h
  5. 2.5

    Blazor

    components, static SSR, forms without script, interactive islands (Server/WebAssembly), layouts, two languages

    55 h
  6. 2.6

    Sign-in and permissions

    cookies, OpenID Connect with Microsoft Entra ID, roles, antiforgery, OWASP Top 10

    25 h
  7. 2.7

    Testing on the web

    unit tests, integration tests with WebApplicationFactory, component tests, an end-to-end test with Playwright for .NET

    30 h
  8. 2.8

    Background work and integration

    BackgroundService, HttpClientFactory, retrying without sending twice, the outbox pattern, mail

    20 h
  9. 2.9

    Containers and a first deployment

    containers with dotnet publish and with a Dockerfile of your own (layers, multi-stage, small and secure images), Azure Container Registry, Docker Compose next to Aspire, Aspire locally, Azure Container Apps with azd

    30 h
  10. 2.10

    Working in a team

    pull requests, reviews, issues, definition of done, SOLID day to day

    15 h
  11. 2.12

    Designing APIs

    REST done well, OpenAPI as the contract, versioning, gRPC, webhooks, Azure API Management

    20 h
  12. 2.13

    Real time with SignalR

    hubs and clients, groups, sign-in and permissions in the hub, scaling with Azure SignalR Service or a backplane

    10 h
  13. 2.14

    SOLID with real examples

    each principle as a refactoring of the Kladde: the smell that shows it, the test that proves the gain, and when not to apply it

    15 h
  14. 2.11

    Final project

    the Kladde as a web application

    60 h

About 415 hours in all (indicative).

Lessons

You see the text and video of every lesson here on the site after buying the course; the titles and goals are already shown. A self-study course: you work through the lessons in order and check your exercises yourself against the solutions.

You can read the first module (2.1) for free, with text and video, without signing in: so you see how the course works before you buy.

The lessons stand under their modules, in the order of the course. Click a module to open or close its lessons.

2.10 Working in a team

Indicative: 15 hours · 4 lessons
  1. Lesson 1 · about 180 minutes

    Issues and definition of done

  2. Lesson 2 · about 180 minutes

    Rules in the repository

  3. Lesson 3 · about 180 minutes

    Reviews that help

2.1 Web fundamentals

Indicative: 35 hours · 8 lessonsfree to read
  1. Lesson 5 · about 240 minutes

    How the web talks: HTTP

  2. Lesson 6 · about 240 minutes

    HTML with meaning

  3. Lesson 7 · about 240 minutes

    Forms without script

  4. Lesson 8 · about 300 minutes

    CSS: the cascade, the box model and layout

  5. Lesson 9 · about 180 minutes

    The browser’s tools

  6. Lesson 10 · about 180 minutes

    SCSS in the build

  7. Lesson 11 · about 300 minutes

    Accessibility with WCAG 2.2

  8. Lesson 12 · about 240 minutes

    Fast pages

2.2 TypeScript, just what is needed

Indicative: 15 hours · 4 lessons
  1. Lesson 13 · about 180 minutes

    Script in moderation: TypeScript in the build

  2. Lesson 14 · about 180 minutes

    Types in TypeScript for C# developers

  3. Lesson 15 · about 240 minutes

    The DOM: read, react, change

  4. Lesson 16 · about 180 minutes

    One script per page, cleanly cut

2.3 ASP.NET Core

Indicative: 40 hours · 10 lessons
  1. Lesson 17 · about 180 minutes

    The first web API

  2. Lesson 18 · about 240 minutes

    Routing and results

  3. Lesson 19 · about 240 minutes

    Dependency injection

  4. Lesson 20 · about 240 minutes

    Configuration and options

  5. Lesson 21 · about 300 minutes

    Middleware and logging

  6. Lesson 22 · about 180 minutes

    Async on the web

  7. Lesson 23 · about 180 minutes

    Errors as ProblemDetails

  8. Lesson 24 · about 240 minutes

    Validation at the edge, rules in the model

  9. Lesson 25 · about 180 minutes

    Time on the web

  10. Lesson 26 · about 180 minutes

    OpenAPI and API design

2.4 Data

Indicative: 45 hours · 11 lessons
  1. Lesson 27 · about 180 minutes

    SQL Server in a container

  2. Lesson 28 · about 300 minutes

    SQL: querying

  3. Lesson 29 · about 240 minutes

    SQL: changing data, data types, constraints

  4. Lesson 30 · about 240 minutes

    Modeling data

  5. Lesson 31 · about 240 minutes

    Indexes and execution plans

  6. Lesson 32 · about 300 minutes

    EF Core: DbContext and mapping

  7. Lesson 33 · about 240 minutes

    Migrations

  8. Lesson 34 · about 120 minutes

    Test data and seeding

  9. Lesson 35 · about 240 minutes

    Queries with EF Core

  10. Lesson 36 · about 240 minutes

    Concurrency and transactions

  11. Lesson 37 · about 180 minutes

    The store as an adapter

2.5 Blazor

Indicative: 55 hours · 13 lessons
  1. Lesson 38 · about 180 minutes

    The Blazor Web App

  2. Lesson 39 · about 300 minutes

    Components

  3. Lesson 40 · about 180 minutes

    Layouts and navigation

  4. Lesson 41 · about 240 minutes

    Showing data with static SSR

  5. Lesson 42 · about 300 minutes

    Forms without script

  6. Lesson 43 · about 300 minutes

    The public appointment booking

  7. Lesson 44 · about 180 minutes

    Errors, empty lists and “not found”

  8. Lesson 45 · about 300 minutes

    Interactive islands with InteractiveServer

  9. Lesson 46 · about 180 minutes

    Lists with QuickGrid

  10. Lesson 47 · about 240 minutes

    Interactive islands with WebAssembly

  11. Lesson 48 · about 180 minutes

    State, events and page scripts

  12. Lesson 49 · about 300 minutes

    Two languages

  13. Lesson 50 · about 180 minutes

    Accessible components

2.7 Testing on the web

Indicative: 30 hours · 8 lessons
  1. Lesson 51 · about 120 minutes

    Which test for what

  2. Lesson 52 · about 180 minutes

    Unit tests for rules and endpoints

  3. Lesson 53 · about 300 minutes

    Integration tests with WebApplicationFactory

  4. Lesson 54 · about 240 minutes

    Against the real database

  5. Lesson 55 · about 120 minutes

    Testing registrations

  6. Lesson 56 · about 240 minutes

    Component tests with bUnit

  7. Lesson 57 · about 300 minutes

    An end-to-end test with Playwright

  8. Lesson 58 · about 120 minutes

    All tests in every pull request

2.6 Sign-in and permissions

Indicative: 25 hours · 6 lessons
  1. Lesson 60 · about 300 minutes

    OpenID Connect with Microsoft Entra ID

  2. Lesson 61 · about 240 minutes

    Roles and policies

  3. Lesson 62 · about 180 minutes

    Testing permissions

  4. Lesson 63 · about 180 minutes

    Antiforgery, XSS and security headers

  5. Lesson 64 · about 240 minutes

    The OWASP Top 10 on the Kladde

2.8 Background work and integration

Indicative: 20 hours · 5 lessons
  1. Lesson 65 · about 240 minutes

    HttpClientFactory and an external API

  2. Lesson 66 · about 240 minutes

    Background services

  3. Lesson 67 · about 180 minutes

    Retrying without sending twice

  4. Lesson 68 · about 240 minutes

    The outbox pattern

  5. Lesson 69 · about 180 minutes

    Sending mail, confirmed

2.9 Containers and a first deployment

Indicative: 30 hours · 9 lessons
  1. Lesson 70 · about 180 minutes

    Understanding containers

  2. Lesson 71 · about 180 minutes

    Containers with dotnet publish

  3. Lesson 72 · about 240 minutes

    Aspire locally

  4. Lesson 74 · about 240 minutes

    Shipping with azd

  5. Lesson 75 · about 180 minutes

    Your own Dockerfile: images and layers

  6. Lesson 76 · about 180 minutes

    Multi-stage, small and secure

  7. Lesson 77 · about 120 minutes

    Azure Container Registry

  8. Lesson 78 · about 120 minutes

    Docker Compose next to Aspire

2.12 Designing APIs

Indicative: 20 hours · 6 lessons
  1. Lesson 79 · about 240 minutes

    REST done right: resources, methods, state

  2. Lesson 80 · about 180 minutes

    Contract first: OpenAPI

  3. Lesson 81 · about 180 minutes

    Versioning without breaking callers

  4. Lesson 82 · about 180 minutes

    gRPC between services

  5. Lesson 83 · about 180 minutes

    Sending and receiving webhooks

  6. Lesson 84 · about 120 minutes

    Azure API Management

2.13 Real time with SignalR

Indicative: 10 hours · 3 lessons
  1. Lesson 85 · about 180 minutes

    Hubs and clients

  2. Lesson 86 · about 180 minutes

    Sign-in, permissions and limits in the hub

  3. Lesson 87 · about 120 minutes

    Scaling SignalR

2.14 SOLID with real examples

Indicative: 15 hours · 6 lessons
  1. Lesson 88 · about 120 minutes

    Recognizing smells before quoting principles

  2. Lesson 89 · about 180 minutes

    S: one responsibility, one reason to change

  3. Lesson 90 · about 120 minutes

    O: extend without touching what works

  4. Lesson 91 · about 180 minutes

    L: substitutability that tests prove

  5. Lesson 92 · about 120 minutes

    I: narrow interfaces by caller

2.11 Final project

Indicative: 60 hours · 13 lessons
  1. Lesson 94 · about 180 minutes

    Planning: the way to the finished Kladde

  2. Lesson 95 · about 300 minutes

    Milestone 1: Contacts and companies

  3. Lesson 96 · about 300 minutes

    Milestone 2: Appointments in the office

  4. Lesson 97 · about 300 minutes

    Milestone 3: Free times and booking

  5. Lesson 98 · about 300 minutes

    Milestone 4: Confirmation and outbox

  6. Lesson 99 · about 300 minutes

    Milestone 5: Importing tenders

  7. Lesson 100 · about 240 minutes

    Milestone 6: Searching tenders

  8. Lesson 101 · about 240 minutes

    Milestone 7: Two languages

  9. Lesson 102 · about 300 minutes

    Milestone 8: Accessibility and security

  10. Lesson 103 · about 240 minutes

    Milestone 9: Completing the tests

  11. Lesson 104 · about 300 minutes

    Milestone 10: Delivering to Azure

  12. Lesson 105 · about 300 minutes

    Review and polish

Final project: the Kladde

What the Kladde can do after this course

A web application with contacts, a public appointment booking with free slots and public tenders from the EU's TED interface, with sign-in through Entra ID, in two languages and delivered to Azure.

At the end you present the application in a demo, explain a part of your code and quiz yourself with practice questions and their answers – on your own or in front of someone you know.

More about the Kladde

Certifications

An offer, never a requirement: these Microsoft exams fit this stage. You take them at Microsoft; we are not a Microsoft training partner.

Keep learning with Microsoft Learn

Microsoft's learning paths and documentation that go with this course.

All courses at a glance