diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6e4630d1ec..da4e2152ee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,9 +11,11 @@
 ### General
 
 - Fix error in tagging GitPod docker images during releases
+- Fix bug when updating modules from old version in old folder structure
 - Don't remove local copy of modules repo, only update it with fetch ([#1881](https://github.com/nf-core/tools/pull/1881))
 - Add subworkflow commands create-test-yml, create and install ([#1897](https://github.com/nf-core/tools/pull/1897))
 - Update subworkflows install so it installs also imported modules and subworkflows ([#1904](https://github.com/nf-core/tools/pull/1904))
+- `check_up_to_date()` function from `modules_json` also checks for subworkflows.
 
 ### Modules
 
diff --git a/README.md b/README.md
index 6ad2846b23..4cfd7a0697 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ A python package with helper tools for the nf-core community.
 ## Table of contents <!-- omit in toc -->
 
 - [`nf-core` tools installation](#installation)
+- [`nf-core` tools update](#update-tools)
 - [`nf-core list` - List available pipelines](#listing-pipelines)
 - [`nf-core launch` - Run a pipeline with interactive parameter prompts](#launch-a-pipeline)
 - [`nf-core download` - Download pipeline for offline use](#downloading-pipelines-for-offline-use)
@@ -186,6 +187,22 @@ If you would prefer to skip this check, set the environment variable `NFCORE_NO_
 export NFCORE_NO_VERSION_CHECK=1
 ```
 
+### Update tools
+
+It is advisable to keep nf-core/tools updated to the most recent version. The command to update depends on the system used to install it, for example if you have installed it with conda you can use:
+
+```bash
+conda update nf-core
+```
+
+if you used pip:
+
+```bash
+pip install --upgrade nf-core
+```
+
+Please refer to the respective documentation for further details to manage packages, as for example [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html#updating-packages) or [pip](https://packaging.python.org/en/latest/tutorials/installing-packages/#upgrading-packages).
+
 ## Listing pipelines
 
 The command `nf-core list` shows all available nf-core pipelines along with their latest version, when that was published and how recently the pipeline code was pulled to your local system (if at all).
@@ -216,7 +233,7 @@ Archived pipelines are not returned by default. To include them, use the `--show
 ## Launch a pipeline
 
 Some nextflow pipelines have a considerable number of command line flags that can be used.
-To help with this, you can use the `nf-core launch` command
+To help with this, you can use the `nf-core launch` command.
 You can choose between a web-based graphical interface or an interactive command-line wizard tool to enter the pipeline parameters for your run.
 Both interfaces show documentation alongside each parameter and validate your inputs.
 
@@ -500,7 +517,7 @@ To help developers working with pipeline schema, nf-core tools has three `schema
 Nextflow can take input parameters in a JSON or YAML file when running a pipeline using the `-params-file` option.
 This command validates such a file against the pipeline schema.
 
-`Usage is `nf-core schema validate <pipeline> <parameter file>`. eg with the pipeline downloaded [above](#download-pipeline), you can run:
+Usage is `nf-core schema validate <pipeline> <parameter file>`. eg with the pipeline downloaded [above](#download-pipeline), you can run:
 
 <!-- RICH-CODEX
 working_dir: tmp
diff --git a/nf_core/modules/install.py b/nf_core/modules/install.py
index ec363f0c80..90295b615a 100644
--- a/nf_core/modules/install.py
+++ b/nf_core/modules/install.py
@@ -29,7 +29,7 @@ def __init__(
         self.prompt = prompt
         self.sha = sha
 
-    def install(self, module):
+    def install(self, module, silent=False):
         if self.repo_type == "modules":
             log.error("You cannot install a module in a clone of nf-core/modules")
             return False
@@ -87,7 +87,6 @@ def install(self, module):
         # Check that the module is not already installed
         if (current_version is not None and os.path.exists(module_dir)) and not self.force:
             log.info("Module is already installed.")
-            print(f"Module {module} is already installed.")
 
             self.force = questionary.confirm(
                 f"Module {module} is already installed. Do you want to force the reinstallation?",
@@ -143,10 +142,14 @@ def install(self, module):
         if not self.install_module_files(module, version, self.modules_repo, install_folder):
             return False
 
-        # Print include statement
-        module_name = "_".join(module.upper().split("/"))
-        log.info(f"Include statement: include {{ {module_name} }} from '.{os.path.join(install_folder, module)}/main'")
+        if not silent:
+            # Print include statement
+            module_name = "_".join(module.upper().split("/"))
+            log.info(
+                f"Include statement: include {{ {module_name} }} from '.{os.path.join(install_folder, module)}/main'"
+            )
 
         # Update module.json with newly installed module
+        modules_json.load()
         modules_json.update(self.modules_repo, module, version)
         return True
diff --git a/nf_core/modules/modules_json.py b/nf_core/modules/modules_json.py
index f02bbccb81..bfeac885b1 100644
--- a/nf_core/modules/modules_json.py
+++ b/nf_core/modules/modules_json.py
@@ -34,6 +34,7 @@ def __init__(self, pipeline_dir):
         """
         self.dir = pipeline_dir
         self.modules_dir = Path(self.dir, "modules")
+        self.subworkflows_dir = Path(self.dir, "subworkflows")
         self.modules_json = None
         self.pipeline_modules = None
         self.pipeline_subworkflows = None
@@ -340,40 +341,55 @@ def unsynced_modules(self):
         # Add all modules from modules.json to missing_installation
         missing_installation = copy.deepcopy(self.modules_json["repos"])
         # Obtain the path of all installed modules
-        dirs = [
+        module_dirs = [
             Path(dir_name).relative_to(self.modules_dir)
             for dir_name, _, file_names in os.walk(self.modules_dir)
             if "main.nf" in file_names and not str(Path(dir_name).relative_to(self.modules_dir)).startswith("local")
         ]
+        untracked_dirs_modules, missing_installation = self.parse_dirs(module_dirs, missing_installation, "modules")
+
+        # Obtain the path of all installed subworkflows
+        subworkflow_dirs = [
+            Path(dir_name).relative_to(self.subworkflows_dir)
+            for dir_name, _, file_names in os.walk(self.subworkflows_dir)
+            if "main.nf" in file_names
+            and not str(Path(dir_name).relative_to(self.subworkflows_dir)).startswith("local")
+        ]
+        untracked_dirs_subworkflows, missing_installation = self.parse_dirs(
+            subworkflow_dirs, missing_installation, "subworkflows"
+        )
+
+        return untracked_dirs_modules, untracked_dirs_subworkflows, missing_installation
+
+    def parse_dirs(self, dirs, missing_installation, component_type):
         untracked_dirs = []
         for dir in dirs:
-            # Check if the modules directory exists in modules.json
+            # Check if the module/subworkflows directory exists in modules.json
             install_dir = dir.parts[0]
-            module = str(Path(*dir.parts[1:]))
-            module_in_file = False
+            component = str(Path(*dir.parts[1:]))
+            component_in_file = False
             git_url = None
             for repo in missing_installation:
-                for dir_name in missing_installation[repo]["modules"]:
-                    if module in missing_installation[repo]["modules"][dir_name]:
-                        module_in_file = True
+                for dir_name in missing_installation[repo][component_type]:
+                    if component in missing_installation[repo][component_type][dir_name]:
+                        component_in_file = True
                         git_url = repo
                         break
-            if not module_in_file:
-                # If it is not, add it to the list of missing modules
-                untracked_dirs.append(module)
+            if not component_in_file:
+                # If it is not, add it to the list of missing subworkflow
+                untracked_dirs.append(component)
             else:
-                # If it does, remove the module from missing_installation
+                # If it does, remove the subworkflow from missing_installation
                 module_repo = missing_installation[git_url]
                 # Check if the entry has a git sha and branch before removing
-                modules = module_repo["modules"][install_dir]
-                if "git_sha" not in modules[module] or "branch" not in modules[module]:
-                    self.determine_module_branches_and_shas(module, git_url, module_repo["base_path"], [module])
-                # Remove the module from modules without installation
-                module_repo["modules"][install_dir].pop(module)
-                if len(module_repo["modules"][install_dir]) == 0:
-                    # If no modules with missing installation left, remove the git_url from missing_installation
+                components_dict = module_repo[component_type][install_dir]
+                if "git_sha" not in components_dict[component] or "branch" not in components_dict[component]:
+                    self.determine_module_branches_and_shas(component, git_url, module_repo["base_path"], [component])
+                # Remove the subworkflow from subworkflows without installation
+                module_repo[component_type][install_dir].pop(component)
+                if len(module_repo[component_type][install_dir]) == 0:
+                    # If no modules/subworkflows with missing installation left, remove the git_url from missing_installation
                     missing_installation.pop(git_url)
-
         return untracked_dirs, missing_installation
 
     def has_git_url_and_modules(self):
@@ -439,14 +455,14 @@ def reinstall_repo(self, install_dir, remote_url, module_entries):
 
     def check_up_to_date(self):
         """
-        Checks whether the modules installed in the directory
+        Checks whether the modules and subworkflows installed in the directory
         are consistent with the entries in the 'modules.json' file and vice versa.
 
-        If a module has an entry in the 'modules.json' file but is missing in the directory,
-        we first try to reinstall the module from the remote and if that fails we remove the entry
+        If a module/subworkflow has an entry in the 'modules.json' file but is missing in the directory,
+        we first try to reinstall the module/subworkflow from the remote and if that fails we remove the entry
         in 'modules.json'.
 
-        If a module is installed but the entry in 'modules.json' is missing we iterate through
+        If a module/subworkflow is installed but the entry in 'modules.json' is missing we iterate through
         the commit log in the remote to try to determine the SHA.
         """
         try:
@@ -457,90 +473,30 @@ def check_up_to_date(self):
             log.info("The 'modules.json' file is not up to date. Recreating the 'module.json' file.")
             self.create()
 
-        missing_from_modules_json, missing_installation = self.unsynced_modules()
+        (
+            modules_missing_from_modules_json,
+            subworkflows_missing_from_modules_json,
+            missing_installation,
+        ) = self.unsynced_modules()
 
-        # If there are any modules left in 'modules.json' after all installed are removed,
+        # If there are any modules/subworkflows left in 'modules.json' after all installed are removed,
         # we try to reinstall them
         if len(missing_installation) > 0:
-            missing_but_in_mod_json = [
-                f"'modules/{install_dir}/{module}'"
-                for repo_url, contents in missing_installation.items()
-                for install_dir, dir_contents in contents["modules"].items()
-                for module in dir_contents
-            ]
-            log.info(
-                f"Reinstalling modules found in 'modules.json' but missing from directory: {', '.join(missing_but_in_mod_json)}"
-            )
-
-            remove_from_mod_json = {}
-            for repo_url, contents in missing_installation.items():
-                for install_dir, module_entries in contents["modules"].items():
-                    remove_from_mod_json[(repo_url, install_dir)] = self.reinstall_repo(
-                        install_dir, repo_url, module_entries
-                    )
-
-            # If the reinstall fails, we remove those entries in 'modules.json'
-            if sum(map(len, remove_from_mod_json.values())) > 0:
-                uninstallable_mods = [
-                    f"'{install_dir}/{module}'"
-                    for (repo_url, install_dir), modules in remove_from_mod_json.items()
-                    for module in modules
-                ]
-                if len(uninstallable_mods) == 1:
-                    log.info(f"Was unable to reinstall {uninstallable_mods[0]}. Removing 'modules.json' entry")
-                else:
-                    log.info(
-                        f"Was unable to reinstall some modules. Removing 'modules.json' entries: {', '.join(uninstallable_mods)}"
-                    )
-
-                for (repo_url, install_dir), module_entries in remove_from_mod_json.items():
-                    for module in module_entries:
-                        self.modules_json["repos"][repo_url]["modules"][install_dir].pop(module)
-                    if len(self.modules_json["repos"][repo_url]["modules"][install_dir]) == 0:
-                        self.modules_json["repos"].pop(repo_url)
-
-        # If some modules didn't have an entry in the 'modules.json' file
+            if "subworkflows" in [
+                c_type for _, repo_content in missing_installation.items() for c_type in repo_content.keys()
+            ]:
+                self.resolve_missing_installation(missing_installation, "subworkflows")
+            if "modules" in [
+                c_type for _, repo_content in missing_installation.items() for c_type in repo_content.keys()
+            ]:
+                self.resolve_missing_installation(missing_installation, "modules")
+
+        # If some modules/subworkflows didn't have an entry in the 'modules.json' file
         # we try to determine the SHA from the commit log of the remote
-        if len(missing_from_modules_json) > 0:
-            format_missing = [f"'{dir}'" for dir in missing_from_modules_json]
-            if len(format_missing) == 1:
-                log.info(f"Recomputing commit SHA for module {format_missing[0]} which was missing from 'modules.json'")
-            else:
-                log.info(
-                    f"Recomputing commit SHAs for modules which were missing from 'modules.json': {', '.join(format_missing)}"
-                )
-
-            # Get the remotes we are missing
-            tracked_repos = {repo_url: (repo_entry) for repo_url, repo_entry in self.modules_json["repos"].items()}
-            repos, _ = self.get_pipeline_module_repositories(self.modules_dir, tracked_repos)
-
-            modules_with_repos = (
-                (
-                    nf_core.modules.module_utils.path_from_remote(repo_url),
-                    str(dir.relative_to(nf_core.modules.module_utils.path_from_remote(repo_url))),
-                )
-                for dir in missing_from_modules_json
-                for repo_url in repos
-                if nf_core.utils.is_relative_to(dir, nf_core.modules.module_utils.path_from_remote(repo_url))
-            )
-
-            repos_with_modules = {}
-            for install_dir, module in modules_with_repos:
-                if install_dir not in repos_with_modules:
-                    repos_with_modules[install_dir] = []
-                repos_with_modules[install_dir].append(module)
-
-            for install_dir, modules in repos_with_modules.items():
-                remote_url = [url for url, content in repos.items() if install_dir in content][0]
-                repo_entry = self.determine_module_branches_and_shas(install_dir, remote_url, modules)
-                if remote_url in self.modules_json["repos"]:
-                    self.modules_json["repos"][remote_url]["modules"][install_dir].update(repo_entry)
-                else:
-                    self.modules_json["repos"][remote_url] = {
-                        "modules": {
-                            install_dir: repo_entry,
-                        }
-                    }
+        if len(modules_missing_from_modules_json) > 0:
+            self.resolve_missing_from_modules_json(modules_missing_from_modules_json, "modules")
+        if len(subworkflows_missing_from_modules_json) > 0:
+            self.resolve_missing_from_modules_json(subworkflows_missing_from_modules_json, "subworkflows")
 
         self.dump()
 
@@ -889,3 +845,84 @@ def get_installed_subworkflows(self):
                         self.pipeline_subworkflows[repo] = [(dir, name) for name in subworkflow]
 
         return self.pipeline_subworkflows
+
+    def resolve_missing_installation(self, missing_installation, component_type):
+        missing_but_in_mod_json = [
+            f"'{component_type}/{install_dir}/{component}'"
+            for repo_url, contents in missing_installation.items()
+            for install_dir, dir_contents in contents[component_type].items()
+            for component in dir_contents
+        ]
+        log.info(
+            f"Reinstalling {component_type} found in 'modules.json' but missing from directory: {', '.join(missing_but_in_mod_json)}"
+        )
+
+        remove_from_mod_json = {}
+        for repo_url, contents in missing_installation.items():
+            for install_dir, component_entries in contents[component_type].items():
+                remove_from_mod_json[(repo_url, install_dir)] = self.reinstall_repo(
+                    install_dir, repo_url, component_entries
+                )
+
+        # If the reinstall fails, we remove those entries in 'modules.json'
+        if sum(map(len, remove_from_mod_json.values())) > 0:
+            uninstallable_components = [
+                f"'{install_dir}/{component}'"
+                for (repo_url, install_dir), components in remove_from_mod_json.items()
+                for component in components
+            ]
+            if len(uninstallable_components) == 1:
+                log.info(f"Was unable to reinstall {uninstallable_components[0]}. Removing 'modules.json' entry")
+            else:
+                log.info(
+                    f"Was unable to reinstall some {component_type}. Removing 'modules.json' entries: {', '.join(uninstallable_components)}"
+                )
+
+            for (repo_url, install_dir), component_entries in remove_from_mod_json.items():
+                for component in component_entries:
+                    self.modules_json["repos"][repo_url][component_type][install_dir].pop(component)
+                if len(self.modules_json["repos"][repo_url][component_type][install_dir]) == 0:
+                    self.modules_json["repos"].pop(repo_url)
+
+    def resolve_missing_from_modules_json(self, missing_from_modules_json, component_type):
+        format_missing = [f"'{dir}'" for dir in missing_from_modules_json]
+        if len(format_missing) == 1:
+            log.info(
+                f"Recomputing commit SHA for {component_type[:-1]} {format_missing[0]} which was missing from 'modules.json'"
+            )
+        else:
+            log.info(
+                f"Recomputing commit SHAs for {component_type} which were missing from 'modules.json': {', '.join(format_missing)}"
+            )
+
+        # Get the remotes we are missing
+        tracked_repos = {repo_url: (repo_entry) for repo_url, repo_entry in self.modules_json["repos"].items()}
+        repos, _ = self.get_pipeline_module_repositories(self.modules_dir, tracked_repos)
+
+        components_with_repos = (
+            (
+                nf_core.modules.module_utils.path_from_remote(repo_url),
+                str(dir.relative_to(nf_core.modules.module_utils.path_from_remote(repo_url))),
+            )
+            for dir in missing_from_modules_json
+            for repo_url in repos
+            if nf_core.utils.is_relative_to(dir, nf_core.modules.module_utils.path_from_remote(repo_url))
+        )
+
+        repos_with_components = {}
+        for install_dir, component in components_with_repos:
+            if install_dir not in repos_with_components:
+                repos_with_components[install_dir] = []
+            repos_with_components[install_dir].append(component)
+
+        for install_dir, components in repos_with_components.items():
+            remote_url = [url for url, content in repos.items() if install_dir in content][0]
+            repo_entry = self.determine_module_branches_and_shas(install_dir, remote_url, components)
+            if remote_url in self.modules_json["repos"]:
+                self.modules_json["repos"][remote_url][component_type][install_dir].update(repo_entry)
+            else:
+                self.modules_json["repos"][remote_url] = {
+                    component_type: {
+                        install_dir: repo_entry,
+                    }
+                }
diff --git a/nf_core/modules/modules_repo.py b/nf_core/modules/modules_repo.py
index 55a0d3412c..81761cbcf5 100644
--- a/nf_core/modules/modules_repo.py
+++ b/nf_core/modules/modules_repo.py
@@ -381,6 +381,10 @@ def install_subworkflow(self, subworkflow_name, install_dir, commit):
 
         # Copy the files from the repo to the install folder
         shutil.copytree(self.get_subworkflow_dir(subworkflow_name), Path(install_dir, subworkflow_name))
+        if Path(install_dir, subworkflow_name, "nextflow.config").is_file():
+            log.info(
+                f"Subworkflow config include statement: includeConfig '{Path(install_dir, subworkflow_name, 'nextflow.config')}'"
+            )
 
         # Switch back to the tip of the branch
         self.checkout_branch()
@@ -430,8 +434,17 @@ def get_module_git_log(self, module_name, depth=None, since="2021-07-07T00:00:00
         """
         self.checkout_branch()
         module_path = os.path.join("modules", self.repo_path, module_name)
-        commits = self.repo.iter_commits(max_count=depth, paths=module_path)
-        commits = ({"git_sha": commit.hexsha, "trunc_message": commit.message.partition("\n")[0]} for commit in commits)
+        commits_new = self.repo.iter_commits(max_count=depth, paths=module_path)
+        commits_new = [
+            {"git_sha": commit.hexsha, "trunc_message": commit.message.partition("\n")[0]} for commit in commits_new
+        ]
+        # Grab commits also from previous modules structure
+        module_path = os.path.join("modules", module_name)
+        commits_old = self.repo.iter_commits(max_count=depth, paths=module_path)
+        commits_old = [
+            {"git_sha": commit.hexsha, "trunc_message": commit.message.partition("\n")[0]} for commit in commits_old
+        ]
+        commits = iter(commits_new + commits_old)
         return commits
 
     def get_subworkflow_git_log(self, subworkflow_name, depth=None, since="2021-07-07T00:00:00Z"):
diff --git a/nf_core/modules/test_yml_builder.py b/nf_core/modules/test_yml_builder.py
index c448d23f42..c6ba65f161 100644
--- a/nf_core/modules/test_yml_builder.py
+++ b/nf_core/modules/test_yml_builder.py
@@ -287,9 +287,9 @@ def get_md5_sums(self, entry_point, command, results_dir=None, results_dir_repea
             for i in range(len(test_files)):
                 if test_files[i].get("md5sum") and not test_files[i].get("md5sum") == test_files_repeat[i]["md5sum"]:
                     test_files[i].pop("md5sum")
-                    test_files[i][
-                        "contains"
-                    ] = "[ # TODO nf-core: file md5sum was variable, please replace this text with a string found in the file instead ]"
+                    test_files[i]["contains"] = [
+                        "# TODO nf-core: file md5sum was variable, please replace this text with a string found in the file instead "
+                    ]
 
         if len(test_files) == 0:
             raise UserWarning(f"Could not find any test result files in '{results_dir}'")
diff --git a/nf_core/pipeline-template/docs/usage.md b/nf_core/pipeline-template/docs/usage.md
index afaceadbfe..843298a3d9 100644
--- a/nf_core/pipeline-template/docs/usage.md
+++ b/nf_core/pipeline-template/docs/usage.md
@@ -33,7 +33,7 @@ CONTROL_REP1,AEG588A1_S1_L004_R1_001.fastq.gz,AEG588A1_S1_L004_R2_001.fastq.gz
 
 ### Full samplesheet
 
-The pipeline will auto-detect whether a sample is single- or paired-end using the information provided in the samplesheet. The samplesheet can have as many columns as you desire, however, there is a strict requirement for the first 3 columns to match those defined in the table below. 
+The pipeline will auto-detect whether a sample is single- or paired-end using the information provided in the samplesheet. The samplesheet can have as many columns as you desire, however, there is a strict requirement for the first 3 columns to match those defined in the table below.
 
 A final samplesheet file consisting of both single- and paired-end data may look something like the one below. This is for 6 samples, where `TREATMENT_REP3` has been sequenced twice.
 
@@ -87,7 +87,7 @@ nextflow pull {{ name }}
 
 It is a good idea to specify a pipeline version when running the pipeline on your data. This ensures that a specific version of the pipeline code and software are used when you run your pipeline. If you keep using the same tag, you'll be running the same version of the pipeline, even if there have been changes to the code since.
 
-First, go to the [{{ name }} releases page](https://github.com/{{ name }}/releases) and find the latest pipeline version - numeric only (eg. `1.3.1`). Then specify this when running the pipeline with `-r` (one hyphen) - eg. `-r 1.3.1`. Of course, you can switch to another version by changing the number after the `-r` flag. 
+First, go to the [{{ name }} releases page](https://github.com/{{ name }}/releases) and find the latest pipeline version - numeric only (eg. `1.3.1`). Then specify this when running the pipeline with `-r` (one hyphen) - eg. `-r 1.3.1`. Of course, you can switch to another version by changing the number after the `-r` flag.
 
 This version number will be logged in reports when you run the pipeline, so that you'll know what you used when you look back in the future. For example, at the bottom of the MultiQC reports.
 
@@ -99,7 +99,7 @@ This version number will be logged in reports when you run the pipeline, so that
 
 Use this parameter to choose a configuration profile. Profiles can give configuration presets for different compute environments.
 
-Several generic profiles are bundled with the pipeline which instruct the pipeline to use software packaged using different methods (Docker, Singularity, Podman, Shifter, Charliecloud, Conda) - see below. 
+Several generic profiles are bundled with the pipeline which instruct the pipeline to use software packaged using different methods (Docker, Singularity, Podman, Shifter, Charliecloud, Conda) - see below.
 
 > We highly recommend the use of Docker or Singularity containers for full pipeline reproducibility, however when this is not possible, Conda is also supported.
 
@@ -111,7 +111,7 @@ The pipeline also dynamically loads configurations from [https://github.com/nf-c
 Note that multiple profiles can be loaded, for example: `-profile test,docker` - the order of arguments is important!
 They are loaded in sequence, so later profiles can overwrite earlier profiles.
 
-If `-profile` is not specified, the pipeline will run locally and expect all software to be installed and available on the `PATH`. This is _not_ recommended, since it can lead to different results on different machines dependent on the computer enviroment. 
+If `-profile` is not specified, the pipeline will run locally and expect all software to be installed and available on the `PATH`. This is _not_ recommended, since it can lead to different results on different machines dependent on the computer enviroment.
 
 - `test`
   - A profile with a complete configuration for automated testing
@@ -129,7 +129,6 @@ If `-profile` is not specified, the pipeline will run locally and expect all sof
 - `conda`
   - A generic configuration profile to be used with [Conda](https://conda.io/docs/). Please only use Conda as a last resort i.e. when it's not possible to run the pipeline with Docker, Singularity, Podman, Shifter or Charliecloud.
 
-
 ### `-resume`
 
 Specify this when restarting a pipeline. Nextflow will use cached results from any pipeline steps where the inputs are the same, continuing from where it got to previously. For input to be considered the same, not only the names must be identical but the files' contents as well. For more info about this parameter, see [this blog post](https://www.nextflow.io/blog/2019/demystifying-nextflow-resume.html).
@@ -176,9 +175,10 @@ Work dir:
 
 Tip: you can replicate the issue by changing to the process work dir and entering the command `bash .command.run`
 ```
+
 #### For beginners
 
-A first step to bypass this error, you could try to increase the amount of CPUs, memory, and time for the whole pipeline. Therefor you can try to increase the resource for the parameters `--max_cpus`, `--max_memory`,  and `--max_time`. Based on the error above, you have to increase the amount of memory. Therefore you can go to the [parameter documentation of rnaseq](https://nf-co.re/rnaseq/3.9/parameters) and scroll down to the `show hidden parameter` button to get the default value for `--max_memory`. In this case 128GB, you than can try to run your pipeline again with `--max_memory 200GB -resume` to skip all process, that were already calculated. If you can not increase the resource of the complete pipeline, you can try to adapt the resource for a single process as mentioned below. 
+A first step to bypass this error, you could try to increase the amount of CPUs, memory, and time for the whole pipeline. Therefor you can try to increase the resource for the parameters `--max_cpus`, `--max_memory`, and `--max_time`. Based on the error above, you have to increase the amount of memory. Therefore you can go to the [parameter documentation of rnaseq](https://nf-co.re/rnaseq/3.9/parameters) and scroll down to the `show hidden parameter` button to get the default value for `--max_memory`. In this case 128GB, you than can try to run your pipeline again with `--max_memory 200GB -resume` to skip all process, that were already calculated. If you can not increase the resource of the complete pipeline, you can try to adapt the resource for a single process as mentioned below.
 
 #### Advanced option on process level
 
diff --git a/nf_core/subworkflows/install.py b/nf_core/subworkflows/install.py
index 337453389b..f7e495b53b 100644
--- a/nf_core/subworkflows/install.py
+++ b/nf_core/subworkflows/install.py
@@ -42,7 +42,7 @@ def __init__(
         except LookupError as e:
             raise UserWarning(e)
 
-    def install(self, subworkflow):
+    def install(self, subworkflow, silent=False):
         if self.repo_type == "modules":
             log.error("You cannot install a subworkflow in a clone of nf-core/modules")
             return False
@@ -52,12 +52,7 @@ def install(self, subworkflow):
 
         # Verify that 'modules.json' is consistent with the installed modules and subworkflows
         modules_json = ModulesJson(self.dir)
-        modules_json.check_up_to_date()  # TODO: check subworkflows also!!!!
-        if "subworkflows" not in modules_json.modules_json["repos"][self.modules_repo.remote_url]:
-            # It's the first subworkflow installed in the pipeline!
-            modules_json.modules_json["repos"][self.modules_repo.remote_url]["subworkflows"] = {
-                self.modules_repo.repo_path: {}
-            }
+        modules_json.check_up_to_date()
 
         if self.prompt and self.sha is not None:
             log.error("Cannot use '--sha' and '--prompt' at the same time!")
@@ -100,7 +95,6 @@ def install(self, subworkflow):
         # Check that the subworkflow is not already installed
         if (current_version is not None and os.path.exists(subworkflow_dir)) and not self.force:
             log.info("Subworkflow is already installed.")
-            print(f"Subworkflow {subworkflow} is already installed.")
 
             self.force = questionary.confirm(
                 f"Subworkflow {subworkflow} is already installed.\nDo you want to force the reinstallation of this subworkflow and all it's imported modules?",
@@ -159,18 +153,27 @@ def install(self, subworkflow):
         # Install included modules and subworkflows
         modules_to_install, subworkflows_to_install = self.get_modules_subworkflows_to_install(subworkflow_dir)
         for s_install in subworkflows_to_install:
-            self.install(s_install)
+            self.install(s_install, silent=True)
         for m_install in modules_to_install:
-            module_install = ModuleInstall(self.dir, force=self.force, prompt=self.prompt)
-            module_install.install(m_install)
-
-        # Print include statement
-        subworkflow_name = subworkflow.upper()
-        log.info(
-            f"Include statement: include {{ {subworkflow_name} }} from '.{os.path.join(install_folder, subworkflow)}/main'"
-        )
+            module_install = ModuleInstall(
+                self.dir,
+                force=self.force,
+                prompt=self.prompt,
+                sha=self.sha,
+                remote_url=self.modules_repo.remote_url,
+                branch=self.modules_repo.branch,
+            )
+            module_install.install(m_install, silent=True)
+
+        if not silent:
+            # Print include statement
+            subworkflow_name = subworkflow.upper()
+            log.info(
+                f"Include statement: include {{ {subworkflow_name} }} from '.{os.path.join(install_folder, subworkflow)}/main'"
+            )
 
         # Update module.json with newly installed subworkflow
+        modules_json.load()
         modules_json.update_subworkflow(self.modules_repo, subworkflow, version)
         return True
 
diff --git a/nf_core/subworkflows/test_yml_builder.py b/nf_core/subworkflows/test_yml_builder.py
index c11172078d..561d2d4033 100644
--- a/nf_core/subworkflows/test_yml_builder.py
+++ b/nf_core/subworkflows/test_yml_builder.py
@@ -305,9 +305,9 @@ def get_md5_sums(self, entry_point, command, results_dir=None, results_dir_repea
             for i in range(len(test_files)):
                 if test_files[i].get("md5sum") and not test_files[i].get("md5sum") == test_files_repeat[i]["md5sum"]:
                     test_files[i].pop("md5sum")
-                    test_files[i][
-                        "contains"
-                    ] = "[ # TODO nf-core: file md5sum was variable, please replace this text with a string found in the file instead ]"
+                    test_files[i]["contains"] = [
+                        " # TODO nf-core: file md5sum was variable, please replace this text with a string found in the file instead "
+                    ]
 
         if len(test_files) == 0:
             raise UserWarning(f"Could not find any test result files in '{results_dir}'")