diff --git a/.gitignore b/.gitignore
index 90c96b27eb..091da139a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -154,6 +154,7 @@ kedro.db
 kedro/html
 docs/tmp-build-artifacts
 docs/build
+docs/temp
 docs/node_modules
 docs/source/04_user_guide/source/.ipynb
 tests/template/fake_project/
diff --git a/docs/build-docs.sh b/docs/build-docs.sh
index 3dacc3bd2c..b506018fab 100755
--- a/docs/build-docs.sh
+++ b/docs/build-docs.sh
@@ -24,4 +24,15 @@ fi
 
 # Clean up build artefacts
 rm -rf docs/build/html/_sources
-rm -rf docs/build/[0-9][0-9]_*
+
+# Copy built HTML to temp directory, clean up build dir and replace with built docs only
+rm -rf docs/temp
+mkdir docs/temp/
+mkdir docs/temp/html
+cp -rf docs/build/html/* docs/temp/html
+
+rm -rf docs/build
+mkdir docs/build
+mkdir docs/build/html
+cp -rf docs/temp/html/* docs/build/html
+rm -rf docs/temp
diff --git a/docs/source/faq/faq.md b/docs/source/faq/faq.md
index 50d18593a3..1ba16ad911 100644
--- a/docs/source/faq/faq.md
+++ b/docs/source/faq/faq.md
@@ -9,51 +9,6 @@ Kedro is an open-source Python framework for creating reproducible, maintainable
 
 For the source code, take a look at the [Kedro repository on Github](https://github.com/kedro-org/kedro).
 
-## Who maintains Kedro?
-
-Kedro was originally designed by [Aris Valtazanos](https://github.com/arisvqb) and [Nikolaos Tsaousis](https://github.com/tsanikgr) at QuantumBlack to solve challenges they faced in their project work. Their work was later turned into an internal product by [Peteris Erins](https://github.com/Pet3ris), [Ivan Danov](https://github.com/idanov), [Nikolaos Kaltsas](https://github.com/nikos-kal), [Meisam Emamjome](https://github.com/misamae) and [Nikolaos Tsaousis](https://github.com/tsanikgr). In the project's latest iteration it is an incubating project within [LF AI & Data](https://lfaidata.foundation/).
-
-Currently, the core Kedro team consists of
-[Ahdra Merali](https://github.com/AhdraMeraliQB),
-[Andrew Mackay](https://github.com/Mackay031),
-[Ankita Katiyar](https://github.com/ankatiyar),
-[Antony Milne](https://github.com/AntonyMilneQB),
-[Cvetanka Nechevska](https://github.com/cvetankanechevska),
-[Deepyaman Datta](https://github.com/deepyaman),
-[Gabriel Comym](https://github.com/comym),
-[Huong Nguyen](https://github.com/Huongg),
-[Ivan Danov](https://github.com/idanov),
-[Jannic Holzer](https://github.com/jmholzer),
-[Jo Stichbury](https://github.com/stichbury),
-[Joel Schwarzmann](https://github.com/datajoely),
-[Lim Hoang](https://github.com/limdauto),
-[Merel Theisen](https://github.com/merelcht),
-[Nero Okwa](https://github.com/NeroOkwa),
-[Nok Lam Chan](https://github.com/noklam),
-[Rashida Kanchwala](https://github.com/rashidakanchwala),
-[Sajid Alam](https://github.com/SajidAlamQB),
-[Tynan DeBold](https://github.com/tynandebold) and
-[Yetunde Dada](https://github.com/yetudada).
-
-Former core team members with significant contributions include:
-[Andrii Ivaniuk](https://github.com/andrii-ivaniuk),
-[Anton Kirilenko](https://github.com/Flid),
-[Dmitrii Deriabin](https://github.com/dmder),
-[Gordon Wrigley](https://github.com/tolomea),
-[Hamza Oza](https://github.com/hamzaoza),
-[Ignacio Paricio](https://github.com/ignacioparicio),
-[Jiri Klein](https://github.com/jiriklein),
-[Kiyohito Kunii](https://github.com/921kiyo),
-[Laís Carvalho](https://github.com/laisbsc),
-[Liam Brummitt](https://github.com/bru5),
-[Lorena Bălan](https://github.com/lorenabalan),
-[Nasef Khan](https://github.com/nakhan98),
-[Richard Westenra](https://github.com/richardwestenra),
-[Susanna Wong](https://github.com/studioswong) and
-[Zain Patel](https://github.com/mzjp2).
-
-And last, but not least, all the open-source contributors whose work went into all Kedro [releases](https://github.com/kedro-org/kedro/blob/main/RELEASE.md).
-
 ## What are the primary advantages of Kedro?
 
 If you're a Data Scientist, then you should be interested in Kedro because it enables you to:
@@ -97,6 +52,37 @@ The responsibility of _"What time will this pipeline run?"_, _"How do I manage m
  failed?"_ is left to the orchestrators. We also have deployment guidelines for using orchestrators as deployment
   targets and are working in collaboration with the maintainers of some of those tools to make the deployment experience as enjoyable as possible.
 
+## What is the typical Kedro project development workflow?
+
+When you build a Kedro project, you will typically follow a standard development workflow:
+
+![](../meta/images/typical_workflow.png)
+
+### 1. Set up the project template
+
+* Create a new project with `kedro new`
+* Install project dependencies with `pip install -r src/requirements.txt`
+* Configure the following in the `conf` folder:
+	* Logging
+	* Credentials
+	* Any other sensitive / personal content
+
+### 2. Set up the data
+
+* Add data to the `data` folder
+* Reference all datasets for the project in the `conf/base/catalog.yml` file
+
+### 3. Create the pipeline
+
+* Create the data transformation steps as Python functions
+* Add your functions as nodes, to construct the pipeline
+* Choose how to run the pipeline: sequentially or in parallel
+
+### 4. Package the project
+
+ * Build the project documentation
+ * Package the project for distribution
+
 ## What is data engineering convention?
 
 [Bruce Philp](https://github.com/bruceaphilp) and [Guilherme Braccialli](https://github.com/gbraccialli-qb) are the
@@ -166,10 +152,115 @@ There are a host of articles, podcasts, talks and Kedro showcase projects in the
 
 Our preferred Kedro-community channel for feedback is through [GitHub issues](https://github.com/kedro-org/kedro/issues). We update the codebase regularly; you can find news about updates and features in the [RELEASE.md file on the Github repository](https://github.com/kedro-org/kedro/blob/develop/RELEASE.md).
 
+## Who maintains Kedro?
+
+Kedro was originally designed by [Aris Valtazanos](https://github.com/arisvqb) and [Nikolaos Tsaousis](https://github.com/tsanikgr) at QuantumBlack to solve challenges they faced in their project work. Their work was later turned into an internal product by [Peteris Erins](https://github.com/Pet3ris), [Ivan Danov](https://github.com/idanov), [Nikolaos Kaltsas](https://github.com/nikos-kal), [Meisam Emamjome](https://github.com/misamae) and [Nikolaos Tsaousis](https://github.com/tsanikgr). In the project's latest iteration it is an incubating project within [LF AI & Data](https://lfaidata.foundation/).
+
+Currently, the core Kedro team consists of
+[Ahdra Merali](https://github.com/AhdraMeraliQB),
+[Andrew Mackay](https://github.com/Mackay031),
+[Ankita Katiyar](https://github.com/ankatiyar),
+[Antony Milne](https://github.com/AntonyMilneQB),
+[Cvetanka Nechevska](https://github.com/cvetankanechevska),
+[Deepyaman Datta](https://github.com/deepyaman),
+[Gabriel Comym](https://github.com/comym),
+[Huong Nguyen](https://github.com/Huongg),
+[Ivan Danov](https://github.com/idanov),
+[Jannic Holzer](https://github.com/jmholzer),
+[Jo Stichbury](https://github.com/stichbury),
+[Joel Schwarzmann](https://github.com/datajoely),
+[Lim Hoang](https://github.com/limdauto),
+[Merel Theisen](https://github.com/merelcht),
+[Nero Okwa](https://github.com/NeroOkwa),
+[Nok Lam Chan](https://github.com/noklam),
+[Rashida Kanchwala](https://github.com/rashidakanchwala),
+[Sajid Alam](https://github.com/SajidAlamQB),
+[Tynan DeBold](https://github.com/tynandebold) and
+[Yetunde Dada](https://github.com/yetudada).
+
+Former core team members with significant contributions include:
+[Andrii Ivaniuk](https://github.com/andrii-ivaniuk),
+[Anton Kirilenko](https://github.com/Flid),
+[Dmitrii Deriabin](https://github.com/dmder),
+[Gordon Wrigley](https://github.com/tolomea),
+[Hamza Oza](https://github.com/hamzaoza),
+[Ignacio Paricio](https://github.com/ignacioparicio),
+[Jiri Klein](https://github.com/jiriklein),
+[Kiyohito Kunii](https://github.com/921kiyo),
+[Laís Carvalho](https://github.com/laisbsc),
+[Liam Brummitt](https://github.com/bru5),
+[Lorena Bălan](https://github.com/lorenabalan),
+[Nasef Khan](https://github.com/nakhan98),
+[Richard Westenra](https://github.com/richardwestenra),
+[Susanna Wong](https://github.com/studioswong) and
+[Zain Patel](https://github.com/mzjp2).
+
+And last, but not least, all the open-source contributors whose work went into all Kedro [releases](https://github.com/kedro-org/kedro/blob/main/RELEASE.md).
+
+
 ## How can I cite Kedro?
 
 If you're an academic, Kedro can also help you, for example, as a tool to solve the problem of reproducible research. Use the "Cite this repository" button on [our repository](https://github.com/kedro-org/kedro) to generate a citation from the [CITATION.cff file](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-citation-files).
 
+## Can I create a virtual environment without `conda`?
+
+You can use `venv` or `pipenv` instead.
+
+### `venv` (instead of `conda`)
+
+If you use Python 3, you should already have the `venv` module installed with the standard library. Create a directory for working with Kedro within your virtual environment:
+
+```bash
+mkdir kedro-environment && cd kedro-environment
+```
+
+This will create a `kedro-environment` directory in your current working directory. Next, to create a new virtual environment in this directory, run:
+
+```bash
+python -m venv env/kedro-environment  # macOS / Linux
+python -m venv env\kedro-environment  # Windows
+```
+
+Activate this virtual environment:
+
+```bash
+source env/kedro-environment/bin/activate # macOS / Linux
+.\env\kedro-environment\Scripts\activate  # Windows
+```
+
+To exit the environment:
+
+```bash
+deactivate
+```
+
+### `pipenv` (instead of `conda`)
+
+Install `pipenv` as follows:
+
+```bash
+pip install pipenv
+```
+
+Create a directory for the virtual environment and change to that directory:
+
+```bash
+mkdir kedro-environment && cd kedro-environment
+```
+
+Once all the dependencies are installed, to start a session with the correct virtual environment activated:
+
+```bash
+pipenv shell
+```
+
+To exit the shell session:
+
+```bash
+exit
+```
+
+
 ## How can I get my question answered?
 
-If your question isn't answered above, check out the [searchable archive from our retired Discord server](https://linen-discord.kedro.org/community or post a new query on the [Slack organisation](https://join.slack.com/t/kedro-org/shared_invite/zt-1eicp0iw6-nkBvDlfAYb1AUJV7DgBIvw).
+If your question isn't answered above, talk to the community on the [Kedro Slack channels](https://join.slack.com/t/kedro-org/shared_invite/zt-1eicp0iw6-nkBvDlfAYb1AUJV7DgBIvw).
diff --git a/docs/source/get_started/install.md b/docs/source/get_started/install.md
index b62f0125ad..66eac9a859 100644
--- a/docs/source/get_started/install.md
+++ b/docs/source/get_started/install.md
@@ -7,11 +7,7 @@ pip install kedro
 ```
 
 ```{note}
-It is also possible to install Kedro using `conda`, as follows, but we recommend you use `pip` at this point to eliminate any potential dependency issues:
-```
-
-```bash
-conda install -c conda-forge kedro
+It is also possible to install Kedro using `conda install -c conda-forge kedro` but we recommend you use `pip` at this point to eliminate any potential dependency issues:
 ```
 
 Both `pip` and `conda` install the core Kedro module, which includes the CLI tool, project template, pipeline abstraction, framework, and support for configuration.
diff --git a/docs/source/get_started/prerequisites.md b/docs/source/get_started/prerequisites.md
index b492502bca..daa2bc00a0 100644
--- a/docs/source/get_started/prerequisites.md
+++ b/docs/source/get_started/prerequisites.md
@@ -1,100 +1,51 @@
 # Installation prerequisites
 
-- Kedro supports macOS, Linux and Windows (7 / 8 / 10 and Windows Server 2016+). If you
-  encounter any problems on these platforms, please check the [frequently asked questions](../faq/faq.md), the [searchable archive from our retired Discord server](https://linen-discord.kedro.org) or post a new query on the [Slack organisation](https://join.slack.com/t/kedro-org/shared_invite/zt-1eicp0iw6-nkBvDlfAYb1AUJV7DgBIvw).
+Kedro supports macOS, Linux and Windows. If you encounter any problems on these platforms, please check the [frequently asked questions](../faq/faq.md), the [searchable archive from our retired Discord server](https://linen-discord.kedro.org) or post a new query on the [Slack organisation](https://join.slack.com/t/kedro-org/shared_invite/zt-1eicp0iw6-nkBvDlfAYb1AUJV7DgBIvw).
 
-- To work with Kedro, we highly recommend that you [download and install Anaconda](https://www.anaconda.com/products/individual#Downloads) (Python 3.x version).
-
-- If you use PySpark, you must also [install Java](https://www.oracle.com/java/technologies/javase-downloads.html). If you are a Windows user, you will need admin rights to complete the installation.
-
-## Virtual environments
-
-The main purpose of Python virtual environments is to create an isolated environment for a Python project to have its own dependencies, regardless of other projects. We recommend you create a new virtual environment for *each* new Kedro project you create.
-
-> [Read more about Python Virtual Environments](https://realpython.com/python-virtual-environments-a-primer/).
-
-Depending on your preferred Python installation, you can create virtual environments to work with Kedro as follows:
-
-- With [`conda`](#conda), a package and environment manager program bundled with Anaconda
-
-- Without Anaconda, using [`venv`](#venv-instead-of-conda) or [`pipenv`](#pipenv-instead-of-conda)
-
-### `conda`
-
-[Install `conda`](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) on your computer.
-
-Create a new Python virtual environment, called `kedro-environment`, using `conda`:
-
-```bash
-conda create --name kedro-environment python=3.7 -y
-```
-
-This will create an isolated Python 3.7 environment. To activate it:
+If you are a Windows user, you will need to install [`git`](https://git-scm.com/) onto your machine if you do not have it. To confirm whether you have it installed:
 
 ```bash
-conda activate kedro-environment
+git -v
 ```
 
-To exit `kedro-environment`:
-
-```bash
-conda deactivate
-```
+You should see the version of `git` available, or an error message to indicate that it is not installed.
 
-```{note}
-The `conda` virtual environment is not dependent on your current working directory and can be activated from any directory.
-```
+PySpark users must [install Java](https://www.oracle.com/java/technologies/javase-downloads.html) (if you are working on Windows, you will need admin rights to complete the installation).
 
-### `venv` (instead of `conda`)
+## Virtual environments
+We recommend that you create a new Python virtual environment for *each* new Kedro project you create. A virtual environment creates an isolated environment for a Python project to have its own dependencies, regardless of other projects.
 
-If you use Python 3, you should already have the `venv` module installed with the standard library. Create a directory for working with Kedro within your virtual environment:
+If you don't already have it, you should [download and install Anaconda](https://www.anaconda.com/products/individual#Downloads) (Python 3.x version), which comes bundled with a package and environment manager called `conda`.
 
-```bash
-mkdir kedro-environment && cd kedro-environment
-```
+> [Read more about Python virtual environments](https://realpython.com/python-virtual-environments-a-primer/) or [watch an explainer video about them](https://youtu.be/YKfAwIItO7M).
 
-This will create a `kedro-environment` directory in your current working directory. Next, to create a new virtual environment in this directory, run:
 
-```bash
-python -m venv env/kedro-environment  # macOS / Linux
-python -m venv env\kedro-environment  # Windows
-```
+Depending on your preferred Python installation, you can also create virtual environments to work with Kedro using `venv` or `pipenv` instead of `conda`. Further information about these can be found in the [FAQ](../faq/faq.md)
 
-Activate this virtual environment:
+### Create a virtual environment with `conda`
 
-```bash
-source env/kedro-environment/bin/activate # macOS / Linux
-.\env\kedro-environment\Scripts\activate  # Windows
-```
+1. [Install `conda`](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) on your computer.
 
-To exit the environment:
+2. Create a new Python virtual environment, called `kedro-environment`, using `conda`:
 
 ```bash
-deactivate
+conda create --name kedro-environment python=3.8 -y
 ```
 
-### `pipenv` (instead of `conda`)
+This will create an isolated Python 3.8 environment.
 
-Install `pipenv` as follows:
+3. Activate the new environment:
 
 ```bash
-pip install pipenv
-```
-
-Create a directory for the virtual environment and change to that directory:
-
-```bash
-mkdir kedro-environment && cd kedro-environment
+conda activate kedro-environment
 ```
 
-Once all the dependencies are installed, to start a session with the correct virtual environment activated:
+4. To exit `kedro-environment`:
 
 ```bash
-pipenv shell
+conda deactivate
 ```
 
-To exit the shell session:
-
-```bash
-exit
+```{note}
+The `conda` virtual environment is not dependent on your current working directory and can be activated from any directory.
 ```
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 13fcf4b3ca..c6458ccb3d 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -78,11 +78,19 @@ Welcome to Kedro's documentation!
    tutorial/spaceflights_tutorial
    tutorial/tutorial_template
    tutorial/set_up_data
-   tutorial/create_pipelines
-   tutorial/visualise_pipeline
-   tutorial/namespace_pipelines
-   tutorial/set_up_experiment_tracking
+   tutorial/create_a_pipeline
+   tutorial/add_another_pipeline
    tutorial/package_a_project
+   tutorial/spaceflights_tutorial_faqs
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Visualisation with Kedro-Viz
+
+   visualisation/kedro-viz_visualisation
+   visualisation/visualise_charts_with_plotly
+   visualisation/experiment_tracking
+
 
 .. toctree::
    :maxdepth: 2
diff --git a/docs/source/logging/experiment_tracking.md b/docs/source/logging/experiment_tracking.md
index 2d230b50f6..47802af01b 100644
--- a/docs/source/logging/experiment_tracking.md
+++ b/docs/source/logging/experiment_tracking.md
@@ -10,7 +10,7 @@ However, Kedro was missing a way to log metrics and capture all this logged data
 
 Experiment tracking in Kedro adds in the missing pieces and will be developed incrementally.
 
-The following section outlines the setup within your Kedro project to enable experiment tracking. You can also refer to the [tutorial on setting up experiment tracking](../tutorial/set_up_experiment_tracking.md) for a step-by-step process to access your tracking datasets on Kedro-Viz.
+The following section outlines the setup within your Kedro project to enable experiment tracking. You can also refer to the [Kedro Viz documentation about experiment tracking](../visualisation/experiment_tracking.md) for a step-by-step process to access your tracking datasets on Kedro-Viz.
 
 ## Enable experiment tracking
 
diff --git a/docs/source/meta/images/coffee-cup.png b/docs/source/meta/images/coffee-cup.png
new file mode 100644
index 0000000000..e394bb0dc1
Binary files /dev/null and b/docs/source/meta/images/coffee-cup.png differ
diff --git a/docs/source/meta/images/moon-rocket.png b/docs/source/meta/images/moon-rocket.png
new file mode 100644
index 0000000000..09f4efc52f
Binary files /dev/null and b/docs/source/meta/images/moon-rocket.png differ
diff --git a/docs/source/nodes_and_pipelines/modular_pipelines.md b/docs/source/nodes_and_pipelines/modular_pipelines.md
index 7d0ae7000e..77212393b8 100644
--- a/docs/source/nodes_and_pipelines/modular_pipelines.md
+++ b/docs/source/nodes_and_pipelines/modular_pipelines.md
@@ -27,7 +27,7 @@ In this section, you will learn about how to take advantage of modular pipelines
 3. **The `kedro.pipeline.modular_pipeline.pipeline` wrapper method unlocks the real power of modular pipelines**
 
    * Applying [namespaces](https://en.wikipedia.org/wiki/Namespace) allows you to simplify your mental model and isolate 'within pipeline' processing steps.
-   * ``Kedro-Viz`` is able to accelerate development by [rendering namespaced](../tutorial/visualise_pipeline.md) pipelines as collapsible 'super nodes'.
+   * ``Kedro-Viz`` is able to accelerate development by rendering namespaced pipelines as collapsible 'super nodes'.
 
 <iframe
     src="https://demo.kedro.org"
diff --git a/docs/source/resources/glossary.md b/docs/source/resources/glossary.md
index d59454a860..c87ce56383 100644
--- a/docs/source/resources/glossary.md
+++ b/docs/source/resources/glossary.md
@@ -33,12 +33,12 @@ You can use Kedro-Viz to visualise your Kedro data pipelines:
 * Get a clear picture when you have lots of datasets and nodes by using tags to visualise sub-pipelines
 * Search for nodes and datasets
 
-[Further information from the Kedro-Viz repository](https://github.com/kedro-org/kedro-viz) and [Kedro tutorial documentation](../tutorial/visualise_pipeline.md)
+[Further information from the Kedro-Viz repository](https://github.com/kedro-org/kedro-viz) and [Kedro-Viz documentation](../visualisation/kedro-viz_visualisation.md)
 
 ## Layers (data engineering convention)
 According to [data engineering convention](../faq/faq.md#what-is-data-engineering-convention), a pipeline can be broken up into different layers according to how data is processed. This convention makes it easier to collaborate with other team members because everyone has an idea of what type of data cleaning or processing has happened.
 
-Kedro-Viz makes it easy to [visualise these data processing stages](../tutorial/visualise_pipeline.md#visualise-layers) by adding a `layer` attribute to the datasets in the Data Catalog.
+Kedro-Viz makes it easy to [visualise these data processing stages](../visualisation/kedro-viz_visualisation.md#visualise-layers) by adding a `layer` attribute to the datasets in the Data Catalog.
 
 ## Modular pipeline
 _(See also [Pipeline](#pipeline))_
diff --git a/docs/source/tutorial/add_another_pipeline.md b/docs/source/tutorial/add_another_pipeline.md
new file mode 100644
index 0000000000..1d9e9283f0
--- /dev/null
+++ b/docs/source/tutorial/add_another_pipeline.md
@@ -0,0 +1,559 @@
+# Create a data science pipeline
+
+```{note}
+Don't forget to check the [tutorial FAQ](spaceflights_tutorial_faqs.md) if you run into problems, or [ask the community for help](spaceflights_tutorial.md#get-help) if you need it!
+```
+
+This section explains the following:
+
+* How to add a second Kedro pipeline for data science code that extends the default project pipeline
+* How to 'slice' the project and run just part of the default pipeline
+* How to visualise the default project pipeline
+* (Optional) How to make a [modular pipeline](../nodes_and_pipelines/modular_pipelines.md)
+* (Optional) How to specify the way the pipeline nodes are run: sequentially or in parallel
+
+
+```{note}
+If you are using the tutorial created by the spaceflights starter, you can omit the copy/paste steps below, but it is worth reviewing the files described.
+```
+
+## Data science pipeline
+
+The data science pipeline uses the [`LinearRegression`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) implementation from the [scikit-learn](https://scikit-learn.org/stable/) library.
+
+### Generate a new pipeline template
+
+Run the following command to create the `data_science` pipeline.
+
+
+```bash
+kedro pipeline create data_science
+```
+
+Add the following code to the `src/kedro_tutorial/pipelines/data_science/nodes.py` file:
+
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+import logging
+from typing import Dict, Tuple
+
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import r2_score
+from sklearn.model_selection import train_test_split
+
+
+def split_data(data: pd.DataFrame, parameters: Dict) -> Tuple:
+    """Splits data into features and targets training and test sets.
+
+    Args:
+        data: Data containing features and target.
+        parameters: Parameters defined in parameters/data_science.yml.
+    Returns:
+        Split data.
+    """
+    X = data[parameters["features"]]
+    y = data["price"]
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=parameters["test_size"], random_state=parameters["random_state"]
+    )
+    return X_train, X_test, y_train, y_test
+
+
+def train_model(X_train: pd.DataFrame, y_train: pd.Series) -> LinearRegression:
+    """Trains the linear regression model.
+
+    Args:
+        X_train: Training data of independent features.
+        y_train: Training data for price.
+
+    Returns:
+        Trained model.
+    """
+    regressor = LinearRegression()
+    regressor.fit(X_train, y_train)
+    return regressor
+
+
+def evaluate_model(
+    regressor: LinearRegression, X_test: pd.DataFrame, y_test: pd.Series
+):
+    """Calculates and logs the coefficient of determination.
+
+    Args:
+        regressor: Trained model.
+        X_test: Testing data of independent features.
+        y_test: Testing data for price.
+    """
+    y_pred = regressor.predict(X_test)
+    score = r2_score(y_test, y_pred)
+    logger = logging.getLogger(__name__)
+    logger.info("Model has a coefficient R^2 of %.3f on test data.", score)
+```
+
+</details>
+
+### Configure the input parameters
+
+You now need to add some parameters that are used by the `DataCatalog` when the pipeline executes.
+
+Add the following to `conf/base/parameters/data_science.yml`:
+
+```yaml
+model_options:
+  test_size: 0.2
+  random_state: 3
+  features:
+    - engines
+    - passenger_capacity
+    - crew
+    - d_check_complete
+    - moon_clearance_complete
+    - iata_approved
+    - company_rating
+    - review_scores_rating
+```
+
+Here, the parameters `test_size` and `random_state` are used as part of the train-test split, and `features` gives the names of columns in the model input table to use as features.
+
+More information about [parameters](../kedro_project_setup/configuration.md#parameters) is available in later documentation for advanced usage.
+
+### Assemble the data science pipeline
+
+To create a modular pipeline for the price prediction model, replace the contents of `src/kedro_tutorial/pipelines/data_science/pipeline.py` with the following:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+from kedro.pipeline import Pipeline, node, pipeline
+
+from .nodes import evaluate_model, split_data, train_model
+
+
+def create_pipeline(**kwargs) -> Pipeline:
+    return pipeline(
+        [
+            node(
+                func=split_data,
+                inputs=["model_input_table", "params:model_options"],
+                outputs=["X_train", "X_test", "y_train", "y_test"],
+                name="split_data_node",
+            ),
+            node(
+                func=train_model,
+                inputs=["X_train", "y_train"],
+                outputs="regressor",
+                name="train_model_node",
+            ),
+            node(
+                func=evaluate_model,
+                inputs=["regressor", "X_test", "y_test"],
+                outputs=None,
+                name="evaluate_model_node",
+            ),
+        ]
+    )
+```
+</details>
+
+### Register the dataset
+
+The next step is to register the dataset that will save the trained model, by adding the following definition to `conf/base/catalog.yml`:
+
+```yaml
+regressor:
+  type: pickle.PickleDataSet
+  filepath: data/06_models/regressor.pickle
+  versioned: true
+```
+
+By setting `versioned` to `true`, versioning is enabled for `regressor`. This means that the pickled output of the `regressor` is saved every time the pipeline runs, which stores the history of the models built using this pipeline. You can learn more in the [Versioning section](../data/kedro_io.md#versioning).
+
+### Test the pipelines
+
+You can now instruct Kedro to run the default pipeline, which automatically executes the data processing and then data science pipeline in turn.
+
+```bash
+kedro run
+```
+
+You should see output similar to the following:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```bash
+[08/09/22 16:56:00] INFO     Kedro project kedro-tutorial                                         session.py:346
+                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
+                    INFO     Running node: preprocess_companies_node:                                node.py:327
+                             preprocess_companies([companies]) -> [preprocessed_companies]
+                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
+                    INFO     Completed 1 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
+[08/09/22 16:56:15] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
+                             -> [preprocessed_shuttles]
+                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
+                    INFO     Completed 2 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
+                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
+                    INFO     Loading data from 'reviews' (CSVDataSet)...                     data_catalog.py:343
+                    INFO     Running node: create_model_input_table_node:                            node.py:327
+                             create_model_input_table([preprocessed_shuttles,preprocessed_companies,
+                             reviews]) -> [model_input_table]
+[08/09/22 16:56:18] INFO     Saving data to 'model_input_table' (MemoryDataSet)...           data_catalog.py:382
+[08/09/22 16:56:19] INFO     Completed 3 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'model_input_table' (MemoryDataSet)...        data_catalog.py:343
+                    INFO     Loading data from 'params:model_options' (MemoryDataSet)...     data_catalog.py:343
+                    INFO     Running node: split_data_node:                                          node.py:327
+                             split_data([model_input_table,params:model_options]) ->
+                             [X_train,X_test,y_train,y_test]
+                    INFO     Saving data to 'X_train' (MemoryDataSet)...                     data_catalog.py:382
+                    INFO     Saving data to 'X_test' (MemoryDataSet)...                      data_catalog.py:382
+                    INFO     Saving data to 'y_train' (MemoryDataSet)...                     data_catalog.py:382
+                    INFO     Saving data to 'y_test' (MemoryDataSet)...                      data_catalog.py:382
+                    INFO     Completed 4 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'X_train' (MemoryDataSet)...                  data_catalog.py:343
+                    INFO     Loading data from 'y_train' (MemoryDataSet)...                  data_catalog.py:343
+                    INFO     Running node: train_model_node: train_model([X_train,y_train]) ->       node.py:327
+                             [regressor]
+[08/09/22 16:56:20] INFO     Saving data to 'regressor' (PickleDataSet)...                   data_catalog.py:382
+                    INFO     Completed 5 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'regressor' (PickleDataSet)...                data_catalog.py:343
+                    INFO     Loading data from 'X_test' (MemoryDataSet)...                   data_catalog.py:343
+                    INFO     Loading data from 'y_test' (MemoryDataSet)...                   data_catalog.py:343
+                    INFO     Running node: evaluate_model_node:                                      node.py:327
+                             evaluate_model([regressor,X_test,y_test]) -> None
+                    INFO     Model has a coefficient R^2 of 0.462 on test data.                      nodes.py:55
+                    INFO     Completed 6 out of 6 tasks                                  sequential_runner.py:85
+                    INFO     Pipeline execution completed successfully.                             runner.py:89
+```
+
+</details>
+
+As you can see we successfully ran both the `data_processing` and `data_science` pipelines, generating a model and evaluating it.
+
+
+#### Slice a pipeline
+
+When you created your project with `kedro new`, one of the files generated was `src/<project_name>/pipeline_registry.py` which constructs the `__default__` pipeline from every pipeline in the project, so you do not need to manually instruct Kedro to run each pipeline.
+
+However, there may be occasions when you want to run just part of the default pipeline. For example, you could skip `data_processing` execution and run only the `data_science` pipeline to tune the hyperparameters of the price prediction model.
+
+You can 'slice' the pipeline and specify just the portion you want to run by using the `--pipeline` command line option. For example, to only run the pipeline named `data_science` (as labelled automatically in `register_pipelines`), execute the following command:
+
+```bash
+kedro run --pipeline=data_science
+```
+
+``` {note}
+This will only work if you have persisted the input to the `data_science` pipeline, which is the `model_input_table`. This was an optional step in the previous chapter.
+```
+
+There are a range of options to run sections of the default pipeline as described in the [pipeline slicing documentation](../nodes_and_pipelines/slice_a_pipeline.md) and the ``kedro run`` [CLI documentation](../development/commands_reference.md#modifying-a-kedro-run).
+
+
+## Visualise the project
+
+The documentation on [visualisation with Kedro-Viz](../visualisation/kedro-viz_visualisation) discusses this topic in greater detail, so this is a swift introduction on how to use Kedro-Viz to visualise the project.
+
+In your terminal type the following:
+
+```bash
+kedro viz
+```
+
+This command automatically opens a browser tab to serve the visualisation at `http://127.0.0.1:4141/`.
+
+You should see the following:
+
+![](../meta/images/pipeline_visualisation.png)
+
+To exit the visualisation, close the browser tab. To regain control of the terminal, enter `⌘+c` on Mac or `Ctrl+c` on Windows or Linux machines.
+
+
+## Optional: modular pipelines
+
+In many typical Kedro projects, a single (“main”) pipeline increases in complexity as the project evolves. To keep your project fit for purpose, we recommend that you create [modular pipelines](../nodes_and_pipelines/modular_pipelines.md), which are logically isolated and can be reused. You can instantiate a modular pipeline multiple times as a "template" pipeline that can run with different inputs/outputs/parameters.
+
+Modular pipelines are easier to develop, test and maintain. They are reusable within the same codebase but also portable across projects via [micro-packaging](../nodes_and_pipelines/micro_packaging.md). This is a scalable way to use Kedro, and will change how you think about Kedro pipelines.
+
+### Extend the project with namespacing and a modular pipeline
+We first add some namespaces to the modelling component of the data science pipeline to instantiate it as a template with different parameters for an `active_modelling_pipeline` and a `candidate_modelling_pipeline` in order to test the model using different combinations of features.
+
+``` {note}
+This is optional code so is **not** provided in the spaceflights starter. Unlike the rest of the tutorial, if you want to see this in action, you need to copy and paste the code as instructed.
+```
+
+
+1. Update your catalog to add namespaces to the outputs of each instance. Replace the `regressor` key with the following two new dataset keys in the `conf/base/catalog.yml` file:
+
+```yaml
+active_modelling_pipeline.regressor:
+  type: pickle.PickleDataSet
+  filepath: data/06_models/regressor_active.pickle
+  versioned: true
+
+candidate_modelling_pipeline.regressor:
+  type: pickle.PickleDataSet
+  filepath: data/06_models/regressor_candidate.pickle
+  versioned: true
+
+```
+
+2. Update the parameters file for the data science pipeline in `conf/base/parameters/data_science.yml` to replace the existing contents for `model_options` with the following for the two instances of the template pipeline:
+
+
+```yaml
+active_modelling_pipeline:
+    model_options:
+      test_size: 0.2
+      random_state: 3
+      features:
+        - engines
+        - passenger_capacity
+        - crew
+        - d_check_complete
+        - moon_clearance_complete
+        - iata_approved
+        - company_rating
+        - review_scores_rating
+
+candidate_modelling_pipeline:
+    model_options:
+      test_size: 0.2
+      random_state: 8
+      features:
+        - engines
+        - passenger_capacity
+        - crew
+        - review_scores_rating
+```
+
+
+3. Replace the code in `pipelines/data_science/pipeline.py` with the snippet below:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+from kedro.pipeline import Pipeline, node
+from kedro.pipeline.modular_pipeline import pipeline
+
+from .nodes import evaluate_model, split_data, train_model
+
+
+def create_pipeline(**kwargs) -> Pipeline:
+    pipeline_instance = pipeline(
+        [
+            node(
+                func=split_data,
+                inputs=["model_input_table", "params:model_options"],
+                outputs=["X_train", "X_test", "y_train", "y_test"],
+                name="split_data_node",
+            ),
+            node(
+                func=train_model,
+                inputs=["X_train", "y_train"],
+                outputs="regressor",
+                name="train_model_node",
+            ),
+            node(
+                func=evaluate_model,
+                inputs=["regressor", "X_test", "y_test"],
+                outputs=None,
+                name="evaluate_model_node",
+            ),
+        ]
+    )
+    ds_pipeline_1 = pipeline(
+        pipe=pipeline_instance,
+        inputs="model_input_table",
+        namespace="active_modelling_pipeline",
+    )
+    ds_pipeline_2 = pipeline(
+        pipe=pipeline_instance,
+        inputs="model_input_table",
+        namespace="candidate_modelling_pipeline",
+    )
+
+    return ds_pipeline_1 + ds_pipeline_2
+```
+
+</details>
+
+<br/>
+
+After executing `kedro run`, you should see output as follows:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```bash
+[11/02/22 10:41:06] WARNING  /Users/<username>/opt/anaconda3/envs/py38/lib/python3.8/site-packages/plotly/graph_objects/ warnings.py:109
+                             __init__.py:288: DeprecationWarning: distutils Version classes are deprecated. Use
+                             packaging.version instead.
+                               if LooseVersion(ipywidgets.__version__) >= LooseVersion("7.0.0"):
+
+[11/02/22 10:41:07] INFO     Kedro project kedro-tutorial                                                                   session.py:340
+[11/02/22 10:41:08] INFO     Loading data from 'companies' (CSVDataSet)...                                             data_catalog.py:343
+                    INFO     Running node: preprocess_companies_node: preprocess_companies([companies]) ->                     node.py:327
+                             [preprocessed_companies]
+                    INFO     Saving data to 'preprocessed_companies' (ParquetDataSet)...                               data_catalog.py:382
+                    INFO     Completed 1 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                                            data_catalog.py:343
+[11/02/22 10:41:13] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) ->                        node.py:327
+                             [preprocessed_shuttles]
+                    WARNING  /Users/<username>/Documents/kedro-projects/kedro-tutorial/src/kedro_tutorial/pipelines/data warnings.py:109
+                             _processing/nodes.py:19: FutureWarning: The default value of regex will change from True to
+                             False in a future version. In addition, single character regular expressions will *not* be
+                             treated as literal strings when regex=True.
+                               x = x.str.replace("$", "").str.replace(",", "")
+
+                    INFO     Saving data to 'preprocessed_shuttles' (ParquetDataSet)...                                data_catalog.py:382
+                    INFO     Completed 2 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'preprocessed_shuttles' (ParquetDataSet)...                             data_catalog.py:343
+                    INFO     Loading data from 'preprocessed_companies' (ParquetDataSet)...                            data_catalog.py:343
+                    INFO     Loading data from 'reviews' (CSVDataSet)...                                               data_catalog.py:343
+                    INFO     Running node: create_model_input_table_node:                                                      node.py:327
+                             create_model_input_table([preprocessed_shuttles,preprocessed_companies,reviews]) ->
+                             [model_input_table]
+^[[B[11/02/22 10:41:14] INFO     Saving data to 'model_input_table' (ParquetDataSet)...                                    data_catalog.py:382
+[11/02/22 10:41:15] INFO     Completed 3 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'model_input_table' (ParquetDataSet)...                                 data_catalog.py:343
+                    INFO     Loading data from 'params:active_modelling_pipeline.model_options' (MemoryDataSet)...     data_catalog.py:343
+                    INFO     Running node: split_data_node:                                                                    node.py:327
+                             split_data([model_input_table,params:active_modelling_pipeline.model_options]) ->
+                             [active_modelling_pipeline.X_train,active_modelling_pipeline.X_test,active_modelling_pipeline.y_t
+                             rain,active_modelling_pipeline.y_test]
+                    INFO     Saving data to 'active_modelling_pipeline.X_train' (MemoryDataSet)...                     data_catalog.py:382
+                    INFO     Saving data to 'active_modelling_pipeline.X_test' (MemoryDataSet)...                      data_catalog.py:382
+                    INFO     Saving data to 'active_modelling_pipeline.y_train' (MemoryDataSet)...                     data_catalog.py:382
+                    INFO     Saving data to 'active_modelling_pipeline.y_test' (MemoryDataSet)...                      data_catalog.py:382
+                    INFO     Completed 4 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'model_input_table' (ParquetDataSet)...                                 data_catalog.py:343
+                    INFO     Loading data from 'params:candidate_modelling_pipeline.model_options' (MemoryDataSet)...  data_catalog.py:343
+                    INFO     Running node: split_data_node:                                                                    node.py:327
+                             split_data([model_input_table,params:candidate_modelling_pipeline.model_options]) ->
+                             [candidate_modelling_pipeline.X_train,candidate_modelling_pipeline.X_test,candidate_modelling_pip
+                             eline.y_train,candidate_modelling_pipeline.y_test]
+                    INFO     Saving data to 'candidate_modelling_pipeline.X_train' (MemoryDataSet)...                  data_catalog.py:382
+                    INFO     Saving data to 'candidate_modelling_pipeline.X_test' (MemoryDataSet)...                   data_catalog.py:382
+                    INFO     Saving data to 'candidate_modelling_pipeline.y_train' (MemoryDataSet)...                  data_catalog.py:382
+                    INFO     Saving data to 'candidate_modelling_pipeline.y_test' (MemoryDataSet)...                   data_catalog.py:382
+                    INFO     Completed 5 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'active_modelling_pipeline.X_train' (MemoryDataSet)...                  data_catalog.py:343
+                    INFO     Loading data from 'active_modelling_pipeline.y_train' (MemoryDataSet)...                  data_catalog.py:343
+                    INFO     Running node: train_model_node:                                                                   node.py:327
+                             train_model([active_modelling_pipeline.X_train,active_modelling_pipeline.y_train]) ->
+                             [active_modelling_pipeline.regressor]
+                    INFO     Saving data to 'active_modelling_pipeline.regressor' (PickleDataSet)...                   data_catalog.py:382
+                    INFO     Completed 6 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'candidate_modelling_pipeline.X_train' (MemoryDataSet)...               data_catalog.py:343
+                    INFO     Loading data from 'candidate_modelling_pipeline.y_train' (MemoryDataSet)...               data_catalog.py:343
+                    INFO     Running node: train_model_node:                                                                   node.py:327
+                             train_model([candidate_modelling_pipeline.X_train,candidate_modelling_pipeline.y_train]) ->
+                             [candidate_modelling_pipeline.regressor]
+                    INFO     Saving data to 'candidate_modelling_pipeline.regressor' (PickleDataSet)...                data_catalog.py:382
+                    INFO     Completed 7 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'active_modelling_pipeline.regressor' (PickleDataSet)...                data_catalog.py:343
+                    INFO     Loading data from 'active_modelling_pipeline.X_test' (MemoryDataSet)...                   data_catalog.py:343
+                    INFO     Loading data from 'active_modelling_pipeline.y_test' (MemoryDataSet)...                   data_catalog.py:343
+                    INFO     Running node: evaluate_model_node:                                                                node.py:327
+                             evaluate_model([active_modelling_pipeline.regressor,active_modelling_pipeline.X_test,active_model
+                             ling_pipeline.y_test]) -> None
+                    INFO     Model has a coefficient R^2 of 0.462 on test data.                                                nodes.py:60
+                    INFO     Completed 8 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Loading data from 'candidate_modelling_pipeline.regressor' (PickleDataSet)...             data_catalog.py:343
+                    INFO     Loading data from 'candidate_modelling_pipeline.X_test' (MemoryDataSet)...                data_catalog.py:343
+                    INFO     Loading data from 'candidate_modelling_pipeline.y_test' (MemoryDataSet)...                data_catalog.py:343
+                    INFO     Running node: evaluate_model_node:                                                                node.py:327
+                             evaluate_model([candidate_modelling_pipeline.regressor,candidate_modelling_pipeline.X_test,candid
+                             ate_modelling_pipeline.y_test]) -> None
+                    INFO     Model has a coefficient R^2 of 0.449 on test data.                                                nodes.py:60
+                    INFO     Completed 9 out of 9 tasks                                                            sequential_runner.py:85
+                    INFO     Pipeline execution completed successfully.
+```
+</details>
+
+#### How it works: the modular `pipeline()` wrapper
+
+The import you added to the code introduces the pipeline wrapper, which enables you to instantiate multiple instances of pipelines with static structure, but dynamic inputs/outputs/parameters:
+
+```python
+from kedro.pipeline.modular_pipeline import pipeline
+```
+
+The `pipeline()` wrapper method takes the following arguments:
+
+| Keyword argument | Description                                                                         |
+| ---------------- | ----------------------------------------------------------------------------------- |
+| `pipe`           | The `Pipeline` object you want to wrap                                              |
+| `inputs`         | Any overrides provided to this instance of the underlying wrapped `Pipeline` object |
+| `outputs`        | Any overrides provided to this instance of the underlying wrapped `Pipeline` object |
+| `parameters`     | Any overrides provided to this instance of the underlying wrapped `Pipeline` object |
+| `namespace`      | The namespace that will be encapsulated by this pipeline instance                   |
+
+
+You can see this snippet as part of the code you added to the example:
+
+```python
+...
+
+ds_pipeline_1 = pipeline(
+    pipe=pipeline_instance,
+    inputs="model_input_table",
+    namespace="active_modelling_pipeline",
+)
+
+ds_pipeline_2 = pipeline(
+    pipe=pipeline_instance,
+    inputs="model_input_table",
+    namespace="candidate_modelling_pipeline",
+)
+```
+
+We instantiate the template_pipeline twice but pass in different parameters. The `pipeline_instance` variable is the template pipeline, and `ds_pipeline_1` and `ds_pipeline_2` are the two separately parameterised instantiations.
+
+So let's go through in detail how those namespaces affect our catalog references:
+
+- All `inputs` and `outputs` within the nodes of our `ds_pipeline_1` have the `active_modelling_pipeline` prefix:
+  - `params:model_options` turns into `active_modelling_pipeline.params:model_options`
+  - `X_train` turns into `active_modelling_pipeline.X_train`
+  - `X_test` turns into `active_modelling_pipeline.X_test`, and so on
+
+- There are a separate set of parameters for `ds_pipeline_2` with the `candidate_modelling_pipeline` prefix:
+  - `params:model_options` turns into `candidate_modelling_pipeline.params:model_options`
+  - `X_train` turns into `candidate_modelling_pipeline.X_train`
+  - `X_test` turns into `candidate_modelling_pipeline.X_test`, and so on
+
+However, `model_input_table` does not get parameterised as it needs to be shared between instances, so is frozen outside the scope of the namespace wrappers.
+
+This renders as follows using `kedro viz` (hover over the datasets to see their full path) :
+
+![modular_ds](../meta/images/modular_ds.gif)
+
+## Optional: Kedro runners
+
+There are three different Kedro runners that can run the pipeline:
+
+* `SequentialRunner` - runs your nodes sequentially; once a node has completed its task then the next one starts.
+* `ParallelRunner` - runs your nodes in parallel; independent nodes are able to run at the same time, which is more efficient when there are independent branches in your pipeline and enables you to take advantage of multiple CPU cores.
+* `ThreadRunner` - runs your nodes in parallel, similarly to `ParallelRunner`, but uses multithreading instead of multiprocessing.
+
+By default, Kedro uses a `SequentialRunner`, which is instantiated when you execute `kedro run` from the command line. If you decide to use `ParallelRunner`, `ThreadRunner` or a custom runner, you can do so through the `--runner` flag as follows:
+
+```bash
+kedro run --runner=ParallelRunner
+kedro run --runner=ThreadRunner
+kedro run --runner=module.path.to.my.runner
+```
+
+```{note}
+`ParallelRunner` performs task parallelisation via multiprocessing, while `ThreadRunner` is intended for use with remote execution engines such as [Spark](../tools_integration/pyspark.md) and [Dask](https://github.com/kedro-org/kedro/blob/develop/kedro/extras/datasets/dask/parquet_dataset.py).
+```
+
+You can find out more about the runners Kedro provides, and how to create your own, in the [pipeline documentation about runners](../nodes_and_pipelines/run_a_pipeline.md).
diff --git a/docs/source/tutorial/create_a_pipeline.md b/docs/source/tutorial/create_a_pipeline.md
new file mode 100644
index 0000000000..84b51c1a6c
--- /dev/null
+++ b/docs/source/tutorial/create_a_pipeline.md
@@ -0,0 +1,338 @@
+# Create a data processing pipeline
+
+```{note}
+Don't forget to check the [tutorial FAQ](spaceflights_tutorial_faqs.md) if you run into problems, or [ask the community for help](spaceflights_tutorial.md#get-help) if you need it!
+```
+
+This section explains the following:
+
+* How to create a Kedro node from a Python function
+* How to construct a Kedro pipeline from a set of nodes
+* How to run the pipeline
+
+```{note}
+If you are using the tutorial created by the spaceflights starter, you can omit the copy/paste steps below, but it is worth reviewing the files described.
+```
+
+## Data processing pipeline
+
+You will use the data to train a model to predict the price of shuttle hire, but before you get to train the model, you need to prepare the data for model building by combining the files to create a model input table.
+
+You previously registered the raw datasets for your Kedro project, so you can now create nodes to preprocess two of the datasets, `companies.csv`, and `shuttles.xlsx`, to prepare the data for modelling.
+
+### Generate a new pipeline template
+
+In the terminal, run the following command to generate a new pipeline for data processing:
+
+```bash
+kedro pipeline create data_processing
+```
+
+This command generates all the files you need for the pipeline:
+
+* Two python files within `src/kedro_tutorial/pipelines/data_processing`
+    * `nodes.py` (for the node functions that form the data processing)
+    * `pipeline.py` (to build the pipeline)
+* A yaml file: `conf/base/parameters/data_processing.yml` to define the parameters used when running the pipeline
+* A folder for test code: `src/tests/pipelines/data_processing`
+* `__init__.py` files in the required folders to ensure that Python can import the pipeline
+
+
+### Add node functions
+
+
+Open `src/kedro_tutorial/pipelines/data_processing/nodes.py` and add the code below, which provides two functions (`preprocess_companies` and `preprocess_shuttles`) that each takes a raw DataFrame as input, convert the data in several columns to different types, and output a DataFrame containing the preprocessed data:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+import pandas as pd
+
+
+def _is_true(x: pd.Series) -> pd.Series:
+    return x == "t"
+
+
+def _parse_percentage(x: pd.Series) -> pd.Series:
+    x = x.str.replace("%", "")
+    x = x.astype(float) / 100
+    return x
+
+
+def _parse_money(x: pd.Series) -> pd.Series:
+    x = x.str.replace("$", "").str.replace(",", "")
+    x = x.astype(float)
+    return x
+
+
+def preprocess_companies(companies: pd.DataFrame) -> pd.DataFrame:
+    """Preprocesses the data for companies.
+
+    Args:
+        companies: Raw data.
+    Returns:
+        Preprocessed data, with `company_rating` converted to a float and
+        `iata_approved` converted to boolean.
+    """
+    companies["iata_approved"] = _is_true(companies["iata_approved"])
+    companies["company_rating"] = _parse_percentage(companies["company_rating"])
+    return companies
+
+
+def preprocess_shuttles(shuttles: pd.DataFrame) -> pd.DataFrame:
+    """Preprocesses the data for shuttles.
+
+    Args:
+        shuttles: Raw data.
+    Returns:
+        Preprocessed data, with `price` converted to a float and `d_check_complete`,
+        `moon_clearance_complete` converted to boolean.
+    """
+    shuttles["d_check_complete"] = _is_true(shuttles["d_check_complete"])
+    shuttles["moon_clearance_complete"] = _is_true(shuttles["moon_clearance_complete"])
+    shuttles["price"] = _parse_money(shuttles["price"])
+    return shuttles
+```
+
+</details>
+
+### Assemble nodes into the data processing pipeline
+
+The next steps are to create a [node](../resources/glossary.md#node) for each function and to create a [modular pipeline](../resources/glossary.md#modular-pipeline) for data processing:
+
+First, add import statements for your functions by adding them to the beginning of `pipeline.py`:
+
+```python
+from kedro.pipeline import Pipeline, node, pipeline
+
+from .nodes import preprocess_companies, preprocess_shuttles
+```
+
+Next, add the following to `src/kedro_tutorial/pipelines/data_processing/pipeline.py`, so the `create_pipeline()` function is as follows:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+def create_pipeline(**kwargs) -> Pipeline:
+    return pipeline(
+        [
+            node(
+                func=preprocess_companies,
+                inputs="companies",
+                outputs="preprocessed_companies",
+                name="preprocess_companies_node",
+            ),
+            node(
+                func=preprocess_shuttles,
+                inputs="shuttles",
+                outputs="preprocessed_shuttles",
+                name="preprocess_shuttles_node",
+            ),
+        ]
+    )
+```
+
+</details>
+
+
+Note that the `inputs` statements for `companies` and `shuttles` refer to the datasets defined in `conf/base/catalog.yml`. They are inputs to the `preprocess_companies` and `preprocess_shuttles` functions. Kedro uses the named node inputs (and outputs) to determine interdependencies between the nodes, and their execution order.
+
+
+### Test the example
+
+Run the following command in your terminal window to test the node named `preprocess_companies_node`:
+
+```bash
+kedro run --node=preprocess_companies_node
+```
+
+You should see output similar to the below:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```bash
+[08/09/22 16:43:10] INFO     Kedro project kedro-tutorial                                         session.py:346
+[08/09/22 16:43:11] INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
+                    INFO     Running node: preprocess_companies_node:                                node.py:327
+                             preprocess_companies([companies]) -> [preprocessed_companies]
+                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
+                    INFO     Completed 1 out of 1 tasks                                  sequential_runner.py:85
+                    INFO     Pipeline execution completed successfully.                             runner.py:89
+                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
+
+```
+</details>
+
+You can run the `preprocess_shuttles` node similarly. To test both nodes together as the complete data processing pipeline:
+
+```bash
+kedro run
+```
+
+You should see output similar to the following:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```bash
+[08/09/22 16:45:46] INFO     Kedro project kedro-tutorial                                         session.py:346
+                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
+                    INFO     Running node: preprocess_companies_node:                                node.py:327
+                             preprocess_companies([companies]) -> [preprocessed_companies]
+                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
+                    INFO     Completed 1 out of 2 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
+[08/09/22 16:46:08] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
+                             -> [preprocessed_shuttles]
+                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
+                    INFO     Completed 2 out of 2 tasks                                  sequential_runner.py:85
+                    INFO     Pipeline execution completed successfully.                             runner.py:89
+                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
+                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
+
+```
+</details>
+
+### Optional: save the preprocessed data
+
+Each of the nodes outputs a new dataset (`preprocessed_companies` and `preprocessed_shuttles`).
+
+When Kedro runs the pipeline, it determines that neither dataset is registered in the data catalog, so it stores these as temporary datasets in memory as Python objects using the [MemoryDataSet](/kedro.io.MemoryDataSet) class. Once all nodes that depend on an temporary dataset have executed, the dataset is cleared and the Python garbage collector releases the memory.
+
+If you prefer to save the preprocessed data to file, add the following to the end of `conf/base/catalog.yml` (If you are using the tutorial created by the spaceflights starter, you can omit the copy/paste):
+
+```yaml
+preprocessed_companies:
+  type: pandas.ParquetDataSet
+  filepath: data/02_intermediate/preprocessed_companies.pq
+
+preprocessed_shuttles:
+  type: pandas.ParquetDataSet
+  filepath: data/02_intermediate/preprocessed_shuttles.pq
+```
+
+Adding the data to the catalog declares explicitly that Kedro should use [pandas.ParquetDataSet](/kedro.extras.datasets.pandas.ParquetDataSet) instead of [`MemoryDataSet`](/kedro.io.MemoryDataSet). The [Data Catalog](../resources/glossary.md#data-catalog) automatically saves the datasets (in Parquet format) to the path specified next time the pipeline is run. There is no need to change any code in your preprocessing functions to accommodate this change.
+
+We chose the [Apache Parquet](https://github.com/apache/parquet-format) format for working with processed and typed data, and we recommend getting your data out of CSV as soon as possible. Parquet supports things like compression, partitioning and types out of the box. While you lose the ability to view the file as text, the benefits greatly outweigh the drawbacks.
+
+### Extend the data processing pipeline
+
+The next step in the tutorial is to add another node for a function that joins together the three datasets into a single model input table. You'll add some code for a function and node called `create_model_input_table`, which Kedro processes as follows:
+
+* Kedro uses the `preprocessed_shuttles`, `preprocessed_companies`, and `reviews` datasets as inputs
+* Kedro saves the output as a dataset called `model_input_table`
+
+First, add the `create_model_input_table()` function from the snippet below to `src/kedro_tutorial/pipelines/data_processing/nodes.py`.
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```python
+def create_model_input_table(
+    shuttles: pd.DataFrame, companies: pd.DataFrame, reviews: pd.DataFrame
+) -> pd.DataFrame:
+    """Combines all data to create a model input table.
+
+    Args:
+        shuttles: Preprocessed data for shuttles.
+        companies: Preprocessed data for companies.
+        reviews: Raw data for reviews.
+    Returns:
+        model input table.
+
+    """
+    rated_shuttles = shuttles.merge(reviews, left_on="id", right_on="shuttle_id")
+    model_input_table = rated_shuttles.merge(
+        companies, left_on="company_id", right_on="id"
+    )
+    model_input_table = model_input_table.dropna()
+    return model_input_table
+```
+
+</details>
+
+Add an import statement for `create_model_input_table` at the top of `src/kedro_tutorial/pipelines/data_processing/pipeline.py`:
+
+```python
+from .nodes import create_model_input_table, preprocess_companies, preprocess_shuttles
+```
+
+Add the code below to include the new node in the pipeline:
+
+```python
+node(
+    func=create_model_input_table,
+    inputs=["preprocessed_shuttles", "preprocessed_companies", "reviews"],
+    outputs="model_input_table",
+    name="create_model_input_table_node",
+),
+```
+
+
+### Optional: save the model input table
+
+If you want the model input table data to be saved to file (in `data/03_primary`) rather than used in memory, add an entry to `conf/base/catalog.yml`:
+
+```yaml
+model_input_table:
+  type: pandas.ParquetDataSet
+  filepath: data/03_primary/model_input_table.pq
+```
+
+### Test the example
+
+To test the progress of the example:
+
+```bash
+kedro run
+```
+
+You should see output similar to the following:
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+```bash
+[08/09/22 17:00:54] INFO     Kedro project kedro-tutorial                                         session.py:346
+[08/09/22 17:01:10] INFO     Reached after_catalog_created hook                                     plugin.py:17
+                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
+                    INFO     Running node: preprocess_companies_node:                                node.py:327
+                             preprocess_companies([companies]) -> [preprocessed_companies]
+                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
+                    INFO     Completed 1 out of 3 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
+[08/09/22 17:01:25] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
+                             -> [preprocessed_shuttles]
+
+                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
+                    INFO     Completed 2 out of 3 tasks                                  sequential_runner.py:85
+                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
+                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
+                    INFO     Loading data from 'reviews' (CSVDataSet)...                     data_catalog.py:343
+                    INFO     Running node: create_model_input_table_node:                            node.py:327
+                             create_model_input_table([preprocessed_shuttles,preprocessed_companies,
+                             reviews]) -> [model_input_table]
+[08/09/22 17:01:28] INFO     Saving data to 'model_input_table' (MemoryDataSet)...           data_catalog.py:382
+[08/09/22 17:01:29] INFO     Completed 3 out of 3 tasks                                  sequential_runner.py:85
+                    INFO     Pipeline execution completed successfully.                             runner.py:89
+                    INFO     Loading data from 'model_input_table' (MemoryDataSet)...        data_catalog.py:343
+```
+</details>
+
+## Checkpoint
+
+This is an excellent place to take a breath and summarise what you have done so far.
+
+![](../meta/images/coffee-cup.png)
+
+Photo by <a href="https://unsplash.com/@maltehelmhold">Malte Helmhold</a> on <a href="https://unsplash.com">Unsplash</a>
+
+
+* Created a new project and installed dependencies
+* Added three datasets to the project and set up the Kedro Data Catalog
+* Created a data processing pipeline with three nodes to transform and merge the input datasets and create a model input table
+
+The next step is to create the data science pipeline for spaceflight price prediction.
diff --git a/docs/source/tutorial/create_pipelines.md b/docs/source/tutorial/create_pipelines.md
deleted file mode 100644
index f1bf947d62..0000000000
--- a/docs/source/tutorial/create_pipelines.md
+++ /dev/null
@@ -1,610 +0,0 @@
-# Create a pipeline
-
-This section covers the third part of the [standard development workflow](./spaceflights_tutorial.md#kedro-project-development-workflow), and covers the following:
-
-* How to create each [node](../resources/glossary.md#node) required by the example
-* How to set up a [pipeline](../resources/glossary.md#pipeline)
-
-## Data processing pipeline
-
-You previously registered the raw datasets for your Kedro project, so you can now create nodes to pre-process two of the datasets, [companies.csv](https://github.com/kedro-org/kedro-starters/blob/main/spaceflights/%7B%7B%20cookiecutter.repo_name%20%7D%7D/data/01_raw/companies.csv) and [shuttles.xlsx](https://github.com/kedro-org/kedro-starters/blob/main/spaceflights/%7B%7B%20cookiecutter.repo_name%20%7D%7D/data/01_raw/shuttles.xlsx), to prepare the data for modelling.
-
-### Generate a new pipeline template
-
-In the terminal, run the following command:
-
-```bash
-kedro pipeline create data_processing
-```
-
-This command generates all the files you need to start to write a `data_processing` pipeline:
-* `nodes.py` and `pipeline.py` in the `src/kedro_tutorial/pipelines/data_processing` folder for the main node functions that form your pipeline
-* `conf/base/parameters/data_processing.yml` to define the parameters used when running the pipeline
-* `src/tests/pipelines/data_processing` for tests for your pipeline
-* `__init__.py` files in the required places to ensure that the pipeline can be imported by Python
-
-```bash
-
-├── README.md
-├── conf
-│   └── base
-│       └── parameters
-│           └── data_processing.yml
-└── src
-    ├── kedro_tutorial
-    │   ├── __init__.py
-    │   └── pipelines
-    │       ├── __init__.py
-    │       └── data_processing
-    │           ├── README.md
-    │           ├── __init__.py
-    │           ├── nodes.py
-    │           └── pipeline.py
-    └── tests
-        ├── __init__.py
-        └── pipelines
-            ├── __init__.py
-            └── data_processing
-                ├── __init__.py
-                └── test_pipeline.py
-```
-
-### Add node functions
-
-Open `src/kedro_tutorial/pipelines/data_processing/nodes.py` and add the code below, which provides two functions (`preprocess_companies` and `preprocess_shuttles`) that each take a raw DataFrame and output a DataFrame containing pre-processed data:
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```python
-import pandas as pd
-
-
-def _is_true(x: pd.Series) -> pd.Series:
-    return x == "t"
-
-
-def _parse_percentage(x: pd.Series) -> pd.Series:
-    x = x.str.replace("%", "")
-    x = x.astype(float) / 100
-    return x
-
-
-def _parse_money(x: pd.Series) -> pd.Series:
-    x = x.str.replace("$", "").str.replace(",", "")
-    x = x.astype(float)
-    return x
-
-
-def preprocess_companies(companies: pd.DataFrame) -> pd.DataFrame:
-    """Preprocesses the data for companies.
-
-    Args:
-        companies: Raw data.
-    Returns:
-        Preprocessed data, with `company_rating` converted to a float and
-        `iata_approved` converted to boolean.
-    """
-    companies["iata_approved"] = _is_true(companies["iata_approved"])
-    companies["company_rating"] = _parse_percentage(companies["company_rating"])
-    return companies
-
-
-def preprocess_shuttles(shuttles: pd.DataFrame) -> pd.DataFrame:
-    """Preprocesses the data for shuttles.
-
-    Args:
-        shuttles: Raw data.
-    Returns:
-        Preprocessed data, with `price` converted to a float and `d_check_complete`,
-        `moon_clearance_complete` converted to boolean.
-    """
-    shuttles["d_check_complete"] = _is_true(shuttles["d_check_complete"])
-    shuttles["moon_clearance_complete"] = _is_true(shuttles["moon_clearance_complete"])
-    shuttles["price"] = _parse_money(shuttles["price"])
-    return shuttles
-```
-
-</details>
-
-### Assemble nodes into the data processing pipeline
-
-The next steps are to create a [node](../resources/glossary.md#node) for each function, and to create a [modular pipeline](../resources/glossary.md#modular-pipeline) for data processing:
-
-Add the following to `src/kedro_tutorial/pipelines/data_processing/pipeline.py`, so the `create_pipeline()` function looks as follows:
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```python
-def create_pipeline(**kwargs) -> Pipeline:
-    return pipeline(
-        [
-            node(
-                func=preprocess_companies,
-                inputs="companies",
-                outputs="preprocessed_companies",
-                name="preprocess_companies_node",
-            ),
-            node(
-                func=preprocess_shuttles,
-                inputs="shuttles",
-                outputs="preprocessed_shuttles",
-                name="preprocess_shuttles_node",
-            ),
-        ]
-    )
-```
-
-</details>
-
-```{note}
-`companies` and `shuttles` refer to the datasets defined in `conf/base/catalog.yml`. These are inputs to the `preprocess_companies` and `preprocess_shuttles` functions. The named node inputs (and outputs) are used by the pipeline to determine interdependencies between the nodes, and hence, their execution order.
-```
-
-Be sure to import `node`, and your functions by adding them to the beginning of `pipeline.py`:
-
-```python
-from kedro.pipeline import Pipeline, node, pipeline
-
-from .nodes import preprocess_companies, preprocess_shuttles
-```
-
-### Test the example
-
-Run the following command in your terminal window to test the node named `preprocess_companies_node`:
-
-```bash
-kedro run --node=preprocess_companies_node
-```
-
-You should see output similar to the below:
-
-```bash
-[08/09/22 16:43:10] INFO     Kedro project kedro-tutorial                                         session.py:346
-[08/09/22 16:43:11] INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
-                    INFO     Running node: preprocess_companies_node:                                node.py:327
-                             preprocess_companies([companies]) -> [preprocessed_companies]
-                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
-                    INFO     Completed 1 out of 1 tasks                                  sequential_runner.py:85
-                    INFO     Pipeline execution completed successfully.                             runner.py:89
-                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
-
-```
-
-To test the entire data processing pipeline:
-
-```bash
-kedro run
-```
-
-You should see output similar to the following:
-
-```bash
-[08/09/22 16:45:46] INFO     Kedro project kedro-tutorial                                         session.py:346
-                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
-                    INFO     Running node: preprocess_companies_node:                                node.py:327
-                             preprocess_companies([companies]) -> [preprocessed_companies]
-                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
-                    INFO     Completed 1 out of 2 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
-[08/09/22 16:46:08] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
-                             -> [preprocessed_shuttles]
-                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
-                    INFO     Completed 2 out of 2 tasks                                  sequential_runner.py:85
-                    INFO     Pipeline execution completed successfully.                             runner.py:89
-                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
-                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
-
-```
-
-### Visualise the pipeline
-
-Kedro-Viz at this point will render a visualisation of a very simple, but valid, pipeline. To show the visualisation, run:
-
-```bash
-kedro viz
-```
-
-This command should open up a visualisation in your browser that looks like the following:
-
-![simple_pipeline](../meta/images/simple_pipeline.png)
-
-### Persist pre-processed data
-
-The nodes above each output a new dataset (`preprocessed_companies` and `preprocessed_shuttles`). When Kedro ran the pipeline, it determined that neither datasets had been registered in the data catalog (`conf/base/catalog.yml`). If a dataset is not registered, Kedro stores it in memory as a Python object using the [MemoryDataSet](/kedro.io.MemoryDataSet) class. Once all nodes depending on it have been executed, the `MemoryDataSet` is cleared and its memory released by the Python garbage collector.
-
-You can persist the preprocessed data by adding the following to `conf/base/catalog.yml`.:
-
-```yaml
-preprocessed_companies:
-  type: pandas.ParquetDataSet
-  filepath: data/02_intermediate/preprocessed_companies.pq
-
-preprocessed_shuttles:
-  type: pandas.ParquetDataSet
-  filepath: data/02_intermediate/preprocessed_shuttles.pq
-```
-
-The code above declares explicitly that [pandas.ParquetDataSet](/kedro.extras.datasets.pandas.ParquetDataSet) should be used instead of [`MemoryDataSet`](/kedro.io.MemoryDataSet).
-
-The [Data Catalog](../resources/glossary.md#data-catalog) will take care of saving the datasets automatically (in this case as Parquet) to the path specified next time the pipeline is run. There is no need to change any code in your preprocessing functions to accommodate this change.
-
-We choose the [Apache Parquet](https://github.com/apache/parquet-format) format for working with processed and typed data. We recommend getting your data out of CSV as soon as possible. Parquet supports things like compression, partitioning and types out of the box. Whilst you lose the ability to view the file as text, the benefits greatly outweigh the drawbacks.
-
-### Extend the data processing pipeline
-
-The next step in the tutorial is to add another node for a function to join together the three DataFrames into a single model input table. First, add the `create_model_input_table()` function from the snippet below to `src/kedro_tutorial/pipelines/data_processing/nodes.py`.
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```python
-def create_model_input_table(
-    shuttles: pd.DataFrame, companies: pd.DataFrame, reviews: pd.DataFrame
-) -> pd.DataFrame:
-    """Combines all data to create a model input table.
-
-    Args:
-        shuttles: Preprocessed data for shuttles.
-        companies: Preprocessed data for companies.
-        reviews: Raw data for reviews.
-    Returns:
-        model input table.
-
-    """
-    rated_shuttles = shuttles.merge(reviews, left_on="id", right_on="shuttle_id")
-    model_input_table = rated_shuttles.merge(
-        companies, left_on="company_id", right_on="id"
-    )
-    model_input_table = model_input_table.dropna()
-    return model_input_table
-```
-
-</details>
-
-Add the function to the data processing pipeline in `src/kedro_tutorial/pipelines/data_processing/pipeline.py` as a node:
-
-```python
-node(
-    func=create_model_input_table,
-    inputs=["preprocessed_shuttles", "preprocessed_companies", "reviews"],
-    outputs="model_input_table",
-    name="create_model_input_table_node",
-),
-```
-
-The code above informs Kedro that the function `create_model_input_table` should be called with the data loaded from datasets `preprocessed_shuttles`, `preprocessed_companies`, and `reviews` and the output should be saved to dataset `model_input_table`.
-
-Add an import statement for `create_model_input_table` at the top of the file:
-
-```python
-from .nodes import create_model_input_table, preprocess_companies, preprocess_shuttles
-```
-
-
-### Persist the model input table
-
-If you want the model input table data to be saved to file rather than used in-memory, add an entry to `conf/base/catalog.yml`:
-
-```yaml
-model_input_table:
-  type: pandas.ParquetDataSet
-  filepath: data/03_primary/model_input_table.pq
-```
-
-### Test the example
-
-To test the progress of the example:
-
-```bash
-kedro run
-```
-
-You should see output similar to the following:
-
-```bash
-[08/09/22 17:00:54] INFO     Kedro project kedro-tutorial                                         session.py:346
-[08/09/22 17:01:10] INFO     Reached after_catalog_created hook                                     plugin.py:17
-                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
-                    INFO     Running node: preprocess_companies_node:                                node.py:327
-                             preprocess_companies([companies]) -> [preprocessed_companies]
-                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
-                    INFO     Completed 1 out of 3 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
-[08/09/22 17:01:25] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
-                             -> [preprocessed_shuttles]
-
-                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
-                    INFO     Completed 2 out of 3 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
-                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
-                    INFO     Loading data from 'reviews' (CSVDataSet)...                     data_catalog.py:343
-                    INFO     Running node: create_model_input_table_node:                            node.py:327
-                             create_model_input_table([preprocessed_shuttles,preprocessed_companies,
-                             reviews]) -> [model_input_table]
-[08/09/22 17:01:28] INFO     Saving data to 'model_input_table' (MemoryDataSet)...           data_catalog.py:382
-[08/09/22 17:01:29] INFO     Completed 3 out of 3 tasks                                  sequential_runner.py:85
-                    INFO     Pipeline execution completed successfully.                             runner.py:89
-                    INFO     Loading data from 'model_input_table' (MemoryDataSet)...        data_catalog.py:343
-```
-### Use `kedro viz --autoreload`
-
-Run the following command:
-
-```bash
-kedro viz --autoreload
-```
-
-The `autoreload` flag will ensure that changes to your pipeline are automatically reflected in Kedro-Viz. For example, commenting out `create_model_input_table_node` in `pipeline.py` will trigger a re-render of the pipeline:
-
-![autoreload](../meta/images/autoreload.gif)
-
-```{note}
-This is also a great time to highlight how Kedro's [topological sorting](https://en.wikipedia.org/wiki/Topological_sorting) works. The actual order of the `node()` calls in the `pipeline` is irrelevant; Kedro works out the execution graph via the inputs/outputs declared, not the order provided by the user. This means that you, as a developer, simply ask Kedro what data you want and it will derive the execution graph automatically.
-```
-
-## Data science pipeline
-
-We have created a modular pipeline for data processing, which merges three input datasets to create a model input table. Now we will create the data science pipeline for price prediction, which uses the [`LinearRegression`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) implementation from the [scikit-learn](https://scikit-learn.org/stable/) library.
-
-### Create the data science pipeline
-
-Run the following command to create the `data_science` pipeline:
-```bash
-kedro pipeline create data_science
-```
-
-Add the following code to the `src/kedro_tutorial/pipelines/data_science/nodes.py` file:
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```python
-import logging
-from typing import Dict, Tuple
-
-import pandas as pd
-from sklearn.linear_model import LinearRegression
-from sklearn.metrics import r2_score
-from sklearn.model_selection import train_test_split
-
-
-def split_data(data: pd.DataFrame, parameters: Dict) -> Tuple:
-    """Splits data into features and targets training and test sets.
-
-    Args:
-        data: Data containing features and target.
-        parameters: Parameters defined in parameters/data_science.yml.
-    Returns:
-        Split data.
-    """
-    X = data[parameters["features"]]
-    y = data["price"]
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=parameters["test_size"], random_state=parameters["random_state"]
-    )
-    return X_train, X_test, y_train, y_test
-
-
-def train_model(X_train: pd.DataFrame, y_train: pd.Series) -> LinearRegression:
-    """Trains the linear regression model.
-
-    Args:
-        X_train: Training data of independent features.
-        y_train: Training data for price.
-
-    Returns:
-        Trained model.
-    """
-    regressor = LinearRegression()
-    regressor.fit(X_train, y_train)
-    return regressor
-
-
-def evaluate_model(
-    regressor: LinearRegression, X_test: pd.DataFrame, y_test: pd.Series
-):
-    """Calculates and logs the coefficient of determination.
-
-    Args:
-        regressor: Trained model.
-        X_test: Testing data of independent features.
-        y_test: Testing data for price.
-    """
-    y_pred = regressor.predict(X_test)
-    score = r2_score(y_test, y_pred)
-    logger = logging.getLogger(__name__)
-    logger.info("Model has a coefficient R^2 of %.3f on test data.", score)
-```
-
-</details>
-
-### Configure the input parameters
-
-Add the following to `conf/base/parameters/data_science.yml`:
-
-```yaml
-model_options:
-  test_size: 0.2
-  random_state: 3
-  features:
-    - engines
-    - passenger_capacity
-    - crew
-    - d_check_complete
-    - moon_clearance_complete
-    - iata_approved
-    - company_rating
-    - review_scores_rating
-```
-
-These are the parameters fed into the `DataCatalog` when the pipeline is executed. More information about [parameters](../kedro_project_setup/configuration.md#parameters) is available in later documentation for advanced usage. Here, the parameters `test_size` and `random_state` are used as part of the train-test split, and `features` gives the names of columns in the model input table to use as features.
-
-### Assemble the data science pipeline
-
-To create a modular pipeline for the price prediction model, add the following to the top of `src/kedro_tutorial/pipelines/data_science/pipeline.py`:
-
-```python
-from kedro.pipeline import Pipeline, node, pipeline
-
-from .nodes import evaluate_model, split_data, train_model
-
-
-def create_pipeline(**kwargs) -> Pipeline:
-    return pipeline(
-        [
-            node(
-                func=split_data,
-                inputs=["model_input_table", "params:model_options"],
-                outputs=["X_train", "X_test", "y_train", "y_test"],
-                name="split_data_node",
-            ),
-            node(
-                func=train_model,
-                inputs=["X_train", "y_train"],
-                outputs="regressor",
-                name="train_model_node",
-            ),
-            node(
-                func=evaluate_model,
-                inputs=["regressor", "X_test", "y_test"],
-                outputs=None,
-                name="evaluate_model_node",
-            ),
-        ]
-    )
-```
-
-### Register the dataset
-
-The next step is to register the dataset that will save the trained model, by adding the following definition to `conf/base/catalog.yml`:
-
-```yaml
-regressor:
-  type: pickle.PickleDataSet
-  filepath: data/06_models/regressor.pickle
-  versioned: true
-```
-
-Versioning is enabled for `regressor`, which means that the pickled output of the `regressor` will be versioned and saved every time the pipeline is run. This allows us to keep the history of the models built using this pipeline. Further details can be found in the [Versioning section](../data/kedro_io.md#versioning).
-
-### Test the pipelines
-
-Execute the default pipeline:
-
-```bash
-kedro run
-```
-
-You should see output similar to the following:
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```bash
-[08/09/22 16:56:00] INFO     Kedro project kedro-tutorial                                         session.py:346
-                    INFO     Loading data from 'companies' (CSVDataSet)...                   data_catalog.py:343
-                    INFO     Running node: preprocess_companies_node:                                node.py:327
-                             preprocess_companies([companies]) -> [preprocessed_companies]
-                    INFO     Saving data to 'preprocessed_companies' (MemoryDataSet)...      data_catalog.py:382
-                    INFO     Completed 1 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'shuttles' (ExcelDataSet)...                  data_catalog.py:343
-[08/09/22 16:56:15] INFO     Running node: preprocess_shuttles_node: preprocess_shuttles([shuttles]) node.py:327
-                             -> [preprocessed_shuttles]
-                    INFO     Saving data to 'preprocessed_shuttles' (MemoryDataSet)...       data_catalog.py:382
-                    INFO     Completed 2 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'preprocessed_shuttles' (MemoryDataSet)...    data_catalog.py:343
-                    INFO     Loading data from 'preprocessed_companies' (MemoryDataSet)...   data_catalog.py:343
-                    INFO     Loading data from 'reviews' (CSVDataSet)...                     data_catalog.py:343
-                    INFO     Running node: create_model_input_table_node:                            node.py:327
-                             create_model_input_table([preprocessed_shuttles,preprocessed_companies,
-                             reviews]) -> [model_input_table]
-[08/09/22 16:56:18] INFO     Saving data to 'model_input_table' (MemoryDataSet)...           data_catalog.py:382
-[08/09/22 16:56:19] INFO     Completed 3 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'model_input_table' (MemoryDataSet)...        data_catalog.py:343
-                    INFO     Loading data from 'params:model_options' (MemoryDataSet)...     data_catalog.py:343
-                    INFO     Running node: split_data_node:                                          node.py:327
-                             split_data([model_input_table,params:model_options]) ->
-                             [X_train,X_test,y_train,y_test]
-                    INFO     Saving data to 'X_train' (MemoryDataSet)...                     data_catalog.py:382
-                    INFO     Saving data to 'X_test' (MemoryDataSet)...                      data_catalog.py:382
-                    INFO     Saving data to 'y_train' (MemoryDataSet)...                     data_catalog.py:382
-                    INFO     Saving data to 'y_test' (MemoryDataSet)...                      data_catalog.py:382
-                    INFO     Completed 4 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'X_train' (MemoryDataSet)...                  data_catalog.py:343
-                    INFO     Loading data from 'y_train' (MemoryDataSet)...                  data_catalog.py:343
-                    INFO     Running node: train_model_node: train_model([X_train,y_train]) ->       node.py:327
-                             [regressor]
-[08/09/22 16:56:20] INFO     Saving data to 'regressor' (PickleDataSet)...                   data_catalog.py:382
-                    INFO     Completed 5 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Loading data from 'regressor' (PickleDataSet)...                data_catalog.py:343
-                    INFO     Loading data from 'X_test' (MemoryDataSet)...                   data_catalog.py:343
-                    INFO     Loading data from 'y_test' (MemoryDataSet)...                   data_catalog.py:343
-                    INFO     Running node: evaluate_model_node:                                      node.py:327
-                             evaluate_model([regressor,X_test,y_test]) -> None
-                    INFO     Model has a coefficient R^2 of 0.462 on test data.                      nodes.py:55
-                    INFO     Completed 6 out of 6 tasks                                  sequential_runner.py:85
-                    INFO     Pipeline execution completed successfully.                             runner.py:89
-```
-
-</details>
-
-## Kedro runners
-
-There are three different Kedro runners that can run the pipeline:
-
-* `SequentialRunner` - runs your nodes sequentially; once a node has completed its task then the next one starts.
-* `ParallelRunner` - runs your nodes in parallel; independent nodes are able to run at the same time, which is more efficient when there are independent branches in your pipeline and allows you to take advantage of multiple CPU cores.
-* `ThreadRunner` - runs your nodes in parallel, similarly to `ParallelRunner`, but uses multithreading instead of multiprocessing.
-
-By default, Kedro uses a `SequentialRunner`, which is instantiated when you execute `kedro run` from the command line. If you decide to use `ParallelRunner`, `ThreadRunner` or a custom runner, you can do so through the `--runner` flag as follows:
-
-```bash
-kedro run --runner=ParallelRunner
-kedro run --runner=ThreadRunner
-kedro run --runner=module.path.to.my.runner
-```
-
-```{note}
-`ParallelRunner` performs task parallelisation via multiprocessing. `ThreadRunner` is intended for use with remote execution engines such as [Spark](../tools_integration/pyspark.md) and [Dask](https://github.com/kedro-org/kedro/blob/develop/kedro/extras/datasets/dask/parquet_dataset.py). You can find out more about the runners Kedro provides, and how to create your own, in the [pipeline documentation about runners](../nodes_and_pipelines/run_a_pipeline.md).
-```
-
-You can find out more about the runners Kedro provides, and how to create your own, in the [pipeline documentation about runners](../nodes_and_pipelines/run_a_pipeline.md).
-
-## Slice a pipeline
-
-In some cases you may want to run just part of a pipeline. For example, you may need to only run the data science pipeline to tune the hyperparameters of the price prediction model and skip data processing execution. You can 'slice' the pipeline and specify just the portion you want to run by using the `--pipeline` command line option. For example, to only run the pipeline named `data_science` (as labelled automatically in `register_pipelines`), execute the following command:
-
-```bash
-kedro run --pipeline=data_science
-```
-
-See the [pipeline slicing documentation](../nodes_and_pipelines/slice_a_pipeline.md) and the ``kedro run`` [CLI documentation](../development/commands_reference.md#modifying-a-kedro-run) for other ways to run sections of your pipeline.
-
-```{warning}
-To successfully run the pipeline, you need to make sure that all required input datasets already exist, otherwise you may get an error similar to this:
-```
-
-```bash
-kedro run --pipeline=data_science
-
-2019-10-04 12:36:12,135 - root - INFO - ** Kedro project kedro-tutorial
-2019-10-04 12:36:12,158 - kedro.io.data_catalog - INFO - Loading data from `model_input_table` (CSVDataSet)...
-2019-10-04 12:36:12,158 - kedro.runner.sequential_runner - WARNING - There are 3 nodes that have not run.
-You can resume the pipeline run with the following command:
-kedro run
-Traceback (most recent call last):
-  ...
-  File "pandas/_libs/parsers.pyx", line 382, in pandas._libs.parsers.TextReader.__cinit__
-  File "pandas/_libs/parsers.pyx", line 689, in pandas._libs.parsers.TextReader._setup_parser_source
-FileNotFoundError: [Errno 2] File b'data/03_primary/model_input_table.csv' does not exist: b'data/03_primary/model_input_table.csv'
-
-The above exception was the direct cause of the following exception:
-
-Traceback (most recent call last):
-  ...
-    raise DataSetError(message) from exc
-kedro.io.core.DataSetError: Failed while loading data from data set CSVDataSet(filepath=data/03_primary/model_input_table.csv, save_args={'index': False}).
-[Errno 2] File b'data/03_primary/model_input_table.csv' does not exist: b'data/03_primary/model_input_table.csv'
-```
diff --git a/docs/source/tutorial/namespace_pipelines.md b/docs/source/tutorial/namespace_pipelines.md
deleted file mode 100644
index bc696398f2..0000000000
--- a/docs/source/tutorial/namespace_pipelines.md
+++ /dev/null
@@ -1,310 +0,0 @@
-# Namespace pipelines
-
-This section covers the following:
-
-* A brief introduction to namespaces and modular pipelines
-* How to convert the existing spaceflights project into a namespaced one
-
-Add namespaces to [modular pipelines](../nodes_and_pipelines/modular_pipelines.md) to unlock some sophisticated functionality in Kedro.
-
-1. You can [instantiate the same pipeline structure multiple times](../nodes_and_pipelines/modular_pipelines.md), but provide different inputs/outputs.
-2. You can unlock the full power of [micro-packaging](../nodes_and_pipelines/micro_packaging.md).
-3. You can de-clutter your mental model with Kedro-Viz rendering collapsible components.
-
-    ![collapsible](../meta/images/collapsible.gif)
-
-## Adding a namespace to the  `data_processing` pipeline
-
-* Update the code in `src/kedro_tutorial/pipelines/data_processing/pipeline.py` using the snippet below.
-* This introduces the lowercase `pipeline()` method imported from `kedro.pipeline.modular_pipeline`.
-
-    <details>
-    <summary><b>Click to expand</b></summary>
-
-    ```python
-    from kedro.pipeline import Pipeline, node
-    from kedro.pipeline.modular_pipeline import pipeline
-
-    from .nodes import (
-        preprocess_companies,
-        preprocess_shuttles,
-        create_model_input_table,
-    )
-
-
-    def create_pipeline(**kwargs) -> Pipeline:
-        return pipeline(
-            [
-                node(
-                    func=preprocess_companies,
-                    inputs="companies",
-                    outputs="preprocessed_companies",
-                    name="preprocess_companies_node",
-                ),
-                node(
-                    func=preprocess_shuttles,
-                    inputs="shuttles",
-                    outputs="preprocessed_shuttles",
-                    name="preprocess_shuttles_node",
-                ),
-                node(
-                    func=create_model_input_table,
-                    inputs=["preprocessed_shuttles", "preprocessed_companies", "reviews"],
-                    outputs="model_input_table",
-                    name="create_model_input_table_node",
-                ),
-            ],
-            namespace="data_processing",
-            inputs=["companies", "shuttles", "reviews"],
-            outputs="model_input_table",
-        )
-    ```
-
-    </details>
-
-* Append the `data_processing` namespace to the catalog entries for `preprocessed_shuttles` and `preprocessed_companies`. This is to ensure both datasets are still persisted when running the pipeline.
-
-### Why must we provide explicit inputs and outputs?
-
-* When introducing a namespace, you must tell Kedro which inputs/outputs live at the 'edges' of the namespace
-* If you fail to do so in this situation, Kedro thinks that `companies` and `data_processing.companies` are two different datasets.
-* Highlighting 'focus mode' Kedro-Viz highlights how the **explicitly declared** inputs/outputs live outside of the collapsed part of the namespace. `model_input_table` in particular is shared across both pipelines and thus must be outside of the `Data Processing` namespace.
-
-    ![focus](../meta/images/focus_mode.png)
-
-> As an experiment, remove the explicit inputs and outputs from your `namespaced_pipeline` and see how this creates a disjointed pipeline visualisation.
-
-## Adding namespaces to the  `data_science` pipeline
-
-In this section, we want to add some namespaces in the modelling component of the pipeline, and also highlight the power of instantiating the same modular pipeline multiple times with different parameters.
-
-1. Update the parameters file `conf/base/parameters/data_science.yml` with this snippet:
-
-    ```yaml
-
-    active_modelling_pipeline:
-        model_options:
-          test_size: 0.2
-          random_state: 3
-          features:
-            - engines
-            - passenger_capacity
-            - crew
-            - d_check_complete
-            - moon_clearance_complete
-            - iata_approved
-            - company_rating
-            - review_scores_rating
-
-    candidate_modelling_pipeline:
-        model_options:
-          test_size: 0.2
-          random_state: 8
-          features:
-            - engines
-            - passenger_capacity
-            - crew
-            - review_scores_rating
-
-    ```
-
-2. Update your catalog to reflect the new namespaced outputs. Replace the `regressor` key with the following two new dataset keys in the `conf/base/catalog.yml` file:
-
-    ```yaml
-
-    active_modelling_pipeline.regressor:
-      type: pickle.PickleDataSet
-      filepath: data/06_models/regressor_active.pickle
-      versioned: true
-      layer: models
-
-    candidate_modelling_pipeline.regressor:
-      type: pickle.PickleDataSet
-      filepath: data/06_models/regressor_candidate.pickle
-      versioned: true
-      layer: models
-
-    ```
-
-3. Update the code in the `pipelines/data_science/pipeline.py` file with the snippet below:
-
-    <details>
-    <summary><b>Click to expand</b></summary>
-
-    ```python
-    from kedro.pipeline import Pipeline, node
-    from kedro.pipeline.modular_pipeline import pipeline
-
-    from .nodes import evaluate_model, split_data, train_model
-
-
-    def create_pipeline(**kwargs) -> Pipeline:
-        pipeline_instance = pipeline(
-            [
-                node(
-                    func=split_data,
-                    inputs=["model_input_table", "params:model_options"],
-                    outputs=["X_train", "X_test", "y_train", "y_test"],
-                    name="split_data_node",
-                ),
-                node(
-                    func=train_model,
-                    inputs=["X_train", "y_train"],
-                    outputs="regressor",
-                    name="train_model_node",
-                ),
-                node(
-                    func=evaluate_model,
-                    inputs=["regressor", "X_test", "y_test"],
-                    outputs=None,
-                    name="evaluate_model_node",
-                ),
-            ]
-        )
-        ds_pipeline_1 = pipeline(
-            pipe=pipeline_instance,
-            inputs="model_input_table",
-            namespace="active_modelling_pipeline",
-        )
-        ds_pipeline_2 = pipeline(
-            pipe=pipeline_instance,
-            inputs="model_input_table",
-            namespace="candidate_modelling_pipeline",
-        )
-
-        return ds_pipeline_1 + ds_pipeline_2
-    ```
-
-    </details>
-
-### Let's explain what's going on here
-
-Modular pipelines allow you to instantiate multiple instances of pipelines with static structure, but dynamic inputs/outputs/parameters.
-
-```python
-pipeline_instance = pipeline(...)
-
-ds_pipeline_1 = pipeline(
-    pipe=pipeline_instance,
-    inputs="model_input_table",
-    namespace="active_modelling_pipeline",
-)
-
-ds_pipeline_2 = pipeline(
-    pipe=pipeline_instance,
-    inputs="model_input_table",
-    namespace="candidate_modelling_pipeline",
-)
-```
-
-> The `pipeline_instance` variable is our 'template' pipeline, `ds_pipeline_1` and `ds_pipeline_2` are our parameterised instantiations.
-
-The table below describes the purpose of each keyword argument in detail:
-
-| Keyword argument | `ds_pipeline_1`                                                                         | `ds_pipeline_2`              |
-| ---------------- | --------------------------------------------------------------------------------------- | ---------------------------- |
-| `inputs`         | Declaring `model_input_table` as a boundary input will not prefix it with the namespace | Same as `ds_pipeline_1`      |
-| `outputs`        | No outputs are at the boundary of this pipeline so nothing to list here                 | Same as `ds_pipeline_1`      |
-| `namespace`      | A unique namespace                                                                      | A different unique namespace |
-
-## Nesting modular pipelines
-
-* Modular pipelines can be nested an arbitrary number of times
-* This can be an effective pattern for simplifying your mental model, and to reduce visual noise
-* Namespaces will be chained using the `.` syntax, just like your `import` modules in Python
-* To wrap your two modelling pipeline instances quickly under one 'Data science' namespace, add the following to your `pipelines/data_science/pipeline.py` return statement:
-
-    ```python
-    ...
-    return pipeline(
-        pipe=ds_pipeline_1 + ds_pipeline_2,
-        inputs="model_input_table",
-        namespace="data_science",
-    )
-    ```
-
-  * As we've created an outer namespace `data_science`, we'll add the `data_science` prefix to our catalog entries for the `regressor` datasets. Additionally, you must add the `data_science` prefix at the top level of your parameter file `data_science.yml` and indent the other entries. The complete `catalog.yml` and `data_science.yml` parameter files should look like the below:
-
-    <details>
-    <summary><b>Click to expand</b></summary>
-
-    `catalog.yml`
-    ```yaml
-    companies:
-      type: pandas.CSVDataSet
-      filepath: data/01_raw/companies.csv
-      # more about layers in the Data Engineering Convention:
-      # https://kedro.readthedocs.io/en/stable/tutorial/visualise_pipeline.html#interact-with-data-engineering-convention
-      layer: raw
-
-    reviews:
-      type: pandas.CSVDataSet
-      filepath: data/01_raw/reviews.csv
-      layer: raw
-
-    shuttles:
-      type: pandas.ExcelDataSet
-      filepath: data/01_raw/shuttles.xlsx
-      layer: raw
-
-    data_processing.preprocessed_companies:
-      type: pandas.ParquetDataSet
-      filepath: data/02_intermediate/preprocessed_companies.pq
-      layer: intermediate
-
-    data_processing.preprocessed_shuttles:
-      type: pandas.ParquetDataSet
-      filepath: data/02_intermediate/preprocessed_shuttles.pq
-      layer: intermediate
-
-    model_input_table:
-      type: pandas.ParquetDataSet
-      filepath: data/03_primary/model_input_table.pq
-      layer: primary
-
-    data_science.active_modelling_pipeline.regressor:
-      type: pickle.PickleDataSet
-      filepath: data/06_models/regressor_active.pickle
-      versioned: true
-      layer: models
-
-    data_science.candidate_modelling_pipeline.regressor:
-      type: pickle.PickleDataSet
-      filepath: data/06_models/regressor_candidate.pickle
-      versioned: true
-      layer: models
-    ```
-
-    `parameters/data_science.yml`
-    ```yaml
-      data_science:
-          active_modelling_pipeline:
-            model_options:
-              test_size: 0.2
-              random_state: 3
-              features:
-                - engines
-                - passenger_capacity
-                - crew
-                - d_check_complete
-                - moon_clearance_complete
-                - iata_approved
-                - company_rating
-                - review_scores_rating
-
-          candidate_modelling_pipeline:
-            model_options:
-              test_size: 0.2
-              random_state: 8
-              features:
-                - engines
-                - passenger_capacity
-                - crew
-                - review_scores_rating
-    ```
-
-    </details>
-
-    This renders as follows:
-
-    ![modular_ds](../meta/images/modular_ds.gif)
diff --git a/docs/source/tutorial/package_a_project.md b/docs/source/tutorial/package_a_project.md
index 0af566334d..e9eea49f8f 100644
--- a/docs/source/tutorial/package_a_project.md
+++ b/docs/source/tutorial/package_a_project.md
@@ -1,46 +1,67 @@
-# Package a project
+# Package an entire Kedro project
+
+This section explains how to build your project documentation, and how to bundle your entire project into a Python package.
+
+Kedro also has an advanced feature which supports packaging on a pipeline level allowing you share and reuse pipelines across projects! To read more about this please look at the [section on micro-packaging](../nodes_and_pipelines/micro_packaging.md).
 
-This section explains how to build your project documentation, and how to bundle your project into a Python package.
 
 ## Add documentation to your project
 
-To generate project-specific documentation, run `kedro build-docs` in the project's root directory. Kedro builds the resulting HTML files in `docs/build/html/`. To browse the documentation generated, open `docs/build/html/index.html` in your browser, or run `kedro build-docs --open` to open the documentation automatically after it builds.
+Kedro uses the [Sphinx framework](https://www.sphinx-doc.org) and creates a `docs` directory that builds a basic template for project-specific documentation. We recommend that you add your project-specific documentation as markdown in `docs/source`
 
-The `build-docs` command creates documentation based on the code structure of your project. Documentation includes any [`docstrings`](https://datacamp.com/community/tutorials/docstrings-python) defined in your code.
+If you want to customise your documentation beyond the basic template, refer to the [Sphinx documentation](https://www.sphinx-doc.org/en/master/usage/configuration.html) for details of how to extend `docs/source/conf.py`.
+
+Once you have added any documentation you need, run the following from the project root directory:
+
+```bash
+kedro build-docs --open
+```
 
-Kedro uses the [Sphinx framework](https://www.sphinx-doc.org), so if you want to customise your documentation, please refer to `docs/source/conf.py` and the [corresponding section of the Sphinx documentation](https://www.sphinx-doc.org/en/master/usage/configuration.html).
+The HTML documention is built to `docs/build/html` and opens automatically in a browser tab.
+
+```{note}
+The `build-docs` command creates documentation based on the code structure of your project. Documentation includes any [`docstrings`](https://datacamp.com/community/tutorials/docstrings-python) defined in your code.
+```
 
 
 ## Package your project
 
-To package your project, run the following in your project's root directory:
+To package your project, run the following in your project root directory:
 
 ```bash
 kedro package
 ```
 
-Kedro builds the package into the `dist/` folder of your project, and creates one `.egg` file and one `.whl` file, which are [Python packaging formats for binary distribution](https://packaging.python.org/).
+Kedro builds the package into the `dist` folder of your project, and creates one `.egg` file and one `.whl` file, which are [Python packaging formats for binary distribution](https://packaging.python.org/).
+
+The resulting package only contains the Python source code of your Kedro pipeline, not any of the `conf`, `data` and `logs` subfolders. This means that you can distribute the project to run elsewhere, such as on a separate computer with different configuration information, dataset and logging locations.
 
-The resulting package only contains the Python source code of your Kedro pipeline, not any of the `conf/`, `data/` and `logs/` subfolders. This means that you can distribute the project to run elsewhere, such as on a separate computer with different configuration, data and logging. When distributed, the packaged project must be run from within a directory that contains the `conf/` subfolder (and `data/` and `logs/` if your pipeline loads/saves local data or uses logging).
+We recommend that you document the configuration required (parameters and catalog) in the local `README.md` file for any project recipients.
 
-Recipients of the `.egg` and `.whl` files need to have Python and `pip` on their machines, but do not need to have Kedro installed. The project is installed to the root of a folder with the relevant `conf/`, `data/` and `logs/` subfolders, by navigating to the root and calling:
+### Package recipients
+
+Recipients of the `.egg` and `.whl` files need to have Python and `pip` on their machines, but do not need to have Kedro installed.
+
+A recipient can install the project by calling:
 
 ```bash
 pip install <path-to-wheel-file>
 ```
 
-For example, having installed project `kedro-spaceflights` and package `kedro_spaceflights`, a recipient can run the Kedro project as follows from the root of the project:
+An executable, `kedro-tutorial`, is placed in the `bin` subfolder of the Python install folder, so the project can be run as follows:
 
 ```bash
-python -m kedro_spaceflights
+python -m kedro_tutorial
 ```
 
-An executable, `kedro-spaceflights`, is also placed in the `bin/` subfolder of the Python installation location.
+```{note}
+The recipient will need to add a `conf` subfolder. They also need to add `data` and `logs` if the pipeline loads/saves local data or uses logging.
+```
 
 Once your project is installed, to run your pipelines from any Python code, simply import it:
 
 ```python
-from kedro_spaceflights.__main__ import main
+from kedro_tutorial.__main__ import main
 
 main(
     ["--pipeline", "__default__"]
@@ -49,10 +70,10 @@ main(
 
 This is equivalent to running `kedro run`, and you can provide all the parameters described by `kedro run --help`.
 
-### Docker, Airflow and Deployment
+### Docker, Airflow and other deployment targets
 
-There are several methods to deploy packaged pipelines via 1st party plugins and associated documentation:
+There are various methods to deploy packaged pipelines via Kedro plugins:
 
 * [Kedro-Docker](https://github.com/kedro-org/kedro-plugins/tree/main/kedro-docker) plugin for packaging and shipping Kedro projects within [Docker](https://www.docker.com/) containers.
 * [Kedro-Airflow](https://github.com/kedro-org/kedro-plugins/tree/main/kedro-airflow) to convert your Kedro project into an [Airflow](https://airflow.apache.org/) project.
-* The [Deployment guide](../deployment/deployment_guide) touches on other deployment targets such as AWS Batch and Prefect.
+* The [Deployment guide](../deployment/deployment_guide) touches on other deployment targets such as AWS Batch and Prefect, and there is a [range of third-party plugins for deployment](extend_kedro/plugins.md#community-developed-plugins).
diff --git a/docs/source/tutorial/set_up_data.md b/docs/source/tutorial/set_up_data.md
index 9608321929..9e53d71775 100644
--- a/docs/source/tutorial/set_up_data.md
+++ b/docs/source/tutorial/set_up_data.md
@@ -1,94 +1,46 @@
 # Set up the data
 
-In this section, we discuss the data set-up phase, which is the second part of the [standard development workflow](./spaceflights_tutorial.md#kedro-project-development-workflow). The steps are as follows:
-
-* Add datasets to your `data/` folder, according to [data engineering convention](../faq/faq.md#what-is-data-engineering-convention)
-* Register the datasets with the Data Catalog in `conf/base/catalog.yml`, which is the registry of all data sources available for use by the project. This ensures that your code is reproducible when it references datasets in different locations and/or environments.
-
-You can find further information about the [Data Catalog](../data/data_catalog.md) in specific documentation covering advanced usage.
-
-
-## Add your datasets to `data`
-
-The spaceflights tutorial makes use of fictional datasets of companies shuttling customers to the Moon and back. You will use the data to train a model to predict the price of shuttle hire. However, before you get to train the model, you will need to prepare the data for model building by creating a model input table.
-
-The spaceflight tutorial has three files and uses two data formats: `.csv` and `.xlsx`. Download and save the files to the `data/01_raw/` folder of your project directory:
-
-* [reviews.csv](https://kedro-org.github.io/kedro/reviews.csv)
-* [companies.csv](https://kedro-org.github.io/kedro/companies.csv)
-* [shuttles.xlsx](https://kedro-org.github.io/kedro/shuttles.xlsx)
-
-Here are some examples of how you can [download the files from GitHub](https://www.quora.com/How-do-I-download-something-from-GitHub) to the `data/01_raw` directory inside your project:
-
-Using [cURL in a Unix terminal](https://curl.se/download.html):
-
-<details>
-<summary><b>Click to expand</b></summary>
-
-```bash
-# reviews
-curl -o data/01_raw/reviews.csv https://kedro-org.github.io/kedro/reviews.csv
-# companies
-curl -o data/01_raw/companies.csv https://kedro-org.github.io/kedro/companies.csv
-# shuttles
-curl -o data/01_raw/shuttles.xlsx https://kedro-org.github.io/kedro/shuttles.xlsx
+```{note}
+Don't forget to check the [tutorial FAQ](spaceflights_tutorial_faqs.md) if you run into problems, or [ask the community for help](spaceflights_tutorial.md#get-help) if you need it!
 ```
-</details>
 
-Using [cURL for Windows](https://curl.se/windows/):
+In this section, we discuss the data setup phase, which is the second part of the standard development workflow. The steps are as follows:
 
-<details>
-<summary><b>Click to expand</b></summary>
+* Add datasets to your `data` folder, according to [data engineering convention](../faq/faq.md#what-is-data-engineering-convention)
+* Register the datasets with the Kedro Data Catalog in `conf/base/catalog.yml`, which is the registry of all data sources available for use by the project. This ensures that your code is reproducible when it references datasets in different locations and/or environments.
 
-```bat
-curl -o data\01_raw\reviews.csv https://kedro-org.github.io/kedro/reviews.csv
-curl -o data\01_raw\companies.csv https://kedro-org.github.io/kedro/companies.csv
-curl -o data\01_raw\shuttles.xlsx https://kedro-org.github.io/kedro/shuttles.xlsx
-```
-</details>
+You can find further information about the [Data Catalog](../data/data_catalog.md) in specific documentation covering advanced usage.
 
-Using [Wget in a Unix terminal](https://www.gnu.org/software/wget/):
+```{note}
+If you are using the tutorial created by the spaceflights starter, you can omit the copy/paste steps below, but it is worth reviewing the files described.
+```
 
-<details>
-<summary><b>Click to expand</b></summary>
+## Download datasets
 
-```bash
-# reviews
-wget -O data/01_raw/reviews.csv https://kedro-org.github.io/kedro/reviews.csv
-# companies
-wget -O data/01_raw/companies.csv https://kedro-org.github.io/kedro/companies.csv
-# shuttles
-wget -O data/01_raw/shuttles.xlsx https://kedro-org.github.io/kedro/shuttles.xlsx
-```
-</details>
+The spaceflights tutorial makes use of three fictional datasets of companies shuttling customers to the Moon and back. The data comes in two different formats: `.csv` and `.xlsx`:
 
-Using [Wget for Windows](https://eternallybored.org/misc/wget/):
+* `companies.csv` contains data about space travel companies, such as their location, fleet count and rating
+* `reviews.csv` is a set of reviews from customers for categories, such as comfort and price
+* `shuttles.xlsx` is a set of attributes for spacecraft across the fleet, such as their engine type and passenger capacity
 
-<details>
-<summary><b>Click to expand</b></summary>
+Download and save the files to the `data/01_raw` folder of your project:
 
-```bat
-wget -O data\01_raw\reviews.csv https://kedro-org.github.io/kedro/reviews.csv
-wget -O data\01_raw\companies.csv https://kedro-org.github.io/kedro/companies.csv
-wget -O data\01_raw\shuttles.xlsx https://kedro-org.github.io/kedro/shuttles.xlsx
-```
-</details>
+* [companies.csv](https://kedro-org.github.io/kedro/companies.csv)
+* [reviews.csv](https://kedro-org.github.io/kedro/reviews.csv)
+* [shuttles.xlsx](https://kedro-org.github.io/kedro/shuttles.xlsx)
 
 ## Register the datasets
 
-You now need to register the datasets so they can be loaded by Kedro. All Kedro projects have a `conf/base/catalog.yml` file, and you register each dataset by adding a named entry into the `.yml` file. The entry should include the following:
+You now need to register the datasets so they can be loaded by Kedro. All Kedro projects have a `conf/base/catalog.yml` file, and you register each dataset by adding a named entry into the `.yml` file that includes the following:
 
 * File location (path)
 * Parameters for the given dataset
 * Type of data
 * Versioning
 
-Kedro supports a number of different data types, and those supported can be found in the API documentation. Kedro uses [`fssspec`](https://filesystem-spec.readthedocs.io/en/latest/) to read data from a variety of data stores including local file systems, network file systems, cloud object stores and HDFS.
-
+### Register `csv` data
 
-### `csv`
-
-For the spaceflights data, first register the `csv` datasets by adding this snippet to the end of the `conf/base/catalog.yml` file:
+First, for the spaceflights data, register the two `csv` datasets by adding this snippet to the end of the `conf/base/catalog.yml` file and saving it:
 
 ```yaml
 companies:
@@ -100,56 +52,83 @@ reviews:
   filepath: data/01_raw/reviews.csv
 ```
 
-To check whether Kedro can load the data correctly, open a `kedro ipython` session and run:
+### Register `xlsx` data
 
-```python
-companies = catalog.load("companies")
-companies.head()
-```
+Now register the `xlsx` dataset by adding this snippet to the end of the `conf/base/catalog.yml` file, and saving it:
 
-```{note}
-If this is the first `kedro` command you have executed in the project, you will be asked whether you wish to opt into [usage analytics](https://github.com/quantumblacklabs/kedro-telemetry). Your decision is recorded in the `.telemetry` file so that subsequent calls to `kedro` in this project do not ask you again.
+```yaml
+shuttles:
+  type: pandas.ExcelDataSet
+  filepath: data/01_raw/shuttles.xlsx
+  load_args:
+    engine: openpyxl # Use modern Excel engine (the default since Kedro 0.18.0)
 ```
 
-The command loads the dataset named `companies` (as per top-level key in `catalog.yml`) from the underlying filepath `data/01_raw/companies.csv` into the variable `companies`, which is of type `pandas.DataFrame`. The `head` method from `pandas` then displays the first five rows of the DataFrame.
+This registration has an additional line: `load_args`, which is passed to the excel file read method (`pd.read_excel`) as a [keyword argument](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html). Although not specified here, the equivalent output is `save_args` and the value would be passed to [`pd.DataFrame.to_excel` method](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_excel.html).
 
-When you have finished, close `ipython` session as follows:
+### Test that Kedro can load the `csv` data
 
-```python
-exit()
-```
+Open a `kedro ipython` session in your terminal from the project root directory:
 
-### `xlsx`
+```bash
+kedro ipython
+```
 
-Now register the `xlsx` dataset by adding this snippet to the end of the `conf/base/catalog.yml` file:
+Then type the following into the IPython prompt:
 
-```yaml
-shuttles:
-  type: pandas.ExcelDataSet
-  filepath: data/01_raw/shuttles.xlsx
-  load_args:
-    engine: openpyxl # Use modern Excel engine, it is the default since Kedro 0.18.0
+```python
+companies = catalog.load("companies")
+companies.head()
 ```
 
-```{note}
+* The first command creates a variable (`companies`), which is of type `pandas.DataFrame` and loads the dataset (also named `companies` as per top-level key in `catalog.yml`) from the underlying filepath `data/01_raw/companies.csv`.
+* The `head` method from `pandas` displays the first five rows of the DataFrame.
 
- The `load_args` are passed to the `pd.read_excel` method as [keyword arguments](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html); although not specified here, `save_args` would be passed to the [`pd.DataFrame.to_excel` method](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_excel.html).
 ```
+INFO     Loading data from 'companies' (CSVDataSet)
+Out[1]:
+      id company_rating       company_location  total_fleet_count iata_approved
+0  35029           100%                   Niue                4.0             f
+1  30292            67%               Anguilla                6.0             f
+2  19032            67%     Russian Federation                4.0             f
+3   8238            91%               Barbados               15.0             t
+4  30342            NaN  Sao Tome and Principe                2.0             t
 
-To test that everything works as expected, load the dataset within a _new_ `kedro ipython` session and display its first five rows:
+```
+
+### Test that Kedro can load the `xlsx` data
+
+To test that everything works as expected, load the dataset within IPython and display its first five rows:
 
 ```python
 shuttles = catalog.load("shuttles")
 shuttles.head()
 ```
-When you have finished, close `ipython` session as follows:
 
-```python
-exit()
+You should see output such as the following:
+
+```
+INFO     Loading data from 'shuttles' (ExcelDataSet)
+Out[1]:
+      id       shuttle_location shuttle_type engine_type  ... d_check_complete  moon_clearance_complete     price company_id
+0  63561                   Niue      Type V5     Quantum  ...                f                        f  $1,325.0      35029
+1  36260               Anguilla      Type V5     Quantum  ...                t                        f  $1,780.0      30292
+2  57015     Russian Federation      Type V5     Quantum  ...                f                        f  $1,715.0      19032
+3  14035               Barbados      Type V5      Plasma  ...                f                        f  $4,770.0       8238
+4  10036  Sao Tome and Principe      Type V2      Plasma  ...                f                        f  $2,820.0      30342
+
 ```
 
-## Custom data
+When you have finished, close `ipython` session with `exit()`.
+
+## Further information
 
-Kedro supports a number of [datasets](/kedro.extras.datasets) out of the box, but you can also add support for any proprietary data format or filesystem in your pipeline.
+### Custom data
+
+[Kedro supports a number of datasets](/kedro.extras.datasets) out of the box, but you can also add support for any proprietary data format or filesystem in your pipeline.
 
 You can find further information about [how to add support for custom datasets](../extend_kedro/custom_datasets.md) in specific documentation covering advanced usage.
+
+### Supported data locations
+
+Kedro uses [`fsspec`](https://filesystem-spec.readthedocs.io/en/latest/) to read data from a variety of data stores including local file systems, network file systems, HDFS, and all of the widely-used cloud object stores.
diff --git a/docs/source/tutorial/spaceflights_tutorial.md b/docs/source/tutorial/spaceflights_tutorial.md
index 69abe06575..fdd043b484 100644
--- a/docs/source/tutorial/spaceflights_tutorial.md
+++ b/docs/source/tutorial/spaceflights_tutorial.md
@@ -1,68 +1,88 @@
 # Kedro spaceflights tutorial
 
-**Scenario**: *It is 2160 and the space tourism industry is booming. Globally, thousands of space shuttle companies take tourists to the Moon and back. You have been able to source amenities offered in each space shuttle, customer reviews and company information.*
+In this tutorial, we construct nodes and pipelines for a price-prediction model to illustrate the steps of a typical Kedro workflow.
 
-**Project**: *You want to construct a model that predicts the price for each trip to the Moon and the corresponding return flight.*
-
-In this tutorial, we illustrate the typical Kedro workflow and the steps necessary to convert an empty Kedro project template into a working project.
-
-In the text, we assume that you create an empty project and follow the flow of the tutorial by copying and pasting the example code into the project as we describe. This tutorial will take approximately two hours, during which time you will learn each step of the Kedro project development workflow, by working on an example to construct nodes and pipelines for the price-prediction model.
+In the text, we assume you have started with an empty Kedro project and we show the steps necessary to convert it into a working project. The tutorial guides you to copy and paste example code into the Kedro project. It takes approximately **one hour** to complete.
 
 ```{note}
-You may prefer to get up and running more swiftly so we provide the full spaceflights example project as a [Kedro starter](../get_started/starters.md). To create the project, run `kedro new --starter=spaceflights`. When prompted for a project name, enter `Kedro Tutorial`. This will generate a project from the [Kedro starter for the spaceflights tutorial](https://github.com/kedro-org/kedro-starters/tree/main/spaceflights) so you can follow the tutorial without any of the copy/pasting.
+You may prefer to get up and running more swiftly. We also provide the example as a [Kedro starter](../get_started/starters.md) so you can follow along without copy/pasting.
 ```
 
-## Kedro project development workflow
+## Scenario
 
-When you build a Kedro project, you will typically follow a standard development workflow:
+*It is 2160, and the space tourism industry is booming. Globally, thousands of space shuttle companies take tourists to the Moon and back. You have been able to source data that lists the amenities offered in each space shuttle, customer reviews, and company information.*
 
-![](../meta/images/typical_workflow.png)
+***Project***: *You want to construct a model that predicts the price for each trip to the Moon and the corresponding return flight.*
 
-### 1. Set up the project template
 
-* Create a new project with `kedro new`
-* Install project dependencies with `pip install -r src/requirements.txt`
-* Configure the following in the `conf` folder:
-	* Logging
-	* Credentials
-	* Any other sensitive / personal content
+![](../meta/images/moon-rocket.png)
 
-### 2. Set up the data
+Photo by <a href="https://unsplash.com/@ivvndiaz">Ivan Diaz</a> on <a href="https://unsplash.com/s/photos/spaceship">Unsplash</a>
 
-* Add data to the `data/` folder
-* Reference all datasets for the project in the `conf/base/catalog.yml` file
 
-### 3. Create the pipeline
+## Get help
+If you hit an issue with the tutorial, the Kedro community can help!
 
-* Create the data transformation steps as Python functions
-* Add your functions as nodes, to construct the pipeline
-* Choose how to run the pipeline: sequentially or in parallel
+Things you can do:
 
-### 4. Package the project
+* check the [spaceflights tutorial FAQ](spaceflights_tutorial_faqs.md) to see if we have answered the question already
+* use the spaceflights starter to [create a new, separate project which contains working example code](./tutorial_template.md#create-a-new-project), and compare that project with your own
+* search the [archive of Discord discussions](https://linen-discord.kedro.org/)
+* use the [#questions channel](https://kedro-org.slack.com/archives/C03RKP2LW64) on our Slack channel (which replaces our Discord server) to ask the community for help
 
- * Build the project documentation
- * Package the project for distribution
+## Terminology
 
-## Optional: Git workflow
+We will explain any Kedro-specific terminology we use in the tutorial as we introduce it. We use additional terminology that may not be familiar to some readers, such as the concepts below.
 
-### Create a project repository
+### Project root directory
+Also known as the "root directory", this is the parent folder for the entire project. It is the top-level folder that contains all other files and directories associated with the project.
 
-We recommend that you use `git` for source control, but Kedro does not require it, and can work without any source control management system. This section is optional if you choose not to use a `git` repository.
+### Dependencies
+These are Python packages or libraries that an individual project depends upon to complete a task. For example, the Spaceflights tutorial project depends on the [scikit-learn](https://scikit-learn.org/stable/) library.
 
-```{note}
-If you are unfamiliar with a typical `git` workflow, you can follow one of the most popular, known as [Gitflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow).
-```
+### Standard development workflow
+When you build a Kedro project, you will typically follow a [standard development workflow](../faq/faq.md#what-is-the-typical-kedro-project-development-workflow):
+
+1. Set up the project template
+
+    * Create a new project and install project dependencies.
+    * Configure credentials and any other sensitive/personal content, and logging
+
+2. Set up the data
+
+    * Add data to the `data` folder
+    * Reference all datasets for the project
 
-If you don't have a local `git` repository for your project already, navigate to the project directory and create one:
+3. Create the pipeline
+
+    * Construct nodes to make up the pipeline
+    * Choose how to run the pipeline: sequentially or in parallel
+
+4. Package the project
+    * Build the project documentation
+    * Package the project for distribution
+
+
+### Optional: source control with `git`
+
+You don't need to do this section for the tutorial, but you may want to familiarise yourself with the use of `git` for source control.
+
+<details>
+<summary><b>Click to expand</b></summary>
+
+If you want to learn more about a typical `git` workflow, we suggest you look into [Gitflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow).
+Navigate to the project root directory and create a `git` repository on your machine (a local repository) for the project:
 
 ```bash
 git init
 git remote add origin https://github.com/<your-repo>
 ```
 
-### Submit your changes to GitHub
+#### Submit your changes to GitHub
+
+If you work on a project as part of a team, you will share the `git` repository via GitHub, which stores a shared copy of the repository. You should periodically save your changes to your local repository and merge them into the GitHub repository.
 
-As you work on a project, you will periodically save your changes. In a team, we suggest that you each develop your code on a branch and create pull requests to submit it to the `develop` or `main` branches:
+Within your team, we suggest that you each develop your code on a branch and create pull requests to submit it to the `develop` or `main` branches:
 
 ```bash
 # create a new feature branch called 'feature/project-template'
@@ -85,3 +105,4 @@ git commit -m 'Create project template'
 # push changes to remote main
 git push origin main
 ```
+</details>
diff --git a/docs/source/tutorial/spaceflights_tutorial_faqs.md b/docs/source/tutorial/spaceflights_tutorial_faqs.md
new file mode 100644
index 0000000000..618f9a2837
--- /dev/null
+++ b/docs/source/tutorial/spaceflights_tutorial_faqs.md
@@ -0,0 +1,74 @@
+# Spaceflights tutorial FAQs
+
+```{note}
+If you can't find the answer you need here, [ask the Kedro community for help](spaceflights_tutorial.md#get-help)!
+```
+
+## How do I resolve these common errors?
+
+### DataSet errors
+#### DataSetError: Failed while loading data from data set
+You're [testing whether Kedro can load the raw test data](./set_up_data.md#test-that-kedro-can-load-the-csv-data) and see the following:
+
+```python
+DataSetError: Failed while loading data from data set
+CSVDataSet(filepath=...).
+[Errno 2] No such file or directory: '.../companies.csv'
+```
+
+or a similar error for the `shuttles` or `reviews` data.
+
+Have you downloaded [the three sample data files](./set_up_data.md#download-datasets) and stored them in the `data/raw` folder?
+
+#### DataSetNotFoundError: DataSet not found in the catalog
+
+Do you see the following for one of the raw datasets, make sure you have saved `catalog.yml`?
+
+```python
+DataSetNotFoundError: DataSet 'companies' not found in the catalog
+```
+
+Call `exit()` within the IPython session and restart `kedro ipython` (or type `@kedro_reload` into the IPython console to reload Kedro into the session without restarting). Then try again.
+
+
+#### DataSetError: An exception occurred when parsing config for DataSet
+
+Are you seeing a message saying that an exception occurred?
+
+```bash
+DataSetError: An exception occurred when parsing config for DataSet
+'data_processing.preprocessed_companies':
+Object 'ParquetDataSet' cannot be loaded from 'kedro.extras.datasets.pandas'. Please see the
+documentation on how to install relevant dependencies for kedro.extras.datasets.pandas.ParquetDataSet:
+https://kedro.readthedocs.io/en/stable/kedro_project_setup/dependencies.html
+```
+
+The Kedro Data Catalog is missing [dependencies needed to parse the data](../kedro_project_setup/dependencies.md#install-dependencies-related-to-the-data-catalog). Check that you've added [all the project dependencies to `requirements.txt`](./tutorial_template.md#project-dependencies) and then call `pip install -r src/requirements.txt` to install them.
+
+### Pipeline run
+
+To successfully run the pipeline, all required input datasets must already exist, otherwise you may get an error similar to this:
+
+
+```bash
+kedro run --pipeline=data_science
+
+2019-10-04 12:36:12,135 - root - INFO - ** Kedro project kedro-tutorial
+2019-10-04 12:36:12,158 - kedro.io.data_catalog - INFO - Loading data from `model_input_table` (CSVDataSet)...
+2019-10-04 12:36:12,158 - kedro.runner.sequential_runner - WARNING - There are 3 nodes that have not run.
+You can resume the pipeline run with the following command:
+kedro run
+Traceback (most recent call last):
+  ...
+  File "pandas/_libs/parsers.pyx", line 382, in pandas._libs.parsers.TextReader.__cinit__
+  File "pandas/_libs/parsers.pyx", line 689, in pandas._libs.parsers.TextReader._setup_parser_source
+FileNotFoundError: [Errno 2] File b'data/03_primary/model_input_table.csv' does not exist: b'data/03_primary/model_input_table.csv'
+
+The above exception was the direct cause of the following exception:
+
+Traceback (most recent call last):
+  ...
+    raise DataSetError(message) from exc
+kedro.io.core.DataSetError: Failed while loading data from data set CSVDataSet(filepath=data/03_primary/model_input_table.csv, save_args={'index': False}).
+[Errno 2] File b'data/03_primary/model_input_table.csv' does not exist: b'data/03_primary/model_input_table.csv'
+```
diff --git a/docs/source/tutorial/tutorial_template.md b/docs/source/tutorial/tutorial_template.md
index a894dd8149..4b75b44caa 100644
--- a/docs/source/tutorial/tutorial_template.md
+++ b/docs/source/tutorial/tutorial_template.md
@@ -1,46 +1,78 @@
-# Set up the spaceflights project
+# Set up the spaceflights tutorial project
 
-In this section, we discuss the project set-up phase, which is the first part of the [standard development workflow](./spaceflights_tutorial.md#kedro-project-development-workflow). The set-up steps are as follows:
+In this section, we discuss the project set-up phase, which is the first part of the standard development workflow. The setup steps are as follows:
 
-* Create a new project
-* Install dependencies
-* Configure the project
+* Create a new project with `kedro new`
+* Install project dependencies with `pip install -r src/requirements.txt`
+* Configure the following in the `conf` folder:
+	* Credentials and any other sensitive information
+	* Logging
+
+```{note}
+Don't forget to check the [tutorial FAQ](spaceflights_tutorial_faqs.md) if you run into problems, or [ask the community for help](spaceflights_tutorial.md#get-help) if you need it!
+```
 
 ## Create a new project
 
-Navigate to your chosen working directory and run the following to [create a new empty Kedro project](../get_started/new_project.md#create-a-new-project-interactively) using the default interactive prompts:
+If you have not yet set up Kedro, please do so by following the guidelines to [set up a virtual environment with `conda`](../get_started/prerequisites.md#create-a-virtual-environment-with-conda) and [install Kedro](../get_started/install.md).
+
+```{important}
+We recommend that you use the same version of Kedro that was most recently used to test this tutorial (0.18.3).
+```
+
+In your terminal window, navigate to the folder you want to store the project and type the following to create an empty project:
 
 ```bash
 kedro new
 ```
 
-When prompted for a project name, enter `Kedro Tutorial`. Subsequently, press enter to accept the default suggestions for `repo_name` and `python_package`. Then navigate to the root directory of the project, `kedro-tutorial`.
+Alternatively, if you want to include a complete set of working example code within the project, generate the project from the [Kedro starter for the spaceflights tutorial](https://github.com/kedro-org/kedro-starters/tree/main/spaceflights):
 
-## Install dependencies
+```bash
+kedro new --starter=spaceflights
+```
+
+For either option, when prompted for a project name, enter `Kedro Tutorial`. When Kedro has created your project, you can navigate to the [project root directory](./spaceflights_tutorial.md#project-root-directory):
 
-Up to this point, we have not discussed project dependencies, so now is a good time to examine them. We use a `requirements.txt` file to specify a project's dependencies and make it easier for others to run your project. This avoids version conflicts by ensuring that you use same Python packages and versions.
+```bash
+cd kedro-tutorial
+```
+
+```{note}
+The first time you type a `kedro` command in your new project, you will be asked whether you wish to opt into [usage analytics](https://github.com/kedro-org/kedro-plugins/tree/main/kedro-telemetry). Your decision is recorded in the `.telemetry` file so that subsequent calls to `kedro` in this project do not ask you again.
+```
+
+## Project dependencies
+
+Kedro projects have a `requirements.txt` file to specify their dependencies and enable sharable projects by ensuring consistency across Python packages and versions.
 
 The generic project template bundles some typical dependencies in `src/requirements.txt`. Here's a typical example, although you may find that the version numbers differ slightly depending on your version of Kedro:
 
 ```text
+# code quality packages
 black==22.1.0 # Used for formatting code with `kedro lint`
 flake8>=3.7.9, <5.0 # Used for linting code with `kedro lint`
 ipython==7.0 # Used for an IPython session with `kedro ipython`
 isort~=5.0 # Used for linting code with `kedro lint`
+nbstripout~=0.4 # Strips the output of a Jupyter Notebook and writes the outputless version to the original file
+
+# notebook tooling
 jupyter~=1.0 # Used to open a Kedro-session in Jupyter Notebook & Lab
 jupyterlab~=3.0 # Used to open a Kedro-session in Jupyter Lab
-kedro~=0.18.3
-nbstripout~=0.4 # Strips the output of a Jupyter Notebook and writes the outputless version to the original file
+
+# Pytest + useful extensions
 pytest-cov~=3.0 # Produces test coverage reports
 pytest-mock>=1.7.1, <2.0 # Wrapper around the mock package for easier use with pytest
 pytest~=6.2 # Testing framework for Python code
 ```
 
-```{note}
-If your project has `conda` dependencies, you can create a `src/environment.yml` file and list them there.
-```
+You can learn more about [project dependencies](../kedro_project_setup/dependencies.md) in the Kedro documentation.
 
-The dependencies above might be sufficient for some projects, but for this tutorial you must add some extra requirements. These requirements will enable us to work with different data formats (including CSV, Excel and Parquet) and to visualise the pipeline.
+### Add dependencies to the project
+
+The dependencies above might be sufficient for some projects, but for this tutorial, you must add some extra requirements. These requirements will enable us to work with different data formats (including CSV, Excel, and Parquet) and to visualise the pipeline.
+
+> If you are using the tutorial created by the spaceflights starter, you can omit the copy/paste, but it's worth opening `src/requirements.txt` to inspect the contents.
 
 Add the following lines to your `src/requirements.txt` file:
 
@@ -50,17 +82,20 @@ kedro-viz~=5.0                                                                 #
 scikit-learn~=1.0                                                              # For modelling in the data science pipeline
 ```
 
-To install all the project-specific dependencies, navigate to the root directory of the project and run:
+### Install the dependencies
+
+To install all the project-specific dependencies, run the following from the project root directory:
 
 ```bash
 pip install -r src/requirements.txt
 ```
 
-You can find out more about [how to work with project dependencies](../kedro_project_setup/dependencies.md) in the Kedro project documentation.
+## Optional: configuration and logging
 
+You may want to store credentials such as usernames and passwords if they are needed for specific data sources used by the project.
 
-## Configure the project
+To do this, add them to `conf/local/credentials.yml` (some examples are included in that file for illustration).
 
-You may optionally add in any credentials to the `conf/local/credentials.yml` file that are required to load specific data sources like usernames and passwords. Some examples are given within the file to illustrate how you store credentials. You can find additional information in the [advanced documentation on configuration](../kedro_project_setup/configuration.md).
+You can find additional information in the [advanced documentation on configuration](../kedro_project_setup/configuration.md).
 
-At this stage of the workflow, you might also want to [set up logging](../logging/logging.md), but we do not use it in this tutorial.
+You might also want to [set up logging](../logging/logging.md) at this stage of the workflow, but we do not use it in this tutorial.
diff --git a/docs/source/tutorial/set_up_experiment_tracking.md b/docs/source/visualisation/experiment_tracking.md
similarity index 95%
rename from docs/source/tutorial/set_up_experiment_tracking.md
rename to docs/source/visualisation/experiment_tracking.md
index b3e76586b1..41f2a23788 100644
--- a/docs/source/tutorial/set_up_experiment_tracking.md
+++ b/docs/source/visualisation/experiment_tracking.md
@@ -9,7 +9,7 @@ Enabling experiment tracking features on Kedro-Viz relies on:
 * [experiment tracking datasets to let Kedro know what metrics should be tracked](#set-up-tracking-datasets)
 * [modifying your nodes and pipelines to output those metrics](#set-up-your-nodes-and-pipelines-to-log-metrics).
 
-This tutorial will provide a step-by-step process to set up experiment tracking and access your logged metrics from each run on Kedro-Viz. It will use the starter outlined in the [spaceflights tutorial](../tutorial/spaceflights_tutorial.md) and build on previously discussed topics such as [namespacing](../tutorial/namespace_pipelines.md). You can also jump directly to [this section for direct reference in setting up experiment tracking](../logging/experiment_tracking.md) for your Kedro project.
+This tutorial will provide a step-by-step process to set up experiment tracking and access your logged metrics from each run on Kedro-Viz. It will use the starter outlined in the [spaceflights tutorial](../tutorial/spaceflights_tutorial.md). You can also jump directly to [this section for direct reference in setting up experiment tracking](../logging/experiment_tracking.md) for your Kedro project.
 
 You can also access a more detailed [Kedro-Viz live demo](https://kedro-viz-live-demo.hfa4c8ufrmn4u.eu-west-2.cs.amazonlightsail.com/).
 
@@ -19,7 +19,7 @@ You can also access a more detailed [Kedro-Viz live demo](https://kedro-viz-live
 You can skip this step if you have followed all previous parts of the tutorial.
 ```
 
-We assume that you have already [installed Kedro](../get_started/install.md) and [Kedro-Viz](../tutorial/visualise_pipeline.md). To set up a new project using the spaceflights starter, run:
+We assume that you have already [installed Kedro](../get_started/install.md) and [Kedro-Viz](../visualisation/kedro-viz_visualisation.md). To set up a new project using the spaceflights starter, run:
 
 ```bash
 kedro new --starter=spaceflights
@@ -225,7 +225,7 @@ After running the pipeline with `kedro run`, the plot will be saved and you will
 ![](../meta/images/expand-plot-comparison-view.gif)
 
 
-Read more about [creating plots and visualising them in Kedro-Viz in the visualise pipeline section.](../tutorial/visualise_pipeline.md#visualise-charts-in-kedro-viz)
+> [Read more about creating plots and visualising them in Kedro-Viz](./kedro-viz_visualisation.md).
 
 ## View your metrics timeline
 
diff --git a/docs/source/visualisation/kedro-viz_visualisation.md b/docs/source/visualisation/kedro-viz_visualisation.md
new file mode 100644
index 0000000000..f0a8e28a16
--- /dev/null
+++ b/docs/source/visualisation/kedro-viz_visualisation.md
@@ -0,0 +1,121 @@
+# Get started with Kedro-Viz
+
+This page assumes you are familiar with the basic Kedro concepts described in the [Spaceflights tutorial](../tutorial/spaceflights_tutorial.md). If you have not yet worked through the tutorial, you can generate the project with all the code in place by using the [Kedro starter for the spaceflights tutorial](https://github.com/kedro-org/kedro-starters/tree/main/spaceflights):
+
+```
+kedro new --starter=spaceflights
+```
+
+When prompted for a project name, you can enter any name, but we will assume `Kedro Tutorial` throughout this documentation. When your project is ready, navigate to the root directory of the project.
+
+
+## Install Kedro-Viz and visualise the project
+
+[Kedro-Viz](https://github.com/kedro-org/kedro-viz) displays data and machine-learning pipelines in an informative way, emphasising the connections between datasets and nodes. It shows the structure of your Kedro pipeline.
+
+To install the dependencies for the project, including Kedro-Viz, type the following in your terminal, from the root of the project directory:
+
+```bash
+pip install -r src/requirements.txt
+```
+
+Next, type the following to run Kedro-Viz:
+
+```bash
+kedro viz
+```
+
+This command automatically opens a browser tab to serve the visualisation at http://127.0.0.1:4141/.
+
+You should see the following:
+
+![](../meta/images/pipeline_visualisation.png)
+
+If a visualisation panel opens up and a pipeline is not visible, then please check that your [pipeline definition](../tutorial/create_a_pipeline.md) is complete. All other errors can be logged as GitHub Issues on the [Kedro-Viz repository](https://github.com/kedro-org/kedro-viz).
+
+### Exit an open visualisation
+To exit the visualisation, close the browser tab. To regain control of the terminal, enter `Ctrl+C` or `Cmd+C`.
+
+## Automatic visualisation updates
+
+You can use the `--autoreload` flag to autoreload Kedro-Viz when a `Python` or `YAML` file changes in the project.
+
+![](../meta/images/kedro_viz_autoreload.gif)
+
+Add the flag to the command you use to start Kedro-Viz:
+
+```bash
+kedro viz --autoreload
+```
+
+The `autoreload` flag reflects changes to the project as they happen. For example, commenting out `create_model_input_table_node` in `pipeline.py` will trigger a re-render of the pipeline:
+
+![autoreload](../meta/images/autoreload.gif)
+
+## Visualise layers
+
+By convention, a [pipeline can be broken up into different layers](../resources/glossary.md#layers-data-engineering-convention) according to how data is processed, which makes it easier to collaborate.
+
+For example, the [data engineering convention](../faq/faq.md#what-is-data-engineering-convention) labels datasets according to the stage of the pipeline (e.g. whether the data has been cleaned).
+
+You can add a `layer` attribute to the datasets in the Data Catalog, which is reflected in the Kedro-Viz visualisation.
+
+Open `catalog.yml` for the completed spaceflights tutorial and replace the existing code with the following:
+
+```yaml
+companies:
+  type: pandas.CSVDataSet
+  filepath: data/01_raw/companies.csv
+  layer: raw
+
+reviews:
+  type: pandas.CSVDataSet
+  filepath: data/01_raw/reviews.csv
+  layer: raw
+
+shuttles:
+  type: pandas.ExcelDataSet
+  filepath: data/01_raw/shuttles.xlsx
+  layer: raw
+
+preprocessed_companies:
+  type: pandas.ParquetDataSet
+  filepath: data/02_intermediate/preprocessed_companies.pq
+  layer: intermediate
+
+preprocessed_shuttles:
+  type: pandas.ParquetDataSet
+  filepath: data/02_intermediate/preprocessed_shuttles.pq
+  layer: intermediate
+
+model_input_table:
+  type: pandas.ParquetDataSet
+  filepath: data/03_primary/model_input_table.pq
+  layer: primary
+
+regressor:
+  type: pickle.PickleDataSet
+  filepath: data/06_models/regressor.pickle
+  versioned: true
+  layer: models
+```
+
+Run Kedro-Viz again and observe how your visualisation has changed to include the layers:
+
+![](../meta/images/pipeline_visualisation_with_layers.png)
+
+## Share a pipeline
+
+You can share a Kedro-Viz visualisation as a JSON file:
+
+```bash
+kedro viz --save-file my_shareable_pipeline.json
+```
+
+This command will save a visualisation of the `__default__` pipeline as a JSON file called `my_shareable_pipeline.json`.
+
+To visualise the JSON file:
+
+```bash
+kedro viz --load-file my_shareable_pipeline.json
+```
diff --git a/docs/source/tutorial/visualise_pipeline.md b/docs/source/visualisation/visualise_charts_with_plotly.md
similarity index 65%
rename from docs/source/tutorial/visualise_pipeline.md
rename to docs/source/visualisation/visualise_charts_with_plotly.md
index a742cc90e4..b6dd8d56d5 100644
--- a/docs/source/tutorial/visualise_pipeline.md
+++ b/docs/source/visualisation/visualise_charts_with_plotly.md
@@ -1,108 +1,8 @@
-# Visualise pipelines
-
-[Kedro-Viz](https://github.com/kedro-org/kedro-viz) displays data and machine-learning pipelines in an informative way, emphasising the connections between datasets and nodes. It shows the structure of your Kedro pipeline. This exercise assumes that you have been following the [Spaceflights tutorial](spaceflights_tutorial.md).
-
-## Install Kedro-Viz
-
-If you did not already install Kedro-Viz when you [installed the tutorial project dependencies](tutorial_template.md#install-dependencies), then you can do so now by running:
-```bash
-pip install kedro-viz
-```
-
-## Visualise a whole pipeline
-
-You should be in your project root directory. Once Kedro-Viz is installed, to visualise your pipeline, run:
-```bash
-kedro viz
-```
-
-This command will run a server on http://127.0.0.1:4141 that will open up your visualisation on a browser. You should be able to see the following:
-
-![](../meta/images/pipeline_visualisation.png)
-
-You can also use the `--autoreload` flag to autoreload Kedro Viz when a `Python` or `YAML` file has changed in the corresponding Kedro project.
-
-![](../meta/images/kedro_viz_autoreload.gif)
-
-If a visualisation panel opens up and a pipeline is not visible, then please check that your [pipeline definition](create_pipelines.md) is complete. All other errors can be logged as GitHub Issues on the [Kedro-Viz repository](https://github.com/kedro-org/kedro-viz).
-
-## Exit an open visualisation
-
-To exit this visualisation, close the open browser and enter **Ctrl+C** or **Cmd+C** in your terminal.
-
-## Visualise layers
-
-A pipeline can be broken up into different layers according to how data is processed, and using a convention for layers makes it easier to collaborate. For example, the [data engineering convention](../faq/faq.md#what-is-data-engineering-convention) shown here labels datasets according to the stage of the pipeline (e.g. whether the data has been cleaned).
-
-Kedro-Viz makes it easy to visualise these data processing stages by adding a `layer` attribute to the datasets in the Data Catalog. We will be modifying the `catalog.yml` file with the following:
-
-```yaml
-companies:
-  type: pandas.CSVDataSet
-  filepath: data/01_raw/companies.csv
-  layer: raw
-
-reviews:
-  type: pandas.CSVDataSet
-  filepath: data/01_raw/reviews.csv
-  layer: raw
-
-shuttles:
-  type: pandas.ExcelDataSet
-  filepath: data/01_raw/shuttles.xlsx
-  layer: raw
-
-preprocessed_companies:
-  type: pandas.ParquetDataSet
-  filepath: data/02_intermediate/preprocessed_companies.pq
-  layer: intermediate
-
-preprocessed_shuttles:
-  type: pandas.ParquetDataSet
-  filepath: data/02_intermediate/preprocessed_shuttles.pq
-  layer: intermediate
-
-model_input_table:
-  type: pandas.ParquetDataSet
-  filepath: data/03_primary/model_input_table.pq
-  layer: primary
-
-regressor:
-  type: pickle.PickleDataSet
-  filepath: data/06_models/regressor.pickle
-  versioned: true
-  layer: models
-```
-
-Run Kedro-Viz again with `kedro viz` and observe how your visualisation has changed to indicate the layers:
-
-![](../meta/images/pipeline_visualisation_with_layers.png)
-
-## Share a pipeline
-
-Visualisations from Kedro-Viz are made shareable by using functionality that allows you to save the visualisation as a JSON file.
-
-To save a visualisation, run:
-```
-kedro viz --save-file my_shareable_pipeline.json
-```
-
-This command will save a pipeline visualisation of your primary `__default__` pipeline as a JSON file called `my_shareable_pipeline.json`.
-
-To visualise a saved pipeline, run:
-```
-kedro viz --load-file my_shareable_pipeline.json
-```
-
-This will visualise the pipeline visualisation saved as `my_shareable_pipeline.json`.
-
-
-## Visualise charts in Kedro-Viz
+# Visualise charts in Kedro-Viz
 
+## Visualisation with Plotly
 Kedro-Viz supports [Plotly](https://plotly.com/python/) and [Matplotlib](https://matplotlib.org/) integrations so that you can share your data insights while exploring your pipeline.
 
-### Visualise Plotly charts in Kedro-Viz
-
 [Plotly](https://plotly.com/python/) is a free and open source Python library that allows you to make interactive, publication-quality graphs. With the Plotly integration on Kedro-Viz, you can output your interactive charts as part of your pipeline visualisation.
 
 We have also used the Plotly integration to allow users to [visualise metrics from experiments](../logging/experiment_tracking.md).
@@ -117,7 +17,7 @@ You can view Plotly charts in Kedro-Viz when you use Kedro's plotly datasets.
 
 There are two types of Plotly datasets in Kedro: the `plotly.PlotlyDataSet` and `plotly.JSONDataSet`.
 
-#### [`plotly.PlotlyDataSet`](https://kedro.readthedocs.io/en/stable/kedro.extras.datasets.plotly.PlotlyDataSet.html#kedro.extras.datasets.plotly.PlotlyDataSet)
+### [`plotly.PlotlyDataSet`](https://kedro.readthedocs.io/en/stable/kedro.extras.datasets.plotly.PlotlyDataSet.html#kedro.extras.datasets.plotly.PlotlyDataSet)
 
 To use this dataset, configure your plot in the `catalog.yml` file. This dataset only supports [Plotly Express](https://plotly.com/python/plotly-express).
 
@@ -168,7 +68,7 @@ shuttle_passenger_capacity_plot:
 ```
 
 
-#### [`plotly.JSONDataSet`](https://kedro.readthedocs.io/en/stable/kedro.extras.datasets.plotly.JSONDataSet.html#kedro.extras.datasets.plotly.JSONDataSet)
+### [`plotly.JSONDataSet`](https://kedro.readthedocs.io/en/stable/kedro.extras.datasets.plotly.JSONDataSet.html#kedro.extras.datasets.plotly.JSONDataSet)
 
 To use this dataset, configure your plot in your Kedro node. This dataset supports [Plotly Express](https://plotly.com/python/plotly-express) and [Plotly Graph Objects](https://plotly.com/python/graph-objects/).
 
@@ -244,7 +144,7 @@ You can view the larger visualisation of the chart by clicking the 'Expand Plotl
 ![](../meta/images/pipeline_visualisation_plotly_expand.png)
 
 
-### Visualise Matplotlib charts in Kedro-Viz
+### Visualisation with Matplotlib
 
 [Matplotlib](https://matplotlib.org/) is a Python library for creating static, animated, and interactive visualisations. Integrating Matplotlib into Kedro-Viz allows you to output your charts as part of your pipeline visualisation.