Published: July 18 2020

Angular 10 - Fake Backend Example for Backendless Development

Built with Angular 10.0.4 and Angular HTTP Interceptor

Other versions available:

The following is an example of how to implement a fake or mock backend in Angular 10 with an HTTP Interceptor.

A fake backend is used for doing backendless development in Angular which allows you to run and test your code without a real backend api, it's perfect for code hosted in StackBlitz which doesn't have a backend, or when you're developing a front end before the backend is available.

I created the below fake backend as part of an Angular 10 User Registration and Login Example & Tutorial, it's built by extending the Angular HttpInterceptor interface and includes mock endpoints for authentication, registration and user management, and uses browser local storage to store data to mimic a real api with a database.

Passing through unmocked requests to a real backend API

Sometimes there's a need to pass through specific requests to the server instead of being caught by the fake backend, for example when the real backend is partially completed and has some endpoints available.

With Angular 10 HTTP interceptors this is done by calling return next.handle(request);, you can see the code for passing through unmocked requests in the default case of the switch statement below.

Angular 10 Fake Backend Provider

import { Injectable } from '@angular/core';
import { HttpRequest, HttpResponse, HttpHandler, HttpEvent, HttpInterceptor, HTTP_INTERCEPTORS } from '@angular/common/http';
import { Observable, of, throwError } from 'rxjs';
import { delay, mergeMap, materialize, dematerialize } from 'rxjs/operators';

// array in local storage for registered users
let users = JSON.parse(localStorage.getItem('users')) || [];

export class FakeBackendInterceptor implements HttpInterceptor {
    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
        const { url, method, headers, body } = request;

        // wrap in delayed observable to simulate server api call
        return of(null)
            .pipe(materialize()) // call materialize and dematerialize to ensure delay even if an error is thrown (

        function handleRoute() {
            switch (true) {
                case url.endsWith('/users/authenticate') && method === 'POST':
                    return authenticate();
                case url.endsWith('/users/register') && method === 'POST':
                    return register();
                case url.endsWith('/users') && method === 'GET':
                    return getUsers();
                case url.match(/\/users\/\d+$/) && method === 'GET':
                    return getUserById();
                case url.match(/\/users\/\d+$/) && method === 'PUT':
                    return updateUser();
                case url.match(/\/users\/\d+$/) && method === 'DELETE':
                    return deleteUser();
                    // pass through any requests not handled above
                    return next.handle(request);

        // route functions

        function authenticate() {
            const { username, password } = body;
            const user = users.find(x => x.username === username && x.password === password);
            if (!user) return error('Username or password is incorrect');
            return ok({
                username: user.username,
                firstName: user.firstName,
                lastName: user.lastName,
                token: 'fake-jwt-token'

        function register() {
            const user = body

            if (users.find(x => x.username === user.username)) {
                return error('Username "' + user.username + '" is already taken')

   = users.length ? Math.max( => + 1 : 1;
            localStorage.setItem('users', JSON.stringify(users));
            return ok();

        function getUsers() {
            if (!isLoggedIn()) return unauthorized();
            return ok(users);

        function getUserById() {
            if (!isLoggedIn()) return unauthorized();

            const user = users.find(x => === idFromUrl());
            return ok(user);

        function updateUser() {
            if (!isLoggedIn()) return unauthorized();

            let params = body;
            let user = users.find(x => === idFromUrl());

            // only update password if entered
            if (!params.password) {
                delete params.password;

            // update and save user
            Object.assign(user, params);
            localStorage.setItem('users', JSON.stringify(users));

            return ok();

        function deleteUser() {
            if (!isLoggedIn()) return unauthorized();

            users = users.filter(x => !== idFromUrl());
            localStorage.setItem('users', JSON.stringify(users));
            return ok();

        // helper functions

        function ok(body?) {
            return of(new HttpResponse({ status: 200, body }))

        function error(message) {
            return throwError({ error: { message } });

        function unauthorized() {
            return throwError({ status: 401, error: { message: 'Unauthorised' } });

        function isLoggedIn() {
            return headers.get('Authorization') === 'Bearer fake-jwt-token';

        function idFromUrl() {
            const urlParts = url.split('/');
            return parseInt(urlParts[urlParts.length - 1]);

export const fakeBackendProvider = {
    // use fake backend in place of Http service for backend-less development
    useClass: FakeBackendInterceptor,
    multi: true

Hooking up the Fake Backend to your Angular 10 App

To add the fake backend provider to your Angular 10 app you need to import the fakeBackendProvider in your app module as shown below, and add the fakeBackendProvider to the list of providers in your app module.

Below is the complete app module from the example project that contains the fake backend, the full tutorial is available here.

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { ReactiveFormsModule } from '@angular/forms';
import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';

// used to create fake backend
import { fakeBackendProvider } from './_helpers';

import { AppRoutingModule } from './app-routing.module';
import { JwtInterceptor, ErrorInterceptor } from './_helpers';
import { AppComponent } from './app.component';
import { AlertComponent } from './_components';
import { HomeComponent } from './home';

    imports: [
    declarations: [
    providers: [
        { provide: HTTP_INTERCEPTORS, useClass: JwtInterceptor, multi: true },
        { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true },

        // provider used to create fake backend
    bootstrap: [AppComponent]
export class AppModule { };


Need Some Angular 10 Help?

Search fiverr for freelance Angular 10 developers.

Follow me for updates

On Twitter or RSS.

When I'm not coding...

Me and Tina are on a motorcycle adventure around Australia.
Come along for the ride!


Supported by