Node js Courses on Udemy

NodeJS – The Complete Guide (MVC, REST APIs, GraphQL, Deno)

Node.js is probably THE most popular and modern server-side programming language you can learn these days!

Node.js developers are in high demand and the language is used for everything from traditional web apps with server-side rendered views over REST APIs all the way up to GraphQL APIs and real-time web services. Not to mention its applications in build workflows for projects of all sizes.

This course will teach you all of that! From scratch with zero prior knowledge assumed. Though if you do bring some knowledge, you’ll of course be able to quickly jump into the course modules that are most interesting to you.

• Node.js Basics & Basic Core Modules
• Parsing Requests & Sending Responses
• Rendering HTML Dynamically (on the Server)
• Using Express.js
• Working with Files and generating PDFs on the Server (on-the-fly)
• File Up- and Download
• Using the Model-View-Controller (MVC) Pattern
• Using Node.js with SQL (MySQL) and Sequelize
• Using Node.js with NoSQL (MongoDB) and Mongoose
• Working with Sessions & Cookies
• User Authentication and Authorization
• Sending E-Mails
• Validating User Input
• Data Pagination
• Handling Payments with Stripe.js
• Building REST APIs
• Authentication in REST APIs
• File Upload in REST APIs
• Building GraphQL APIs
• Authentication in GraphQL APIs
• File Upload in GraphQL APIs
• Building a Realtime Node.js App with Websockets
• Automated Testing (Unit Tests)
• Deploying a Node.js Application
• Using TypeScript with Node.js
• Exploring Deno.js

If you got basic Node.js experience, this course is also a perfect match because you can go through the basic modules quickly and you’ll benefit from all the deep dives and advanced topics the course covers.

• Work with one of the most in-demand web development programming languages
• Learn the basics as well as advanced concepts of NodeJS in great detail
• Build modern, fast and scalable server-side web applications with NodeJS, databases like SQL or MongoDB and more
• Understand the NodeJS ecosystem and build server-side rendered apps, REST APIs and GraphQL APIs
• Get a thorough introduction to DenoJS

Course Duration: 40.5hrs | Course Rating: 4.6

Total Articles: 65 | Downloadable resources: 500

Node.js, Express, MongoDB & More: The Complete Bootcamp

This course is the perfect all-in-one package that will take you from a complete beginner to an advanced, highly-skilled Node.js developer.

this one is completely project-based! And not just any project: it’s a complete, beautiful, and feature-rich application, containing both a RESTful API and a server-side rendered website. It’s the most fantastic and complete project that you will find in any Node.js course on the internet!

By building this huge project, you will learn all the skills that you need in order to plan, build, and deploy your own modern back-end applications with Node.js and related technologies.

• Fundamentals of Node.js, core modules, and NPM (Node Package Manager)
• How Node.js works behind the scenes: event loop, blocking vs non-blocking code, event-driven architecture, streams, modules, etc.
• Fundamentals of Express (Node.js framework): routing, middleware, sending responses, etc.
• RESTful API design and development with advanced features: filtering, sorting, aliasing, pagination
• Server-side website rendering (HTML) with Pug templates
• CRUD operations with MongoDB database locally and on the Atlas platform (in the cloud)
• Advanced MongoDB: geospatial queries, aggregation pipeline, and operators
• Fundamentals of Mongoose (MongoDB JS driver): Data models, CRUD operations, data validation, and middleware
• Advanced Mongoose features: modeling geospatial data, populates, virtual populates, indexes, etc.
• Using the MVC (Model-View-Controller) architecture
• How to work with data in NoSQL databases
• Advanced data modelling: relationships between data, embedding, referencing, and more
• Complete modern authentication with JWT: user sign up, log in, password reset, secure cookies, etc.
• Authorization (user roles)
• Security: best practices, encryption, sanitization, rate limiting, etc.
• Accepting credit card payments with Stripe: Complete integration on the back-end and front-end
• Uploading files and image processing
• Sending emails with Mailtrap and Sendgrid
• Advanced error handling workflows
• Deploying Node.js application to production with Heroku
• Git and GitHub crash course

If you want to learn Node.js and modern back-end development, then there is no doubt that this course is for you!

• Master the entire modern back-end stack: Node, Express, MongoDB and Mongoose (MongoDB JS driver)
• Build a complete, beautiful & real-world application from start to finish (API and server-side rendered website)
• Build a fast, scalable, feature-rich RESTful API (includes filters, sorts, pagination, and much more)
• Learn how Node really works behind the scenes: event loop, blocking vs non-blocking code, streams, modules, etc.
• CRUD operations with MongoDB and Mongoose
• Deep dive into mongoose (including all advanced features)
• How to work with data in NoSQL databases (including geospatial data)
• Advanced authentication and authorization (including password reset)
• Security: encryption, sanitization, rate limiting, etc.
• Server-side website rendering with Pug templates
• Credit card payments with Stripe
• Sending emails & uploading files
• Deploy the final application to production (including a Git crash-course)
• Downloadable videos, code and design assets for projects

Course Rating: 4.6 | Course Duration: 42hrs | Total Articles: 3

The Complete Node.js Developer Course (3rd Edition)

The Complete Node.js Developer Course covers the fundamentals of Node before diving deep into great tools like Express, Mongoose, and MongoDB.

The entire course is based around a single goal: Turning you into a professional Node developer capable of developing, testing, and deploying real-world production applications.

The best way to learn Node is by building Node apps.

From the very start you’ll be programming every project and working through challenges that I’ve designed to reinforce what you’ve learned. This will give you the hands-on experience necessary to be able to create and launch your own project once you’re done.

You’ll be building four projects:

• A note-taking app to get your feet wet
• A weather application that interacts with the MapBox and Dark Sky APIs
• A task manager REST API complete with user accounts and authentication
• 4. real-time chat app with a client-side companion

By the end, you’ll be able to take what you’ve learned and launch your own Node application.

• Completely refilmed for 3rd edition
• Build, test, and launch Node apps
• Create Express web servers and APIs
• Store data with Mongoose and MongoDB
• Use cutting-edge ES6/ES7 JavaScript
• Deploy your Node apps to production
• Create real-time web apps with SocketIO

Course Rating: 4.5 | Course Duration: 35 hrs | Total Downloadable Resources: 143

Learn and Understand NodeJS

In this course you will gain a deep understanding of Node, learn how NodeJS works under the hood, and how that knowledge helps you avoid common pitfalls and drastically improve your ability to debug problems.

In this course we’ll look at how the C++ written V8 Javascript engine works and how NodeJS uses it to expand the abilities of Javascript. You’ll learn how to structure your code for reuse and to be easier to understand, manage, and expand using modules and understand how modules really work.

You’ll learn how asynchronous code works in Node and the Node event loop, as well as how to use the event emitter, streams, buffers, pipes, and work with files. We’ll see how that leads to building a web server in Node.

We’ll dive into web sites, web apps and APIs with Express and learn how Express can save us time as Node developers.

You’ll also gain an understanding of npm, connecting to databases, and the MEAN stack!

During it all you’ll gain a deep understanding of the Javascript concepts and other computer science concepts that power Node.

I believe the best way to learn is to understand how a tool works and what it does for you, look at examples, and then try it yourself. That’s how this course is built, with the goal to help you both learn and understand NodeJS.

• Grasp how NodeJS works under the hood
• Understand the Javascript and technical concepts behind NodeJS
• Structure a Node application in modules
• Understand and use the Event Emitter
• Understand Buffers, Streams, and Pipes
• Build a Web Server in Node and understand how it really works
• Use npm and manage node packages
• Build a web application and API more easily using Express
• Connect to a SQL or Mongo database in Node
• Understand how the MEAN stack works
• Be the coder that explains NodeJS to everyone else because you understand it better than anyone else

Course Rating: 4.6 | Course Duration: 13 hrs | Total Articles:4 | Downloadable Resources: 53

Node JS: Advanced Concepts

Node Internals: Here’s one of the most common interview questions you’ll face when looking for a Node job: “Can you explain Node’s Event Loop?” There are two types of engineers: those who can describe the Event Loop and those who cannot!  This course will ensure that you are incredibly well prepared to answer that most important question.  Besides being critical for interviews, knowledge of the Event Loop will give you a better understanding of how Node works internally.  Many engineers know not to ‘block’ the Event Loop, but they don’t necessarily understand why.  You will be one of the engineers who can clearly articulate the performance profile of Node and its Event Loop.

Caching with Redis: We’ll also supercharge the performance of database queries by implementing caching backed by Redis.  No previous experience of Redis is required!  Redis is an in-memory data store purpose built for solving caching needs.  By adding caching to your application, you can decrease the amount of time that any given request takes, improving the overall response time of your app.

File Upload: There are many resources online that offer suggestions on how to handle file upload, but few show a solution that can truly scale.  Hint: saving files directly on your server isn’t a scalable solution!  Learn how to leverage AWS S3 to implement file upload that can scale to millions of users with a few dozen lines of simple code.  Plentiful discussions are included on security concerns with handling uploads, as well.

Continuous Integration Testing: This is a must have feature for any serious production app.  We’ll first learn how to test huge swaths of our codebase with just a few lines of code by using Puppeteer and Jest.  After writing many effective tests, we’ll enable continuous integration on Travis CI, a popular – and free – CI platform.  Testing can sometimes be boring, so we’ll use this section to brush up on some advanced Javascript techniques, including one of the only legitimate uses of ES2015 Proxies that you’ll ever see!

• Master the Node Event Loop – understand how Node executes your source code. 
• Understand the purpose of Node, and how the code you write is eventually executed by  C++ code in the V8 engine
• Add a huge boost to performance in your Node app through clustering and worker threads
• Turbocharge MongoDB queries by adding query caching backed by a lightning-fast Redis instance
• Scale your app to infinity with image and file upload backed by Amazon’s S3 file service
• Implement a continuous integration testing pipeline so you always know your project functions properly
• Think you know everything there is about managing  cookies and session?  Well, you might, but learn even more!
• Ensure your app works the way you expect with automated browser testing using Jest and Puppeteer
• Bonus – learn advanced JS techniques along the way, including where to use ES2015 proxies!

Course Rating: 4.7 | Course Duration: 16hrs | Articles: 15 | Total Resources: 5

Microservices with Node JS and React

This course tackles every major issues around microservices head on. From challenges with data replication to confusing unordered event streams, every major challenge of building microservices is covered. 

Beyond focusing on the basics of microservices, this course is a perfect introduction to the world of full-stack development.  You will work all the way from the frontend, assembling a React app using Hooks, to the backend, including database design and deployment strategies.  Every step along the way is covered in tremendous detail, with ample diagrams to ensure every step is crystal clear.

Many other resources show only the easiest, simplest apps written with microservices.  This course does the opposite: we focus on the most challenging aspects of microservices, challenges that you will likely encounter every single day.  You will see these difficulties first hand, then solve them with easy-to-understand strategies.

This course doesn’t focus on using an off-the-shelf microservices framework. Many exist, but they hide the inner workings and challenges of microservices away from you. Instead, we will be using a minimal number of libraries, and write as much custom code as possible. This will expose you to challenging problems and clever solutions when handling subjects like async events!

• Practice patterns to create scalable microservices for a variety of app domains
• Build a Server-Side-Rendered React app using Hooks and Next JS
• Write a custom implementation of an event bus
• Optionally, run a development environment through a cloud provider
• Guarantee consistently structured responses from your different API’s
• See best practices in communication between different services
• Configure and scale your services using Kubernetes Deployments
• Document and enforce structure constraints on events shared across microservices
• Limit access to your APIs using JWT-based authentication

A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering microservices!

• Architect large, scalable apps using a collection of microservices
• Deploy a multi-service app to the cloud with Docker and Kubernetes
• Solve concurrency issues in a distributed systems environment
• Leverage your Javascript skills to build a complex web app
• Build a Server-Side Rendered React App to render data from your microservices
• Understand how enterprise companies design their infrastructure
• Share reusable code between multiple Express servers using custom NPM packages
• Write comprehensive tests to ensure each service works as designed
• Communicate data between services using a lightning-fast event bus
• Write nothing but production-level code. No cutting corners!

Course Rating: 4.7 | Course Duration: 54 hrs | Articles: 69 | Downloadable Resources: 349