diff --git a/supervisor/addons/addon.py b/supervisor/addons/addon.py
index a2f956ec134..f08391b5d60 100644
--- a/supervisor/addons/addon.py
+++ b/supervisor/addons/addon.py
@@ -259,7 +259,7 @@ async def load(self) -> None:
             # Ensure we are using correct image for this system
             await self.instance.check_image(self.version, default_image, self.arch)
         except DockerError:
-            _LOGGER.info("No %s addon Docker image %s found", self.slug, self.image)
+            _LOGGER.info("No %s app Docker image %s found", self.slug, self.image)
             with suppress(DockerError, AddonNotSupportedError):
                 await self.instance.install(self.version, default_image, arch=self.arch)
 
@@ -567,7 +567,7 @@ def ingress_port(self) -> int | None:
 
         port = self.data[ATTR_INGRESS_PORT]
         if port == 0:
-            raise RuntimeError(f"No port set for add-on {self.slug}")
+            raise RuntimeError(f"No port set for app {self.slug}")
         return port
 
     @property
@@ -748,10 +748,10 @@ async def write_options(self) -> None:
                 validation_error=humanize_error(self.options, ex),
             ) from None
         except ConfigurationFileError as err:
-            _LOGGER.error("Add-on %s can't write options", self.slug)
+            _LOGGER.error("App %s can't write options", self.slug)
             raise AddonUnknownError(addon=self.slug) from err
 
-        _LOGGER.debug("Add-on %s write options: %s", self.slug, options)
+        _LOGGER.debug("App %s write options: %s", self.slug, options)
 
     @Job(
         name="addon_unload",
@@ -771,7 +771,7 @@ async def unload(self) -> None:
 
         def remove_data_dir():
             if self.path_data.is_dir():
-                _LOGGER.info("Removing add-on data folder %s", self.path_data)
+                _LOGGER.info("Removing app data folder %s", self.path_data)
                 remove_data(self.path_data)
 
         await self.sys_run_in_executor(remove_data_dir)
@@ -801,7 +801,7 @@ async def install(self) -> None:
         def setup_data():
             if not self.path_data.is_dir():
                 _LOGGER.info(
-                    "Creating Home Assistant add-on data folder %s", self.path_data
+                    "Creating Home Assistant app data folder %s", self.path_data
                 )
                 self.path_data.mkdir()
 
@@ -819,14 +819,14 @@ def setup_data():
             await self.sys_addons.data.uninstall(self)
             raise
         except DockerBuildError as err:
-            _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not build image for app %s: %s", self.slug, err)
             await self.sys_addons.data.uninstall(self)
             raise AddonBuildFailedUnknownError(addon=self.slug) from err
         except DockerRegistryAuthError:
             await self.sys_addons.data.uninstall(self)
             raise
         except DockerError as err:
-            _LOGGER.error("Could not pull image to update addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not pull image to update app %s: %s", self.slug, err)
             await self.sys_addons.data.uninstall(self)
             raise AddonUnknownError(addon=self.slug) from err
 
@@ -852,7 +852,7 @@ async def uninstall(
         try:
             await self.instance.remove(remove_image=remove_image)
         except DockerError as err:
-            _LOGGER.error("Could not remove image for addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not remove image for app %s: %s", self.slug, err)
             raise AddonUnknownError(addon=self.slug) from err
 
         self.state = AddonState.UNKNOWN
@@ -927,12 +927,12 @@ async def update(self) -> asyncio.Task | None:
         try:
             await self.instance.update(store.version, store.image, arch=self.arch)
         except DockerBuildError as err:
-            _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not build image for app %s: %s", self.slug, err)
             raise AddonBuildFailedUnknownError(addon=self.slug) from err
         except DockerRegistryAuthError:
             raise
         except DockerError as err:
-            _LOGGER.error("Could not pull image to update addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not pull image to update app %s: %s", self.slug, err)
             raise AddonUnknownError(addon=self.slug) from err
 
         # Stop the addon if running
@@ -940,7 +940,7 @@ async def update(self) -> asyncio.Task | None:
             await self.stop()
 
         try:
-            _LOGGER.info("Add-on '%s' successfully updated", self.slug)
+            _LOGGER.info("App '%s' successfully updated", self.slug)
             await self.sys_addons.data.update(store)
             await self._check_ingress_port()
 
@@ -983,19 +983,19 @@ async def rebuild(self) -> asyncio.Task | None:
             try:
                 await self.instance.remove()
             except DockerError as err:
-                _LOGGER.error("Could not remove image for addon %s: %s", self.slug, err)
+                _LOGGER.error("Could not remove image for app %s: %s", self.slug, err)
                 raise AddonUnknownError(addon=self.slug) from err
 
             try:
                 await self.instance.install(self.version)
             except DockerBuildError as err:
-                _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+                _LOGGER.error("Could not build image for app %s: %s", self.slug, err)
                 raise AddonBuildFailedUnknownError(addon=self.slug) from err
             except DockerRegistryAuthError:
                 raise
             except DockerError as err:
                 _LOGGER.error(
-                    "Could not pull image to update addon %s: %s", self.slug, err
+                    "Could not pull image to update app %s: %s", self.slug, err
                 )
                 raise AddonUnknownError(addon=self.slug) from err
 
@@ -1008,7 +1008,7 @@ async def rebuild(self) -> asyncio.Task | None:
             if self.with_ingress:
                 await self.sys_ingress.reload()
 
-            _LOGGER.info("Add-on '%s' successfully rebuilt", self.slug)
+            _LOGGER.info("App '%s' successfully rebuilt", self.slug)
 
         finally:
             # restore state
@@ -1035,12 +1035,10 @@ def write_pulse_config():
             await self.sys_run_in_executor(write_pulse_config)
         except OSError as err:
             self.sys_resolution.check_oserror(err)
-            _LOGGER.error(
-                "Add-on %s can't write pulse/client.config: %s", self.slug, err
-            )
+            _LOGGER.error("App %s can't write pulse/client.config: %s", self.slug, err)
         else:
             _LOGGER.debug(
-                "Add-on %s write pulse/client.config: %s", self.slug, self.path_pulse
+                "App %s write pulse/client.config: %s", self.slug, self.path_pulse
             )
 
     async def install_apparmor(self) -> None:
@@ -1106,7 +1104,7 @@ def test_update_schema(self) -> bool:
         try:
             new_schema(options)
         except vol.Invalid:
-            _LOGGER.warning("Add-on %s new schema is not compatible", self.slug)
+            _LOGGER.warning("App %s new schema is not compatible", self.slug)
             return False
         return True
 
@@ -1116,12 +1114,12 @@ async def _wait_for_startup(self) -> None:
             await asyncio.wait_for(self._startup_event.wait(), STARTUP_TIMEOUT)
         except TimeoutError:
             _LOGGER.warning(
-                "Timeout while waiting for addon %s to start, took more than %s seconds",
+                "Timeout while waiting for app %s to start, took more than %s seconds",
                 self.name,
                 STARTUP_TIMEOUT,
             )
         except asyncio.CancelledError as err:
-            _LOGGER.info("Wait for addon startup task cancelled due to: %s", err)
+            _LOGGER.info("Wait for app startup task cancelled due to: %s", err)
         finally:
             if self._wait_for_startup_task is asyncio.current_task():
                 self._wait_for_startup_task = None
@@ -1162,7 +1160,7 @@ def _check_addon_config_dir():
                 return
 
             _LOGGER.info(
-                "Creating Home Assistant add-on config folder %s", self.path_config
+                "Creating Home Assistant app config folder %s", self.path_config
             )
             self.path_config.mkdir()
 
@@ -1180,7 +1178,7 @@ def _check_addon_config_dir():
                 port=cast(dict[str, Any], err.extra_fields)["port"],
             ) from err
         except DockerError as err:
-            _LOGGER.error("Could not start container for addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not start container for app %s: %s", self.slug, err)
             self.state = AddonState.ERROR
             raise AddonUnknownError(addon=self.slug) from err
 
@@ -1198,7 +1196,7 @@ async def stop(self) -> None:
         try:
             await self.instance.stop()
         except DockerError as err:
-            _LOGGER.error("Could not stop container for addon %s: %s", self.slug, err)
+            _LOGGER.error("Could not stop container for app %s: %s", self.slug, err)
             self.state = AddonState.ERROR
             raise AddonUnknownError(addon=self.slug) from err
 
@@ -1232,7 +1230,7 @@ async def stats(self) -> DockerStats:
             return await self.instance.stats()
         except DockerError as err:
             _LOGGER.error(
-                "Could not get stats of container for addon %s: %s", self.slug, err
+                "Could not get stats of container for app %s: %s", self.slug, err
             )
             raise AddonUnknownError(addon=self.slug) from err
 
@@ -1253,7 +1251,7 @@ async def write_stdin(self, data) -> None:
             await self.instance.write_stdin(data)
         except DockerError as err:
             _LOGGER.error(
-                "Could not write stdin to container for addon %s: %s", self.slug, err
+                "Could not write stdin to container for app %s: %s", self.slug, err
             )
             raise AddonUnknownError(addon=self.slug) from err
 
@@ -1288,7 +1286,7 @@ async def begin_backup(self) -> bool:
             return False
 
         if self.backup_mode == AddonBackupMode.COLD:
-            _LOGGER.info("Shutdown add-on %s for cold backup", self.slug)
+            _LOGGER.info("Shutdown app %s for cold backup", self.slug)
             await self.stop()
 
         elif self.backup_pre is not None:
@@ -1308,7 +1306,7 @@ async def end_backup(self) -> asyncio.Task | None:
         for cold backup. Else nothing is returned.
         """
         if self.backup_mode is AddonBackupMode.COLD:
-            _LOGGER.info("Starting add-on %s again", self.slug)
+            _LOGGER.info("Starting app %s again", self.slug)
             return await self.start()
 
         if self.backup_post is not None:
@@ -1417,7 +1415,7 @@ def _addon_backup(
             TemporaryDirectory, dir=self.sys_config.path_tmp
         )
         temp_path = Path(temp_dir.name)
-        _LOGGER.info("Building backup for add-on %s", self.slug)
+        _LOGGER.info("Building backup for app %s", self.slug)
         try:
             # store local image
             if self.need_build:
@@ -1433,12 +1431,12 @@ def _addon_backup(
                     temp_path=temp_path,
                 )
             )
-            _LOGGER.info("Finish backup for addon %s", self.slug)
+            _LOGGER.info("Finish backup for app %s", self.slug)
         except DockerError as err:
-            _LOGGER.error("Can't export image for addon %s: %s", self.slug, err)
+            _LOGGER.error("Can't export image for app %s: %s", self.slug, err)
             raise BackupRestoreUnknownError() from err
         except (tarfile.TarError, OSError, AddFileError) as err:
-            _LOGGER.error("Can't write backup tarfile for addon %s: %s", self.slug, err)
+            _LOGGER.error("Can't write backup tarfile for app %s: %s", self.slug, err)
             raise BackupRestoreUnknownError() from err
         finally:
             await self.sys_run_in_executor(temp_dir.cleanup)
@@ -1507,7 +1505,7 @@ def _extract_tarfile() -> tuple[TemporaryDirectory, dict[str, Any]]:
             self._validate_availability(data[ATTR_SYSTEM], logger=_LOGGER.error)
 
             # Restore local add-on information
-            _LOGGER.info("Restore config for addon %s", self.slug)
+            _LOGGER.info("Restore config for app %s", self.slug)
             restore_image = self._image(data[ATTR_SYSTEM])
             await self.sys_addons.data.restore(
                 self.slug, data[ATTR_USER], data[ATTR_SYSTEM], restore_image
@@ -1521,7 +1519,7 @@ def _extract_tarfile() -> tuple[TemporaryDirectory, dict[str, Any]]:
                 # Check version / restore image
                 version = data[ATTR_VERSION]
                 if not await self.instance.exists():
-                    _LOGGER.info("Restore/Install of image for addon %s", self.slug)
+                    _LOGGER.info("Restore/Install of image for app %s", self.slug)
 
                     image_file = Path(tmp.name, "image.tar")
                     if image_file.is_file():
@@ -1534,7 +1532,7 @@ def _extract_tarfile() -> tuple[TemporaryDirectory, dict[str, Any]]:
                             )
                             await self.instance.cleanup()
                 elif self.instance.version != version or self.legacy:
-                    _LOGGER.info("Restore/Update of image for addon %s", self.slug)
+                    _LOGGER.info("Restore/Update of image for app %s", self.slug)
                     with suppress(DockerError):
                         await self.instance.update(version, restore_image, self.arch)
                 await self._check_ingress_port()
@@ -1542,7 +1540,7 @@ def _extract_tarfile() -> tuple[TemporaryDirectory, dict[str, Any]]:
                 # Restore data and config
                 def _restore_data():
                     """Restore data and config."""
-                    _LOGGER.info("Restoring data and config for addon %s", self.slug)
+                    _LOGGER.info("Restoring data and config for app %s", self.slug)
                     if self.path_data.is_dir():
                         remove_data(self.path_data)
                     if self.path_config.is_dir():
@@ -1577,7 +1575,7 @@ def _restore_data():
                         )
                     except HostAppArmorError as err:
                         _LOGGER.error(
-                            "Can't restore AppArmor profile for add-on %s: %s",
+                            "Can't restore AppArmor profile for app %s: %s",
                             self.slug,
                             err,
                         )
@@ -1593,7 +1591,7 @@ def _restore_data():
                     wait_for_start = await self.start()
         finally:
             await self.sys_run_in_executor(tmp.cleanup)
-        _LOGGER.info("Finished restore for add-on %s", self.slug)
+        _LOGGER.info("Finished restore for app %s", self.slug)
         return wait_for_start
 
     @Job(
@@ -1609,7 +1607,7 @@ async def _restart_after_problem(self, state: ContainerState):
         while await self.instance.current_state() == state:
             if not self.in_progress:
                 _LOGGER.warning(
-                    "Watchdog found addon %s is %s, restarting...",
+                    "Watchdog found app %s is %s, restarting...",
                     self.name,
                     state,
                 )
@@ -1625,14 +1623,14 @@ async def _restart_after_problem(self, state: ContainerState):
                         await (await self.restart())
                 except AddonsError as err:
                     attempts = attempts + 1
-                    _LOGGER.error("Watchdog restart of addon %s failed!", self.name)
+                    _LOGGER.error("Watchdog restart of app %s failed!", self.name)
                     await async_capture_exception(err)
                 else:
                     break
 
             if attempts >= WATCHDOG_MAX_ATTEMPTS:
                 _LOGGER.critical(
-                    "Watchdog cannot restart addon %s, failed all %s attempts",
+                    "Watchdog cannot restart app %s, failed all %s attempts",
                     self.name,
                     attempts,
                 )
@@ -1641,7 +1639,7 @@ async def _restart_after_problem(self, state: ContainerState):
             # Exponential backoff to spread retries over the throttle window
             delay = WATCHDOG_RETRY_SECONDS * (1 << max(attempts - 1, 0))
             _LOGGER.debug(
-                "Watchdog will retry addon %s in %s seconds (attempt %s)",
+                "Watchdog will retry app %s in %s seconds (attempt %s)",
                 self.name,
                 delay,
                 attempts + 1,
diff --git a/supervisor/addons/build.py b/supervisor/addons/build.py
index 41ae7934b6b..70a512542f1 100644
--- a/supervisor/addons/build.py
+++ b/supervisor/addons/build.py
@@ -92,7 +92,7 @@ def base_image(self) -> str:
         # Evaluate correct base image
         if self.arch not in self._data[ATTR_BUILD_FROM]:
             raise HassioArchNotFound(
-                f"Add-on {self.addon.slug} is not supported on {self.arch}"
+                f"App {self.addon.slug} is not supported on {self.arch}"
             )
         return self._data[ATTR_BUILD_FROM][self.arch]
 
diff --git a/supervisor/addons/manager.py b/supervisor/addons/manager.py
index 04e7787206e..c69436772e8 100644
--- a/supervisor/addons/manager.py
+++ b/supervisor/addons/manager.py
@@ -97,7 +97,7 @@ async def load(self) -> None:
             tasks.append(addon.load())
 
         # Run initial tasks
-        _LOGGER.info("Found %d installed add-ons", len(self.data.system))
+        _LOGGER.info("Found %d installed apps", len(self.data.system))
         if tasks:
             await asyncio.gather(*tasks)
 
@@ -116,7 +116,7 @@ async def boot(self, stage: AddonStartup) -> None:
                 in self.sys_resolution.unhealthy
             ):
                 _LOGGER.warning(
-                    "Skipping boot of add-on %s because gateway firewall"
+                    "Skipping boot of app %s because gateway firewall"
                     " rules are not active",
                     addon.slug,
                 )
@@ -124,7 +124,7 @@ async def boot(self, stage: AddonStartup) -> None:
             tasks.append(addon)
 
         # Evaluate add-ons which need to be started
-        _LOGGER.info("Phase '%s' starting %d add-ons", stage, len(tasks))
+        _LOGGER.info("Phase '%s' starting %d apps", stage, len(tasks))
         if not tasks:
             return
 
@@ -148,7 +148,7 @@ async def boot(self, stage: AddonStartup) -> None:
             else:
                 continue
 
-            _LOGGER.warning("Can't start Add-on %s", addon.slug)
+            _LOGGER.warning("Can't start app %s", addon.slug)
 
         # Ignore exceptions from waiting for addon startup, addon errors handled elsewhere
         await asyncio.gather(*wait_boot, return_exceptions=True)
@@ -175,7 +175,7 @@ async def shutdown(self, stage: AddonStartup) -> None:
             tasks.append(addon)
 
         # Evaluate add-ons which need to be stopped
-        _LOGGER.info("Phase '%s' stopping %d add-ons", stage, len(tasks))
+        _LOGGER.info("Phase '%s' stopping %d apps", stage, len(tasks))
         if not tasks:
             return
 
@@ -185,7 +185,7 @@ async def shutdown(self, stage: AddonStartup) -> None:
             try:
                 await addon.stop()
             except Exception as err:  # pylint: disable=broad-except
-                _LOGGER.warning("Can't stop Add-on %s: %s", addon.slug, err)
+                _LOGGER.warning("Can't stop app %s: %s", addon.slug, err)
                 await async_capture_exception(err)
 
     @Job(
@@ -204,11 +204,11 @@ async def install(
         self.sys_jobs.current.reference = slug
 
         if slug in self.local:
-            raise AddonsError(f"Add-on {slug} is already installed", _LOGGER.warning)
+            raise AddonsError(f"App {slug} is already installed", _LOGGER.warning)
         store = self.store.get(slug)
 
         if not store:
-            raise AddonsError(f"Add-on {slug} does not exist", _LOGGER.error)
+            raise AddonsError(f"App {slug} does not exist", _LOGGER.error)
 
         store.validate_availability()
 
@@ -218,13 +218,13 @@ async def install(
 
         await Addon(self.coresys, slug).install()
 
-        _LOGGER.info("Add-on '%s' successfully installed", slug)
+        _LOGGER.info("App '%s' successfully installed", slug)
 
     @Job(name="addon_manager_uninstall")
     async def uninstall(self, slug: str, *, remove_config: bool = False) -> None:
         """Remove an add-on."""
         if slug not in self.local:
-            _LOGGER.warning("Add-on %s is not installed", slug)
+            _LOGGER.warning("App %s is not installed", slug)
             return
 
         shared_image = any(
@@ -237,7 +237,7 @@ async def uninstall(self, slug: str, *, remove_config: bool = False) -> None:
             remove_config=remove_config, remove_image=not shared_image
         )
 
-        _LOGGER.info("Add-on '%s' successfully removed", slug)
+        _LOGGER.info("App '%s' successfully removed", slug)
 
     @Job(
         name="addon_manager_update",
@@ -266,17 +266,17 @@ async def update(
         self.sys_jobs.current.reference = slug
 
         if slug not in self.local:
-            raise AddonsError(f"Add-on {slug} is not installed", _LOGGER.error)
+            raise AddonsError(f"App {slug} is not installed", _LOGGER.error)
         addon = self.local[slug]
 
         if addon.is_detached:
             raise AddonsError(
-                f"Add-on {slug} is not available inside store", _LOGGER.error
+                f"App {slug} is not available inside store", _LOGGER.error
             )
         store = self.store[slug]
 
         if addon.version == store.version:
-            raise AddonsError(f"No update available for add-on {slug}", _LOGGER.warning)
+            raise AddonsError(f"No update available for app {slug}", _LOGGER.warning)
 
         # Check if available, Maybe something have changed
         store.validate_availability()
@@ -294,7 +294,7 @@ async def update(
 
         task = await addon.update()
 
-        _LOGGER.info("Add-on '%s' successfully updated", slug)
+        _LOGGER.info("App '%s' successfully updated", slug)
         return task
 
     @Job(
@@ -315,12 +315,12 @@ async def rebuild(self, slug: str, *, force: bool = False) -> asyncio.Task | Non
         self.sys_jobs.current.reference = slug
 
         if slug not in self.local:
-            raise AddonsError(f"Add-on {slug} is not installed", _LOGGER.error)
+            raise AddonsError(f"App {slug} is not installed", _LOGGER.error)
         addon = self.local[slug]
 
         if addon.is_detached:
             raise AddonsError(
-                f"Add-on {slug} is not available inside store", _LOGGER.error
+                f"App {slug} is not available inside store", _LOGGER.error
             )
         store = self.store[slug]
 
@@ -331,7 +331,7 @@ async def rebuild(self, slug: str, *, force: bool = False) -> asyncio.Task | Non
             )
         if not force and not addon.need_build:
             raise AddonNotSupportedError(
-                "Can't rebuild a image based add-on", _LOGGER.error
+                "Can't rebuild an image-based app", _LOGGER.error
             )
 
         return await addon.rebuild()
@@ -354,11 +354,11 @@ async def restore(self, slug: str, tar_file: SecureTarFile) -> asyncio.Task | No
         self.sys_jobs.current.reference = slug
 
         if slug not in self.local:
-            _LOGGER.debug("Add-on %s is not local available for restore", slug)
+            _LOGGER.debug("App %s is not locally available for restore", slug)
             addon = Addon(self.coresys, slug)
             had_ingress: bool | None = False
         else:
-            _LOGGER.debug("Add-on %s is local available for restore", slug)
+            _LOGGER.debug("App %s is locally available for restore", slug)
             addon = self.local[slug]
             had_ingress = addon.ingress_panel
 
@@ -366,7 +366,7 @@ async def restore(self, slug: str, tar_file: SecureTarFile) -> asyncio.Task | No
 
         # Check if new
         if slug not in self.local:
-            _LOGGER.info("Detect new Add-on after restore %s", slug)
+            _LOGGER.info("Detected new app after restore: %s", slug)
             self.local[slug] = addon
 
         # Update ingress
@@ -390,12 +390,12 @@ async def repair(self) -> None:
                 continue
             needs_repair.append(addon)
 
-        _LOGGER.info("Found %d add-ons to repair", len(needs_repair))
+        _LOGGER.info("Found %d apps to repair", len(needs_repair))
         if not needs_repair:
             return
 
         for addon in needs_repair:
-            _LOGGER.info("Repairing for add-on: %s", addon.slug)
+            _LOGGER.info("Repairing for app: %s", addon.slug)
             with suppress(DockerError, KeyError):
                 # Need pull a image again
                 if not addon.need_build:
@@ -423,7 +423,7 @@ async def sync_dns(self) -> None:
                 if not await addon.instance.is_running():
                     continue
             except DockerError as err:
-                _LOGGER.warning("Add-on %s is corrupt: %s", addon.slug, err)
+                _LOGGER.warning("App %s is corrupt: %s", addon.slug, err)
                 self.sys_resolution.create_issue(
                     IssueType.CORRUPT_DOCKER,
                     ContextType.ADDON,
diff --git a/supervisor/addons/utils.py b/supervisor/addons/utils.py
index 9cf151b301e..07b43f0fe2c 100644
--- a/supervisor/addons/utils.py
+++ b/supervisor/addons/utils.py
@@ -102,4 +102,4 @@ def remove_data(folder: Path) -> None:
     else:
         return
 
-    _LOGGER.error("Can't remove Add-on Data: %s", error_msg)
+    _LOGGER.error("Can't remove app data: %s", error_msg)
diff --git a/supervisor/addons/validate.py b/supervisor/addons/validate.py
index 2f8a2a1dedf..208ec41ce6e 100644
--- a/supervisor/addons/validate.py
+++ b/supervisor/addons/validate.py
@@ -190,13 +190,13 @@ def _warn_addon_config(config: dict[str, Any]):
     """Warn about miss configs."""
     name = config.get(ATTR_NAME)
     if not name:
-        raise vol.Invalid("Invalid Add-on config!")
+        raise vol.Invalid("Invalid app config!")
 
     if ATTR_ADVANCED in config:
         # Deprecated since Supervisor 2026.03.0; this field is ignored and the
         # warning can be removed once that version is the minimum supported.
         _LOGGER.warning(
-            "Add-on '%s' uses deprecated 'advanced' field in config. "
+            "App '%s' uses deprecated 'advanced' field in config. "
             "This field is ignored by the Supervisor. Please report this to the maintainer.",
             name,
         )
@@ -208,7 +208,7 @@ def _warn_addon_config(config: dict[str, Any]):
         or config.get(ATTR_GPIO)
     ):
         _LOGGER.warning(
-            "Add-on have full device access, and selective device access in the configuration. Please report this to the maintainer of %s",
+            "App has full device access, and selective device access in the configuration. Please report this to the maintainer of %s",
             name,
         )
 
@@ -216,7 +216,7 @@ def _warn_addon_config(config: dict[str, Any]):
         config.get(ATTR_BACKUP_POST) or config.get(ATTR_BACKUP_PRE)
     ):
         _LOGGER.warning(
-            "Add-on which only support COLD backups trying to use post/pre commands. Please report this to the maintainer of %s",
+            "An app that only supports COLD backups is trying to use pre/post commands. Please report this to the maintainer of %s",
             name,
         )
 
@@ -224,7 +224,7 @@ def _warn_addon_config(config: dict[str, Any]):
         arch for arch in config.get(ATTR_ARCH, []) if arch in ARCH_DEPRECATED
     ]:
         _LOGGER.warning(
-            "Add-on config 'arch' uses deprecated values %s. Please report this to the maintainer of %s",
+            "App config 'arch' uses deprecated values %s. Please report this to the maintainer of %s",
             deprecated_arches,
             name,
         )
@@ -235,14 +235,14 @@ def _warn_addon_config(config: dict[str, Any]):
         if machine.lstrip("!") in MACHINE_DEPRECATED
     ]:
         _LOGGER.warning(
-            "Add-on config 'machine' uses deprecated values %s. Please report this to the maintainer of %s",
+            "App config 'machine' uses deprecated values %s. Please report this to the maintainer of %s",
             deprecated_machines,
             name,
         )
 
     if ATTR_CODENOTARY in config:
         _LOGGER.warning(
-            "Add-on '%s' uses deprecated 'codenotary' field in config. This field is no longer used and will be ignored. Please report this to the maintainer.",
+            "App '%s' uses deprecated 'codenotary' field in config. This field is no longer used and will be ignored. Please report this to the maintainer.",
             name,
         )
 
@@ -254,17 +254,17 @@ def _migrate_addon_config(protocol=False):
 
     def _migrate(config: dict[str, Any]):
         if not isinstance(config, dict):
-            raise vol.Invalid("Add-on config must be a dictionary!")
+            raise vol.Invalid("App config must be a dictionary!")
         name = config.get(ATTR_NAME)
         if not name:
-            raise vol.Invalid("Invalid Add-on config!")
+            raise vol.Invalid("Invalid app config!")
 
         # Startup 2018-03-30
         if config.get(ATTR_STARTUP) in ("before", "after"):
             value = config[ATTR_STARTUP]
             if protocol:
                 _LOGGER.warning(
-                    "Add-on config 'startup' with '%s' is deprecated. Please report this to the maintainer of %s",
+                    "App config 'startup' with '%s' is deprecated. Please report this to the maintainer of %s",
                     value,
                     name,
                 )
@@ -277,7 +277,7 @@ def _migrate(config: dict[str, Any]):
         if "auto_uart" in config:
             if protocol:
                 _LOGGER.warning(
-                    "Add-on config 'auto_uart' is deprecated, use 'uart'. Please report this to the maintainer of %s",
+                    "App config 'auto_uart' is deprecated, use 'uart'. Please report this to the maintainer of %s",
                     name,
                 )
             config[ATTR_UART] = config.pop("auto_uart")
@@ -286,7 +286,7 @@ def _migrate(config: dict[str, Any]):
         if ATTR_DEVICES in config and any(":" in line for line in config[ATTR_DEVICES]):
             if protocol:
                 _LOGGER.warning(
-                    "Add-on config 'devices' use a deprecated format, the new format uses a list of paths only. Please report this to the maintainer of %s",
+                    "App config 'devices' uses a deprecated format instead of a list of paths only. Please report this to the maintainer of %s",
                     name,
                 )
             config[ATTR_DEVICES] = [line.split(":")[0] for line in config[ATTR_DEVICES]]
@@ -295,7 +295,7 @@ def _migrate(config: dict[str, Any]):
         if ATTR_TMPFS in config and not isinstance(config[ATTR_TMPFS], bool):
             if protocol:
                 _LOGGER.warning(
-                    "Add-on config 'tmpfs' use a deprecated format, new it's only a boolean. Please report this to the maintainer of %s",
+                    "App config 'tmpfs' uses a deprecated format instead of just a boolean. Please report this to the maintainer of %s",
                     name,
                 )
             config[ATTR_TMPFS] = True
@@ -311,7 +311,7 @@ def _migrate(config: dict[str, Any]):
                 new_entry = entry.replace("snapshot", "backup")
                 config[new_entry] = config.pop(entry)
                 _LOGGER.warning(
-                    "Add-on config '%s' is deprecated, '%s' should be used instead. Please report this to the maintainer of %s",
+                    "App config '%s' is deprecated, '%s' should be used instead. Please report this to the maintainer of %s",
                     entry,
                     new_entry,
                     name,
@@ -324,7 +324,7 @@ def _migrate(config: dict[str, Any]):
                 # Validate that dict entries have required 'type' field
                 if ATTR_TYPE not in entry:
                     _LOGGER.warning(
-                        "Add-on config has invalid map entry missing 'type' field: %s. Skipping invalid entry for %s",
+                        "App config has invalid map entry missing 'type' field: %s. Skipping invalid entry for %s",
                         entry,
                         name,
                     )
@@ -334,7 +334,7 @@ def _migrate(config: dict[str, Any]):
                 result = RE_VOLUME.match(entry)
                 if not result:
                     _LOGGER.warning(
-                        "Add-on config has invalid map entry: %s. Skipping invalid entry for %s",
+                        "App config has invalid map entry: %s. Skipping invalid entry for %s",
                         entry,
                         name,
                     )
@@ -358,7 +358,7 @@ def _migrate(config: dict[str, Any]):
                 for volume in volumes
             ):
                 _LOGGER.warning(
-                    "Add-on config using incompatible map options, '%s' and '%s' are ignored if '%s' is included. Please report this to the maintainer of %s",
+                    "App config using incompatible map options, '%s' and '%s' are ignored if '%s' is included. Please report this to the maintainer of %s",
                     MappingType.ADDON_CONFIG,
                     MappingType.HOMEASSISTANT_CONFIG,
                     MappingType.CONFIG,
@@ -366,7 +366,7 @@ def _migrate(config: dict[str, Any]):
                 )
             else:
                 _LOGGER.debug(
-                    "Add-on config using deprecated map option '%s' instead of '%s'. Please report this to the maintainer of %s",
+                    "App config using deprecated map option '%s' instead of '%s'. Please report this to the maintainer of %s",
                     MappingType.CONFIG,
                     MappingType.HOMEASSISTANT_CONFIG,
                     name,
diff --git a/supervisor/api/addons.py b/supervisor/api/addons.py
index 5fdb58e8bd3..f8f14192afe 100644
--- a/supervisor/api/addons.py
+++ b/supervisor/api/addons.py
@@ -173,9 +173,9 @@ def get_addon_for_request(self, request: web.Request) -> Addon:
 
         addon = self.sys_addons.get(addon_slug)
         if not addon:
-            raise APINotFound(f"Addon {addon_slug} does not exist")
+            raise APINotFound(f"App {addon_slug} does not exist")
         if not isinstance(addon, Addon) or not addon.is_installed:
-            raise APIAddonNotInstalled("Addon is not installed")
+            raise APIAddonNotInstalled("App is not installed")
 
         return addon
 
@@ -389,7 +389,7 @@ async def options_validate(self, request: web.Request) -> OptionsValidateRespons
             if data["pwned"] is None:
                 data["message"] = "Error happening on pwned secrets check!"
             else:
-                data["message"] = "Add-on uses pwned secrets!"
+                data["message"] = "App uses pwned secrets!"
 
         return data
 
@@ -398,7 +398,7 @@ async def options_config(self, request: web.Request) -> dict[str, Any]:
         """Validate user options for add-on."""
         slug: str = request.match_info["addon"]
         if slug != "self":
-            raise APIForbidden("This can be only read by the Add-on itself!")
+            raise APIForbidden("This can be only read by the app itself!")
         addon = self.get_addon_for_request(request)
 
         # Lookup/reload secrets
@@ -406,7 +406,7 @@ async def options_config(self, request: web.Request) -> dict[str, Any]:
         try:
             return addon.schema.validate(addon.options)
         except vol.Invalid:
-            raise APIError("Invalid configuration data for the add-on") from None
+            raise APIError("Invalid configuration data for the app") from None
 
     @api_process
     async def security(self, request: web.Request) -> None:
diff --git a/supervisor/api/discovery.py b/supervisor/api/discovery.py
index 82e37c0e7d2..aa37e398220 100644
--- a/supervisor/api/discovery.py
+++ b/supervisor/api/discovery.py
@@ -81,12 +81,12 @@ async def set_discovery(self, request: web.Request) -> dict[str, str]:
         # Access?
         if body[ATTR_SERVICE] not in addon.discovery:
             _LOGGER.error(
-                "Add-on %s attempted to send discovery for service %s which is not listed in its config. Please report this to the maintainer of the add-on",
+                "App %s attempted to send discovery for service %s which is not listed in its config. Please report this to the maintainer of the app",
                 addon.name,
                 service,
             )
             raise APIForbidden(
-                "Add-ons must list services they provide via discovery in their config!"
+                "Apps must list services they provide via discovery in their config!"
             )
 
         # Process discovery message
diff --git a/supervisor/api/proxy.py b/supervisor/api/proxy.py
index 4bb5fd27302..b5a04214d62 100644
--- a/supervisor/api/proxy.py
+++ b/supervisor/api/proxy.py
@@ -249,7 +249,7 @@ async def _proxy_message(
                     logger.debug(
                         "Received WebSocket message type %r from %s.",
                         msg.type,
-                        "add-on" if type(source) is web.WebSocketResponse else "Core",
+                        "app" if type(source) is web.WebSocketResponse else "Core",
                     )
                     await target.close()
                 case WSMsgType.CLOSING:
diff --git a/supervisor/api/store.py b/supervisor/api/store.py
index 2767a8d5b17..16561f11bbc 100644
--- a/supervisor/api/store.py
+++ b/supervisor/api/store.py
@@ -108,7 +108,7 @@ def _extract_addon(self, request: web.Request, installed=False) -> AnyAddon:
             raise StoreAddonNotFoundError(addon=addon_slug)
 
         if installed and not addon.is_installed:
-            raise APIError(f"Addon {addon_slug} is not installed")
+            raise APIError(f"App {addon_slug} is not installed")
 
         if not installed and addon.is_installed:
             addon = cast(Addon, addon)
@@ -247,7 +247,7 @@ async def addons_addon_update(self, request: web.Request) -> dict[str, str] | No
         """Update add-on."""
         addon = self._extract_addon(request, installed=True)
         if addon == request.get(REQUEST_FROM):
-            raise APIForbidden(f"Add-on {addon.slug} can't update itself!")
+            raise APIForbidden(f"App {addon.slug} can't update itself!")
 
         body = await api_validate(SCHEMA_UPDATE, request)
         background = body[ATTR_BACKGROUND]
@@ -282,7 +282,7 @@ async def addons_addon_icon(self, request: web.Request) -> bytes:
         """Return icon from add-on."""
         addon = self._extract_addon(request)
         if not addon.with_icon:
-            raise APIError(f"No icon found for add-on {addon.slug}!")
+            raise APIError(f"No icon found for app {addon.slug}!")
 
         return await self.sys_run_in_executor(_read_static_binary_file, addon.path_icon)
 
@@ -291,7 +291,7 @@ async def addons_addon_logo(self, request: web.Request) -> bytes:
         """Return logo from add-on."""
         addon = self._extract_addon(request)
         if not addon.with_logo:
-            raise APIError(f"No logo found for add-on {addon.slug}!")
+            raise APIError(f"No logo found for app {addon.slug}!")
 
         return await self.sys_run_in_executor(_read_static_binary_file, addon.path_logo)
 
@@ -305,7 +305,7 @@ async def addons_addon_changelog(self, request: web.Request) -> str:
             return str(err)
 
         if not addon.with_changelog:
-            return f"No changelog found for add-on {addon.slug}!"
+            return f"No changelog found for app {addon.slug}!"
 
         return await self.sys_run_in_executor(
             _read_static_text_file, addon.path_changelog
@@ -321,7 +321,7 @@ async def addons_addon_documentation(self, request: web.Request) -> str:
             return str(err)
 
         if not addon.with_documentation:
-            return f"No documentation found for add-on {addon.slug}!"
+            return f"No documentation found for app {addon.slug}!"
 
         return await self.sys_run_in_executor(
             _read_static_text_file, addon.path_documentation
diff --git a/supervisor/backups/backup.py b/supervisor/backups/backup.py
index e6ba1c03c1f..69c883895a6 100644
--- a/supervisor/backups/backup.py
+++ b/supervisor/backups/backup.py
@@ -609,7 +609,7 @@ async def _addon_save(self, addon: Addon) -> asyncio.Task | None:
         # Ensure it is still installed and get current data before proceeding
         if not (curr_addon := self.sys_addons.get_local_only(slug)):
             _LOGGER.warning(
-                "Skipping backup of add-on %s because it has been uninstalled",
+                "Skipping backup of app %s because it has been uninstalled",
                 slug,
             )
             return None
@@ -697,7 +697,7 @@ async def restore_addons(
             try:
                 start_task = await self._addon_restore(slug)
             except Exception as err:  # pylint: disable=broad-except
-                _LOGGER.warning("Can't restore Add-on %s: %s", slug, err)
+                _LOGGER.warning("Can't restore app %s: %s", slug, err)
                 success = False
             else:
                 if start_task:
@@ -719,7 +719,7 @@ async def remove_delta_addons(self) -> bool:
                 await self.sys_addons.uninstall(addon.slug)
             except AddonsError as err:
                 self.sys_jobs.current.capture_error(err)
-                _LOGGER.warning("Can't uninstall Add-on %s: %s", addon.slug, err)
+                _LOGGER.warning("Can't uninstall app %s: %s", addon.slug, err)
                 success = False
 
         return success
diff --git a/supervisor/backups/manager.py b/supervisor/backups/manager.py
index da077011829..2a9e80e9061 100644
--- a/supervisor/backups/manager.py
+++ b/supervisor/backups/manager.py
@@ -681,7 +681,7 @@ async def do_backup_partial(
             if addon and addon.is_installed:
                 addon_list.append(cast(Addon, addon))
                 continue
-            _LOGGER.warning("Add-on %s not found/installed", addon_slug)
+            _LOGGER.warning("App %s not found/installed", addon_slug)
 
         # If being run in the background, notify caller that validation has completed
         if validation_complete:
diff --git a/supervisor/backups/validate.py b/supervisor/backups/validate.py
index a23ed37acfb..8f669b6b3a7 100644
--- a/supervisor/backups/validate.py
+++ b/supervisor/backups/validate.py
@@ -47,7 +47,7 @@ def unique_addons(addons_list):
     single = {addon[ATTR_SLUG] for addon in addons_list}
 
     if len(single) != len(addons_list):
-        raise vol.Invalid("Invalid addon list in backup!") from None
+        raise vol.Invalid("Invalid app list in backup!") from None
     return addons_list
 
 
diff --git a/supervisor/bootstrap.py b/supervisor/bootstrap.py
index 6a849781d3a..179aa5a6e49 100644
--- a/supervisor/bootstrap.py
+++ b/supervisor/bootstrap.py
@@ -132,20 +132,20 @@ def initialize_system(coresys: CoreSys) -> None:
     # Supervisor addon data folder
     if not config.path_addons_data.is_dir():
         _LOGGER.debug(
-            "Creating Supervisor Add-on data folder at '%s'", config.path_addons_data
+            "Creating Supervisor app data folder at '%s'", config.path_addons_data
         )
         config.path_addons_data.mkdir(parents=True)
 
     if not config.path_addons_local.is_dir():
         _LOGGER.debug(
-            "Creating Supervisor Add-on local repository folder at '%s'",
+            "Creating Supervisor app local repository folder at '%s'",
             config.path_addons_local,
         )
         config.path_addons_local.mkdir(parents=True)
 
     if not config.path_addons_git.is_dir():
         _LOGGER.debug(
-            "Creating Supervisor Add-on git repositories folder at '%s'",
+            "Creating Supervisor app git repositories folder at '%s'",
             config.path_addons_git,
         )
         config.path_addons_git.mkdir(parents=True)
@@ -221,7 +221,7 @@ def initialize_system(coresys: CoreSys) -> None:
     # Addon Configs folder
     if not config.path_addon_configs.is_dir():
         _LOGGER.debug(
-            "Creating Supervisor add-on configs folder at '%s'",
+            "Creating Supervisor app configs folder at '%s'",
             config.path_addon_configs,
         )
         config.path_addon_configs.mkdir()
diff --git a/supervisor/docker/addon.py b/supervisor/docker/addon.py
index bf4627c8fed..7db7a5c0bcb 100644
--- a/supervisor/docker/addon.py
+++ b/supervisor/docker/addon.py
@@ -112,7 +112,7 @@ def ip_address(self) -> IPv4Address:
             return IPv4Address(
                 self._meta["NetworkSettings"]["Networks"]["hassio"]["IPAddress"]
             )
-        except (KeyError, TypeError, ValueError):
+        except KeyError, TypeError, ValueError:
             return NO_ADDDRESS
 
     @property
@@ -173,7 +173,7 @@ def cgroups_rules(self) -> list[str] | None:
             # Check access
             if not self.sys_hardware.policy.allowed_for_access(device):
                 _LOGGER.error(
-                    "Add-on %s try to access to blocked device %s!",
+                    "App %s tried to access to blocked device %s!",
                     self.addon.name,
                     device.name,
                 )
@@ -184,7 +184,7 @@ def cgroups_rules(self) -> list[str] | None:
         for device in self.addon.devices:
             if not self.sys_hardware.policy.allowed_for_access(device):
                 _LOGGER.error(
-                    "Add-on %s try to access to blocked device %s!",
+                    "App %s tried to access to blocked device %s!",
                     self.addon.name,
                     device.name,
                 )
@@ -611,9 +611,7 @@ async def run(self) -> None:
             )
             raise
 
-        _LOGGER.info(
-            "Starting Docker add-on %s with version %s", self.image, self.version
-        )
+        _LOGGER.info("Starting Docker app %s with version %s", self.image, self.version)
 
         # Write data to DNS server
         try:
diff --git a/supervisor/exceptions.py b/supervisor/exceptions.py
index 975b9a8747a..3b9415506cb 100644
--- a/supervisor/exceptions.py
+++ b/supervisor/exceptions.py
@@ -357,7 +357,7 @@ class AddonConfigurationInvalidError(AddonConfigurationError, APIError):
     """Raise if invalid configuration provided for addon."""
 
     error_key = "addon_configuration_invalid_error"
-    message_template = "Add-on {addon} has invalid options: {validation_error}"
+    message_template = "App {addon} has invalid options: {validation_error}"
 
     def __init__(
         self,
@@ -376,7 +376,7 @@ class AddonBootConfigCannotChangeError(AddonsError, APIError):
 
     error_key = "addon_boot_config_cannot_change_error"
     message_template = (
-        "Addon {addon} boot option is set to {boot_config} so it cannot be changed"
+        "App {addon} boot option is set to {boot_config} so it cannot be changed"
     )
 
     def __init__(
@@ -391,7 +391,7 @@ class AddonNotRunningError(AddonsError, APIError):
     """Raise when an addon is not running."""
 
     error_key = "addon_not_running_error"
-    message_template = "Add-on {addon} is not running"
+    message_template = "App {addon} is not running"
 
     def __init__(
         self, logger: Callable[..., None] | None = None, *, addon: str
@@ -405,7 +405,7 @@ class AddonPortConflict(AddonsError, APIError):
     """Raise if addon cannot start due to a port conflict."""
 
     error_key = "addon_port_conflict"
-    message_template = "Cannot start addon {name} because port {port} is already in use"
+    message_template = "Cannot start app {name} because port {port} is already in use"
 
     def __init__(
         self, logger: Callable[..., None] | None = None, *, name: str, port: int
@@ -423,7 +423,7 @@ class AddonNotSupportedArchitectureError(AddonNotSupportedError):
     """Addon does not support system due to architecture."""
 
     error_key = "addon_not_supported_architecture_error"
-    message_template = "Add-on {slug} not supported on this platform, supported architectures: {architectures}"
+    message_template = "App {slug} not supported on this platform, supported architectures: {architectures}"
 
     def __init__(
         self,
@@ -441,7 +441,7 @@ class AddonNotSupportedMachineTypeError(AddonNotSupportedError):
     """Addon does not support system due to machine type."""
 
     error_key = "addon_not_supported_machine_type_error"
-    message_template = "Add-on {slug} not supported on this machine, supported machine types: {machine_types}"
+    message_template = "App {slug} not supported on this machine, supported machine types: {machine_types}"
 
     def __init__(
         self,
@@ -459,7 +459,7 @@ class AddonNotSupportedHomeAssistantVersionError(AddonNotSupportedError):
     """Addon does not support system due to Home Assistant version."""
 
     error_key = "addon_not_supported_home_assistant_version_error"
-    message_template = "Add-on {slug} not supported on this system, requires Home Assistant version {version} or greater"
+    message_template = "App {slug} not supported on this system, requires Home Assistant version {version} or greater"
 
     def __init__(
         self,
@@ -477,7 +477,7 @@ class AddonNotSupportedWriteStdinError(AddonNotSupportedError, APIError):
     """Addon does not support writing to stdin."""
 
     error_key = "addon_not_supported_write_stdin_error"
-    message_template = "Add-on {addon} does not support writing to stdin"
+    message_template = "App {addon} does not support writing to stdin"
 
     def __init__(
         self, logger: Callable[..., None] | None = None, *, addon: str
@@ -492,9 +492,9 @@ class AddonBuildDockerfileMissingError(AddonNotSupportedError, APIError):
 
     error_key = "addon_build_dockerfile_missing_error"
     message_template = (
-        "Cannot build addon '{addon}' because dockerfile is missing. A repair "
+        "Cannot build app '{addon}' because dockerfile is missing. A repair "
         "using '{repair_command}' will fix this if the cause is data "
-        "corruption. Otherwise please report this to the addon developer."
+        "corruption. Otherwise please report this to the app developer."
     )
 
     def __init__(
@@ -510,7 +510,7 @@ class AddonBuildArchitectureNotSupportedError(AddonNotSupportedError, APIError):
 
     error_key = "addon_build_architecture_not_supported_error"
     message_template = (
-        "Cannot build addon '{addon}' because its supported architectures "
+        "Cannot build app '{addon}' because its supported architectures "
         "({addon_arches}) do not match the system supported architectures ({system_arches})"
     )
 
@@ -535,7 +535,7 @@ class AddonUnknownError(AddonsError, APIUnknownSupervisorError):
     """Raise when unknown error occurs taking an action for an addon."""
 
     error_key = "addon_unknown_error"
-    message_template = "An unknown error occurred with addon {addon}"
+    message_template = "An unknown error occurred with app {addon}"
 
     def __init__(
         self, logger: Callable[..., None] | None = None, *, addon: str
@@ -550,7 +550,7 @@ class AddonBuildFailedUnknownError(AddonsError, APIUnknownSupervisorError):
 
     error_key = "addon_build_failed_unknown_error"
     message_template = (
-        "An unknown error occurred while trying to build the image for addon {addon}"
+        "An unknown error occurred while trying to build the image for app {addon}"
     )
 
     def __init__(
@@ -1032,7 +1032,7 @@ class StoreAddonNotFoundError(StoreError, APINotFound):
     """Raise if a requested addon is not in the store."""
 
     error_key = "store_addon_not_found_error"
-    message_template = "Addon {addon} does not exist in the store"
+    message_template = "App {addon} does not exist in the store"
 
     def __init__(
         self, logger: Callable[..., None] | None = None, *, addon: str
@@ -1066,7 +1066,7 @@ class StoreRepositoryUnknownError(StoreError, APIUnknownSupervisorError):
     """Raise when unknown error occurs taking an action for a store repository."""
 
     error_key = "store_repository_unknown_error"
-    message_template = "An unknown error occurred with addon repository {repo}"
+    message_template = "An unknown error occurred with app repository {repo}"
 
     def __init__(self, logger: Callable[..., None] | None = None, *, repo: str) -> None:
         """Initialize exception."""
@@ -1118,7 +1118,7 @@ class AddonBackupMetadataInvalidError(BackupError, APIError):
 
     error_key = "addon_backup_metadata_invalid_error"
     message_template = (
-        "Metadata file for add-on {addon} in backup is invalid: {validation_error}"
+        "Metadata file for app {addon} in backup is invalid: {validation_error}"
     )
 
     def __init__(
@@ -1138,8 +1138,8 @@ class AddonPrePostBackupCommandReturnedError(BackupError, APIError):
 
     error_key = "addon_pre_post_backup_command_returned_error"
     message_template = (
-        "Pre-/Post backup command for add-on {addon} returned error code: "
-        "{exit_code}. Please report this to the addon developer. Enable debug "
+        "Pre-/Post backup command for app {addon} returned error code: "
+        "{exit_code}. Please report this to the app developer. Enable debug "
         "logging to capture complete command output using {debug_logging_command}"
     )
 
diff --git a/supervisor/misc/tasks.py b/supervisor/misc/tasks.py
index 90cabcb6b42..7c6c2507bcf 100644
--- a/supervisor/misc/tasks.py
+++ b/supervisor/misc/tasks.py
@@ -121,7 +121,7 @@ async def _update_addons(self):
                 continue
             if not addon.auto_update_available:
                 _LOGGER.debug(
-                    "Not updating add-on %s from %s to %s as that would cross a known breaking version",
+                    "Not updating app %s from %s to %s as that would cross a known breaking version",
                     addon.slug,
                     addon.version,
                     addon.latest_version,
@@ -130,7 +130,7 @@ async def _update_addons(self):
             # Delay auto-updates for a day in case of issues
             if utcnow() < addon.latest_version_timestamp + timedelta(days=1):
                 _LOGGER.debug(
-                    "Not updating add-on %s from %s to %s as the latest version is less than a day old",
+                    "Not updating app %s from %s to %s as the latest version is less than a day old",
                     addon.slug,
                     addon.version,
                     addon.latest_version,
@@ -138,11 +138,11 @@ async def _update_addons(self):
                 continue
             if not addon.test_update_schema():
                 _LOGGER.warning(
-                    "Add-on %s will be ignored, schema tests failed", addon.slug
+                    "App %s will be ignored, schema tests failed", addon.slug
                 )
                 continue
 
-            _LOGGER.info("Add-on auto update process %s", addon.slug)
+            _LOGGER.info("App auto update process %s", addon.slug)
             # Call Home Assistant Core to update add-on to make sure that backups
             # get created through the Home Assistant Core API (categorized correctly).
             # Ultimately auto updates should be handled by Home Assistant Core itself
@@ -153,14 +153,14 @@ async def _update_addons(self):
                 "backup": True,
             }
             _LOGGER.debug(
-                "Sending update add-on WebSocket command to Home Assistant Core: %s",
+                "Sending update app WebSocket command to Home Assistant Core: %s",
                 message,
             )
             try:
                 await self.sys_homeassistant.websocket.async_send_command(message)
             except HomeAssistantWSError as err:
                 _LOGGER.warning(
-                    "Could not send add-on update command to Home Assistant Core: %s",
+                    "Could not send app update command to Home Assistant Core: %s",
                     err,
                 )
 
diff --git a/supervisor/resolution/fixups/addon_disable_boot.py b/supervisor/resolution/fixups/addon_disable_boot.py
index 86575e69ff5..4bdb2f3eef5 100644
--- a/supervisor/resolution/fixups/addon_disable_boot.py
+++ b/supervisor/resolution/fixups/addon_disable_boot.py
@@ -24,7 +24,7 @@ async def process_fixup(self, reference: str | None = None) -> None:
             return
 
         if not (addon := self.sys_addons.get_local_only(reference)):
-            _LOGGER.info("Cannot change addon %s as it does not exist", reference)
+            _LOGGER.info("Cannot change app %s as it does not exist", reference)
             return
 
         # Disable boot on addon
diff --git a/supervisor/resolution/fixups/addon_execute_rebuild.py b/supervisor/resolution/fixups/addon_execute_rebuild.py
index 4dd453118f1..8fe58149217 100644
--- a/supervisor/resolution/fixups/addon_execute_rebuild.py
+++ b/supervisor/resolution/fixups/addon_execute_rebuild.py
@@ -26,7 +26,7 @@ async def process_fixup(self, reference: str | None = None) -> None:
         addon = self.sys_addons.get_local_only(reference)
         if not addon:
             _LOGGER.info(
-                "Cannot rebuild addon %s as it is not installed, dismissing suggestion",
+                "Cannot rebuild app %s as it is not installed, dismissing suggestion",
                 reference,
             )
             return
@@ -34,12 +34,12 @@ async def process_fixup(self, reference: str | None = None) -> None:
         state = await addon.instance.current_state()
         if state == ContainerState.UNKNOWN:
             _LOGGER.info(
-                "Container for addon %s does not exist, it will be rebuilt when started next",
+                "Container for app %s does not exist, it will be rebuilt when started next",
                 reference,
             )
         elif state == ContainerState.STOPPED:
             _LOGGER.info(
-                "Addon %s is stopped, removing its container so it rebuilds when started next",
+                "App %s is stopped, removing its container so it rebuilds when started next",
                 reference,
             )
             await addon.stop()
diff --git a/supervisor/resolution/fixups/addon_execute_remove.py b/supervisor/resolution/fixups/addon_execute_remove.py
index ae77806c323..f0461b49278 100644
--- a/supervisor/resolution/fixups/addon_execute_remove.py
+++ b/supervisor/resolution/fixups/addon_execute_remove.py
@@ -24,11 +24,11 @@ async def process_fixup(self, reference: str | None = None) -> None:
             return
 
         if not (addon := self.sys_addons.get_local_only(reference)):
-            _LOGGER.info("Addon %s already removed", reference)
+            _LOGGER.info("App %s already removed", reference)
             return
 
         # Remove addon
-        _LOGGER.info("Remove addon: %s", reference)
+        _LOGGER.info("Remove app: %s", reference)
         try:
             await addon.uninstall(remove_config=False)
         except AddonsError as err:
diff --git a/supervisor/resolution/fixups/addon_execute_repair.py b/supervisor/resolution/fixups/addon_execute_repair.py
index 5302a383820..45276fdbca8 100644
--- a/supervisor/resolution/fixups/addon_execute_repair.py
+++ b/supervisor/resolution/fixups/addon_execute_repair.py
@@ -31,18 +31,18 @@ async def process_fixup(self, reference: str | None = None) -> None:
         addon = self.sys_addons.get_local_only(reference)
         if not addon:
             _LOGGER.info(
-                "Cannot repair addon %s as it is not installed, dismissing suggestion",
+                "Cannot repair app %s as it is not installed, dismissing suggestion",
                 reference,
             )
             return
 
         if await addon.instance.exists():
             _LOGGER.info(
-                "Addon %s does not need repair, dismissing suggestion", reference
+                "App %s does not need repair, dismissing suggestion", reference
             )
             return
 
-        _LOGGER.info("Installing image for addon %s", reference)
+        _LOGGER.info("Installing image for app %s", reference)
         self.attempts += 1
         await addon.instance.install(addon.version)
 
diff --git a/supervisor/resolution/fixups/addon_execute_restart.py b/supervisor/resolution/fixups/addon_execute_restart.py
index 0b00427bde0..c6270e08021 100644
--- a/supervisor/resolution/fixups/addon_execute_restart.py
+++ b/supervisor/resolution/fixups/addon_execute_restart.py
@@ -24,7 +24,7 @@ async def process_fixup(self, reference: str | None = None) -> None:
             return
 
         if not (addon := self.sys_addons.get_local_only(reference)):
-            _LOGGER.info("Cannot restart addon %s as it does not exist", reference)
+            _LOGGER.info("Cannot restart app %s as it does not exist", reference)
             return
 
         # Stop addon
diff --git a/supervisor/resolution/fixups/addon_execute_start.py b/supervisor/resolution/fixups/addon_execute_start.py
index 359bdf3c265..ab49b79257f 100644
--- a/supervisor/resolution/fixups/addon_execute_start.py
+++ b/supervisor/resolution/fixups/addon_execute_start.py
@@ -25,7 +25,7 @@ async def process_fixup(self, reference: str | None = None) -> None:
             return
 
         if not (addon := self.sys_addons.get_local_only(reference)):
-            _LOGGER.info("Cannot start addon %s as it does not exist", reference)
+            _LOGGER.info("Cannot start app %s as it does not exist", reference)
             return
 
         # Start addon
@@ -38,7 +38,7 @@ async def process_fixup(self, reference: str | None = None) -> None:
         # Wait for addon start. If it ends up in error or unknown state it's not fixed
         await start_task
         if addon.state in {AddonState.ERROR, AddonState.UNKNOWN}:
-            _LOGGER.error("Addon %s could not start successfully", reference)
+            _LOGGER.error("App %s could not start successfully", reference)
             raise ResolutionFixupError()
 
     @property
diff --git a/supervisor/store/__init__.py b/supervisor/store/__init__.py
index c8529f4775e..8e219e15f13 100644
--- a/supervisor/store/__init__.py
+++ b/supervisor/store/__init__.py
@@ -186,7 +186,7 @@ async def _add_repository(
         else:
             if not await repository.validate():
                 if issue_on_error:
-                    _LOGGER.error("%s is not a valid add-on repository", url)
+                    _LOGGER.error("%s is not a valid app repository", url)
                     self.sys_resolution.create_issue(
                         IssueType.CORRUPT_REPOSITORY,
                         ContextType.STORE,
@@ -196,7 +196,7 @@ async def _add_repository(
                 else:
                     await repository.remove()
                     raise StoreInvalidAddonRepo(
-                        f"{url} is not a valid add-on repository", logger=_LOGGER.error
+                        f"{url} is not a valid app repository", logger=_LOGGER.error
                     )
 
         # Add Repository to list
@@ -221,7 +221,7 @@ async def remove_repository(self, repository: Repository, *, persist: bool = Tru
 
         if repository.slug in (addon.repository for addon in self.sys_addons.installed):
             raise StoreError(
-                f"Can't remove '{repository.source}'. It's used by installed add-ons",
+                f"Can't remove '{repository.source}'. It's used by installed apps",
                 logger=_LOGGER.error,
             )
         await self.repositories.pop(repository.slug).remove()
@@ -296,7 +296,7 @@ async def _read_addons(self) -> None:
         del_addons = set(self.sys_addons.store) - all_addons
 
         _LOGGER.info(
-            "Loading add-ons from store: %d all - %d new - %d remove",
+            "Loading apps from store: %d all - %d new - %d remove",
             len(all_addons),
             len(add_addons),
             len(del_addons),
diff --git a/supervisor/store/git.py b/supervisor/store/git.py
index ad29fe9d577..9a528123831 100644
--- a/supervisor/store/git.py
+++ b/supervisor/store/git.py
@@ -56,7 +56,7 @@ async def load(self) -> None:
         # Load repository
         async with self.lock:
             try:
-                _LOGGER.info("Loading add-on %s repository", self.path)
+                _LOGGER.info("Loading app %s repository", self.path)
                 self.repo = await self.sys_run_in_executor(git.Repo, str(self.path))
 
             except (
@@ -71,7 +71,7 @@ async def load(self) -> None:
         # Fix possible corruption
         async with self.lock:
             try:
-                _LOGGER.debug("Integrity check add-on %s repository", self.path)
+                _LOGGER.debug("Integrity check app %s repository", self.path)
                 await self.sys_run_in_executor(self.repo.git.execute, ["git", "fsck"])
             except git.CommandError as err:
                 _LOGGER.error("Integrity check on %s failed: %s.", self.path, err)
@@ -135,7 +135,7 @@ async def _clone(self, path: Path | None = None) -> None:
         }
 
         try:
-            _LOGGER.info("Cloning add-on %s repository from %s", path, self.url)
+            _LOGGER.info("Cloning app %s repository from %s", path, self.url)
             self.repo = await self.sys_run_in_executor(
                 ft.partial(
                     git.Repo.clone_from,
@@ -169,7 +169,7 @@ async def pull(self) -> bool:
             return False
 
         async with self.lock:
-            _LOGGER.info("Update add-on %s repository from %s", self.path, self.url)
+            _LOGGER.info("Update app %s repository from %s", self.path, self.url)
 
             try:
                 git_cmd = git.Git()
@@ -239,12 +239,12 @@ async def remove(self) -> None:
         """Remove a repository."""
         if self.lock.locked():
             _LOGGER.warning(
-                "Cannot remove add-on repository %s, there is already a task in progress",
+                "Cannot remove app repository %s, there is already a task in progress",
                 self.url,
             )
             return
 
-        _LOGGER.info("Removing custom add-on repository %s", self.url)
+        _LOGGER.info("Removing custom app repository %s", self.url)
 
         def _remove_git_dir(path: Path) -> None:
             if not path.is_dir():
diff --git a/tests/addons/test_addon.py b/tests/addons/test_addon.py
index acd3ae6bc09..500749c3411 100644
--- a/tests/addons/test_addon.py
+++ b/tests/addons/test_addon.py
@@ -406,7 +406,7 @@ async def test_start_timeout(
     ):
         await start_task
 
-    assert "Timeout while waiting for addon Terminal & SSH to start" in caplog.text
+    assert "Timeout while waiting for app Terminal & SSH to start" in caplog.text
 
 
 @pytest.mark.usefixtures("tmp_supervisor_data", "path_extern")
@@ -1021,7 +1021,7 @@ async def test_addon_load_succeeds_with_docker_errors(
     )
     caplog.clear()
     await install_addon_ssh.load()
-    assert "Cannot build addon 'local_ssh' because dockerfile is missing" in caplog.text
+    assert "Cannot build app 'local_ssh' because dockerfile is missing" in caplog.text
 
     # Image build failure
     caplog.clear()
diff --git a/tests/addons/test_config.py b/tests/addons/test_config.py
index 2385b66c495..a26a86355f1 100644
--- a/tests/addons/test_config.py
+++ b/tests/addons/test_config.py
@@ -210,7 +210,7 @@ def test_warn_legacy_arch_values(caplog: pytest.LogCaptureFixture):
 
     vd.SCHEMA_ADDON_CONFIG(config)
 
-    assert "Add-on config 'arch' uses deprecated values" in caplog.text
+    assert "App config 'arch' uses deprecated values" in caplog.text
 
 
 def test_warn_legacy_machine_values(caplog: pytest.LogCaptureFixture):
@@ -220,7 +220,7 @@ def test_warn_legacy_machine_values(caplog: pytest.LogCaptureFixture):
 
     vd.SCHEMA_ADDON_CONFIG(config)
 
-    assert "Add-on config 'machine' uses deprecated values" in caplog.text
+    assert "App config 'machine' uses deprecated values" in caplog.text
 
 
 def test_warn_advanced_deprecated(caplog: pytest.LogCaptureFixture):
diff --git a/tests/addons/test_manager.py b/tests/addons/test_manager.py
index fd3152f8252..04b8d2a9cf4 100644
--- a/tests/addons/test_manager.py
+++ b/tests/addons/test_manager.py
@@ -284,7 +284,7 @@ async def test_load(coresys: CoreSys, caplog: pytest.LogCaptureFixture):
         attach.assert_called_once_with(version=AwesomeVersion("9.2.1"))
         write_hosts.assert_called_once()
 
-    assert "Found 1 installed add-ons" in caplog.text
+    assert "Found 1 installed apps" in caplog.text
 
 
 @pytest.mark.usefixtures("tmp_supervisor_data", "path_extern")
diff --git a/tests/api/test_addons.py b/tests/api/test_addons.py
index d11509d7432..51252932577 100644
--- a/tests/api/test_addons.py
+++ b/tests/api/test_addons.py
@@ -87,7 +87,7 @@ async def test_api_addon_logs_not_installed(api_client: TestClient):
     assert resp.status == 404
     assert resp.content_type == "text/plain"
     content = await resp.text()
-    assert content == "Addon hic_sunt_leones does not exist"
+    assert content == "App hic_sunt_leones does not exist"
 
 
 @pytest.mark.usefixtures("docker_logs", "install_addon_ssh")
@@ -308,7 +308,7 @@ async def container_events_task(*args, **kwargs):
 
     assert resp.status == 400
     result = await resp.json()
-    assert "Can't rebuild a image based add-on" in result["message"]
+    assert "Can't rebuild an image-based app" in result["message"]
 
     # Reset state for next test
     state_changes.clear()
@@ -458,7 +458,7 @@ async def test_addon_options_boot_mode_manual_only_invalid(
     body = await resp.json()
     assert (
         body["message"]
-        == "Addon local_example boot option is set to manual_only so it cannot be changed"
+        == "App local_example boot option is set to manual_only so it cannot be changed"
     )
     assert body["error_key"] == "addon_boot_config_cannot_change_error"
     assert body["extra_fields"] == {
@@ -502,7 +502,7 @@ async def test_addon_not_found(
     """Test addon not found error."""
     resp = await api_client.request(method, url)
     assert resp.status == 404
-    assert await get_message(resp, json_expected) == "Addon bad does not exist"
+    assert await get_message(resp, json_expected) == "App bad does not exist"
 
 
 @pytest.mark.parametrize(
@@ -532,7 +532,7 @@ async def test_addon_not_installed(
     """Test addon not installed error."""
     resp = await api_client.request(method, url)
     assert resp.status == 400
-    assert await get_message(resp, json_expected) == "Addon is not installed"
+    assert await get_message(resp, json_expected) == "App is not installed"
 
 
 async def test_addon_set_options(api_client: TestClient, install_addon_example: Addon):
@@ -575,7 +575,7 @@ async def test_addon_set_options_error(api_client: TestClient):
     body = await resp.json()
     assert (
         body["message"]
-        == "Add-on local_example has invalid options: not a valid value. Got {'message': True}"
+        == "App local_example has invalid options: not a valid value. Got {'message': True}"
     )
     assert body["error_key"] == "addon_configuration_invalid_error"
     assert body["extra_fields"] == {
@@ -599,13 +599,13 @@ async def test_addon_start_options_error(
         body = await resp.json()
         assert (
             body["message"]
-            == "An unknown error occurred with addon local_example. Check Supervisor logs for details"
+            == "An unknown error occurred with app local_example. Check Supervisor logs for details"
         )
         assert body["error_key"] == "addon_unknown_error"
         assert body["extra_fields"] == {
             "addon": "local_example",
         }
-        assert "Add-on local_example can't write options" in caplog.text
+        assert "App local_example can't write options" in caplog.text
 
     # Simulate an update with a breaking change for options schema creating failure on start
     caplog.clear()
@@ -615,7 +615,7 @@ async def test_addon_start_options_error(
     body = await resp.json()
     assert (
         body["message"]
-        == "Add-on local_example has invalid options: expected boolean. Got {'message': 'hello'}"
+        == "App local_example has invalid options: expected boolean. Got {'message': 'hello'}"
     )
     assert body["error_key"] == "addon_configuration_invalid_error"
     assert body["extra_fields"] == {
@@ -623,7 +623,7 @@ async def test_addon_start_options_error(
         "validation_error": "expected boolean. Got {'message': 'hello'}",
     }
     assert (
-        "Add-on local_example has invalid options: expected boolean. Got {'message': 'hello'}"
+        "App local_example has invalid options: expected boolean. Got {'message': 'hello'}"
         in caplog.text
     )
 
@@ -639,7 +639,7 @@ async def test_addon_not_running_error(
 
     assert resp.status == 400
     body = await resp.json()
-    assert body["message"] == "Add-on local_example is not running"
+    assert body["message"] == "App local_example is not running"
     assert body["error_key"] == "addon_not_running_error"
     assert body["extra_fields"] == {"addon": "local_example"}
 
@@ -650,7 +650,7 @@ async def test_addon_write_stdin_not_supported_error(api_client: TestClient):
     resp = await api_client.post("/addons/local_example/stdin")
     assert resp.status == 400
     body = await resp.json()
-    assert body["message"] == "Add-on local_example does not support writing to stdin"
+    assert body["message"] == "App local_example does not support writing to stdin"
     assert body["error_key"] == "addon_not_supported_write_stdin_error"
     assert body["extra_fields"] == {"addon": "local_example"}
 
@@ -681,7 +681,7 @@ async def test_addon_rebuild_fails_error(api_client: TestClient, coresys: CoreSy
     body = await resp.json()
     assert (
         body["message"]
-        == "An unknown error occurred while trying to build the image for addon local_ssh. Check Supervisor logs for details"
+        == "An unknown error occurred while trying to build the image for app local_ssh. Check Supervisor logs for details"
     )
     assert body["error_key"] == "addon_build_failed_unknown_error"
     assert body["extra_fields"] == {
diff --git a/tests/api/test_backups.py b/tests/api/test_backups.py
index 59827c8aa8d..34d9dcb486b 100644
--- a/tests/api/test_backups.py
+++ b/tests/api/test_backups.py
@@ -1527,8 +1527,8 @@ async def test_pre_post_backup_command_error(
     assert job.done is True
     assert job.errors[0].type_ == AddonPrePostBackupCommandReturnedError
     assert job.errors[0].message == (
-        "Pre-/Post backup command for add-on local_example returned error code: "
-        "1. Please report this to the addon developer. Enable debug "
+        "Pre-/Post backup command for app local_example returned error code: "
+        "1. Please report this to the app developer. Enable debug "
         "logging to capture complete command output using ha supervisor options --logging debug"
     )
     assert job.errors[0].error_key == "addon_pre_post_backup_command_returned_error"
diff --git a/tests/api/test_discovery.py b/tests/api/test_discovery.py
index e0ec28ad5c2..fc2d4850c02 100644
--- a/tests/api/test_discovery.py
+++ b/tests/api/test_discovery.py
@@ -32,9 +32,9 @@ async def test_api_discovery_forbidden(
     assert result["result"] == "error"
     assert (
         result["message"]
-        == "Add-ons must list services they provide via discovery in their config!"
+        == "Apps must list services they provide via discovery in their config!"
     )
-    assert "Please report this to the maintainer of the add-on" in caplog.text
+    assert "Please report this to the maintainer of the app" in caplog.text
 
 
 @pytest.mark.parametrize(
diff --git a/tests/api/test_store.py b/tests/api/test_store.py
index ecf64027163..9c0e2cd6754 100644
--- a/tests/api/test_store.py
+++ b/tests/api/test_store.py
@@ -47,9 +47,7 @@ async def test_api_store(
     assert result["data"]["addons"][-1]["slug"] == store_addon.slug
     assert result["data"]["repositories"][-1]["slug"] == test_repository.slug
 
-    assert (
-        f"Add-on {store_addon.slug} not supported on this platform" not in caplog.text
-    )
+    assert f"App {store_addon.slug} not supported on this platform" not in caplog.text
 
 
 @pytest.mark.asyncio
@@ -198,7 +196,7 @@ async def test_api_store_repair_repository_git_error(
     }
     assert (
         result["message"]
-        == f"An unknown error occurred with addon repository {test_repository.slug}. Check Supervisor logs for details"
+        == f"An unknown error occurred with app repository {test_repository.slug}. Check Supervisor logs for details"
     )
 
 
@@ -294,7 +292,7 @@ async def test_api_store_addons_no_changelog(
     resp = await api_client.get(f"/{resource}/{store_addon.slug}/changelog")
     assert resp.status == 200
     result = await resp.text()
-    assert result == "No changelog found for add-on test_store_addon!"
+    assert result == "No changelog found for app test_store_addon!"
 
 
 @pytest.mark.parametrize("resource", ["store/addons", "addons"])
@@ -322,7 +320,7 @@ async def test_api_detached_addon_changelog(
     resp = await api_client.get(f"/{resource}/{install_addon_ssh.slug}/changelog")
     assert resp.status == 200
     result = await resp.text()
-    assert result == "Addon local_ssh does not exist in the store"
+    assert result == "App local_ssh does not exist in the store"
 
 
 @pytest.mark.parametrize("resource", ["store/addons", "addons"])
@@ -338,7 +336,7 @@ async def test_api_store_addons_no_documentation(
     resp = await api_client.get(f"/{resource}/{store_addon.slug}/documentation")
     assert resp.status == 200
     result = await resp.text()
-    assert result == "No documentation found for add-on test_store_addon!"
+    assert result == "No documentation found for app test_store_addon!"
 
 
 @pytest.mark.parametrize("resource", ["store/addons", "addons"])
@@ -366,7 +364,7 @@ async def test_api_detached_addon_documentation(
     resp = await api_client.get(f"/{resource}/{install_addon_ssh.slug}/documentation")
     assert resp.status == 200
     result = await resp.text()
-    assert result == "Addon local_ssh does not exist in the store"
+    assert result == "App local_ssh does not exist in the store"
 
 
 @pytest.mark.parametrize(
@@ -396,11 +394,11 @@ async def test_store_addon_not_found(
     assert resp.status == 404
     if json_expected:
         body = await resp.json()
-        assert body["message"] == "Addon bad does not exist in the store"
+        assert body["message"] == "App bad does not exist in the store"
         assert body["error_key"] == "store_addon_not_found_error"
         assert body["extra_fields"] == {"addon": "bad"}
     else:
-        assert await resp.text() == "Addon bad does not exist in the store"
+        assert await resp.text() == "App bad does not exist in the store"
 
 
 @pytest.mark.parametrize(
@@ -418,7 +416,7 @@ async def test_store_addon_not_installed(api_client: TestClient, method: str, ur
     resp = await api_client.request(method, url)
     assert resp.status == 400
     body = await resp.json()
-    assert body["message"] == "Addon local_ssh is not installed"
+    assert body["message"] == "App local_ssh is not installed"
 
 
 @pytest.mark.parametrize(
@@ -508,7 +506,7 @@ async def test_background_addon_install_fails_fast(
     )
     assert resp.status == 400
     body = await resp.json()
-    assert body["message"] == "Add-on local_ssh is already installed"
+    assert body["message"] == "App local_ssh is already installed"
 
 
 @pytest.mark.parametrize(
@@ -572,7 +570,7 @@ async def test_background_addon_update_fails_fast(
     )
     assert resp.status == 400
     body = await resp.json()
-    assert body["message"] == "No update available for add-on local_ssh"
+    assert body["message"] == "No update available for app local_ssh"
 
 
 async def test_api_store_addons_addon_availability_success(
@@ -640,7 +638,7 @@ async def test_api_store_addons_addon_availability_arch_not_supported(
         }
         assert (
             result["message"]
-            == f"Add-on test_arch_addon not supported on this platform, supported architectures: {architectures}"
+            == f"App test_arch_addon not supported on this platform, supported architectures: {architectures}"
         )
 
 
@@ -703,7 +701,7 @@ async def test_api_store_addons_addon_availability_machine_not_supported(
         }
         assert (
             result["message"]
-            == f"Add-on test_machine_addon not supported on this machine, supported machine types: {machine_types}"
+            == f"App test_machine_addon not supported on this machine, supported machine types: {machine_types}"
         )
 
 
@@ -763,7 +761,7 @@ async def test_api_store_addons_addon_availability_homeassistant_version_too_old
         }
         assert (
             result["message"]
-            == "Add-on test_version_addon not supported on this system, requires Home Assistant version 2023.1.1 or greater"
+            == "App test_version_addon not supported on this system, requires Home Assistant version 2023.1.1 or greater"
         )
 
 
diff --git a/tests/backups/test_backup.py b/tests/backups/test_backup.py
index 53c6cba4966..6f7ab797d31 100644
--- a/tests/backups/test_backup.py
+++ b/tests/backups/test_backup.py
@@ -83,7 +83,7 @@ async def test_backup_error_addon(
     backup.new("test", "2023-07-21T21:05:00.000000+00:00", BackupType.FULL)
 
     install_addon_ssh.backup = MagicMock(
-        side_effect=(err := AddonsError("Fake add-on backup error"))
+        side_effect=(err := AddonsError("Fake app backup error"))
     )
 
     async with backup.create():
diff --git a/tests/backups/test_manager.py b/tests/backups/test_manager.py
index 131836e2bcf..dd5e1cae4c2 100644
--- a/tests/backups/test_manager.py
+++ b/tests/backups/test_manager.py
@@ -2219,6 +2219,6 @@ async def mock_store_addons(*args, **kwargs):
     assert "local_example" not in coresys.addons.local
     assert not backup.addons
     assert (
-        "Skipping backup of add-on local_example because it has been uninstalled"
+        "Skipping backup of app local_example because it has been uninstalled"
         in caplog.text
     )
diff --git a/tests/resolution/check/test_check_docker_config.py b/tests/resolution/check/test_check_docker_config.py
index bd52cf7a886..709e4bcf850 100644
--- a/tests/resolution/check/test_check_docker_config.py
+++ b/tests/resolution/check/test_check_docker_config.py
@@ -193,7 +193,7 @@ async def test_addon_volume_mount_not_flagged(
         if issue.context == ContextType.ADDON and issue.reference == "local_ssh"
     ]
     assert len(addon_issues) == 0, (
-        "Add-on should not be flagged for VOLUME mounts not in config"
+        "App should not be flagged for VOLUME mounts not in config"
     )
 
     # No system issue should be created either if no containers have issues
@@ -258,7 +258,7 @@ async def mock_container_get(name):
         if issue.context == ContextType.ADDON and issue.reference == "local_ssh"
     ]
     assert len(addon_issues) == 1, (
-        "Add-on should be flagged for configured mounts with wrong propagation"
+        "App should be flagged for configured mounts with wrong propagation"
     )
 
 
@@ -317,7 +317,7 @@ async def mock_container_get(name: str) -> MagicMock:
         if issue.context == ContextType.ADDON and issue.reference == "local_ssh"
     ]
     assert len(addon_issues) == 1, (
-        "Add-on should be flagged for configured mounts with custom paths and wrong propagation"
+        "App should be flagged for configured mounts with custom paths and wrong propagation"
     )
 
 
diff --git a/tests/resolution/fixup/test_addon_execute_rebuild.py b/tests/resolution/fixup/test_addon_execute_rebuild.py
index 7feb852cb4f..491664d5beb 100644
--- a/tests/resolution/fixup/test_addon_execute_rebuild.py
+++ b/tests/resolution/fixup/test_addon_execute_rebuild.py
@@ -78,7 +78,7 @@ async def test_fixup_stopped_core(
     (await docker.containers.get("addon_local_ssh")).delete.assert_called_once_with(
         force=True, v=True
     )
-    assert "Addon local_ssh is stopped" in caplog.text
+    assert "App local_ssh is stopped" in caplog.text
 
 
 @pytest.mark.usefixtures("install_addon_ssh")
@@ -108,7 +108,7 @@ async def test_fixup_unknown_core(
 
     assert not coresys.resolution.issues
     assert not coresys.resolution.suggestions
-    assert "Container for addon local_ssh does not exist" in caplog.text
+    assert "Container for app local_ssh does not exist" in caplog.text
 
 
 async def test_fixup_addon_removed(coresys: CoreSys, caplog: pytest.LogCaptureFixture):
@@ -123,4 +123,4 @@ async def test_fixup_addon_removed(coresys: CoreSys, caplog: pytest.LogCaptureFi
         suggestions=[SuggestionType.EXECUTE_REBUILD],
     )
     await addon_execute_rebuild()
-    assert "Cannot rebuild addon local_ssh as it is not installed" in caplog.text
+    assert "Cannot rebuild app local_ssh as it is not installed" in caplog.text
diff --git a/tests/resolution/fixup/test_addon_execute_restart.py b/tests/resolution/fixup/test_addon_execute_restart.py
index 7dec5bd72bf..bfec0228405 100644
--- a/tests/resolution/fixup/test_addon_execute_restart.py
+++ b/tests/resolution/fixup/test_addon_execute_restart.py
@@ -117,4 +117,4 @@ async def test_fixup_no_addon(coresys: CoreSys, caplog: pytest.LogCaptureFixture
 
     assert not coresys.resolution.issues
     assert not coresys.resolution.suggestions
-    assert "Cannot restart addon local_ssh as it does not exist" in caplog.text
+    assert "Cannot restart app local_ssh as it does not exist" in caplog.text
diff --git a/tests/store/test_custom_repository.py b/tests/store/test_custom_repository.py
index 51c9c2bfca3..928b15b79f0 100644
--- a/tests/store/test_custom_repository.py
+++ b/tests/store/test_custom_repository.py
@@ -246,7 +246,7 @@ async def test_remove_used_repository(
 
     with pytest.raises(
         StoreError,
-        match="Can't remove 'https://github.com/awesome-developer/awesome-repo'. It's used by installed add-ons",
+        match="Can't remove 'https://github.com/awesome-developer/awesome-repo'. It's used by installed apps",
     ):
         if use_update:
             await store_manager.update_repositories(set())
diff --git a/tests/store/test_store_manager.py b/tests/store/test_store_manager.py
index 73659186291..95863e82840 100644
--- a/tests/store/test_store_manager.py
+++ b/tests/store/test_store_manager.py
@@ -128,19 +128,19 @@ async def test_reload_fails_if_out_of_date(coresys: CoreSys):
     [
         (
             {"arch": ["aarch64"]},
-            "Add-on local_ssh not supported on this platform, supported architectures: aarch64",
+            "App local_ssh not supported on this platform, supported architectures: aarch64",
         ),
         (
             {"machine": ["odroid-n2"]},
-            "Add-on local_ssh not supported on this machine, supported machine types: odroid-n2",
+            "App local_ssh not supported on this machine, supported machine types: odroid-n2",
         ),
         (
             {"machine": ["!qemux86-64"]},
-            "Add-on local_ssh not supported on this machine, supported machine types: !qemux86-64",
+            "App local_ssh not supported on this machine, supported machine types: !qemux86-64",
         ),
         (
             {"homeassistant": AwesomeVersion("2023.1.1")},
-            "Add-on local_ssh not supported on this system, requires Home Assistant version 2023.1.1 or greater",
+            "App local_ssh not supported on this system, requires Home Assistant version 2023.1.1 or greater",
         ),
     ],
 )
@@ -187,19 +187,19 @@ async def test_update_unavailable_addon(
     [
         (
             {"arch": ["aarch64"]},
-            "Add-on local_ssh not supported on this platform, supported architectures: aarch64",
+            "App local_ssh not supported on this platform, supported architectures: aarch64",
         ),
         (
             {"machine": ["odroid-n2"]},
-            "Add-on local_ssh not supported on this machine, supported machine types: odroid-n2",
+            "App local_ssh not supported on this machine, supported machine types: odroid-n2",
         ),
         (
             {"machine": ["!qemux86-64"]},
-            "Add-on local_ssh not supported on this machine, supported machine types: !qemux86-64",
+            "App local_ssh not supported on this machine, supported machine types: !qemux86-64",
         ),
         (
             {"homeassistant": AwesomeVersion("2023.1.1")},
-            "Add-on local_ssh not supported on this system, requires Home Assistant version 2023.1.1 or greater",
+            "App local_ssh not supported on this system, requires Home Assistant version 2023.1.1 or greater",
         ),
     ],
 )