Frontend Developer Course with the SVILUPPATORE MIGLIORE method
Become a Frontend Developer with Blazor and .NET. Create modern, performant and scalable interfaces without depending on JavaScript and the npm chaos.
1-on-1 Mentor On YOUR code Measurable results
Frontend development does not have to mean JavaScript.
With Blazor and .NET, your team can build interactive web interfaces entirely in C#, same logic, same models, same language as the backend. No more context-switching, no more npm hell, no more JavaScript frameworks that change every year.
This programme is for .NET teams who want to bring frontend skills in-house without hiring JavaScript developers or learning React from scratch.
What you learn: the complete programme
2 phases, 8 modules of intensive training on YOUR code.
2 phases, 8 modules of intensive training on YOUR code.
PHASE 1: Blazor UI Foundations (Weeks 1-4)
- 1
Blazor Component Model: the building block of every interface
Components are the fundamental unit of Blazor. Understanding their lifecycle, rendering and composition is the difference between UIs that work and UIs that scale. Without this foundation, every component added increases chaos instead of reducing it. Here we build the understanding that makes every future implementation solid.
Programma
- Component lifecycleHow to control exactly when the UI updates and intervene at every phase of the lifecycle
- Parameter and CascadingParameterHow to manage downward data flow in a predictable way without chaotic prop drilling
- EventCallbackHow to communicate from child to parent components cleanly without global events
- Routing with parametersHow to associate each URL with its component with parameters and query strings without complex configuration
- EditForm and DataAnnotationHow to build forms with automatic validation without writing validation code
- Templatable RenderFragmentHow to create generic components that receive UI as a parameter and are reusable in any context
Risultato
Interactive UIs in pure C#. You know how to build components that compose, communicate and manage their own state predictably.
- 2
CSS and Design System: interfaces that look like they were made by a designer
Frontend is not just logic, it is interface. A C# developer doing frontend with 2000s-era CSS delivers UIs that look like they were made by a backend developer. Here you learn modern CSS and how to build design systems that guarantee visual consistency.
Programma
- Advanced CSS Grid and FlexboxHow to build complex layouts that adapt without floats and obsolete CSS tricks
- CSS isolation in BlazorHow to give dedicated styles to each component eliminating class conflicts between different modules
- Bootstrap and Tailwind in BlazorHow to integrate CSS frameworks that work with the component lifecycle without surprises
- Design system with custom propertiesHow to manage CSS tokens to update colours and spacing from a single place
- Responsive interfacesHow to build optimal layouts for desktop, tablet and mobile with media queries
- Dark mode and brand customisationHow to change theme and brand at runtime without a page reload
Risultato
Professional interfaces that do not look like they were made by a backend developer. The design system guarantees visual consistency throughout the application.
- 3
State Management: consistent data across all components
State is the most complex problem in frontend applications. Managing it badly means impossible-to-reproduce bugs and inconsistent UIs that erode user trust. Here you learn the patterns that make state predictable and controllable.
Programma
- Local component stateHow to manage each component as an autonomous unit with predictable behaviour
- CascadingValue for shared stateHow to distribute state between distant components without prop drilling through every intermediate level
- Fluxor for the Redux patternHow to implement predictable, debuggable and testable global state with Fluxor
- .NET services as state storesHow to use the simple pattern that works for 90% of applications without Redux
- Persistence with localStorageHow to save state between sessions so the user finds the app as they left it
- Multi-step forms with shared stateHow to manage complex flows where each step can see the data from the others without losing it
Risultato
State managed with clear patterns. The UI is always consistent and state-related bugs disappear before they ever appear.
- 4
Rendering Model: choose the right model and build on it
Blazor has multiple rendering models and choosing the wrong one costs months of work. Server, WebAssembly, Hybrid and Static SSR have completely different trade-offs: using the wrong model is not recoverable halfway through a project. Here you understand the criteria and choose with confidence.
Programma
- Blazor Server for enterprise applicationsHow to leverage controlled latency, zero download and code always on the server
- Blazor WebAssembly for distributed appsHow to run C# in the browser without an intermediate server for offline-capable apps
- Blazor Hybrid with MAUI, WPF and WinFormsHow to reuse web components in desktop apps without rewriting them
- Static SSR and Streaming Rendering in .NET 10How to achieve perfect SEO, instant first paint and progressive interactivity
- Enhanced Navigation and Form HandlingHow to get a smooth SPA experience without reloading the entire page
- Multi-rendering-model architectureHow to design the codebase to support flexible deployment based on requirements
Risultato
Informed rendering model choice. The architecture supports the right model for every project scenario without future rewrites.
PHASE 2: Professional UI and Production (Weeks 5-8)
- 5
Component Library: the design system the team shares
Building reusable components is what separates a project with copy-paste everywhere from a scalable design system. Without a shared library, every project starts from scratch and every bug gets fixed in ten different places. Here we build the library the team reuses for years.
Programma
- Generic components with TypeParamHow to make the same DataGrid work with any data type without duplication
- Templatable RenderFragmentHow to let the consumer control the UI while the component controls the behaviour
- Shared Razor Class LibraryHow to create the shared component package for all team projects
- Wrappers for third-party librariesHow to integrate charts, calendars and editors with a consistent C# API in the Blazor ecosystem
- Storybook pattern for documentationHow to give each component a demo page with all states and variants
- Distribution via NuGetHow to version, publish and update the UI library like any .NET package
Risultato
Team UI library ready to use. Components are reusable, documented and distributed as a package that every project updates in seconds.
- 6
JavaScript Interop: the entire web ecosystem available from C#
Blazor does not live in isolation. The JavaScript ecosystem has thousands of libraries that do not need to be rewritten in C#. Integrating charts, maps and editors without understanding JS isolation leads to invisible crashes and memory leaks on navigation. Here you learn to use interop correctly without giving up anything.
Programma
- IJSRuntime for JS callsHow to reach any browser API from C# without abandoning .NET
- JS isolation with module importHow to avoid global variables by giving each JS module its own isolated scope
- Integrating chart and map librariesHow to connect JS libraries to the Blazor lifecycle without crashes on DOM updates
- Browser APIs from C#How to access clipboard, notifications and geolocation in a single line of code
- HttpClient in BlazorHow to consume REST APIs with correct patterns for authentication, error handling and cancellation
- Real-time with SignalRHow to add push notifications, live updates and chat integrated into the Blazor component
Risultato
Blazor integrated with the web ecosystem. The JS libraries you need work, and APIs are consumed with clean, maintainable patterns.
- 7
Frontend Performance: the app that responds instantly
A slow Blazor app is an app nobody wants to use. Frontend performance requires specific attention, different from the backend: virtualisation, bundle size and re-renders are not optimised with the same server-side techniques. Here you learn where to act and how to measure the impact.
Programma
- Virtualise for huge listsHow to render only visible elements eliminating lag even with datasets of thousands of records
- Lazy loading of WebAssembly assembliesHow to halve the initial download and load the app in seconds
- Prerendering and Static SSRHow to get an instant first load with content indexable by search engines
- ShouldRender for re-render controlHow to update the UI only when it makes sense, saving unnecessary CPU
- Trimming and AOT compilationHow to optimise the WebAssembly bundle size for faster startup with fewer MB downloaded
- Profiling with browser DevToolsHow to find the bottleneck in minutes instead of optimising blindly
Risultato
Fast and responsive frontend. The user perceives no latency and the application handles thousands of records without visible slowdown.
- 8
Testing with bUnit: tested UI, zero regressions
Testing Blazor components is possible and necessary. Without UI tests, every component refactoring risks breaking behaviours that seemed obvious. bUnit makes UI tests as simple as unit tests: no browser, no complex configuration.
Programma
- bUnit and markup assertionsHow to verify the HTML produced by the component with precise assertions without opening a browser
- Simulating user interactionsHow to test clicks, keyboard input and form submissions in the test runner
- Mocking injected servicesHow to test each component in isolation without real external dependencies
- JS interop in testsHow to simulate expected JavaScript behaviour without a real browser
- Snapshot testing for visual regressionsHow to get an immediate signal if the markup changes unexpectedly
- Automated accessibility in testsHow to verify heading structure, ARIA labels and keyboard navigation in the CI pipeline
Risultato
UI tested with confidence. Visual and functional regressions are found in tests, not reported by users in production.
Who this programme is for
CTO who wants to eliminate the dependency on JavaScript
Your team is strong on C# but frontend is a bottleneck. You want the same team to handle both frontend and backend with a single language and technology stack.
C# developer who wants to go full-stack
You want frontend skills without abandoning C#. Blazor gives you this, HTML, CSS and web interactivity with the power of .NET.
Team that wants to unify the stack
Maintaining a JavaScript frontend and a C# backend is costly and fragmented. You want a single language, a single framework and a team that can work on everything.
Who is Matteo Migliore
What professionals who have followed the programme say
Those who study with Matteo have the opportunity to access a very meaningful and concrete experience, entering the world of software development with a reliable and competent guide.
His training is a real opportunity for young people who want to pursue a career as a software architect.
I definitely recommend him, especially for the professionalism he has always shown and his ability to explain numerous topics that are normally not covered in these types of courses.
The WPF course I had the fortune to take with Matteo Migliore literally opened up an incredible world for me, allowing me to acquire all the techniques that will enable me to tackle increasingly important projects.
I definitely recommend Matteo for the technical content and the experience he brings; the training journey was also rich in anecdotes where he shared his experiences going all the way back to when he was a child.
I recommend Matteo's course especially to beginners and anyone who needs to learn how to structure an application, because this way you can start already with a correctly built architecture.
One difference I notice compared to other courses is a great passion for training, understood in a very broad sense. It is a mission for them, and beyond the specific WPF course topics, I always find tips and suggestions on cross-cutting subjects like design, software control and testing — which gives me something extra in my overall development approach.
Often there is little time and great difficulty managing on your own the issues you encounter daily, and if you tend to limit yourself to your own knowledge you end up stuck in your own mistakes.
Going back over things I had studied at university, explained step by step in a new language I had not studied before, was extremely useful.
I turned to our consultant, Matteo Migliore, to enter this new world.
Thanks to the course I learned a programming approach built in a much more sensible way than what I was doing before.
I recommend Matteo because he is a very competent person who loves his work and cares about helping others, making them more productive and more capable of mastering technology.
What I liked most was the new management of the project structure: separating the UI from the design layer, and in particular not writing code directly in the UI but structuring it properly.
Matteo doesn't simply read from a pre-prepared script but is able to go deeper into syntactic elements and design patterns, perfectly following the needs of whoever is learning.
Investment and programme
Programmes are tailored to the number of participants, duration and project complexity.
Fill in the form to receive the complete programme and a personalised quote based on your specific needs.
Individual Programme
1 participant, personalised mentoring
- 8 complete modules
- Biweekly live 1-to-1 sessions
- Platform access for 12 months
- Continuous chat support
Team Programme
2-3 participants, department transformation
- 8 complete modules
- Work on the company codebase
- Blazor frontend architecture
- Platform access for 12 months for all
Intensive Workshop
1-2 days on specific topics
- Focus on specific modules of your choice
- Up to 5 participants
- Complete training materials
- Follow-up session at 30 days
Ready to become a frontend developer with C#?
Fill in the form and receive all the information about the Frontend Developer programme. We analyse your scenario and the best path for you or your team.
Free analysis We assess the team's skills and frontend objectives
Talk to one of our tutors Not a salesperson, but a real expert who will guide you
Practical advice You receive useful guidance even if you decide not to continue