"I'm really not sure if I'm building this right"

Confidently deliver fast, reliable, modern Blazor web apps, one component at a time.

Web development should be fun.

Write code, hit F5, view it in the browser and bask in the glory of a job well done.

But you're not basking… Why aren't you basking!

The problem is, web development has this nasty habit of getting complicated…

You aren't sure how to break your app down into smaller components so you end up with one page which does 'everything'.

You don't fancy building everything yourself so you decide to use a third party library and end up losing days to learning, testing and choosing the 'right' one.

You decide to make your code as generic and re-usable as possible but now you're drowning in a sea of conditional logic.

Blazor to the rescue?

Blazor brings something new to .NET web development, a powerful component model.

This component model frees you up to break complex requirements down into smaller tasks, to build entire applications, one component at a time.

But there's a catch…

Now you have to decide if, and when to break your UI down into smaller components.

You have to figure out how to pass state between components.

It's on you to decide whether to lean on third party components or build your own.

It's a lot to wrap your head around

But what if you knew you could make immediate, fast progress whenever a feature request reached your inbox?

What if, instead of losing hours to 'research', you could find a way in to every new feature and deliver it with minimal fuss?

What if you could turn features around quickly and get them into the hands of real, grateful, users who would actually benefit from your efforts?

You absolutely can speed up your development process without comprising on quality, you just need a practical approach that meets reality where it is!

Introducing Practical Blazor Components

It's all well and good people like me telling you to "keep it simple" or "start with the basics" but what does that actually mean?

Who's going to tell you how to take the 'simplest' approach when you're working on your own projects?

That's the kind thing you learn with practice but what if (like most of us) you don't have endless weeks to spend figuring this stuff out?

Practical Blazor Components will get you up to speed quickly.

Learn, practice, and internalise a repeatable, simple process for building just about any feature using Blazor's powerful component model.

Discover how to take small steps, maximise the power of fast feedback loops and use the power of the 'last responsbile moment' to really supercharge with your projects.

Your pathway to building better Blazor web applications, faster

These are the skills and capabilities you will have by the time you're done with Practical Blazor Components

  • Iterative UI Development - Quick Start 
    • Build a small feature "UI first"
    • Use hardcoded data to speed up the initial design process
    • Build the UI "in situ"
    • Establish fast feedback loops to keep you on the right track
  • arrow pointing downwards
    Just Enough CSS 
    • Use flexbox to control how elements are arranged on the screen
    • Use flexbox to implement basic layout 'templates'
    • Build UI "mobile first" to support devices with smaller screens
    • Use conditional logic to tweak the style of a component
  • arrow pointing downwards
    Build Reusable Components 
    • Refactor markup and CSS into smaller components (easier to maintain)
    • Create re-usable components for commonly used parts of the UI
    • Extend your UI by adding new components (rather than modifying existing ones)
    • Use RenderFragments to render child content
    • Use Template Parameters to build re-usable components
    • Understand when it makes sense to introduce re-usable components
    • Use callbacks to communicate between components
  • arrow pointing downwards
    Capture User Input 
    • Capture user data via forms
    • Push data "down" to the database
    • Employ validation (to prevent invalid data entering the application)
  • arrow pointing downwards
    Beyond CRUD: Model User Interactions 
    • Build UI and business logic around the tasks your users need to perform
    • Implement business logic in a way that's easy to adapt and extend
    • Prioritise modelling the business logic over removing/avoiding duplication
  • arrow pointing downwards
    Manage State Between Components 
    • Pass data between components using cascading state
    • Implement state management (using C# classes)
  • arrow pointing downwards
    Expect (and Handle) The Unexpected 
    • Guard against invalid route parameters
    • Handle errors more gracefully using error boundaries
  • arrow pointing downwards
    Build More Resilient UI 
    • Employ automated unit tests to make ongoing change easier
    • Make your API calls more resilient (automatic retries to handle transient errors)
    • Understand when to use unit tests and when to use E2E testing
    • Implement E2E tests for the critical paths in your application
    • Employ Optimistic UI to provide a better user experience

Coming Soon

Ready to speed up your development process and build better Blazor web applications, faster?

Practical Blazor Components is coming soon. Pop your email in the box below and I'll let you know as soon as it's ready.

I respect your email privacy. Unsubscribe with one click.