​"​I'm stuck trying to build even the simplest of features using ASP.NET Core Web API and React.js"

​Everyone ​keeps banging on about ​javascript these days.

You can't move for people telling you ​how ​productive React.js is and how you really should be embracing it for everything ​above and beyond "simple" web applications.

But from where you're standing, with all the ceremony required just to get a simple ASP.NET Core Web API + ​React.js application up and running, you're not feeling very productive right about now.

It's ​impossible to ​imagine how you'll ever be able to stay on ​any bosses' good side when even the simplest of features takes days to implement.

​Everyone else appears to be off building amazing apps using React and ASP.NET Core, so why ​do you just feel like you're drowning in new concepts and endless terminology?

​Can it really be true, that to get even the simplest feature up and running ​you need to learn webpack, react, state management, node/npm, Typescript?

And that's just the frontend.

​Sprinkle in some ​API concerns like ​dependency injection, ORMs, REST and it's hard to see how anyone ever gets anything  built in any kind of reasonable time frame.

But what if you could ​sideline all this complexity and focus on building your features.

​Imagine being able to calmly and confidently use React + Web API to quickly (and reliably) build any feature that comes your way.

​You could be that developer, you know, the one who embraces new feature requests ​instead of trying to dive out of sight every time the product owner walks towards you!

​Figuring ​out how to build solid React + Web API applications on your own is an uphill struggle, ​but you don't have to tackle this by yourself.​

Practical React ​+ ASP.NET Core Web API ​is coming and will fast-track your React + Web API journey.

  • Learn the fundamental building blocks of ASP.NET Core Web API and React.js
  • Discover the simplest way to ​deconstruct features and build them, one React.js component at a time
  • Discover ​a time (and sanity) saving approach for quickly building up an ASP.NET Core Web API so you can glide, effortlessly from one feature to the next​

All you need is a few hours

By the end of the course you'll be able to...

  • Take any feature all the way from idea to fully working implementation using ASP.NET Core and React.js
  • Reliably break features down into smaller components in order to build them as quickly and simply as possible
  • Create a fully-functional ASP.NET Core Web API backend
  • Build an API that is easily extended and adapted as requirements change
  • Integrate your API with third party systems (e.g. Stripe)
  • Secure your Web API
  • Configure authentication for any React.js application (and talk to an ASP.NET Core backend)

​Here's what we'll cover

  • ​Prototype ​the first feature (the product listing page)
    • A brief introduction to React.js and ASP.NET Core
    • ​Spin up ​a ASP.NET Core Web API + React.js project
    • Show a static list of products (using hard coded data)
    • Refactor the product "card" into a ​separate React component
  • ​Rinse and repeat (product details)
    • ​Show product details (using hard coded data)
    • ​​Routing (add a route ​for product details)
    • Link ​each product ​to its details page
  • "Hook it up to the backend" (hard coded data)
    • Create an API endpoint for ​getting the product list
    • Create an API endpoint for ​retrieving ​product details
    • Connect our product list and details components to the backend
  • ​Hello Entity Framework Core
    • ​Add EF Core to the project
    • ​Refactor existing API calls to pull data from SQL using EF Core
  • Search
    • Search for products by title
  • ​​​I'll have one of those, and one of those...
    • ​​​Add items to your ​cart(and persist via API)​
    • View your ​cart
    • ​Remove items from your ​cart(and persist via API)​
  • Anonymous checkout
    • ​Show order summary (items, total cost)
    • Prompt for details (delivery address, billing address)
    • ​Integrate with Stripe for taking payment
  • ​Authentication (using Auth0)
    • Set up Auth0 integration (backend)
    • ​Implement user registration ​
    • ​Add Authentication ​to React.js frontend
    • Implement User sign in
  • Authenticated user checkout
    • Retrieve existing user's details
    • ​Update existing user's details during checkout

And more (details to be finalised).

​Want to ​​​know when the course becomes available?

Pop your details in the boxes below to get progress updates and an exclusive launch discount​.

© Jon Hilton All rights Reserved

Privacy Policy