Take this

Software Development / Web Development

Mastering Meteor: Powerful Reactive Applications with Full-Stack JavaScript

Master one of the most exciting full-stack JavaScript platforms to build powerful, reactive applications


Meteor is a powerful platform that enables end-to-end, client and server-side web application development entirely in JavaScript. It enters as an alternative to popular full-stack options such as MEAN and offers developers the opportunity to vastly simplify development concerns while building applications on the run. Meteor's reactive approach to development makes good to create real-time applications with, and the platform provides an excellent option for deployment to mobile.

This course gets right under the hood of the Meteor platform, demonstrating how to take advantage of its powerful development engine to build exciting, versatile applications.

We start by carefully designing an application structure, building a single page layout with multipage routing, and adding authentication. We’ll expose database data, and then look at how to work with subscriptions and queries. Then, we dive into the options for templating, with a look at dynamic Blaze templates and the Spacebars templating language. You’ll learn event handling and then test our application using Cucumber and Jasmine. After that, we deploy our application locally on the Meteor server, and then to Amazon to set it up for frequent updates and hot code deployment. Finally, you’ll learn how to work with third-party integrations, and set up REST endpoints to interact with other external services such as PayPal.

This course will help you to work at your own pace while mastering the patterns used to define all of the critical pieces of a web application.

Full details


  • Introduction and Structure
    The Course Overview
    This video will offer an overview of the course.
    What Is Meteor?
    Understanding what makes Meteor different and explaining web sockets and reactivity. • Explain differences with web sockets • Explain reactivity • Explain JavaScript everywhere
    A folder setup can be almost anything. We show a proven structure. • Explain the rules • Explain the load order • Build our sample application's starting structure
  • Routing and Layout
    Single Page Applications
    Understanding single page applications • Explain single page applications • Explain why we use single page applications • Explain the benefits of routing
    Routing URLs
    We set up routing so that our sample application can use URLs • Add custom packages for routing • Define placeholders within our page • Define routes for our sample application
    Callback Methods
    Sometimes, it is necessary to deviate from the route • We set up actions within our routes • Add triggers and API calls • Manage subscriptions inside a route
  • Roles and Authorization
    Without authorizing, our application is insecure. So, secure the application. • Add packages for authentication and authorization • Build an accounts management • Configure routes for registration, sign-in, and resetting passwords
    User Profile and Avatars
    More information than just an e-mail is required from the user. Add profile information. • Modify the registration to include additional fields • Add an avatar field to store an image of each user • Display the avatar in the header and in the profile form
    Add Roles and Authorization
    Specific areas of the application should be accessible to administrators only. • Set up the administration role • Add users to the admin role • Lock areas in the application with roles
  • Collections and Publications
    Defining a Collection
    Without collections, you can't make any data persist. So add collections. • Add all collections used in the sample application • Define allow/deny rules for collections • Show client database calls
    Forcing Server-side Operations
    Database functions performed from the client are not secure. Add methods to the server. • Show the user how the client is not secure • Add methods to the server • Call a method from the client
    Hooks, Helpers, and Relationships
    Applying additional information to every query is necessary. Add a hook before an insert. • Add the creation date to every insert • Show a related collection • Use the related collection in a view
  • Subscriptions and Queries
    Template-based Subscriptions
    Templates are not modular, but they still need a route to get the data context • Add a route-based subscription • We style our product list within a category • Check for subscription availability within the template
    Route-based Subscriptions
    Listing products shows all products • Filter the product list by category • Add the route parameter to the subscription parameters • List products by category
    Complex Query Syntax
    We have a more complex filter • Filter and sort a collection based on a rating • Update conditionally • Use Robomongo to administer your mini-mongo database
  • Templates and Spacebars
    Templates Expressions
    Adding dynamic variables in a template requires a handlebars type language. • Cover the available template expressions for variable replacement • Cover the template expressions for conditions • Cover the template expressions for looping through an array
    Reusable Components
    Some elements can repeat throughout the application. • Use the templating system to create reusable components • Define the dynamic parts of a reusable template • See how to place and configure a reusable component
    Helper Functions
    Replacing template data dynamically requires helpers. • See the template helpers • Define global helpers • Pass arguments and format data
    Using Variables for Application State
    Managing application state can help to make the application more responsive. • Add reactive variables for managing state • Add session variables for managing state • Demonstrate changing the state by changing the variables
  • Helpers and Events
    Data Context and Helpers
    Templates use dynamic placeholders • Add helper methods to fill in dynamic data • Add placeholders within templates
    Best Practices
    Define where to place any template callbacks • Utilize the template JavaScript file for template helpers, events, and callbacks • Initialize external jQuery plugins in the onRendered callback • Clean up bindings in the onDestroyed callback
    Template Events
    Where should we intercept events within the application? • Attaching methods to element events within the JavaScript file • Using classes or IDs to make an element accessible
  • Server Methods
    Invoking Methods from the Client
    Database interaction is not secure when done from the client • Add server methods and invoke them from the client • Remove insecure packages, which should be used only for development
    Securing Data on the Server
    Methods should incorporate some permissions logic • Add logic for each collection
    Before invoking a server method, you should validate the data coming in • Add logic to the server method to check the input
    CRUD Functions
    Create, read, update, and delete are all common functions applied to a collection • Show how to accomplish each of these methods
  • Testing Your Application
    Types of Testing
    There are several testing frameworks to choose from • Add Cucumber for end-to-end testing • Add Jasmine for unit testing and integration testing
    Writing Useful Tests
    Testing your application is only useful with useful tests • We show a test where we validate a key component of the application • Verify that the test is working by purposely breaking the application • Fix the component and verify that the test shows it as successful
  • Deploying Your Application
    Deploying Locally
    Building a Meteor application is most quickly facilitated by developing locally first • Deploy your application on your development server • View the console commands that provide options for local deployment
    Deploying to the Meteor Server
    Testing on the Internet would normally require you to purchase hosting and a domain • Meteor provides a testing environment that runs on the Meteor server • Deploy your application on yourapplication.meteor.com
    Deploying to the Amazon EC2 Instance
    Deploy to an enterprise-level hosting provider • Obtain an Amazon account and create an EC2 instance • Deploy your Meteor application using Meteor Up
    Update Your Deployed Application
    Making changes and hot code push • Change the application • Redeploy while the application is running
  • Troubleshooting Meteor
    Client Debugging
    Finding problems can seem difficult • Use the console to output messages • Use the shell to observe Meteor commands • Place debugger statements to step through the code
    Server Debugging
    Where can you look when there are problems with the server code? • Use the console log within server functions • Add debugger statements to allow the code to break at a specific section
  • Integrating Other Frameworks
    Adding PayPal Integration
    Our store needs to facilitate a checkout • Configure the Paypal package • Place the card form within the checkout dialog
    Connecting to a REST Endpoint
    Connecting to data outside of Meteor • Add the http package • Configure a call to an external JSON REST API • Consume the JSON and use it within your templates
    More in Meteor
    Discussing frequently occurring issues and external resources. • Common mistakes • Cutting-edge technologies • Resources for exploring further


  • MongoDB
  • Meteor.js
  • React.JS
  • PayPal
  • Web Development

Similar Courses

More Courses by this Instructor