Максим

webpack-dev-server - средство для удобной разработки ваших одностраничных приложений от webpack (то есть, из "коробки")

webpack-dev-middleware - собственно, middleware, который добавляет возможности вашему другому серверу (в случае тэга вопросов - написанному на node.js и фреймворке express). Что добавляет? Ну хотя бы, возможность hot-reload'a..

Что и где использовать разницы нет. Как вам удобнее так и делайте. Либо просто webpack-dev-server, либо какой-то ваш "усложенный" сервер написанный на node.js + middleware webpack-dev-server. Под middlewar'ом можно понимать некий "усилитель", как уже было написано, например: усиливай мой "сервер" на "hot-reload"

1) либо не создан index.html на одном уровне с конфигом webpack
2) либо нет роута по '/'

p.s. + покажите console браузера, может там еще какая ошибка по делу будет.

Ищите поиском по статье, которую вы привели в примере:
Здесь будут жить все ваши макеты и файлы представления Jade.

То есть, ваши шаблоны нужно класть в директорию views. В статье используется jade, поэтому посмотрите как работает этот шаблонизатор. Шаблон главной страницы, доступной по урлу mysite.com
demo-app/views/index.jade

Далее, как запустить, снова ищем поиском в статье:
Это код, который позволяет вам запускать npm start для приложения.

=> для запуска, нужно выполнить в терминале:
node ./bin/www

или можно
npm start

Это стадартный роутинг. Вы переходите по урлу, например mysite.com/abe или mysite.com/abcde , что сервер будет вам отдавать? Правильно, то что вы указали внутри "сопоставимого" роута, в случае этого примера, это ваш последний кейс:

app.get('/ab(cd)?e', function(req, res) {
res.send('ab(cd)?e'); // здесь может быть что-нибудь, например: покажи страницу с такой-то картинкой
});

По первому пункту, ссылка от Антона в помощь.

По второму вопросу: вы на node.js будете делать бэкэнд. Который будет являться API сервером, не более. Здесь придется поизучать что такое REST API. Следовательно, если вы будете писать фронтенд на react/redux, то кладете его в другую директорию, там уже свой package.json и т.д., так как ваш фронтенд и бэкэнд - это две разные вещи.

Пригодится jwt. (гугл)

В общих словах: вам нужно выдать юзеру токен. С этим токеном юзер будет выполнять запросы к вашим защищенным методам api (вы можете оставить какие-то методы "без токена").

Node.js часть
Пример роута на логин (сделано не лучшим образом, в плане коллбэков, но что нашлось под рукой...):

auth.js

...
const v4 = require('node-uuid').v4
const jwt = require('jsonwebtoken')
...
router.post('/signin', (req, res, next) => {

  // валидация, например... 

  if (errors) {
    return res.status(400).json({ errors })
  } else {
    // поиск юзера в базе, сравнение хэша и прочие необходимые операции
    ...
   // допустим все ок, нужно ответить токеном
  // генерируем необходимые опции и сам токен

        const payload = {
          _id: user._id,
          iss: 'http://localhost:3000',
          permissions: 'poll',
        }
        const options = {
          expiresIn: '7d',
          jwtid: v4(),
        }
        const secret = new Buffer(process.env.AUTH0_CLIENT_SECRET, 'base64')
        jwt.sign(payload, secret, options, (err, token) => {
          // отвечаем токеном, для будущих запросов с клиента
          return res.json({ data: token })
        })
     ...
})

module.exports = router;

Пример защищенного роута (метода, который требует токен):

...
const jwt = require('jsonwebtoken')
const Poll = require('../models/poll')
...

const requireToken = (req,res,next) => {
  const token = req.headers['x-api-key']
  const secret = new Buffer(process.env.AUTH0_CLIENT_SECRET, 'base64')

  jwt.verify(token, secret, (err, decoded) => {
    if (err) {
      return res.status(401).json({ error: err.message })
    }
    req.params.userId = decoded._id
    next()
  })
}
...

// обратите внимание на requireToken - функция вызывается при каждом обращении к роуту
// то есть при каждом PUT запросе по адресу (например: PUT api/v1/products/1238914)
// будет вызываться requireToken

router.put('/:id', requireToken, (req, res, next) => {
  const { productId } = req.body
  const userId = req.params.userId

  Poll.findById(req.params.id)
    .populate({ path: 'products' })
    .exec((err, poll) => {
        // ... необходимые действия в базе, в процессе успешного зачтения голоса...
    }
})

Клиентское приложение:

Типичный ActionCreator (в качестве библиотеки для запросов можно взять bluebird, isomorphic-fetch, да хоть нативный xhr)
actions/LoginActions.js

export function login(data) {
  return dispatch => {
    dispatch({ type: LOGIN_REQUEST })

    // request в данном случае - https://github.com/KyleAMathews/superagent-bluebird-promise
    return request.post(`${API_ROOT_V1}/auth/signin`)
      .send(data)
      .then(res => {
        if (!res.ok) {
          dispatch({ type: LOGIN_FAILURE })
        } else {
          dispatch({
            type: LOGIN_SUCCESS,
            data: res.body.data,
          })
          //сохранение токена в localStorage
          localStorage.setItem('cks_token', res.body.data)
        }
      }, err => {
        dispatch({ type: LOGIN_FAILURE })
      })
  }
}

Пример голосования с токеном (выше, в node.js части был метод апи, а это PUT запрос с клиента)

export function vote(productId, voteId) {
  return dispatch => {
    dispatch({ type: POLL_VOTE_REQUEST })

    return request.put(`${API_ROOT_V1}/api/v1/vote/${voteId}`)
      .set('X-API-Key', localStorage.getItem('cks_token')) // установка ТОКЕНА в заголовок 'X-API-Key'
      .send({ productId })
      .then(res => {
        if (!res.ok) {
          dispatch({ type: POLL_VOTE_FAILURE })
        } else {
          dispatch({
            type: POLL_VOTE_SUCCESS,
            data: normalize(res.body.data, schema.poll),
          })
        }
      }, err => {
        dispatch({ type: POLL_VOTE_FAILURE })
      })
  }
}

Надеюсь код формы с кнопкой "голосовать" не трубется.
====

Все это можно организовать удобнее, например, выставлять токен всем запросам автоматически (речь про клиентскую часть):

import fetch from 'isomorphic-fetch'
...
const defaultHeaders = {
  Accept: 'application/json',
  'Content-Type': 'application/json',
}

function buildHeaders() {
  const authToken = localStorage.getItem('TOKEN')
  return { ...defaultHeaders, Authorization: authToken }
}
...
export function httpPost(url, data) {
  const body = JSON.stringify(data)

  return fetch(url, {
    method: 'post',
    headers: buildHeaders(),
    body: body,
  })
  .then(... код оработки запроса ...)
}

===

Проверить наличие токена, можно с в роутере, с помощью хука на onEnter.

root.js

...
<Provider store={store}>
      <Router history={routerHistory}>
        {configRoutes(store)} // Роуты создаются функцией, чтобы можно было использовать внутри нее store.getState()
      </Router>
    </Provider>
...

routes.js

export default function configRoutes(store) {
  function _ensureAuthenticated(nextState, replace, callback) {
    const { dispatch } = store
    const { session } = store.getState()
    const { currentUser } = session
    let nextUrl

    if (!currentUser && localStorage.getItem('cks.token')) {
      dispatch(getCurrentAccount())
    } else if (!localStorage.getItem('cks.token')) {
      replace('/signin')
    }
    callback()
  }

  return (
    <Route path='/' component={App}>
      <Route path='/signin' component={SigninContainer} />
      <Route path='/signup' component={SignupContainer} />

      <Route path='/locked' component={AuthenticatedContainer} onEnter={_ensureAuthenticated}>
        <Route component={LockedArea}>
          <Route path='/locked/a' component={A} />
          <Route path='/locked/b/:id' component={B} />
          <Route path='/locked/c' component={C} />
        </Route>
      </Route>
    </Route>
  )

Остается только создать AuthenticatedContainer в котором проверять: есть ли currentUser (в рамках этого примера) и если нет - возвращать false. А если есть - this.props.children (в которых будут дальнейшие роуты..)
===

Итого:
1) у вас есть API написанное на node.js.
2) У этого API есть защищенные методы, которые проверяют наличия токена в http-запросе. Токен выдается при запросе на логин. Само собой, операция логина (то есть POST запрос на your-api/login) не требует токена.
3) После удачного логина, вы получаете в ответе на свой запрос токен (это уже внутри клиентского кода, и если мы говорим о redux - то внутри асинхронного вызова в actions)
4) Сохраняете токен (например, в localStorage)
5) Во все необходимые http-запросы устанавливаете заголовок с токеном

Можно запускать команду через screen
То есть, команда screen как будто бы открывает виртуальную вкладку, в ней запускаете meteor, затем выходите из скрина (обычно это ctrl + A,D ) и у вас "сессия" в той виртуальной вкладке остается висеть. Чтобы снова к ней присоединиться, нужно написать screen -R. Ну или просто почитайте подробнее про screen.

А какие требования были? Если: видео, русский язык - то лучше курса я не знаю.
Если же требования: видео/статьи, язык: русский/английский, то думаю да, после изучения первой части курса, лучше поискать боевой пример поновее. Но! Много не потеряете, если посмотрите вторую часть и поделаете на старой версии.

А как вы вообще планируете использовать express ? MEAN стэк подразумевает, что ваш бэкэнд - это только REST API, если не ошибаюсь. Следовательно - у вас все запросы на youhost.com/api/, например, идут в express и там он разруливает роуты, а все остальные запросы идут в клиентское приложение и там разруливает ангуляр.

Логин класть в токен не нужно. В токене не должно быть "личной информации", а вот ObjectId уже можно. Это не подходит "под личную", так как по 5821d94dbb021a1360582da3 нельзя узнать что-то о пользователе, если у вас не своровали базу (могу ошибаться).

Приведу на всякий случай полный код роута с выдачей токена, если вам не особо пригодится, так может кто поругает, так как в бэкэнде не силен. Код не на промисах, а на коллбэках (как в древние времена). Это плохо. С помощью промисов будет "более плоский" и удобный в поддержке код.

const express = require('express')
const router = express.Router()
const User = require('../models/user')
const v4 = require('node-uuid').v4
const jwt = require('jsonwebtoken')

router.post('/signup', (req, res, next) => {

  req.check('email', 'Please enter a valid email').len(1).isEmail()
  req.check('password', 'Please enter a password with a length between 4 and 34 digits').len(4, 34)

  const errors = req.validationErrors()

  if (errors) {
    return res.status(400).json({ errors })
  } else {
    User.hashPassword(req.body.password, (err, passwordHash) => {
      if (err) {
        return res.status(400).json({ error: err.message })
      }

      const user = new User({
        name: req.body.name,
        nickname: req.body.nickname,
        email: req.body.email,
        password: req.body.password,
      })

      user.passwordHash = passwordHash
      user.save((err, item) => {
        if (err) {
          return res.status(400).json({ error: err.message })
        }
        const payload = {
          _id: item._id,
          iss: 'http://localhost:3000',
          permissions: 'poll',
        }
        const options = {
          expiresIn: '7d',
          jwtid: v4(),
        }
        const secret = new Buffer(process.env.AUTH0_CLIENT_SECRET, 'base64')
        jwt.sign(payload, secret, options, (err, token) => {
          return res.json({ data: token })
        })
      })
    })
  }
})

router.post('/signin', (req, res, next) => {

  req.check('email', 'Please enter a valid email').len(1).isEmail()
  req.check('password', 'Please enter a password with a length between 4 and 34 digits').len(4, 34)

  const errors = req.validationErrors()
  const password = req.body.password

  if (errors) {
    return res.status(400).json({ errors })
  } else {
    User.findOne({ email: req.body.email }, (err, user) => {
      if (err) {
        return res.status(400).json({ error: err.message })
      }
      if (!user) {
        return res.status(400).json({ error: 'User not found' })
      }
      User.comparePasswordAndHash(password, user.passwordHash, (err, areEqual) => {
        if (err) {
          return res.status(400).json({ error: err.message })
        }
        if (!areEqual) {
          return res.status(400).json({ error: 'Wrong password' })
        }
        const payload = {
          _id: user._id,
          iss: 'http://localhost:3000',
          permissions: 'poll',
        }
        const options = {
          expiresIn: '7d',
          jwtid: v4(),
        }
        const secret = new Buffer(process.env.AUTH0_CLIENT_SECRET, 'base64')
        jwt.sign(payload, secret, options, (err, token) => {
          return res.json({ data: token })
        })
      })
    })
  }
})

module.exports = router;

В дальнейшем, кусочек payload:

const payload = {
          _id: item._id,
          iss: 'http://localhost:3000',
          permissions: 'poll',
        }

можно "декодировать" прямо на клиенте, что очень удобно.

Потому что у вас не определена переменная Schema
добавьте в начало файла: var Schema = mongoose.Schema

p.s. ну и на всякий случай, давайте разберемся.

ReferenceError: Schema is not defined

в переводе - Schema - не определено. И действительно, если вы посмотрите в свой код, то у вас нигде нет записи в стиле var Schema = ..., следовательно вы не можете использовать эту переменную, так как ее просто не существует. Она никак не requir'ится в ваш файл, вы никак ее не определяете...