diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a16435057..fed991f850 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,8 @@
 
 ### Subworkflows
 
+- Add `nf-core subworkflows patch` command ([#2861](https://github.com/nf-core/tools/pull/2861))
+
 ### General
 
 - Include .nf-core.yml in `nf-core pipelines bump-version` ([#3220](https://github.com/nf-core/tools/pull/3220))
diff --git a/nf_core/__main__.py b/nf_core/__main__.py
index 4612b8b39a..81d088e13d 100644
--- a/nf_core/__main__.py
+++ b/nf_core/__main__.py
@@ -1024,7 +1024,7 @@ def command_modules_update(
     default=".",
     help=r"Pipeline directory. [dim]\[default: current working directory][/]",
 )
-@click.option("-r", "--remove", is_flag=True, default=False)
+@click.option("-r", "--remove", is_flag=True, default=False, help="Remove an existent patch file and regenerate it.")
 def command_modules_patch(ctx, tool, directory, remove):
     """
     Create a patch file for minor changes in a module
@@ -1567,6 +1567,43 @@ def command_subworkflows_install(ctx, subworkflow, directory, prompt, force, sha
     subworkflows_install(ctx, subworkflow, directory, prompt, force, sha)
 
 
+# nf-core subworkflows patch
+@subworkflows.command("patch")
+@click.pass_context
+@click.argument("tool", type=str, required=False, metavar="<tool> or <tool/subtool>")
+@click.option(
+    "-d",
+    "--dir",
+    type=click.Path(exists=True),
+    default=".",
+    help=r"Pipeline directory. [dim]\[default: current working directory][/]",
+)
+@click.option("-r", "--remove", is_flag=True, default=False, help="Remove an existent patch file and regenerate it.")
+def subworkflows_patch(ctx, tool, dir, remove):
+    """
+    Create a patch file for minor changes in a subworkflow
+
+    Checks if a subworkflow has been modified locally and creates a patch file
+    describing how the module has changed from the remote version
+    """
+    from nf_core.subworkflows import SubworkflowPatch
+
+    try:
+        subworkflow_patch = SubworkflowPatch(
+            dir,
+            ctx.obj["modules_repo_url"],
+            ctx.obj["modules_repo_branch"],
+            ctx.obj["modules_repo_no_pull"],
+        )
+        if remove:
+            subworkflow_patch.remove(tool)
+        else:
+            subworkflow_patch.patch(tool)
+    except (UserWarning, LookupError) as e:
+        log.error(e)
+        sys.exit(1)
+
+
 # nf-core subworkflows remove
 @subworkflows.command("remove")
 @click.pass_context
diff --git a/nf_core/modules/modules_differ.py b/nf_core/components/components_differ.py
similarity index 80%
rename from nf_core/modules/modules_differ.py
rename to nf_core/components/components_differ.py
index 6b0781bb89..db51c1910d 100644
--- a/nf_core/modules/modules_differ.py
+++ b/nf_core/components/components_differ.py
@@ -16,10 +16,10 @@
 log = logging.getLogger(__name__)
 
 
-class ModulesDiffer:
+class ComponentsDiffer:
     """
     Static class that provides functionality for computing diffs between
-    different instances of a module
+    different instances of a module or subworkflow
     """
 
     class DiffEnum(enum.Enum):
@@ -34,15 +34,15 @@ class DiffEnum(enum.Enum):
         REMOVED = enum.auto()
 
     @staticmethod
-    def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_dir=None):
+    def get_component_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_dir=None):
         """
-        Compute the diff between the current module version
+        Compute the diff between the current component version
         and the new version.
 
         Args:
-            from_dir (strOrPath): The folder containing the old module files
-            to_dir (strOrPath): The folder containing the new module files
-            path_in_diff (strOrPath): The directory displayed containing the module
+            from_dir (strOrPath): The folder containing the old component files
+            to_dir (strOrPath): The folder containing the new component files
+            path_in_diff (strOrPath): The directory displayed containing the component
                                       file in the diff. Added so that temporary dirs
                                       are not shown
             for_git (bool): indicates whether the diff file is to be
@@ -52,7 +52,7 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
             dsp_to_dir (str | Path): The to directory to display in the diff
 
         Returns:
-            dict[str, (ModulesDiffer.DiffEnum, str)]: A dictionary containing
+            dict[str, (ComponentsDiffer.DiffEnum, str)]: A dictionary containing
             the diff type and the diff string (empty if no diff)
         """
         if for_git:
@@ -72,7 +72,7 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
         )
         files = list(files)
 
-        # Loop through all the module files and compute their diffs if needed
+        # Loop through all the component files and compute their diffs if needed
         for file in files:
             temp_path = Path(to_dir, file)
             curr_path = Path(from_dir, file)
@@ -84,7 +84,7 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
 
                 if new_lines == old_lines:
                     # The files are identical
-                    diffs[file] = (ModulesDiffer.DiffEnum.UNCHANGED, ())
+                    diffs[file] = (ComponentsDiffer.DiffEnum.UNCHANGED, ())
                 else:
                     # Compute the diff
                     diff = difflib.unified_diff(
@@ -93,7 +93,7 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
                         fromfile=str(Path(dsp_from_dir, file)),
                         tofile=str(Path(dsp_to_dir, file)),
                     )
-                    diffs[file] = (ModulesDiffer.DiffEnum.CHANGED, diff)
+                    diffs[file] = (ComponentsDiffer.DiffEnum.CHANGED, diff)
 
             elif temp_path.exists():
                 with open(temp_path) as fh:
@@ -106,7 +106,7 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
                     fromfile=str(Path("/dev", "null")),
                     tofile=str(Path(dsp_to_dir, file)),
                 )
-                diffs[file] = (ModulesDiffer.DiffEnum.CREATED, diff)
+                diffs[file] = (ComponentsDiffer.DiffEnum.CREATED, diff)
 
             elif curr_path.exists():
                 # The file was removed
@@ -119,14 +119,14 @@ def get_module_diffs(from_dir, to_dir, for_git=True, dsp_from_dir=None, dsp_to_d
                     fromfile=str(Path(dsp_from_dir, file)),
                     tofile=str(Path("/dev", "null")),
                 )
-                diffs[file] = (ModulesDiffer.DiffEnum.REMOVED, diff)
+                diffs[file] = (ComponentsDiffer.DiffEnum.REMOVED, diff)
 
         return diffs
 
     @staticmethod
     def write_diff_file(
         diff_path,
-        module,
+        component,
         repo_path,
         from_dir,
         to_dir,
@@ -139,20 +139,19 @@ def write_diff_file(
         limit_output=False,
     ):
         """
-        Writes the diffs of a module to the diff file.
+        Writes the diffs of a component to the diff file.
 
         Args:
             diff_path (str | Path): The path to the file that should be appended
-            module (str): The module name
-            repo_path (str): The name of the repo where the module resides
-            from_dir (str | Path): The directory containing the old module files
-            to_dir (str | Path): The directory containing the new module files
-            diffs (dict[str, (ModulesDiffer.DiffEnum, str)]): A dictionary containing
+            component (str): The component name
+            repo_path (str): The name of the repo where the component resides
+            from_dir (str | Path): The directory containing the old component files
+            to_dir (str | Path): The directory containing the new component files
+            diffs (dict[str, (ComponentsDiffer.DiffEnum, str)]): A dictionary containing
                                                               the type of change and
                                                               the diff (if any)
-            module_dir (str | Path): The path to the current installation of the module
-            current_version (str): The installed version of the module
-            new_version (str): The version of the module the diff is computed against
+            current_version (str): The installed version of the component
+            new_version (str): The version of the component the diff is computed against
             for_git (bool): indicates whether the diff file is to be
                             compatible with `git apply`. If true it
                             adds a/ and b/ prefixes to the file paths
@@ -165,36 +164,36 @@ def write_diff_file(
         if dsp_to_dir is None:
             dsp_to_dir = to_dir
 
-        diffs = ModulesDiffer.get_module_diffs(from_dir, to_dir, for_git, dsp_from_dir, dsp_to_dir)
-        if all(diff_status == ModulesDiffer.DiffEnum.UNCHANGED for _, (diff_status, _) in diffs.items()):
-            raise UserWarning("Module is unchanged")
-        log.debug(f"Writing diff of '{module}' to '{diff_path}'")
+        diffs = ComponentsDiffer.get_component_diffs(from_dir, to_dir, for_git, dsp_from_dir, dsp_to_dir)
+        if all(diff_status == ComponentsDiffer.DiffEnum.UNCHANGED for _, (diff_status, _) in diffs.items()):
+            raise UserWarning("Component is unchanged")
+        log.debug(f"Writing diff of '{component}' to '{diff_path}'")
         with open(diff_path, file_action) as fh:
             if current_version is not None and new_version is not None:
                 fh.write(
-                    f"Changes in module '{Path(repo_path, module)}' between"
+                    f"Changes in component '{Path(repo_path, component)}' between"
                     f" ({current_version}) and"
                     f" ({new_version})\n"
                 )
             else:
-                fh.write(f"Changes in module '{Path(repo_path, module)}'\n")
+                fh.write(f"Changes in component '{Path(repo_path, component)}'\n")
 
             for file, (diff_status, diff) in diffs.items():
-                if diff_status == ModulesDiffer.DiffEnum.UNCHANGED:
+                if diff_status == ComponentsDiffer.DiffEnum.UNCHANGED:
                     # The files are identical
                     fh.write(f"'{Path(dsp_from_dir, file)}' is unchanged\n")
-                elif diff_status == ModulesDiffer.DiffEnum.CREATED:
+                elif diff_status == ComponentsDiffer.DiffEnum.CREATED:
                     # The file was created between the commits
                     fh.write(f"'{Path(dsp_from_dir, file)}' was created\n")
-                elif diff_status == ModulesDiffer.DiffEnum.REMOVED:
+                elif diff_status == ComponentsDiffer.DiffEnum.REMOVED:
                     # The file was removed between the commits
                     fh.write(f"'{Path(dsp_from_dir, file)}' was removed\n")
                 elif limit_output and not file.suffix == ".nf":
                     # Skip printing the diff for files other than main.nf
-                    fh.write(f"Changes in '{Path(module, file)}' but not shown\n")
+                    fh.write(f"Changes in '{Path(component, file)}' but not shown\n")
                 else:
                     # The file has changed write the diff lines to the file
-                    fh.write(f"Changes in '{Path(module, file)}':\n")
+                    fh.write(f"Changes in '{Path(component, file)}':\n")
                     for line in diff:
                         fh.write(line)
                     fh.write("\n")
@@ -237,7 +236,7 @@ def append_modules_json_diff(diff_path, old_modules_json, new_modules_json, modu
 
     @staticmethod
     def print_diff(
-        module,
+        component,
         repo_path,
         from_dir,
         to_dir,
@@ -248,16 +247,15 @@ def print_diff(
         limit_output=False,
     ):
         """
-        Prints the diffs between two module versions to the terminal
+        Prints the diffs between two component versions to the terminal
 
         Args:
-            module (str): The module name
-            repo_path (str): The name of the repo where the module resides
-            from_dir (str | Path): The directory containing the old module files
-            to_dir (str | Path): The directory containing the new module files
-            module_dir (str): The path to the current installation of the module
-            current_version (str): The installed version of the module
-            new_version (str): The version of the module the diff is computed against
+            component (str): The component name
+            repo_path (str): The name of the repo where the component resides
+            from_dir (str | Path): The directory containing the old component files
+            to_dir (str | Path): The directory containing the new component files
+            current_version (str): The installed version of the component
+            new_version (str): The version of the component the diff is computed against
             dsp_from_dir (str | Path): The 'from' directory displayed in the diff
             dsp_to_dir (str | Path): The 'to' directory displayed in the diff
             limit_output (bool): If true, don't print the diff for files other than main.nf
@@ -267,41 +265,43 @@ def print_diff(
         if dsp_to_dir is None:
             dsp_to_dir = to_dir
 
-        diffs = ModulesDiffer.get_module_diffs(
+        diffs = ComponentsDiffer.get_component_diffs(
             from_dir, to_dir, for_git=False, dsp_from_dir=dsp_from_dir, dsp_to_dir=dsp_to_dir
         )
         console = Console(force_terminal=nf_core.utils.rich_force_colors())
         if current_version is not None and new_version is not None:
             log.info(
-                f"Changes in module '{Path(repo_path, module)}' between" f" ({current_version}) and" f" ({new_version})"
+                f"Changes in component '{Path(repo_path, component)}' between"
+                f" ({current_version}) and"
+                f" ({new_version})"
             )
         else:
-            log.info(f"Changes in module '{Path(repo_path, module)}'")
+            log.info(f"Changes in component '{Path(repo_path, component)}'")
 
         panel_group: list[RenderableType] = []
         for file, (diff_status, diff) in diffs.items():
-            if diff_status == ModulesDiffer.DiffEnum.UNCHANGED:
+            if diff_status == ComponentsDiffer.DiffEnum.UNCHANGED:
                 # The files are identical
                 log.info(f"'{Path(dsp_from_dir, file)}' is unchanged")
-            elif diff_status == ModulesDiffer.DiffEnum.CREATED:
+            elif diff_status == ComponentsDiffer.DiffEnum.CREATED:
                 # The file was created between the commits
                 log.info(f"'{Path(dsp_from_dir, file)}' was created")
-            elif diff_status == ModulesDiffer.DiffEnum.REMOVED:
+            elif diff_status == ComponentsDiffer.DiffEnum.REMOVED:
                 # The file was removed between the commits
                 log.info(f"'{Path(dsp_from_dir, file)}' was removed")
             elif limit_output and not file.suffix == ".nf":
                 # Skip printing the diff for files other than main.nf
-                log.info(f"Changes in '{Path(module, file)}' but not shown")
+                log.info(f"Changes in '{Path(component, file)}' but not shown")
             else:
                 # The file has changed
-                log.info(f"Changes in '{Path(module, file)}':")
+                log.info(f"Changes in '{Path(component, file)}':")
                 # Pretty print the diff using the pygments diff lexer
                 syntax = Syntax("".join(diff), "diff", theme="ansi_dark", line_numbers=True)
                 panel_group.append(Panel(syntax, title=str(file), title_align="left", padding=0))
             console.print(
                 Panel(
                     Group(*panel_group),
-                    title=f"[white]{str(module)}[/white]",
+                    title=f"[white]{str(component)}[/white]",
                     title_align="left",
                     padding=0,
                     border_style="blue",
@@ -422,7 +422,7 @@ def try_apply_single_patch(file_lines, patch, reverse=False):
             LookupError: If it fails to find the old lines from the patch in
                          the file.
         """
-        org_lines, patch_lines = ModulesDiffer.get_new_and_old_lines(patch)
+        org_lines, patch_lines = ComponentsDiffer.get_new_and_old_lines(patch)
         if reverse:
             patch_lines, org_lines = org_lines, patch_lines
 
@@ -466,16 +466,22 @@ def try_apply_single_patch(file_lines, patch, reverse=False):
 
     @staticmethod
     def try_apply_patch(
-        module: str, repo_path: Union[str, Path], patch_path: Union[str, Path], module_dir: Path, reverse: bool = False
+        component_type: str,
+        component: str,
+        repo_path: Union[str, Path],
+        patch_path: Union[str, Path],
+        component_dir: Path,
+        reverse: bool = False,
     ) -> Dict[str, List[str]]:
         """
-        Try applying a full patch file to a module
+        Try applying a full patch file to a module or subworkflow
 
         Args:
-            module (str): Name of the module
-            repo_path (str): Name of the repository where the module resides
+            component_type (str): The type of component (modules or subworkflows)
+            component (str): Name of the module or subworkflow
+            repo_path (str): Name of the repository where the component resides
             patch_path (str): The absolute path to the patch file to be applied
-            module_dir (Path): The directory containing the module
+            component_dir (Path): The directory containing the component
             reverse (bool): Apply the patch in reverse
 
         Returns:
@@ -485,19 +491,19 @@ def try_apply_patch(
         Raises:
             LookupError: If the patch application fails in a file
         """
-        module_relpath = Path("modules", repo_path, module)
-        patches = ModulesDiffer.per_file_patch(patch_path)
+        component_relpath = Path(component_type, repo_path, component)
+        patches = ComponentsDiffer.per_file_patch(patch_path)
         new_files = {}
         for file, patch in patches.items():
             log.debug(f"Applying patch to {file}")
-            fn = Path(file).relative_to(module_relpath)
-            file_path = module_dir / fn
+            fn = Path(file).relative_to(component_relpath)
+            file_path = component_dir / fn
             try:
                 with open(file_path) as fh:
                     file_lines = fh.readlines()
             except FileNotFoundError:
                 # The file was added with the patch
                 file_lines = [""]
-            patched_new_lines = ModulesDiffer.try_apply_single_patch(file_lines, patch, reverse=reverse)
+            patched_new_lines = ComponentsDiffer.try_apply_single_patch(file_lines, patch, reverse=reverse)
             new_files[str(fn)] = patched_new_lines
         return new_files
diff --git a/nf_core/components/patch.py b/nf_core/components/patch.py
index 41fccd8be2..59ec7a381b 100644
--- a/nf_core/components/patch.py
+++ b/nf_core/components/patch.py
@@ -8,7 +8,7 @@
 
 import nf_core.utils
 from nf_core.components.components_command import ComponentCommand
-from nf_core.modules.modules_differ import ModulesDiffer
+from nf_core.components.components_differ import ComponentsDiffer
 from nf_core.modules.modules_json import ModulesJson
 
 log = logging.getLogger(__name__)
@@ -65,7 +65,9 @@ def patch(self, component=None):
         component_fullname = str(Path(self.component_type, self.modules_repo.repo_path, component))
 
         # Verify that the component has an entry in the modules.json file
-        if not self.modules_json.module_present(component, self.modules_repo.remote_url, component_dir):
+        if not self.modules_json.component_present(
+            component, self.modules_repo.remote_url, component_dir, self.component_type
+        ):
             raise UserWarning(
                 f"The '{component_fullname}' {self.component_type[:-1]} does not have an entry in the 'modules.json' file. Cannot compute patch"
             )
@@ -112,7 +114,7 @@ def patch(self, component=None):
         # Write the patch to a temporary location (otherwise it is printed to the screen later)
         patch_temp_path = tempfile.mktemp()
         try:
-            ModulesDiffer.write_diff_file(
+            ComponentsDiffer.write_diff_file(
                 patch_temp_path,
                 component,
                 self.modules_repo.repo_path,
@@ -127,11 +129,13 @@ def patch(self, component=None):
             raise UserWarning(f"{self.component_type[:-1]} '{component_fullname}' is unchanged. No patch to compute")
 
         # Write changes to modules.json
-        self.modules_json.add_patch_entry(component, self.modules_repo.remote_url, component_dir, patch_relpath)
+        self.modules_json.add_patch_entry(
+            self.component_type, component, self.modules_repo.remote_url, component_dir, patch_relpath
+        )
         log.debug(f"Wrote patch path for {self.component_type[:-1]} {component} to modules.json")
 
         # Show the changes made to the module
-        ModulesDiffer.print_diff(
+        ComponentsDiffer.print_diff(
             component,
             self.modules_repo.repo_path,
             component_install_dir,
@@ -166,7 +170,9 @@ def remove(self, component):
         component_fullname = str(Path(self.component_type, component_dir, component))
 
         # Verify that the component has an entry in the modules.json file
-        if not self.modules_json.module_present(component, self.modules_repo.remote_url, component_dir):
+        if not self.modules_json.component_present(
+            component, self.modules_repo.remote_url, component_dir, self.component_type
+        ):
             raise UserWarning(
                 f"The '{component_fullname}' {self.component_type[:-1]} does not have an entry in the 'modules.json' file. Cannot compute patch"
             )
@@ -202,7 +208,7 @@ def remove(self, component):
 
         # Try to apply the patch in reverse and move resulting files to module dir
         temp_component_dir = self.modules_json.try_apply_patch_reverse(
-            component, self.modules_repo.repo_path, patch_relpath, component_path
+            self.component_type, component, self.modules_repo.repo_path, patch_relpath, component_path
         )
         try:
             for file in Path(temp_component_dir).glob("*"):
diff --git a/nf_core/components/remove.py b/nf_core/components/remove.py
index c2c5843918..37208629c0 100644
--- a/nf_core/components/remove.py
+++ b/nf_core/components/remove.py
@@ -68,7 +68,7 @@ def remove(self, component, removed_by=None, removed_components=None, force=Fals
         if not component_dir.exists():
             log.error(f"Installation directory '{component_dir}' does not exist.")
 
-            if modules_json.module_present(component, self.modules_repo.remote_url, repo_path):
+            if modules_json.component_present(component, self.modules_repo.remote_url, repo_path, self.component_type):
                 log.error(f"Found entry for '{component}' in 'modules.json'. Removing...")
                 modules_json.remove_entry(self.component_type, component, self.modules_repo.remote_url, repo_path)
             return False
diff --git a/nf_core/components/update.py b/nf_core/components/update.py
index bf176fb6d9..901a7f02fe 100644
--- a/nf_core/components/update.py
+++ b/nf_core/components/update.py
@@ -9,13 +9,13 @@
 import nf_core.modules.modules_utils
 import nf_core.utils
 from nf_core.components.components_command import ComponentCommand
+from nf_core.components.components_differ import ComponentsDiffer
 from nf_core.components.components_utils import (
     get_components_to_install,
     prompt_component_version_sha,
 )
 from nf_core.components.install import ComponentInstall
 from nf_core.components.remove import ComponentRemove
-from nf_core.modules.modules_differ import ModulesDiffer
 from nf_core.modules.modules_json import ModulesJson
 from nf_core.modules.modules_repo import ModulesRepo
 from nf_core.utils import plural_es, plural_s, plural_y
@@ -223,7 +223,7 @@ def update(self, component=None, silent=False, updated=None, check_diff_exist=Tr
                         f"Writing diff file for {self.component_type[:-1]} '{component_fullname}' to '{self.save_diff_fn}'"
                     )
                     try:
-                        ModulesDiffer.write_diff_file(
+                        ComponentsDiffer.write_diff_file(
                             self.save_diff_fn,
                             component,
                             modules_repo.repo_path,
@@ -265,7 +265,7 @@ def update(self, component=None, silent=False, updated=None, check_diff_exist=Tr
                         self.manage_changes_in_linked_components(component, modules_to_update, subworkflows_to_update)
 
                 elif self.show_diff:
-                    ModulesDiffer.print_diff(
+                    ComponentsDiffer.print_diff(
                         component,
                         modules_repo.repo_path,
                         component_dir,
@@ -313,7 +313,7 @@ def update(self, component=None, silent=False, updated=None, check_diff_exist=Tr
 
         if self.save_diff_fn:
             # Write the modules.json diff to the file
-            ModulesDiffer.append_modules_json_diff(
+            ComponentsDiffer.append_modules_json_diff(
                 self.save_diff_fn,
                 old_modules_json,
                 self.modules_json.get_modules_json(),
@@ -449,7 +449,9 @@ def get_single_component_info(self, component):
                 self.modules_repo.setup_branch(current_branch)
 
         # If there is a patch file, get its filename
-        patch_fn = self.modules_json.get_patch_fn(component, self.modules_repo.remote_url, install_dir)
+        patch_fn = self.modules_json.get_patch_fn(
+            self.component_type, component, self.modules_repo.remote_url, install_dir
+        )
 
         return (self.modules_repo, component, sha, patch_fn)
 
@@ -695,7 +697,12 @@ def get_all_components_info(self, branch=None):
 
         # Add patch filenames to the components that have them
         components_info = [
-            (repo, comp, sha, self.modules_json.get_patch_fn(comp, repo.remote_url, repo.repo_path))
+            (
+                repo,
+                comp,
+                sha,
+                self.modules_json.get_patch_fn(self.component_type, comp, repo.remote_url, repo.repo_path),
+            )
             for repo, comp, sha in components_info
         ]
 
@@ -810,7 +817,9 @@ def try_apply_patch(
         shutil.copytree(component_install_dir, temp_component_dir)
 
         try:
-            new_files = ModulesDiffer.try_apply_patch(component, repo_path, patch_path, temp_component_dir)
+            new_files = ComponentsDiffer.try_apply_patch(
+                self.component_type, component, repo_path, patch_path, temp_component_dir
+            )
         except LookupError:
             # Patch failed. Save the patch file by moving to the install dir
             shutil.move(patch_path, Path(component_install_dir, patch_path.relative_to(component_dir)))
@@ -828,7 +837,7 @@ def try_apply_patch(
 
         # Create the new patch file
         log.debug("Regenerating patch file")
-        ModulesDiffer.write_diff_file(
+        ComponentsDiffer.write_diff_file(
             Path(temp_component_dir, patch_path.relative_to(component_dir)),
             component,
             repo_path,
@@ -848,7 +857,12 @@ def try_apply_patch(
 
         # Add the patch file to the modules.json file
         self.modules_json.add_patch_entry(
-            component, self.modules_repo.remote_url, repo_path, patch_relpath, write_file=write_file
+            self.component_type,
+            component,
+            self.modules_repo.remote_url,
+            repo_path,
+            patch_relpath,
+            write_file=write_file,
         )
 
         return True
diff --git a/nf_core/modules/lint/main_nf.py b/nf_core/modules/lint/main_nf.py
index df5a48d5bf..848e17130e 100644
--- a/nf_core/modules/lint/main_nf.py
+++ b/nf_core/modules/lint/main_nf.py
@@ -15,8 +15,8 @@
 
 import nf_core
 import nf_core.modules.modules_utils
+from nf_core.components.components_differ import ComponentsDiffer
 from nf_core.components.nfcore_component import NFCoreComponent
-from nf_core.modules.modules_differ import ModulesDiffer
 
 log = logging.getLogger(__name__)
 
@@ -50,7 +50,8 @@ def main_nf(
     # otherwise read the lines directly from the module
     lines: List[str] = []
     if module.is_patched:
-        lines = ModulesDiffer.try_apply_patch(
+        lines = ComponentsDiffer.try_apply_patch(
+            module.component_type,
             module.component_name,
             module_lint_object.modules_repo.repo_path,
             module.patch_path,
diff --git a/nf_core/modules/lint/meta_yml.py b/nf_core/modules/lint/meta_yml.py
index 4ad728d10b..d0268a40cc 100644
--- a/nf_core/modules/lint/meta_yml.py
+++ b/nf_core/modules/lint/meta_yml.py
@@ -6,9 +6,9 @@
 import ruamel.yaml
 from jsonschema import exceptions, validators
 
+from nf_core.components.components_differ import ComponentsDiffer
 from nf_core.components.lint import ComponentLint, LintExceptionError
 from nf_core.components.nfcore_component import NFCoreComponent
-from nf_core.modules.modules_differ import ModulesDiffer
 
 log = logging.getLogger(__name__)
 
@@ -46,7 +46,8 @@ def meta_yml(module_lint_object: ComponentLint, module: NFCoreComponent) -> None
     # Check if we have a patch file, get original file in that case
     meta_yaml = read_meta_yml(module_lint_object, module)
     if module.is_patched and module_lint_object.modules_repo.repo_path is not None:
-        lines = ModulesDiffer.try_apply_patch(
+        lines = ComponentsDiffer.try_apply_patch(
+            module.component_type,
             module.component_name,
             module_lint_object.modules_repo.repo_path,
             module.patch_path,
@@ -207,7 +208,8 @@ def read_meta_yml(module_lint_object: ComponentLint, module: NFCoreComponent) ->
     yaml.preserve_quotes = True
     # Check if we have a patch file, get original file in that case
     if module.is_patched:
-        lines = ModulesDiffer.try_apply_patch(
+        lines = ComponentsDiffer.try_apply_patch(
+            module.component_type,
             module.component_name,
             module_lint_object.modules_repo.repo_path,
             module.patch_path,
diff --git a/nf_core/modules/lint/module_changes.py b/nf_core/modules/lint/module_changes.py
index eb76f4b88b..121de00c0a 100644
--- a/nf_core/modules/lint/module_changes.py
+++ b/nf_core/modules/lint/module_changes.py
@@ -7,7 +7,7 @@
 from pathlib import Path
 
 import nf_core.modules.modules_repo
-from nf_core.modules.modules_differ import ModulesDiffer
+from nf_core.components.components_differ import ComponentsDiffer
 
 
 def module_changes(module_lint_object, module):
@@ -30,7 +30,8 @@ def module_changes(module_lint_object, module):
         tempdir = tempdir_parent / "tmp_module_dir"
         shutil.copytree(module.component_dir, tempdir)
         try:
-            new_lines = ModulesDiffer.try_apply_patch(
+            new_lines = ComponentsDiffer.try_apply_patch(
+                module.component_type,
                 module.component_name,
                 module.org,
                 module.patch_path,
diff --git a/nf_core/modules/lint/module_patch.py b/nf_core/modules/lint/module_patch.py
index 29bf78a66b..6347c5c553 100644
--- a/nf_core/modules/lint/module_patch.py
+++ b/nf_core/modules/lint/module_patch.py
@@ -1,7 +1,7 @@
 from pathlib import Path
 
+from ...components.components_differ import ComponentsDiffer
 from ...components.nfcore_component import NFCoreComponent
-from ..modules_differ import ModulesDiffer
 
 
 def module_patch(module_lint_obj, module: NFCoreComponent):
@@ -66,11 +66,11 @@ def check_patch_valid(module, patch_path):
                     continue
                 topath = Path(line.split(" ")[1].strip("\n"))
                 if frompath == Path("/dev/null"):
-                    paths_in_patch.append((frompath, ModulesDiffer.DiffEnum.CREATED))
+                    paths_in_patch.append((frompath, ComponentsDiffer.DiffEnum.CREATED))
                 elif topath == Path("/dev/null"):
-                    paths_in_patch.append((frompath, ModulesDiffer.DiffEnum.REMOVED))
+                    paths_in_patch.append((frompath, ComponentsDiffer.DiffEnum.REMOVED))
                 elif frompath == topath:
-                    paths_in_patch.append((frompath, ModulesDiffer.DiffEnum.CHANGED))
+                    paths_in_patch.append((frompath, ComponentsDiffer.DiffEnum.CHANGED))
                 else:
                     module.failed.append(
                         (
@@ -105,7 +105,7 @@ def check_patch_valid(module, patch_path):
     # Warn about any created or removed files
     passed = True
     for path, diff_status in paths_in_patch:
-        if diff_status == ModulesDiffer.DiffEnum.CHANGED:
+        if diff_status == ComponentsDiffer.DiffEnum.CHANGED:
             if not Path(module.base_dir, path).exists():
                 module.failed.append(
                     (
@@ -116,7 +116,7 @@ def check_patch_valid(module, patch_path):
                 )
                 passed = False
                 continue
-        elif diff_status == ModulesDiffer.DiffEnum.CREATED:
+        elif diff_status == ComponentsDiffer.DiffEnum.CREATED:
             if not Path(module.base_dir, path).exists():
                 module.failed.append(
                     (
@@ -130,7 +130,7 @@ def check_patch_valid(module, patch_path):
             module.warned.append(
                 ("patch", f"Patch file performs file creation of {path}. This is discouraged."), patch_path
             )
-        elif diff_status == ModulesDiffer.DiffEnum.REMOVED:
+        elif diff_status == ComponentsDiffer.DiffEnum.REMOVED:
             if Path(module.base_dir, path).exists():
                 module.failed.append(
                     (
@@ -161,7 +161,8 @@ def patch_reversible(module_lint_object, module, patch_path):
         (bool): False if any test failed, True otherwise
     """
     try:
-        ModulesDiffer.try_apply_patch(
+        ComponentsDiffer.try_apply_patch(
+            module.component_type,
             module.component_name,
             module_lint_object.modules_repo.repo_path,
             patch_path,
diff --git a/nf_core/modules/modules_json.py b/nf_core/modules/modules_json.py
index 05c64b6dee..9ae735b1c0 100644
--- a/nf_core/modules/modules_json.py
+++ b/nf_core/modules/modules_json.py
@@ -19,7 +19,7 @@
 from nf_core.modules.modules_repo import ModulesRepo
 from nf_core.pipelines.lint_utils import dump_json_with_prettier
 
-from .modules_differ import ModulesDiffer
+from ..components.components_differ import ComponentsDiffer
 
 log = logging.getLogger(__name__)
 
@@ -308,7 +308,9 @@ def determine_branches_and_shas(
                 # If the module/subworkflow is patched
                 patch_file = component_path / f"{component}.diff"
                 if patch_file.is_file():
-                    temp_module_dir = self.try_apply_patch_reverse(component, install_dir, patch_file, component_path)
+                    temp_module_dir = self.try_apply_patch_reverse(
+                        component_type, component, install_dir, patch_file, component_path
+                    )
                     correct_commit_sha = self.find_correct_commit_sha(
                         component_type, component, temp_module_dir, modules_repo
                     )
@@ -805,7 +807,7 @@ def remove_entry(self, component_type, name, repo_url, install_dir, removed_by=N
 
         return False
 
-    def add_patch_entry(self, module_name, repo_url, install_dir, patch_filename, write_file=True):
+    def add_patch_entry(self, component_type, component_name, repo_url, install_dir, patch_filename, write_file=True):
         """
         Adds (or replaces) the patch entry for a module
         """
@@ -815,9 +817,11 @@ def add_patch_entry(self, module_name, repo_url, install_dir, patch_filename, wr
 
         if repo_url not in self.modules_json["repos"]:
             raise LookupError(f"Repo '{repo_url}' not present in 'modules.json'")
-        if module_name not in self.modules_json["repos"][repo_url]["modules"][install_dir]:
-            raise LookupError(f"Module '{install_dir}/{module_name}' not present in 'modules.json'")
-        self.modules_json["repos"][repo_url]["modules"][install_dir][module_name]["patch"] = str(patch_filename)
+        if component_name not in self.modules_json["repos"][repo_url][component_type][install_dir]:
+            raise LookupError(
+                f"{component_type[:-1].title()} '{install_dir}/{component_name}' not present in 'modules.json'"
+            )
+        self.modules_json["repos"][repo_url][component_type][install_dir][component_name]["patch"] = str(patch_filename)
         if write_file:
             self.dump()
 
@@ -833,17 +837,17 @@ def remove_patch_entry(self, module_name, repo_url, install_dir, write_file=True
         if write_file:
             self.dump()
 
-    def get_patch_fn(self, module_name, repo_url, install_dir):
+    def get_patch_fn(self, component_type, component_name, repo_url, install_dir):
         """
-        Get the patch filename of a module
+        Get the patch filename of a component
 
         Args:
-            module_name (str): The name of the module
-            repo_url (str): The URL of the repository containing the module
-            install_dir (str): The name of the directory where modules are installed
+            component_name (str): The name of the component
+            repo_url (str): The URL of the repository containing the component
+            install_dir (str): The name of the directory where components are installed
 
         Returns:
-            (str): The patch filename for the module, None if not present
+            (str): The patch filename for the component, None if not present
         """
         if self.modules_json is None:
             self.load()
@@ -851,48 +855,53 @@ def get_patch_fn(self, module_name, repo_url, install_dir):
         path = (
             self.modules_json["repos"]
             .get(repo_url, {})
-            .get("modules")
+            .get(component_type)
             .get(install_dir)
-            .get(module_name, {})
+            .get(component_name, {})
             .get("patch")
         )
         return Path(path) if path is not None else None
 
-    def try_apply_patch_reverse(self, module, repo_name, patch_relpath, module_dir):
+    def try_apply_patch_reverse(self, component_type, component, repo_name, patch_relpath, component_dir):
         """
-        Try reverse applying a patch file to the modified module files
+        Try reverse applying a patch file to the modified module or subworkflow files
 
         Args:
-            module (str): The name of the module
-            repo_name (str): The name of the repository where the module resides
+            component_type (str): The type of component [modules, subworkflows]
+            component (str): The name of the module or subworkflow
+            repo_name (str): The name of the repository where the component resides
             patch_relpath (Path | str): The path to patch file in the pipeline
-            module_dir (Path | str): The module directory in the pipeline
+            component_dir (Path | str): The component directory in the pipeline
 
         Returns:
-            (Path | str): The path of the folder where the module patched files are
+            (Path | str): The path of the folder where the component patched files are
 
         Raises:
             LookupError: If patch was not applied
         """
-        module_fullname = str(Path(repo_name, module))
+        component_fullname = str(Path(repo_name, component))
         patch_path = Path(self.directory / patch_relpath)
 
         try:
-            new_files = ModulesDiffer.try_apply_patch(module, repo_name, patch_path, module_dir, reverse=True)
+            new_files = ComponentsDiffer.try_apply_patch(
+                component_type, component, repo_name, patch_path, component_dir, reverse=True
+            )
         except LookupError as e:
-            raise LookupError(f"Failed to apply patch in reverse for module '{module_fullname}' due to: {e}")
+            raise LookupError(
+                f"Failed to apply patch in reverse for {component_type[:-1]} '{component_fullname}' due to: {e}"
+            )
 
         # Write the patched files to a temporary directory
         log.debug("Writing patched files to tmpdir")
         temp_dir = Path(tempfile.mkdtemp())
-        temp_module_dir = temp_dir / module
-        temp_module_dir.mkdir(parents=True, exist_ok=True)
+        temp_component_dir = temp_dir / component
+        temp_component_dir.mkdir(parents=True, exist_ok=True)
         for file, new_content in new_files.items():
-            fn = temp_module_dir / file
+            fn = temp_component_dir / file
             with open(fn, "w") as fh:
                 fh.writelines(new_content)
 
-        return temp_module_dir
+        return temp_component_dir
 
     def repo_present(self, repo_name):
         """
@@ -908,20 +917,21 @@ def repo_present(self, repo_name):
 
         return repo_name in self.modules_json.get("repos", {})
 
-    def module_present(self, module_name, repo_url, install_dir):
+    def component_present(self, module_name, repo_url, install_dir, component_type):
         """
         Checks if a module is present in the modules.json file
         Args:
             module_name (str): Name of the module
             repo_url (str): URL of the repository
             install_dir (str): Name of the directory where modules are installed
+            component_type (str): Type of component [modules, subworkflows]
         Returns:
             (bool): Whether the module is present in the 'modules.json' file
         """
         if self.modules_json is None:
             self.load()
             assert self.modules_json is not None  # mypy
-        return module_name in self.modules_json.get("repos", {}).get(repo_url, {}).get("modules", {}).get(
+        return module_name in self.modules_json.get("repos", {}).get(repo_url, {}).get(component_type, {}).get(
             install_dir, {}
         )
 
diff --git a/nf_core/subworkflows/__init__.py b/nf_core/subworkflows/__init__.py
index 88e8a09388..8e3c85a271 100644
--- a/nf_core/subworkflows/__init__.py
+++ b/nf_core/subworkflows/__init__.py
@@ -3,5 +3,6 @@
 from .install import SubworkflowInstall
 from .lint import SubworkflowLint
 from .list import SubworkflowList
+from .patch import SubworkflowPatch
 from .remove import SubworkflowRemove
 from .update import SubworkflowUpdate
diff --git a/nf_core/subworkflows/lint/subworkflow_changes.py b/nf_core/subworkflows/lint/subworkflow_changes.py
index a9c9616a21..cf0fd7211c 100644
--- a/nf_core/subworkflows/lint/subworkflow_changes.py
+++ b/nf_core/subworkflows/lint/subworkflow_changes.py
@@ -2,9 +2,12 @@
 Check whether the content of a subworkflow has changed compared to the original repository
 """
 
+import shutil
+import tempfile
 from pathlib import Path
 
 import nf_core.modules.modules_repo
+from nf_core.components.components_differ import ComponentsDiffer
 
 
 def subworkflow_changes(subworkflow_lint_object, subworkflow):
@@ -20,7 +23,29 @@ def subworkflow_changes(subworkflow_lint_object, subworkflow):
 
     Only runs when linting a pipeline, not the modules repository
     """
-    tempdir = subworkflow.component_dir
+    if subworkflow.is_patched:
+        # If the subworkflow is patched, we need to apply
+        # the patch in reverse before comparing with the remote
+        tempdir_parent = Path(tempfile.mkdtemp())
+        tempdir = tempdir_parent / "tmp_subworkflow_dir"
+        shutil.copytree(subworkflow.component_dir, tempdir)
+        try:
+            new_lines = ComponentsDiffer.try_apply_patch(
+                subworkflow.component_type,
+                subworkflow.component_name,
+                subworkflow.org,
+                subworkflow.patch_path,
+                tempdir,
+                reverse=True,
+            )
+            for file, lines in new_lines.items():
+                with open(tempdir / file, "w") as fh:
+                    fh.writelines(lines)
+        except LookupError:
+            # This error is already reported by subworkflow_patch, so just return
+            return
+    else:
+        tempdir = subworkflow.component_dir
     subworkflow.branch = subworkflow_lint_object.modules_json.get_component_branch(
         "subworkflows", subworkflow.component_name, subworkflow.repo_url, subworkflow.org
     )
diff --git a/nf_core/subworkflows/patch.py b/nf_core/subworkflows/patch.py
new file mode 100644
index 0000000000..3c8b3d5e4d
--- /dev/null
+++ b/nf_core/subworkflows/patch.py
@@ -0,0 +1,10 @@
+import logging
+
+from nf_core.components.patch import ComponentPatch
+
+log = logging.getLogger(__name__)
+
+
+class SubworkflowPatch(ComponentPatch):
+    def __init__(self, pipeline_dir, remote_url=None, branch=None, no_pull=False, installed_by=False):
+        super().__init__(pipeline_dir, "subworkflows", remote_url, branch, no_pull, installed_by)
diff --git a/tests/modules/test_modules_json.py b/tests/modules/test_modules_json.py
index 0368c146c4..325a8073b7 100644
--- a/tests/modules/test_modules_json.py
+++ b/tests/modules/test_modules_json.py
@@ -175,14 +175,17 @@ def test_mod_json_repo_present(self):
         assert mod_json_obj.repo_present(NF_CORE_MODULES_REMOTE) is True
         assert mod_json_obj.repo_present("INVALID_REPO") is False
 
-    def test_mod_json_module_present(self):
-        """Tests the module_present function"""
+    def test_mod_json_component_present(self):
+        """Tests the component_present function"""
         mod_json_obj = ModulesJson(self.pipeline_dir)
 
-        assert mod_json_obj.module_present("fastqc", NF_CORE_MODULES_REMOTE, NF_CORE_MODULES_NAME) is True
-        assert mod_json_obj.module_present("INVALID_MODULE", NF_CORE_MODULES_REMOTE, NF_CORE_MODULES_NAME) is False
-        assert mod_json_obj.module_present("fastqc", "INVALID_REPO", "INVALID_DIR") is False
-        assert mod_json_obj.module_present("INVALID_MODULE", "INVALID_REPO", "INVALID_DIR") is False
+        assert mod_json_obj.component_present("fastqc", NF_CORE_MODULES_REMOTE, NF_CORE_MODULES_NAME, "modules") is True
+        assert (
+            mod_json_obj.component_present("INVALID_MODULE", NF_CORE_MODULES_REMOTE, NF_CORE_MODULES_NAME, "modules")
+            is False
+        )
+        assert mod_json_obj.component_present("fastqc", "INVALID_REPO", "INVALID_DIR", "modules") is False
+        assert mod_json_obj.component_present("INVALID_MODULE", "INVALID_REPO", "INVALID_DIR", "modules") is False
 
     def test_mod_json_get_module_version(self):
         """Test the get_module_version function"""
diff --git a/tests/modules/test_patch.py b/tests/modules/test_patch.py
index 2f60cd4a20..f608278618 100644
--- a/tests/modules/test_patch.py
+++ b/tests/modules/test_patch.py
@@ -76,11 +76,11 @@ def test_create_patch_no_change(self):
         module_path = Path(self.pipeline_dir, "modules", REPO_NAME, BISMARK_ALIGN)
 
         # Check that no patch file has been added to the directory
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml"}
+        assert not (module_path / "bismark-align.diff").exists()
 
         # Check the 'modules.json' contains no patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) is None
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) is None
 
     def test_create_patch_change(self):
         """Test creating a patch when there is a change to the module"""
@@ -94,11 +94,11 @@ def test_create_patch_change(self):
 
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -127,11 +127,11 @@ def test_create_patch_try_apply_successful(self):
 
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -153,11 +153,11 @@ def test_create_patch_try_apply_successful(self):
         update_obj.move_files_from_tmp_dir(BISMARK_ALIGN, install_dir, REPO_NAME, SUCCEED_SHA)
 
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -195,11 +195,11 @@ def test_create_patch_try_apply_failed(self):
 
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -234,11 +234,11 @@ def test_create_patch_update_success(self):
 
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, GITLAB_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, GITLAB_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -254,13 +254,13 @@ def test_create_patch_update_success(self):
         assert update_obj.update(BISMARK_ALIGN)
 
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, GITLAB_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, GITLAB_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
-        ), modules_json_obj.get_patch_fn(BISMARK_ALIGN, GITLAB_URL, REPO_NAME)
+        ), modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, GITLAB_URL, REPO_NAME)
 
         # Check that the correct lines are in the patch file
         with open(module_path / patch_fn) as fh:
@@ -295,11 +295,11 @@ def test_create_patch_update_fail(self):
 
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
         # Check that a patch file with the correct name has been created
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -349,11 +349,11 @@ def test_remove_patch(self):
 
         # Check that a patch file with the correct name has been created
         patch_fn = f"{'-'.join(BISMARK_ALIGN.split('/'))}.diff"
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml", patch_fn}
+        assert (module_path / patch_fn).exists()
 
         # Check the 'modules.json' contains a patch file for the module
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) == Path(
             "modules", REPO_NAME, BISMARK_ALIGN, patch_fn
         )
 
@@ -361,8 +361,8 @@ def test_remove_patch(self):
             mock_questionary.unsafe_ask.return_value = True
             patch_obj.remove(BISMARK_ALIGN)
         # Check that the diff file has been removed
-        assert set(os.listdir(module_path)) == {"main.nf", "meta.yml", "environment.yml"}
+        assert not (module_path / patch_fn).exists()
 
         # Check that the 'modules.json' entry has been removed
         modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
-        assert modules_json_obj.get_patch_fn(BISMARK_ALIGN, REPO_URL, REPO_NAME) is None
+        assert modules_json_obj.get_patch_fn("modules", BISMARK_ALIGN, REPO_URL, REPO_NAME) is None
diff --git a/tests/subworkflows/test_patch.py b/tests/subworkflows/test_patch.py
new file mode 100644
index 0000000000..5bb6a6798e
--- /dev/null
+++ b/tests/subworkflows/test_patch.py
@@ -0,0 +1,307 @@
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+import nf_core.components.components_command
+import nf_core.components.patch
+import nf_core.subworkflows
+
+from ..test_subworkflows import TestSubworkflows
+from ..utils import GITLAB_REPO, GITLAB_SUBWORKFLOWS_BRANCH, GITLAB_URL
+
+OLD_SHA = "dbb12457e32d3da8eea7dc4ae096201fff4747c5"
+SUCCEED_SHA = "0a33e6a0d730ad22a0ec9f7f9a7540af6e943221"
+FAIL_SHA = "b6e5e8739de9a1a0c4f85267144e43dbaf8f1461"
+
+
+class TestSubworkflowsPatch(TestSubworkflows):
+    """
+    Test the 'nf-core subworkflows patch' command
+    """
+
+    def modify_main_nf(self, path):
+        """Modify a file to test patch creation"""
+        with open(path) as fh:
+            lines = fh.readlines()
+        # We want a patch file that looks something like:
+        # -    ch_fasta // channel: [ fasta ]
+        for line_index in range(len(lines)):
+            if lines[line_index] == "    ch_fasta // channel: [ fasta ]\n":
+                to_pop = line_index
+        lines.pop(to_pop)
+        with open(path, "w") as fh:
+            fh.writelines(lines)
+
+    def setup_patch(self, pipeline_dir, modify_subworkflow):
+        # Install the subworkflow bam_sort_stats_samtools
+        install_obj = nf_core.subworkflows.SubworkflowInstall(
+            pipeline_dir,
+            prompt=False,
+            force=False,
+            remote_url=GITLAB_URL,
+            branch=GITLAB_SUBWORKFLOWS_BRANCH,
+            sha=OLD_SHA,
+        )
+
+        # Install the module
+        install_obj.install("bam_sort_stats_samtools")
+
+        if modify_subworkflow:
+            # Modify the subworkflow
+            subworkflow_path = Path(pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+            self.modify_main_nf(subworkflow_path / "main.nf")
+
+    def test_create_patch_no_change(self):
+        """Test creating a patch when there is a change to the module"""
+        self.setup_patch(self.pipeline_dir, False)
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        with pytest.raises(UserWarning):
+            patch_obj.patch("bam_sort_stats_samtools")
+
+        subworkflow_path = Path(self.pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+
+        # Check that no patch file has been added to the directory
+        assert not (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+    def test_create_patch_change(self):
+        """Test creating a patch when there is no change to the subworkflow"""
+        self.setup_patch(self.pipeline_dir, True)
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        subworkflow_path = Path(self.pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+
+        # Check that a patch file with the correct name has been created
+        assert (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+        # Check that the correct lines are in the patch file
+        with open(subworkflow_path / "bam_sort_stats_samtools.diff") as fh:
+            patch_lines = fh.readlines()
+        print(patch_lines)
+        subworkflow_relpath = subworkflow_path.relative_to(self.pipeline_dir)
+        assert f"--- {subworkflow_relpath / 'main.nf'}\n" in patch_lines, subworkflow_relpath / "main.nf"
+        assert f"+++ {subworkflow_relpath / 'main.nf'}\n" in patch_lines
+        assert "-    ch_fasta // channel: [ fasta ]\n" in patch_lines
+
+    def test_create_patch_try_apply_successful(self):
+        """Test creating a patch file and applying it to a new version of the the files"""
+        self.setup_patch(self.pipeline_dir, True)
+        subworkflow_relpath = Path("subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+        subworkflow_path = Path(self.pipeline_dir, subworkflow_relpath)
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        # Check that a patch file with the correct name has been created
+        assert (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+        update_obj = nf_core.subworkflows.SubworkflowUpdate(
+            self.pipeline_dir, sha=OLD_SHA, remote_url=GITLAB_URL, branch=GITLAB_SUBWORKFLOWS_BRANCH
+        )
+
+        # Install the new files
+        install_dir = Path(tempfile.mkdtemp())
+        update_obj.install_component_files("bam_sort_stats_samtools", OLD_SHA, update_obj.modules_repo, install_dir)
+
+        # Try applying the patch
+        subworkflow_install_dir = install_dir / "bam_sort_stats_samtools"
+        patch_relpath = subworkflow_relpath / "bam_sort_stats_samtools.diff"
+        assert (
+            update_obj.try_apply_patch(
+                "bam_sort_stats_samtools", GITLAB_REPO, patch_relpath, subworkflow_path, subworkflow_install_dir
+            )
+            is True
+        )
+
+        # Move the files from the temporary directory
+        update_obj.move_files_from_tmp_dir("bam_sort_stats_samtools", install_dir, GITLAB_REPO, OLD_SHA)
+
+        # Check that a patch file with the correct name has been created
+        assert (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+        # Check that the correct lines are in the patch file
+        with open(subworkflow_path / "bam_sort_stats_samtools.diff") as fh:
+            patch_lines = fh.readlines()
+        subworkflow_relpath = subworkflow_path.relative_to(self.pipeline_dir)
+        assert f"--- {subworkflow_relpath / 'main.nf'}\n" in patch_lines, subworkflow_relpath / "main.nf"
+        assert f"+++ {subworkflow_relpath / 'main.nf'}\n" in patch_lines
+        assert "-    ch_fasta // channel: [ fasta ]\n" in patch_lines
+
+        # Check that 'main.nf' is updated correctly
+        with open(subworkflow_path / "main.nf") as fh:
+            main_nf_lines = fh.readlines()
+        # These lines should have been removed by the patch
+        assert "-    ch_fasta // channel: [ fasta ]\n" not in main_nf_lines
+
+    def test_create_patch_try_apply_failed(self):
+        """Test creating a patch file and applying it to a new version of the the files"""
+        self.setup_patch(self.pipeline_dir, True)
+        subworkflow_relpath = Path("subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+        subworkflow_path = Path(self.pipeline_dir, subworkflow_relpath)
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        # Check that a patch file with the correct name has been created
+        assert (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+        update_obj = nf_core.subworkflows.SubworkflowUpdate(
+            self.pipeline_dir, remote_url=GITLAB_URL, branch=GITLAB_SUBWORKFLOWS_BRANCH
+        )
+
+        # Install the new files
+        install_dir = Path(tempfile.mkdtemp())
+        update_obj.install_component_files("bam_sort_stats_samtools", FAIL_SHA, update_obj.modules_repo, install_dir)
+
+        # Try applying the patch
+        subworkflow_install_dir = install_dir / "bam_sort_stats_samtools"
+        patch_relpath = subworkflow_relpath / "bam_sort_stats_samtools.diff"
+        assert (
+            update_obj.try_apply_patch(
+                "bam_sort_stats_samtools", GITLAB_REPO, patch_relpath, subworkflow_path, subworkflow_install_dir
+            )
+            is False
+        )
+
+    def test_create_patch_update_success(self):
+        """
+        Test creating a patch file and the updating the subworkflow
+
+        Should have the same effect as 'test_create_patch_try_apply_successful'
+        but uses higher level api
+        """
+        self.setup_patch(self.pipeline_dir, True)
+        swf_path = Path(self.pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        patch_fn = "bam_sort_stats_samtools.diff"
+        # Check that a patch file with the correct name has been created
+        assert (swf_path / patch_fn).exists()
+
+        # Check the 'modules.json' contains a patch file for the subworkflow
+        modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
+        assert modules_json_obj.get_patch_fn(
+            "subworkflows", "bam_sort_stats_samtools", GITLAB_URL, GITLAB_REPO
+        ) == Path("subworkflows", GITLAB_REPO, "bam_sort_stats_samtools", patch_fn)
+
+        # Update the subworkflow
+        update_obj = nf_core.subworkflows.update.SubworkflowUpdate(
+            self.pipeline_dir,
+            sha=OLD_SHA,
+            show_diff=False,
+            update_deps=True,
+            remote_url=GITLAB_URL,
+            branch=GITLAB_SUBWORKFLOWS_BRANCH,
+        )
+        assert update_obj.update("bam_sort_stats_samtools")
+
+        # Check that a patch file with the correct name has been created
+        assert (swf_path / patch_fn).exists()
+
+        # Check the 'modules.json' contains a patch file for the subworkflow
+        modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
+        assert modules_json_obj.get_patch_fn(
+            "subworkflows", "bam_sort_stats_samtools", GITLAB_URL, GITLAB_REPO
+        ) == Path("subworkflows", GITLAB_REPO, "bam_sort_stats_samtools", patch_fn), modules_json_obj.get_patch_fn(
+            "subworkflows", "bam_sort_stats_samtools", GITLAB_URL, GITLAB_REPO
+        )
+
+        # Check that the correct lines are in the patch file
+        with open(swf_path / patch_fn) as fh:
+            patch_lines = fh.readlines()
+        swf_relpath = swf_path.relative_to(self.pipeline_dir)
+        assert f"--- {swf_relpath / 'main.nf'}\n" in patch_lines
+        assert f"+++ {swf_relpath / 'main.nf'}\n" in patch_lines
+        assert "-    ch_fasta // channel: [ fasta ]\n" in patch_lines
+
+        # Check that 'main.nf' is updated correctly
+        with open(swf_path / "main.nf") as fh:
+            main_nf_lines = fh.readlines()
+        # this line should have been removed by the patch
+        assert "    ch_fasta // channel: [ fasta ]\n" not in main_nf_lines
+
+    def test_create_patch_update_fail(self):
+        """
+        Test creating a patch file and updating a subworkflow when there is a diff conflict
+        """
+        self.setup_patch(self.pipeline_dir, True)
+        swf_path = Path(self.pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        patch_fn = "bam_sort_stats_samtools.diff"
+        # Check that a patch file with the correct name has been created
+        assert (swf_path / patch_fn).exists()
+
+        # Check the 'modules.json' contains a patch file for the subworkflow
+        modules_json_obj = nf_core.modules.modules_json.ModulesJson(self.pipeline_dir)
+        assert modules_json_obj.get_patch_fn(
+            "subworkflows", "bam_sort_stats_samtools", GITLAB_URL, GITLAB_REPO
+        ) == Path("subworkflows", GITLAB_REPO, "bam_sort_stats_samtools", patch_fn)
+
+        # Save the file contents for downstream comparison
+        with open(swf_path / patch_fn) as fh:
+            patch_contents = fh.read()
+
+        update_obj = nf_core.subworkflows.update.SubworkflowUpdate(
+            self.pipeline_dir,
+            sha=FAIL_SHA,
+            show_diff=False,
+            update_deps=True,
+            remote_url=GITLAB_URL,
+            branch=GITLAB_SUBWORKFLOWS_BRANCH,
+        )
+        update_obj.update("bam_sort_stats_samtools")
+
+        # Check that the installed files have not been affected by the attempted patch
+        temp_dir = Path(tempfile.mkdtemp())
+        nf_core.components.components_command.ComponentCommand(
+            "subworkflows", self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH
+        ).install_component_files("bam_sort_stats_samtools", FAIL_SHA, update_obj.modules_repo, temp_dir)
+
+        temp_module_dir = temp_dir / "bam_sort_stats_samtools"
+        for file in os.listdir(temp_module_dir):
+            assert file in os.listdir(swf_path)
+            with open(swf_path / file) as fh:
+                installed = fh.read()
+            with open(temp_module_dir / file) as fh:
+                shouldbe = fh.read()
+            assert installed == shouldbe
+
+        # Check that the patch file is unaffected
+        with open(swf_path / patch_fn) as fh:
+            new_patch_contents = fh.read()
+        assert patch_contents == new_patch_contents
+
+    def test_remove_patch(self):
+        """Test creating a patch when there is no change to the subworkflow"""
+        self.setup_patch(self.pipeline_dir, True)
+
+        # Try creating a patch file
+        patch_obj = nf_core.subworkflows.SubworkflowPatch(self.pipeline_dir, GITLAB_URL, GITLAB_SUBWORKFLOWS_BRANCH)
+        patch_obj.patch("bam_sort_stats_samtools")
+
+        subworkflow_path = Path(self.pipeline_dir, "subworkflows", GITLAB_REPO, "bam_sort_stats_samtools")
+
+        # Check that a patch file with the correct name has been created
+        assert (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
+
+        with mock.patch.object(nf_core.components.patch.questionary, "confirm") as mock_questionary:
+            mock_questionary.unsafe_ask.return_value = True
+            patch_obj.remove("bam_sort_stats_samtools")
+        # Check that the diff file has been removed
+        assert not (subworkflow_path / "bam_sort_stats_samtools.diff").exists()
diff --git a/tests/subworkflows/test_update.py b/tests/subworkflows/test_update.py
index 153038cd1d..9f5d1939f3 100644
--- a/tests/subworkflows/test_update.py
+++ b/tests/subworkflows/test_update.py
@@ -98,7 +98,7 @@ def test_install_at_hash_and_update_and_save_diff_to_file(self):
         with open(patch_path) as fh:
             line = fh.readline()
             assert line.startswith(
-                "Changes in module 'nf-core/fastq_align_bowtie2' between (f3c078809a2513f1c95de14f6633fe1f03572fdb) and"
+                "Changes in component 'nf-core/fastq_align_bowtie2' between (f3c078809a2513f1c95de14f6633fe1f03572fdb) and"
             )
 
     def test_install_at_hash_and_update_and_save_diff_limit_output(self):