Web Development with Node and Express.

Node.js development is extremely fun and satisfying. There are over 35k modules to choose from, and overall node is very easy to develop a working application that can scale easily.
  •   Certificate : by TechSim+

Key Features

Master the Concept of your Training Module

20+ Real-Time Industry-Based Projects

Instructor-led training

Hands on Practical Classes

One Year Training Menbership with TechSim+

What You Will Learn
In this Journey

  • Stage 1

    1. Getting Started with Node

    Getting Node

    Using the Terminal

    Editors

    npm

    A Simple Web Server with Node

    Onward to Express

  • Stage 2

    2. Saving Time with Express

    Scaffolding

    The Meadowlark Travel Website

    Views and Layouts

    Static Files and Views

    Dynamic Content in Views

  • Stage 3

    3. Tidying Up

    Best Practices

    Version Control

    npm Packages

    Project Metadata

    Node Modules

  • Stage 4

    4. Quality Assurance

    QA: Is It Worth It?

    Logic Versus Presentation

    The Types of Tests

    Overview of QA Techniques

    Running Your Server

    Page Testing

    Cross-Page Testing

    Logic Testing

    Linting

    Link Checking

    Automating with Grunt

    Continuous Integration (CI)

  • Stage 5

    5. The Request and Response Objects

    The Parts of a URL

    HTTP Request Methods

    Request Headers

    Response Headers

    Internet Media Types

    Request Body

    Parameters

    The Request Object

    The Response Object

    Getting More Information

    Rendering Content

    Processing Forms

    Providing an API

  • Stage 6

    6. Templating with Handlebars

    There Are No Absolute Rules Except This One

    Choosing a Template Engine

    Jade: A Different Approach

    Comments

    Blocks

    Server-Side Templates

    Views and Layouts

    Using Layouts (or Not) in Express

    Partials

    Sections

    Perfecting Your Templates

    Client-Side Handlebars

    Conclusion

  • Stage 7

    8. Form Handling

    Sending Client Data to the Server

    HTML Forms

    Encoding

    Different Approaches to Form Handling

    Form Handling with Express

    Handling AJAX Forms

    File Uploads

    jQuery File Upload

  • Stage 8

    8. Cookies and Sessions

    Externalizing Credentials

    Cookies in Express

    Examining Cookies

    Memory Stores

    Using Sessions

    Using Sessions to Implement Flash Messages

    What to Use Sessions For

  • Stage 9

    9. Middleware

    Common Middleware

    Third-Party Middleware

  • Stage 10

    10. Sending Email

    SMTP, MSAs, and MTAs

    Receiving Email

    Email Headers

    Email Formats

    HTML Email

    Sending Mail

    Sending Mail to Multiple Recipients

    Better Options for Bulk Email

    Images in HTML Email

    Using Views to Send HTML Email

    Encapsulating Email Functionality

    Email as a Site Monitoring Tool

  • Stage 11

    11. Production Concerns

    Execution Environments

    Environment-Specific Configuration

    Scaling Out with App Clusters

    Handling Uncaught Exceptions

    Scaling Out with Multiple Servers

    Third-Party Uptime Monitors

    Application Failures

    Stress Testing

  • Stage 12

    12 Persistence

    Filesystem Persistence

    Cloud Persistence

    A Note on Performance

    Setting Up MongoDB

    Mongoose

    Database Connections with Mongoose

    Creating Schemas and Models

    Seeding Initial Data

    Retrieving Data

    Adding Data

    Using MongoDB for Session Storage

  • Stage 13

    13. Routing

    Routes and SEO

    Subdomains

    Route Handlers Are Middleware

    Route Paths and Regular Expressions

    Route Parameters

    Organizing Routes

    Declaring Routes in a Module

    Grouping Handlers Logically

    Automatically Rendering Views

    Other Approaches to Route Organization

  • Stage 14

    14. REST APIs and JSON

    JSON and XML

    Our API

    API Error Reporting

    Cross-Origin Resource Sharing (CORS)

    Our Data Store

    Our Tests

    Using Express to Provide an API

    Using a REST Plugin

    Using a Subdomain

  • Stage 15

    15. Static Content

    Performance Considerations

    Static Mapping

    Static Resources in Views

    Static Resources in CSS

    Static Resources in Server-Side JavaScript

    Static Resources in Client-Side JavaScript

    Serving Static Resources

    Changing Your Static Content

    Skipping Bundling and Minification in Development Mode

    A Note on Third-Party Libraries

  • Stage 16

    16. Implementing MVC in Express

    Models

    View Models

    Controllers

    Conclusion

  • Stage 17

    17. Security.

    Generating Your Own Certificate

    Using a Free Certificate Authority

    Purchasing a Certificate

    Enabling HTTPS for Your Express App

    A Note on Ports

    HTTPS and Proxies

    Cross-Site Request Forgery

    Authentication Versus Authorization

    The Problem with Passwords

    Third-Party Authentication

    Storing Users in Your Database

    Authentication Versus Registration and the User Experience

    Passport

    Role-Based Authorization

    Adding Additional Authentication Providers

    Conclusion

  • Stage 18

    18. Integrating with Third-Party APIs

    Social Media Plugins and Site Performance

    Searching for Tweets

    Rendering Tweets

    Geocoding with Google

    Geocoding Your Data

    Displaying a Map

    Improving Client-Side Performance

    Weather Data

    Conclusion

  • Stage 19

    19. Debugging

    The First principal of Debuging

    Take Advantage of REPL and the console

    Using Node's Built-in Debuging

    Node Inspector

    Debugging Asynchronous Functions

    Debugging Express

  • Stage 20

    20. Going Live

    Domain Name System

    Security

    Top-Level Domains

    Subdomains

    Nameservers

    Hosting

    Deployment

    Conclusion

  • Stage 21

    21. Maintenance

    The Principles of Maintenance

    Have a Longevity Plan

    Use Source Control

    Use an Issue Tracker

    Exercise Good Hygiene

    Don’t Procrastinate

    Do Routine QA Checks

    Monitor Analytics

    Optimize Performance

    Prioritize Lead Tracking

    Prevent “Invisible” Failures

    Code Reuse and Refactoring

    Private npm Registry

    Middleware

    Conclusion