Learn MEAN Stack
4.4 (64 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
514 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learn MEAN Stack to your Wishlist.

Add to Wishlist

Learn MEAN Stack

MEAN - MongoDB, Express.js, AngluarJS and Node.js
4.4 (64 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
514 students enrolled
Last updated 7/2017
Current price: $10 Original price: $150 Discount: 93% off
5 hours left at this price!
30-Day Money-Back Guarantee
  • 10 hours on-demand video
  • 2 Articles
  • 2 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Code a MEAN Project with an Online IDE
  • Understand what the MEAN stack is and when to use it
  • Develop MEAN REST API's with Node and Express
  • Program and configure MongoDB in a MEAN project
  • Develop rich, functional UI's with Angular2 in a MEAN project
  • Work efficiently with amazing MEAN dev tools
  • Scaffold a MEAN UI client project with Angular-CLI
  • ... and much, much more!
View Curriculum
  • Before taking this course, a student should ideally (but not absolutely) have some experience in:
  • Creating web UI’s with normal Javascript tools (i.e. jQuery, Bootstrap, ASP.NET, AngularJS, etc.) Programming with a common object-oriented or scripting language (i.e. Java, C#, Python, PHP, etc.) Server-side JavaScript development or some familiarity with Node.

Being a one-trick programming pony doesn’t cut it anymore in today’s tech job market. The more strings you have on your bow, the more in-demand you’ll be. When it comes to web app development, having the know-how to create something fully-functioning from start to finish boosts your employability credentials in a big way.  Thankfully, the MEAN Stack is the tool set that allows you to do just that. Want to get involved? Read on...

Learn a Suite of In-Demand Programming Skills

·         Understand MEAN Stack and how to use it effectively

·         Code MEAN projects with an online IDE

·         Develop MEAN REST APIs with Node and Express

·         Create top-notch UIs with Angular 2

·         Gain the skills needed to become a sought after web developer

Build Full-Stack Solutions for Mobile and the Web

This MEAN Stack online course is designed for any web developer or IT professional who wants to understand and use MEAN Stack for their projects. If you have some experience with an object-oriented/scripting language and JavaScript tools, great. But if you don’t, no worries – we guide you through every part of the process.

You’ll gain a solid foundation of knowledge in using the MEAN Stack (that’s MongoDB, Express, Angular and Node JS) for web and mobile development, with hours of instruction and code-alongs to help you through. You’ll study each component individually, learning how to assemble them to provide a highly efficient JavaScript-based development stack.

That means setting up an online IDE, developing MEAN REST APIs with Node and Express, programming and configuring with MongoDB, developing rich and functional UIs with Angular, scaffolding a MEAN UI client project, and much more.

Plus, we make sure your skills are future-proofed by using Angular 2, the much-discussed rewrite of Angular JS that’s guaranteed to set the market on fire in the coming months. By the time you’ve finished this course, you’ll be more than ready to start working on your own MEAN Stack projects.

What is MEAN Stack?

MEAN Stack is a collection JavaScript-based technologies used for web app development. Namely: MongoDB, ExpressJS, Angular 2 and NodeJS. It is a ‘full stack’ development toolkit, from client and server sides to databases. Basically MEAN Stack allows you to create functional, fun and flawless web applications from beginning to end, with one ‘stack’ of tools.

Who is the target audience?
  • This course was built for web developers who design and build full-stack solutions for mobile and the web.
  • This course is designed for those developers who want to design with the MEAN Stack (with Angular2) as easily as they may with other JavaScript development stacks.
  • Of course, the info presented in this course is just as valuable for architects, testers, and product managers as they too should understand the architecture of the MEAN stack and how development works with MEAN when creating mobile and web solutions.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
186 Lectures
Welcome to MEAN
3 Lectures 08:46

Download reference document here

Preview 02:06

In this course we will be introduced to MEAN stack — a full-stack JavaScript solution that helps us build fast, robust, and maintainable web applications. Let's look at each of the technologies in the stack.

What We Will Learn

Let’s overview the sections of the course so we know what to expect.

Course Specifics
What Does MEAN mean?
5 Lectures 12:19

Not unlike the way LAMP (Linux, Apache, MySQL, and PHP/Python/Perl) came about, MEAN bubbled up in developer camps as a logical, convenient way to build out a Javascript-based web application. 

Preview 03:30

We are looking at MEAN from the side, studying the 4 distinct layers of the stack. Once we have an understanding of each layer, we’ll then discover how the layers dovetail to produce efficiencies for us.

Our Take On MEAN

We need an understanding of how the MEAN layers all play nicely together.  From a high-level, let’s see how this all works.

Preview 04:05

Section Summary
Node.js & Express
45 Lectures 02:37:21
Section Introduction

A review of this sub-course's format and an explanation of how it's organized, then a walk thru of the course Learning Objectives

Preview 03:57

Let’s understand the hands-on course project and see a demo of the final product.

Course Project intro

We can get a Cloud9 account set up if necessary and get our initial project set up in the cloud.


We now understand what to expect in the sections of this course and what we can expect to learn. Plus, we’ve got our online development environment all set up and ready to go!

Section Summary

What are Node & Express and how do we start using them? Let’s begin with the basics.

Discover Node.js

What are Node & Express and how do we start using them? Let’s begin with the basics.

What are Node.js & Express?

Let’s see what we can do with Node from the command line.

Try Node from Command Line

At the command line, we’ll set up a Node.js project, write a simple app in the project, and run it.

Set up a Node.js app

Let’s make our Cloud 9 project point to a GITHub repo so we can preserve and version our work..

Use GIT with C9.io

We have a better understanding now of what Node.js is and what it does and what Express is and how it works with Node.js to create Web Applications. We set up a project using the Node console and got our Cloud9 project pointed to a GIT repository for safe keeping.

Section Summary

In this section we will begin working directly with Express, We’ll get the Express packages downloaded & installed, get our app startup standardized, and define some basic routing.

Work With Express

Let’s use NPM to get the Express packages we need to begin coding our Express-based Web App.

Get Express set up

We can configure our project with a standard start script so standards ready and able to deploy our app to any Node service provider.

Create an NPM Start script

We’ll define some routes with Express and make requests with different URL’s respond properly.

Preview 03:21

In this section we began working directly with Express, We got the Express packages downloaded & installed, got our app starting up appropriately, and defined some basic routing.

Section Summary

Using a Bootstrap.js template to base our app’s HTML page upon is a quick, easy way to get our app’s UI up and running, yet still allows us to modify the UI to meet our needs.

Kickstart a Node Web App

Let’s pull in a Bootstrap.js template and easily get our HTML output looking sharp!

Use a Bootstrap Template

Let’s setup a static directory for serving our resource files with Express.

Configuring Resources

We can use Bower to manage our UI components just like NPM does for our Node packages.

Manage UI Components with Bower

We downloaded a cool Bootstrap.js template & got it working in our project so it produces great HTML pages for us.  Then we got Bower set up to manage all of the Bootstrap dependencies that we now have.

Section Summary

Gulp is a task manager that can take care of all kinds of tedious, mundane tasks for us and make development so much easier. We’ll get Gulp working for us in our project.

Work with Gulp

Let’s use JSHint so Gulp can automatically check our JavaScript code quality and completeness.

Use JSHint in Gulp

Wire up Wiredep and get or CSS and Javascript files injected into our HTML files automatically!

Inject dependencies with Wiredep

We can have all of our custom JavaScript and CSS files injected for us automatically and make our lives so much easier!

Injection with Gulp-Inject

Nodemon can monitor for changes to our Javascript files. If a file changes Nodemon process them, then restart our server with the changes loaded up. Let’s have this feature!

Watch Changes with Nodemon

We’re now familiar with some of the great things Gulp can do for us as we build out our Node.js project.

Preview 00:50

Templating Engine: allows Express to build out HTML pages &/or components for us.

Work with Node Templating Engines

A quick review of 3 different Node.js Template Engines.

Review of Templating Engine Options

Let’s get EJS Templating Engine set up and working in our project.

Begin with EJS

We’ll add some EJS code to our project’s HTML page.

Put EJS to Work

We’ve now familiarized ourselves with templating engines in Node & Express and have chosen EJS as the template engine for our course project.

Section Summary

Routing is a key part of any web app. Let’s get some more sophisticated routing going in our project.

Preview 00:33

Let’s get a Router into our code and create some new Routes.

Use a Router

We’ll create some new pages and wire them to our new Routes

New Pages

Our app.js file is getting a bit cluttered. Let’s move all of our routing code into it’s own .js file.

Separate code into different files

Let’s wire up our new routes to our new templates and finish the EJS in our templates so our pages display what we want.

Wire our new pages back to Express & Node

We’ve written routers for our app and moved them into separate, supporting .js files. Our routers and routes are now structured more effectively and our app quality has improved.

Section Summary

Let’s get MongoDB behind the project we’ve built. We can get MongoDB running, load our data into it, then query that data for display in our web page

Use a Database with Node.js

We can get MongoDB running and install the MongoDB package into our project.

Get MongoDB setup and installed

Let’s use our routes knowledge to create a temporary route for inserting our hard-coded events data into MongoDB.

Get Events data ready to be inserted into MongoDB

Using our new temporary route, we can write insert code to get our data into MongoDB.

Write code to insert our data into MongoDB

We can query the database directly from our Node.js JavaScript code and display the query results in our web page.

Query MongoDB and display results in our page

We integrated MongoDB with our Node.js app, loaded our data into a new collection, queried Mongo for that data, and displayed the results in our app’s pages.

Section Summary

Congratulations, we’ve reached the end of our NOde & Express study! Let’s review the learning objectives we’ve met.

Sub-Course Wrap-Up
Mongo DB
47 Lectures 02:25:58
Welcome to MongoDb

I’ll explain how this course is organized,including a quick review of the course’s sections & our learning objectives.

Preview 07:03

We’ll view a quick demo of the completed course project so we know what we’ll be building over the course. A list of the features we’ll build to complete our project will also be reviewed.

Our Hands-On Project

Let’s create a Cloud9 account and set up a MongoDB project by pulling a version from Github. Then, we can install all of the tools we’ll need to build our project.

Setup Our Tools

We now know what we’ll be learning & how we’ll learn it all. Plus we’re all set up to begin coding our project.

Section Summary

Let’s begin building our our project with some of the Mongo tools. Our first step is to create a new database and import some data.Learning Objective:Setup & configure a MongoDB instance

Set Up our Project

Let’s create a new database and import some data.

Import Data with MongoImport

We can use the Mongo Shell tool to check out our database, its collections, and data.

Use the Mongo Shell

The Shell Tool is a Javascript editor as well and can execute Javascript on the fly. Let’s use some Javascript in the Shell.

Javascript in the Mongo Shell

We hit the ground running in this section! We’ve already set up a fully functioning project with data and have begun working with the Mongo Shell Tool.

Section Summary

Let’s start working with standard database queries and operations, including CRUD.

Start with Queries and Operations

We can manipulate queries for retrieving data from our database. Let’s begin working with the ‘find’ command on our ‘Users’ data.

Retrieve data with .find()

Let’s use the .insert() and .save() commands to Create data in a collection in two distinct ways.

Create data with .save() & .insert()

We can Update existing data in a collection using the .update() command. We can also use $set:{} to add a field to an existing document.

Update data with .update()

Deleting data is very simple, as long as we know which document we want removed.

Deleting data with .remove()

Now that our User Data is ready for display, let’s update our app so it will pass User Data from the database thru to the rendered web page.

Display User Data in our App

We learned about the generality of CRUD operations & how simple they are to use. We then used these operations to shape up our User data and ready it for use in our app.

Section Summary

Let’s learn to Model data for use in our document-oriented MongoDB database.

Model New Entities

What are the things we need to be thinking about when we Model our data for use in MongoDB?

Rules for Modeling

We can work with models that are Simple or go for more Complex structures. Let’s consider speed and data types as we make modeling choices.

Simple & Complex Models

Let’s use our new knowledge to model the ‘Event’ document for our project.

Modeling ‘Event’ Data

Registry has some interesting characteristics. Let’s make good decisions when creating a model for our project and consider all scenarios.

Let’s use our new knowledge to model the ‘Event’ document for our project.

We have learned MongoDB specific data modeling concepts and applied them in creating models for our project’s database.

Section Summary

Let’s look at how Indexing works in MongoDB and what kind of indices are available.

MongoDb & Indexes

Indexes are an important part of a properly functioning MOngoDB database. Let’s find out what they do, how they do it, and how we can create them to optimize our database.

Indexing MongoDb

We can use Mongo commands to see which indices exist and how they’re used in a query.

Using Indexes

Let’s go through the steps of Creating Indexes and optimize our project with faster queries.

Creating Indexes

We learned how indices work in MongoDB, why we need them, and how to optimize our existing database by adding indices where they are needed.

Section Summary

We can build some amazing queries with the Aggregation Framework. Let’s find out how it works.

MongoDb Aggregation Framework

We’ll discuss data aggregation from 10K ft and learn about pipeline processing & result sets.

Aggregation Concepts

Let’s walk thru Aggregation Pipeline Stages & see the significance of each. Then, let’s review the Pipeline Operators and see what each one does.

Pipeline Stages & Operators

We can apply Aggregation Queries and Filters to create our project’s aggregated data. Let’s see how.

Aggregation in our Project

Now that we have Aggregated Data, we need to use it in our project. We will plug it right into our templates.

Use our Aggregated Data

We learned how to create Aggregation Queries with the MongoDB Aggregation Framework. We then used Aggregation in our project to create new data from existing records and plugged that data into our HTML templates.

Section Summary

Replication and Sharding provide the availability and durability that makes MongoDB so great. We’ll look at these concepts from a Developer’s perspective.

Replication & Sharding

Let’s find out what Replica sets are & how they work.

What are Replica Sets?

How do Replica Sets stay available? We’ll investigate.

Automated Failover

Let’s find out what Sharding is and how it is configured.

What is Sharding?

What considerations are there when we are Sharding our data?

Rules for Sharding data

We reviewed the steps involved in Replication and Sharding of MongoDB databases and how instances work together when distributed. We can assume that availability and durability standards are provided with these techniques when we design apps for MongoDB.

Section Summary

Our app has come together nicely. Let’s examine the project as a whole and see how all of the pieces fit together.

Our Web App

Let’s review the current state of our project and how it got that way.

Our Project’s State

App.js is the heart of our app. Let’s look into how it drives our application.

Our app.js file

We’ll look into how the aggregation functions work in our application.

Our Aggregate Queries

We can now see how the ‘pieces’ of our app fit together and how JSON data is passed from MongoDB thru to the web pages.

Section Summary

Congratulations! We’ve reached the end of the course. Let’s review the great things we’ve learned.

Sub Course Wrap up

A walk thru of completed checklists.

Learning Objectives & Project Requirements Review
Angular 2
69 Lectures 03:45:25

This course teaches you how to design and build components, how to use templates to create your application’s user interface, how to extend HTML with directives and data binding, and how routing is done.

Course Introduction

What is Angular? Why should we use Angular? Why is there an Angular2?

Say Hello to Angular2

Let’s understand what we’ll do over the life of this course and how we’ll do it.

How this course works

We can get a Cloud9 account set up if necessary and get our initial project set up in the cloud.

The Course Project

We now understand what to expect in the sections of this course and what we can expect to learn.

Section Summary

Before we go head’s down with Angular2, we need to prepare ourselves with some significant background info and a functioning development environment.

Pack Our Lunch

TypeScript is the language of choice for Angular2. Let’s learn why.

Preview 03:56

We need to get our Cloud9 online IDE set up and ready for development.

Getting the Cloud9 Online IDE

We’ll code every concept that we learn in our course project. Let’s set it up and get it ready for our first lesson.

Setting Up the Cloud9 IDE

Modules are a foundational part of Angular2. Let’s be sure to understand what they are and how we’ll use them.

Setting Up The Course Project

Using Angular 2 Modules

We are now primed and ready to dive into Angular2.

Section Summary

In this section we will take a close look at what Angular2 components are and learn the steps involved in creating one.

Angular Components

Let’s learn what components are and what they’re made of.

Component Defined

Components consist of 3 parts. Let’s learn what they are and what each part does.

The Component Parts

Let’s learn the interactions of the 3 component parts and how to stitch them together to create a complete component.

Tying a Component Together

The App Component is the heart of an Angular2 application. Let’s learn to create it.

The App Component

With enough ammunition to get an app up and running, let’s learn how to do it.

Bootstrapping an Angular2 App

We learned enough to get an app up and running. With a very app is simple and very high-level Angular2 knowledg, we’re ready to dive deep into the Angular2 depths.

Section Summary

We will learn to define the visible aspects of components as HTML within a template.

Building Angular2 UI

Our view is defined in HTML which can then be inserted into our component’s template.

The Component Template

We can create a template in a separate file.

Create A Template

There are 3 steps in using a component as a directive.

The Directive Component

Binding data from our component’s class to it’s template is easy with interpolation.


Angular2 has tons of built-in directives that we need.

Angular2 Built-In Directives

We learned to work with templates within components, to bind data in those components, and how to use components as directives.

Section Summary

We’ll learn to use Angular2’s property binding to set HTML element properties in the DOM.

Binding in Angular2

When data changes in our class, we need to reflect the change in our HTML. Let’s learn how this works..

Property Binding

Certain user interactions with our web page need to update properties in our class. We can use Event Binding to have this happen automatically.

Event Binding

We can use both Property binding and Event binding at the same time to synchronize class properties and page elements.

2-Way Binding

Let’s learn to use Pipes to transform bound properties before they are displayed.

Formatting Bound Data with Pipes

In this section we learned to use Property binding & Event binding and how to combine them for 2-Way binding. We also learned how Pipes help us control the display of our data.

Section Summary

We will learn several ways to improve upon our components.

Advanced Component Concepts

Let’s see how to make the most of Angular2’s TypeScript benefits thru use of Interfaces.

Interface & Components

There is a better way to do styling in Angular2 than simply referencing a CSS file. Let’s learn how!

Styling Components

Let’s learn to listen to an Angular2 application and react to it’s many events.

Component Lifecycle Events

We can transform and apply logic to data before we display it in the browser. Let’s see how it works.

Pipe Transform Interface

In this section we learned to leverage TypeScript strong typing with interfaces, saw how to encapsulate styling within a component, and how to tap into component lifecycle events to trigger operations.

Section Summary

We will discus how to build components designed to be nested within other components and have these components talk to one another.

Component Composition

Let’s see how components can work “inside” other components.

Parent/Child Components

We can use a Nested Component as a Directive. Let’s discuss how this is done.

More Parent/Child Components

Let’s learn how a Nested Component can take input from its Parent Component.

Property Binding with @Input

A Nested Component can send data to its Parent Component. Let’s examine this functionality.

Event Binding with @Output

In this section we learned how Components can nest within one another and still maintain normal data binding.

Section Summary

We can use Services when we have data or logic that is not associated with a specific view or that we want to share across components.

Preview 01:39

Let’s learn how Dependency Injection can make Services most effective.

Angular2 Dependency Injection

Services are created quite similarly to Components and Pipes. Let’s see how simple it really is.

Creating Serivices

Let’s learn to get Services into play by registering them as Providers.

Using Services

We can leverage Dependency Injection to expose services where they’re needed.

Service Injection

In this section we learned to create Services, register them as Providers, and how to expose them most efficiently with Dependency Injection.

Section Summary

We will learn how to use HTTP with observables to retrieve data from the interwebs.

Web Services

We can use Reactive Extensions (RxJS) to implement Angular2’s Observables instead of simply using Promises.

Observables vs. Promises

Let’s learn to get Reactive Extensions (RxJS) into play along with Angular2’s HTTP library.

Using Reactive Extensions

We’ll learn to send HTTP requests in Angular2.

HTTP Requests

Let’s see how to use Observables to work with data requested via HTTP.

Implementing Observables

In this section we learned about using Reactive Extensions (RxJS) and it’s Observables instead of relying on Promises. We learned how Angular2’s HTTP library gets us HTTP requests and how to use Observables to handle data in an HTTP response.

Section Summary

We will learn to define routes for navigate between multiple views in an Angular2 application.

Section Introduction

In Angular2 routing is component based. Let’s learn to configure routing targets and to define routes for components.

Routing Configuration

We will discuss the technique of tying routes to user actions for effective navigation within an application

Routes and Actions

Let’s learn to use the RouterOutlet directive to specify where we want a router component to display its view.

Routes and Views

Oftentimes routes need to be passed a parameter. Let’s discover how this works in Angular2

Routes and Parameters

Let’s find out how to do routing with code vs. user interactions. We can implement Angular2’s RouterService to make this happen.

Routes and Code

In this section we walked through how to configure routes, tie routes to actions, and define where the routed component’s view should appear. We also uncovered some additional routing techniques, including passing parameters to a route and activating a route with code.

Section Summary

Let's look under the hood of Angular2’s main configuration files and see what they are, what information they contain, and how to use them.

Setting Up Angular2 From Scratch

Let’s see how tsconfig.json gets our TypeScript compiler working for us.

Configuring the Compiler

We will take a look at what NPM’s package.json file does for us (a whole lot) and how it’s organized.

Project Dependencies

Let’s pick apart the imports in our index.html file and see what all of those imports are doing for us.

Core Libraries

We’ll pat ourselves on the back for completing this course.

Section Introduction

Let's recap the concepts presented in this course

Review of Concepts
The Real Challenge
6 Lectures 30:24
Section Introduction

What's going on with 

Angular & Express

What's going on with Express & Angular2?

Preview 08:10

Let's configure Express to perform for us with a new REST API.

Make Express MEAN & RESTful

Our project needs to be able to consume a REST API.

RESTful Local Events in Angular2

Express & Angular2 are now dovetailed.  Let's review how we did it.

Section Summary
MEAN Approaches
5 Lectures 23:31
Section Introduction

MEAN.io & MEAN.JS are full-stack solutions that helps you build fast, robust, and maintainable production web applications

Preview 03:59

What are our options when considering other frameworks?

Exchangeable Frameworks

Yeoman is one of the greatest tools for scaffolding MEAN projects.

Scaffolding with Yeoman

We've seen the differenct ways MEAN can be approached and taken.  We also are now aware of some of the great tools and optional solutions available for use. 

Section Summary
Course Conclusion
4 Lectures 05:35
Section Introduction

Where do we go from here now that all of the technologies are familiar?

Preview 00:58

Considerations, limitations, advantages, etc.

More comments on MEAN

Thank you for viewing this course

Thank You
Bonus Material
2 Lectures 01:18
Bonus Lecture: Certificate of Completion

Bonus Lecture: Course Discounts
About the Instructor
Stone River eLearning
4.2 Average rating
16,531 Reviews
274,005 Students
201 Courses
270,000+ Happy Udemy Students

At Stone River eLearning, technology is all we teach. If you're interested in programming, development or design - we have it covered. 

Check out our huge catalog of courses and join the over 450,000 students currently taking Stone River eLearning courses. We currently offer 100+ different technology training courses on our Stone River eLearning website and are adding new courses on hot and trending topics every month. A subscription option is available for those with a real passion for learning.