diff --git a/.dialyzer_ignore.exs b/.dialyzer_ignore.exs
index 11bb9da67..ebcccd6aa 100644
--- a/.dialyzer_ignore.exs
+++ b/.dialyzer_ignore.exs
@@ -1,7 +1,7 @@
 [
   {"lib/x509/certificate.ex", "Unknown type: X509.ASN1.record/1."},
   {"lib/x509/certificate/extension.ex", "Unknown type: X509.ASN1.record/1."},
-  {"lib/nerves_hub/deployments/orchestrator.ex", :unmatched_return, 1},
+  {"lib/nerves_hub/managed_deployments/orchestrator.ex", :unmatched_return, 1},
   {"lib/nerves_hub_web/channels/device_channel.ex", :unmatched_return, 1},
   {"lib/nerves_hub_web/channels/device_socket.ex", :unmatched_return, 1}
 ]
diff --git a/assets/css/_custom.scss b/assets/css/_custom.scss
index 1352e5515..a76c3a3b5 100644
--- a/assets/css/_custom.scss
+++ b/assets/css/_custom.scss
@@ -219,7 +219,7 @@
   line-height: 44px;
 }
 
-.deployment-meta-grid {
+.deployment-group-meta-grid {
   display: grid;
   grid-template-columns: max-content max-content max-content max-content 1fr;
   grid-column-gap: 5.5rem;
@@ -397,7 +397,7 @@ html {
 }
 
 @media (max-width: 1000px) and (min-width: 480px) {
-  .collapse.deployment-form.show {
+  .collapse.deployment-group-form.show {
     display: grid !important;
   }
 }
diff --git a/assets/css/_layout.scss b/assets/css/_layout.scss
index e38061359..b75dcfef8 100644
--- a/assets/css/_layout.scss
+++ b/assets/css/_layout.scss
@@ -396,7 +396,7 @@ html {
     grid-column-gap: 2rem;
     grid-row-gap: 2rem;
 
-    &.deployment-form {
+    &.deployment-group-form {
       grid-template-columns: 360px 360px;
       grid-row-gap: 0;
       grid-column-gap: 3rem;
diff --git a/assets/css/_table.scss b/assets/css/_table.scss
index fdd848c71..1dd607145 100644
--- a/assets/css/_table.scss
+++ b/assets/css/_table.scss
@@ -111,7 +111,7 @@ html {
     gap: 6px;
   }
 
-  .deployment-state {
+  .deployment-group-state {
     background-size: 1.5rem;
     background-repeat: no-repeat;
     background-position: left center;
@@ -128,10 +128,10 @@ html {
   }
 
   .certificate-status-expired {
-    color: var(--danger);;
+    color: var(--danger);
   }
 
   .certificate-status-expiring-soon {
     color: var(--warning);
   }
-}
+}
\ No newline at end of file
diff --git a/lib/nerves_hub/accounts/remove_account.ex b/lib/nerves_hub/accounts/remove_account.ex
index 7f8fca296..22884c580 100644
--- a/lib/nerves_hub/accounts/remove_account.ex
+++ b/lib/nerves_hub/accounts/remove_account.ex
@@ -11,7 +11,6 @@ defmodule NervesHub.Accounts.RemoveAccount do
   alias NervesHub.Accounts.OrgMetric
   alias NervesHub.Accounts.OrgUser
   alias NervesHub.Accounts.User
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices.CACertificate
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.DeviceCertificate
@@ -19,6 +18,7 @@ defmodule NervesHub.Accounts.RemoveAccount do
   alias NervesHub.Firmwares.Firmware
   alias NervesHub.Firmwares.FirmwareDelta
   alias NervesHub.Firmwares.FirmwareTransfer
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Products.Product
   alias NervesHub.Scripts.Script
 
@@ -32,7 +32,7 @@ defmodule NervesHub.Accounts.RemoveAccount do
     |> Multi.delete_all(:invites, &query_by_org_id(Invite, &1))
     |> Multi.delete_all(:device_certificates, &query_by_org_id(DeviceCertificate, &1))
     |> Multi.delete_all(:ca_certificates, &query_by_org_id(CACertificate, &1))
-    |> Multi.delete_all(:deployments, &query_by_org_id(Deployment, &1))
+    |> Multi.delete_all(:deployment_groups, &query_by_org_id(DeploymentGroup, &1))
     |> Multi.delete_all(:firmware_deltas, &query_firmware_deltas/1)
     |> Multi.delete_all(:firmware_transfers, &query_by_org_id(FirmwareTransfer, &1))
     |> Multi.delete_all(:pinned_devices, &query_by_user_id(PinnedDevice, &1))
diff --git a/lib/nerves_hub/application.ex b/lib/nerves_hub/application.ex
index f71feb408..c77d1f11d 100644
--- a/lib/nerves_hub/application.ex
+++ b/lib/nerves_hub/application.ex
@@ -81,13 +81,13 @@ defmodule NervesHub.Application do
   defp deployments_orchestrator(_) do
     case Application.get_env(:nerves_hub, :app) do
       ["device"] ->
-        [NervesHub.Deployments.Supervisor]
+        [NervesHub.ManagedDeployments.Supervisor]
 
       _ ->
         [
-          NervesHub.Deployments.Supervisor,
+          NervesHub.ManagedDeployments.Supervisor,
           ProcessHub.child_spec(%ProcessHub{hub_id: :deployment_orchestrators}),
-          NervesHub.Deployments.Distributed.OrchestratorRegistration
+          NervesHub.ManagedDeployments.Distributed.OrchestratorRegistration
         ]
     end
   end
diff --git a/lib/nerves_hub/archives.ex b/lib/nerves_hub/archives.ex
index e2ddcb4ca..d394ca9a0 100644
--- a/lib/nerves_hub/archives.ex
+++ b/lib/nerves_hub/archives.ex
@@ -8,8 +8,8 @@ defmodule NervesHub.Archives do
   require Logger
 
   alias NervesHub.Archives.Archive
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Fwup
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Products.Product
   alias NervesHub.Repo
   alias NervesHub.Workers.DeleteArchive
@@ -67,12 +67,12 @@ defmodule NervesHub.Archives do
     |> Repo.one!()
   end
 
-  @spec archive_for_deployment(integer()) :: Archive.t() | nil
-  def archive_for_deployment(nil), do: nil
+  @spec archive_for_deployment_group(integer()) :: Archive.t() | nil
+  def archive_for_deployment_group(nil), do: nil
 
-  def archive_for_deployment(deployment_id) do
+  def archive_for_deployment_group(deployment_id) do
     Archive
-    |> join(:inner, [a], d in Deployment, on: d.archive_id == a.id)
+    |> join(:inner, [a], d in DeploymentGroup, on: d.archive_id == a.id)
     |> where([a, d], d.id == ^deployment_id)
     |> Repo.one()
   end
diff --git a/lib/nerves_hub/audit_logs.ex b/lib/nerves_hub/audit_logs.ex
index 0d0e06ad6..b32b70351 100644
--- a/lib/nerves_hub/audit_logs.ex
+++ b/lib/nerves_hub/audit_logs.ex
@@ -2,7 +2,7 @@ defmodule NervesHub.AuditLogs do
   import Ecto.Query
 
   alias NervesHub.AuditLogs.AuditLog
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Repo
   alias NimbleCSV.RFC4180, as: CSV
 
@@ -60,8 +60,8 @@ defmodule NervesHub.AuditLogs do
     |> Flop.run(flop)
   end
 
-  defp query_for_feed(%Deployment{id: id}) do
-    resource_type = to_string(Deployment)
+  defp query_for_feed(%DeploymentGroup{id: id}) do
+    resource_type = to_string(DeploymentGroup)
 
     from(al in AuditLog, where: [resource_type: ^resource_type, resource_id: ^id])
     |> order_by(desc: :inserted_at)
diff --git a/lib/nerves_hub/audit_logs/templates/deployment_group_templates.ex b/lib/nerves_hub/audit_logs/templates/deployment_group_templates.ex
new file mode 100644
index 000000000..704720632
--- /dev/null
+++ b/lib/nerves_hub/audit_logs/templates/deployment_group_templates.ex
@@ -0,0 +1,47 @@
+defmodule NervesHub.AuditLogs.DeploymentGroupTemplates do
+  @moduledoc """
+  Templates for and handling of audit logging for deployment operations.
+  """
+  alias NervesHub.Accounts.User
+  alias NervesHub.AuditLogs
+  alias NervesHub.Devices.Device
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+
+  @spec audit_deployment_created(User.t(), DeploymentGroup.t()) :: :ok
+  def audit_deployment_created(user, deployment_group) do
+    description = "User #{user.name} created deployment group #{deployment_group.name}"
+    AuditLogs.audit!(user, deployment_group, description)
+  end
+
+  @spec audit_deployment_updated(User.t(), DeploymentGroup.t()) :: :ok
+  def audit_deployment_updated(user, deployment_group) do
+    description = "User #{user.name} updated deployment group #{deployment_group.name}"
+    AuditLogs.audit!(user, deployment_group, description)
+  end
+
+  @spec audit_deployment_deleted(User.t(), DeploymentGroup.t()) :: :ok
+  def audit_deployment_deleted(user, deployment_group) do
+    description = "User #{user.name} deleted deployment group #{deployment_group.name}"
+    AuditLogs.audit!(user, deployment_group, description)
+  end
+
+  @spec audit_deployment_toggle_active(User.t(), DeploymentGroup.t(), String.t()) :: :ok
+  def audit_deployment_toggle_active(user, deployment_group, status) do
+    description = "User #{user.name} marked deployment group #{deployment_group.name} #{status}"
+    AuditLogs.audit!(user, deployment_group, description)
+  end
+
+  @spec audit_deployment_mismatch(Device.t(), DeploymentGroup.t(), String.t()) :: :ok
+  def audit_deployment_mismatch(device, deployment_group, reason) do
+    description =
+      "Device no longer matches deployment group #{deployment_group.name}'s requirements because of #{reason}"
+
+    AuditLogs.audit!(device, deployment_group, description)
+  end
+
+  @spec audit_deployment_group_change(DeploymentGroup.t(), String.t()) :: :ok
+  def audit_deployment_group_change(deployment_group, change_string) do
+    description = "Deployment group #{deployment_group.name} #{change_string}"
+    AuditLogs.audit!(deployment_group, deployment_group, description)
+  end
+end
diff --git a/lib/nerves_hub/audit_logs/templates/deployment_templates.ex b/lib/nerves_hub/audit_logs/templates/deployment_templates.ex
deleted file mode 100644
index af27fce47..000000000
--- a/lib/nerves_hub/audit_logs/templates/deployment_templates.ex
+++ /dev/null
@@ -1,47 +0,0 @@
-defmodule NervesHub.AuditLogs.DeploymentTemplates do
-  @moduledoc """
-  Templates for and handling of audit logging for deployment operations.
-  """
-  alias NervesHub.Accounts.User
-  alias NervesHub.AuditLogs
-  alias NervesHub.Deployments.Deployment
-  alias NervesHub.Devices.Device
-
-  @spec audit_deployment_created(User.t(), Deployment.t()) :: :ok
-  def audit_deployment_created(user, deployment) do
-    description = "User #{user.name} created deployment #{deployment.name}"
-    AuditLogs.audit!(user, deployment, description)
-  end
-
-  @spec audit_deployment_updated(User.t(), Deployment.t()) :: :ok
-  def audit_deployment_updated(user, deployment) do
-    description = "User #{user.name} updated deployment #{deployment.name}"
-    AuditLogs.audit!(user, deployment, description)
-  end
-
-  @spec audit_deployment_deleted(User.t(), Deployment.t()) :: :ok
-  def audit_deployment_deleted(user, deployment) do
-    description = "User #{user.name} deleted deployment #{deployment.name}"
-    AuditLogs.audit!(user, deployment, description)
-  end
-
-  @spec audit_deployment_toggle_active(User.t(), Deployment.t(), String.t()) :: :ok
-  def audit_deployment_toggle_active(user, deployment, status) do
-    description = "User #{user.name} marked deployment #{deployment.name} #{status}"
-    AuditLogs.audit!(user, deployment, description)
-  end
-
-  @spec audit_deployment_mismatch(Device.t(), Deployment.t(), String.t()) :: :ok
-  def audit_deployment_mismatch(device, deployment, reason) do
-    description =
-      "Device no longer matches deployment #{deployment.name}'s requirements because of #{reason}"
-
-    AuditLogs.audit!(device, deployment, description)
-  end
-
-  @spec audit_deployment_change(Deployment.t(), String.t()) :: :ok
-  def audit_deployment_change(deployment, change_string) do
-    description = "Deployment #{deployment.name} #{change_string}"
-    AuditLogs.audit!(deployment, deployment, description)
-  end
-end
diff --git a/lib/nerves_hub/audit_logs/templates/device_templates.ex b/lib/nerves_hub/audit_logs/templates/device_templates.ex
index bf0e13709..5a8da5cbf 100644
--- a/lib/nerves_hub/audit_logs/templates/device_templates.ex
+++ b/lib/nerves_hub/audit_logs/templates/device_templates.ex
@@ -6,9 +6,9 @@ defmodule NervesHub.AuditLogs.DeviceTemplates do
   alias NervesHub.Accounts.User
   alias NervesHub.Archives.Archive
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices.Device
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   require Logger
 
@@ -34,10 +34,10 @@ defmodule NervesHub.AuditLogs.DeviceTemplates do
     AuditLogs.audit(device, device, description)
   end
 
-  @spec audit_pushed_available_update(User.t(), Device.t(), Deployment.t()) :: :ok
-  def audit_pushed_available_update(user, device, deployment) do
+  @spec audit_pushed_available_update(User.t(), Device.t(), DeploymentGroup.t()) :: :ok
+  def audit_pushed_available_update(user, device, deployment_group) do
     description =
-      "User #{user.name} pushed available firmware update #{deployment.firmware.version} #{deployment.firmware.uuid} to device #{device.identifier}"
+      "User #{user.name} pushed available firmware update #{deployment_group.firmware.version} #{deployment_group.firmware.uuid} to device #{device.identifier}"
 
     AuditLogs.audit!(user, device, description)
   end
@@ -56,14 +56,14 @@ defmodule NervesHub.AuditLogs.DeviceTemplates do
     AuditLogs.audit!(device, device, description)
   end
 
-  @spec audit_firmware_upgrade_blocked(Deployment.t(), Device.t()) :: :ok
-  def audit_firmware_upgrade_blocked(deployment, device) do
+  @spec audit_firmware_upgrade_blocked(DeploymentGroup.t(), Device.t()) :: :ok
+  def audit_firmware_upgrade_blocked(deployment_group, device) do
     description = """
-    Device #{device.identifier} automatically blocked firmware upgrades for #{deployment.penalty_timeout_minutes} minutes.
-    Device failure rate met for firmware #{deployment.firmware.uuid} in deployment #{deployment.name}.
+    Device #{device.identifier} automatically blocked firmware upgrades for #{deployment_group.penalty_timeout_minutes} minutes.
+    Device failure rate met for firmware #{deployment_group.firmware.uuid} in deployment group #{deployment_group.name}.
     """
 
-    AuditLogs.audit!(deployment, device, description)
+    AuditLogs.audit!(deployment_group, device, description)
   end
 
   @spec audit_firmware_updated(Device.t()) :: :ok
@@ -74,39 +74,43 @@ defmodule NervesHub.AuditLogs.DeviceTemplates do
     AuditLogs.audit!(device, device, description)
   end
 
-  @spec audit_device_deployment_update_triggered(Device.t(), Deployment.t(), UUIDv7.t()) :: :ok
-  def audit_device_deployment_update_triggered(device, deployment, reference_id) do
-    firmware = deployment.firmware
+  @spec audit_device_deployment_group_update_triggered(
+          Device.t(),
+          DeploymentGroup.t(),
+          UUIDv7.t()
+        ) :: :ok
+  def audit_device_deployment_group_update_triggered(device, deployment_group, reference_id) do
+    firmware = deployment_group.firmware
 
     description =
-      "Deployment #{deployment.name} update triggered device #{device.identifier} to update firmware #{firmware.uuid}"
+      "Deployment #{deployment_group.name} update triggered device #{device.identifier} to update firmware #{firmware.uuid}"
 
-    AuditLogs.audit_with_ref!(deployment, device, description, reference_id)
+    AuditLogs.audit_with_ref!(deployment_group, device, description, reference_id)
   end
 
-  @spec audit_device_deployment_update(User.t(), Device.t(), Deployment.t()) :: :ok
-  def audit_device_deployment_update(user, device, deployment) do
+  @spec audit_device_deployment_group_update(User.t(), Device.t(), DeploymentGroup.t()) :: :ok
+  def audit_device_deployment_group_update(user, device, deployment_group) do
     AuditLogs.audit!(
       user,
       device,
-      "User #{user.name} set #{device.identifier}'s deployment to #{deployment.name}"
+      "User #{user.name} set #{device.identifier}'s deployment group to #{deployment_group.name}"
     )
   end
 
-  @spec audit_set_deployment(Device.t(), Deployment.t(), :one_found | :multiple_found) :: :ok
-  def audit_set_deployment(device, deployment, :one_found) do
+  @spec audit_set_deployment(Device.t(), DeploymentGroup.t(), :one_found | :multiple_found) :: :ok
+  def audit_set_deployment(device, deployment_group, :one_found) do
     AuditLogs.audit!(
       device,
       device,
-      "Updating #{device.identifier}'s deployment to #{deployment.name}"
+      "Updating #{device.identifier}'s deployment group to #{deployment_group.name}"
     )
   end
 
-  def audit_set_deployment(device, deployment, :multiple_found) do
+  def audit_set_deployment(device, deployment_group, :multiple_found) do
     AuditLogs.audit!(
       device,
       device,
-      "Multiple matching deployments found, updating #{device.identifier}'s deployment to #{deployment.name}"
+      "Multiple matching deployments found, updating #{device.identifier}'s deployment group to #{deployment_group.name}"
     )
   end
 
diff --git a/lib/nerves_hub/deployments/inflight_deployment_check.ex b/lib/nerves_hub/deployments/inflight_deployment_check.ex
deleted file mode 100644
index 340402405..000000000
--- a/lib/nerves_hub/deployments/inflight_deployment_check.ex
+++ /dev/null
@@ -1,15 +0,0 @@
-defmodule NervesHub.Deployments.InflightDeploymentCheck do
-  use Ecto.Schema
-
-  @timestamps_opts updated_at: false
-
-  alias NervesHub.Deployments.Deployment
-  alias NervesHub.Devices.Device
-
-  schema "inflight_deployment_checks" do
-    belongs_to(:device, Device)
-    belongs_to(:deployment, Deployment)
-
-    timestamps()
-  end
-end
diff --git a/lib/nerves_hub/deployments/monitor.ex b/lib/nerves_hub/deployments/monitor.ex
deleted file mode 100644
index 116702ce4..000000000
--- a/lib/nerves_hub/deployments/monitor.ex
+++ /dev/null
@@ -1,66 +0,0 @@
-defmodule NervesHub.Deployments.Monitor do
-  @moduledoc """
-  Deployment Monitor starts a deployment orchestrator per deployment
-
-  Listens for new deployments and starts as necessary
-  """
-
-  use GenServer
-
-  alias NervesHub.DeploymentDynamicSupervisor
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Orchestrator
-  alias Phoenix.PubSub
-  alias Phoenix.Socket.Broadcast
-
-  defmodule State do
-    defstruct [:deployments]
-  end
-
-  def start_link(_) do
-    GenServer.start_link(__MODULE__, [])
-  end
-
-  def init(_) do
-    _ = PubSub.subscribe(NervesHub.PubSub, "deployment:monitor")
-
-    {:ok, %State{}, {:continue, :boot}}
-  end
-
-  def handle_continue(:boot, state) do
-    deployments =
-      Enum.into(Deployments.all(), %{}, fn deployment ->
-        {:ok, orchestrator_pid} =
-          DynamicSupervisor.start_child(
-            DeploymentDynamicSupervisor,
-            {Deployments.Orchestrator, deployment}
-          )
-
-        {deployment.id, %{orchestrator_pid: orchestrator_pid}}
-      end)
-
-    {:noreply, %{state | deployments: deployments}}
-  end
-
-  def handle_info(%Broadcast{event: "deployments/new", payload: payload}, state) do
-    {:ok, deployment} = Deployments.get(payload.deployment_id)
-
-    {:ok, orchestrator_pid} =
-      DynamicSupervisor.start_child(
-        DeploymentDynamicSupervisor,
-        {Deployments.Orchestrator, deployment}
-      )
-
-    deployments =
-      Map.put(state.deployments, deployment.id, %{orchestrator_pid: orchestrator_pid})
-
-    {:noreply, %{state | deployments: deployments}}
-  end
-
-  def handle_info(%Broadcast{event: "deployments/delete", payload: payload}, state) do
-    pid = GenServer.whereis(Orchestrator.name(payload.deployment_id))
-    _ = DynamicSupervisor.terminate_child(DeploymentDynamicSupervisor, pid)
-    deployments = Map.delete(state.deployments, payload.deployment_id)
-    {:noreply, %{state | deployments: deployments}}
-  end
-end
diff --git a/lib/nerves_hub/deployments/supervisor.ex b/lib/nerves_hub/deployments/supervisor.ex
deleted file mode 100644
index 1121b6b9e..000000000
--- a/lib/nerves_hub/deployments/supervisor.ex
+++ /dev/null
@@ -1,19 +0,0 @@
-defmodule NervesHub.Deployments.Supervisor do
-  @moduledoc false
-
-  use Supervisor
-
-  def start_link(_) do
-    Supervisor.start_link(__MODULE__, [], name: __MODULE__)
-  end
-
-  def init(_) do
-    children = [
-      {Registry, keys: :unique, name: NervesHub.Deployments},
-      NervesHub.Deployments.Monitor,
-      {DynamicSupervisor, strategy: :one_for_one, name: NervesHub.DeploymentDynamicSupervisor}
-    ]
-
-    Supervisor.init(children, strategy: :one_for_one)
-  end
-end
diff --git a/lib/nerves_hub/devices.ex b/lib/nerves_hub/devices.ex
index 026c2c34f..e497b8c59 100644
--- a/lib/nerves_hub/devices.ex
+++ b/lib/nerves_hub/devices.ex
@@ -13,9 +13,6 @@ defmodule NervesHub.Devices do
   alias NervesHub.AuditLogs
   alias NervesHub.AuditLogs.DeviceTemplates
   alias NervesHub.Certificate
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
-  alias NervesHub.Deployments.Orchestrator
   alias NervesHub.Devices.CACertificate
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.DeviceCertificate
@@ -30,6 +27,9 @@ defmodule NervesHub.Devices do
   alias NervesHub.Firmwares
   alias NervesHub.Firmwares.Firmware
   alias NervesHub.Firmwares.FirmwareMetadata
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+  alias NervesHub.ManagedDeployments.Orchestrator
   alias NervesHub.Products
   alias NervesHub.Products.Product
   alias NervesHub.Repo
@@ -78,17 +78,17 @@ defmodule NervesHub.Devices do
     |> where([d], d.product_id == ^product_id)
     |> join(:left, [d], o in assoc(d, :org))
     |> join(:left, [d, o], p in assoc(d, :product))
-    |> join(:left, [d, o, p], dp in assoc(d, :deployment))
-    |> join(:left, [d, o, p, dp], f in assoc(dp, :firmware))
-    |> join(:left, [d, o, p, dp, f], lc in assoc(d, :latest_connection), as: :latest_connection)
-    |> join(:left, [d, o, p, dp, f, lc], lh in assoc(d, :latest_health), as: :latest_health)
+    |> join(:left, [d, o, p], dg in assoc(d, :deployment_group))
+    |> join(:left, [d, o, p, dg], f in assoc(dg, :firmware))
+    |> join(:left, [d, o, p, dg, f], lc in assoc(d, :latest_connection), as: :latest_connection)
+    |> join(:left, [d, o, p, dg, f, lc], lh in assoc(d, :latest_health), as: :latest_health)
     |> Repo.exclude_deleted()
     |> sort_devices(sorting)
     |> Filtering.build_filters(filters)
-    |> preload([d, o, p, dp, f, latest_connection: lc, latest_health: lh],
+    |> preload([d, o, p, dg, f, latest_connection: lc, latest_health: lh],
       org: o,
       product: p,
-      deployment: {dp, firmware: f},
+      deployment_group: {dg, firmware: f},
       latest_connection: lc,
       latest_health: lh
     )
@@ -235,7 +235,7 @@ defmodule NervesHub.Devices do
         {:error, :not_found}
 
       device ->
-        {:ok, Repo.preload(device, [:org, :product, deployment: [:firmware]])}
+        {:ok, Repo.preload(device, [:org, :product, deployment_group: [:firmware]])}
     end
   end
 
@@ -262,9 +262,9 @@ defmodule NervesHub.Devices do
     |> where(identifier: ^identifier)
     |> where(org_id: ^org_id)
     |> join(:left, [d], o in assoc(d, :org))
-    |> join(:left, [d], dp in assoc(d, :deployment))
+    |> join(:left, [d], dp in assoc(d, :deployment_group))
     |> join_and_preload(preload_assoc)
-    |> preload([d, o, dp], org: o, deployment: dp)
+    |> preload([d, o, dp], org: o, deployment_group: dp)
   end
 
   defp join_and_preload(query, assocs) when is_list(assocs) do
@@ -360,28 +360,6 @@ defmodule NervesHub.Devices do
     end
   end
 
-  def get_eligible_deployments(%Device{firmware_metadata: nil}), do: []
-
-  def get_eligible_deployments(%Device{firmware_metadata: meta} = device) do
-    from(
-      d in Deployment,
-      join: p in assoc(d, :product),
-      on: [org_id: ^device.org_id, name: ^meta.product],
-      join: f in assoc(d, :firmware),
-      on: f.product_id == p.id,
-      where: d.is_active,
-      where: d.healthy,
-      where: f.architecture == ^meta.architecture,
-      where: f.platform == ^meta.platform,
-      where: f.uuid != ^meta.uuid,
-      preload: [firmware: f]
-    )
-    |> Repo.all()
-    |> Enum.filter(fn dep -> matches_deployment?(device, dep) end)
-  end
-
-  def get_eligible_deployments(_), do: []
-
   @spec create_device(map) :: {:ok, Device.t()} | {:error, Changeset.t()}
   def create_device(params) do
     %Device{}
@@ -653,7 +631,7 @@ defmodule NervesHub.Devices do
   @spec get_device_firmware_for_delta_generation_by_product(binary()) ::
           list({source_firmware_id(), target_firmware_id()})
   def get_device_firmware_for_delta_generation_by_product(product_id) do
-    Deployment
+    DeploymentGroup
     |> where([dep], dep.product_id == ^product_id)
     |> join(:inner, [dep], dev in Device, on: dev.deployment_id == dep.id)
     |> join(:inner, [dep, dev], f in Firmware,
@@ -665,10 +643,10 @@ defmodule NervesHub.Devices do
     |> Repo.all()
   end
 
-  @spec get_device_firmware_for_delta_generation_by_deployment(binary()) ::
+  @spec get_device_firmware_for_delta_generation_by_deployment_group(binary()) ::
           list({source_firmware_id(), target_firmware_id()})
-  def get_device_firmware_for_delta_generation_by_deployment(deployment_id) do
-    Deployment
+  def get_device_firmware_for_delta_generation_by_deployment_group(deployment_id) do
+    DeploymentGroup
     |> where([dep], dep.id == ^deployment_id)
     |> join(:inner, [dep], dev in Device, on: dev.deployment_id == dep.id)
     |> join(:inner, [dep, dev], f in Firmware,
@@ -716,19 +694,19 @@ defmodule NervesHub.Devices do
   The list is ordered by current connection age. Devices that have been online longer
   are updated first.
   """
-  @spec available_for_update(Deployment.t(), non_neg_integer()) :: [Device.t()]
-  def available_for_update(deployment, count) do
+  @spec available_for_update(DeploymentGroup.t(), non_neg_integer()) :: [Device.t()]
+  def available_for_update(deployment_group, count) do
     now = DateTime.utc_now(:second)
 
     Device
     |> join(:inner, [d], dc in assoc(d, :latest_connection), as: :latest_connection)
-    |> join(:inner, [d], dp in assoc(d, :deployment), as: :deployment)
-    |> join(:inner, [deployment: dp], f in assoc(dp, :firmware),
-      on: [product_id: ^deployment.product_id],
+    |> join(:inner, [d], dg in assoc(d, :deployment_group), as: :deployment_group)
+    |> join(:inner, [deployment_group: dg], f in assoc(dg, :firmware),
+      on: [product_id: ^deployment_group.product_id],
       as: :firmware
     )
     |> join(:left, [d], ifu in InflightUpdate, on: d.id == ifu.device_id, as: :inflight_update)
-    |> where(deployment_id: ^deployment.id)
+    |> where(deployment_id: ^deployment_group.id)
     |> where(updates_enabled: true)
     |> where([latest_connection: lc], lc.status == :connected)
     |> where([d], not is_nil(d.firmware_metadata))
@@ -749,22 +727,22 @@ defmodule NervesHub.Devices do
   def resolve_update(%{deployment_id: nil}), do: %UpdatePayload{update_available: false}
 
   def resolve_update(device) do
-    {:ok, deployment} = Deployments.get_deployment_for_device(device)
+    {:ok, deployment_group} = ManagedDeployments.get_deployment_group_for_device(device)
 
-    case verify_update_eligibility(device, deployment) do
+    case verify_update_eligibility(device, deployment_group) do
       {:ok, _device} ->
-        {:ok, url} = Firmwares.get_firmware_url(deployment.firmware)
-        {:ok, meta} = Firmwares.metadata_from_firmware(deployment.firmware)
+        {:ok, url} = Firmwares.get_firmware_url(deployment_group.firmware)
+        {:ok, meta} = Firmwares.metadata_from_firmware(deployment_group.firmware)
 
         %UpdatePayload{
           update_available: true,
           firmware_url: url,
           firmware_meta: meta,
-          deployment: deployment,
-          deployment_id: deployment.id
+          deployment_group: deployment_group,
+          deployment_id: deployment_group.id
         }
 
-      {:error, :deployment_not_active, _device} ->
+      {:error, :deployment_group_not_active, _device} ->
         %UpdatePayload{update_available: false}
 
       {:error, :up_to_date, _device} ->
@@ -793,9 +771,9 @@ defmodule NervesHub.Devices do
   @doc """
   Returns true if Version.match? and all deployment tags are in device tags.
   """
-  def matches_deployment?(
+  def matches_deployment_group?(
         %Device{tags: tags, firmware_metadata: %FirmwareMetadata{version: version}},
-        %Deployment{conditions: %{"version" => requirement, "tags" => dep_tags}}
+        %DeploymentGroup{conditions: %{"version" => requirement, "tags" => dep_tags}}
       ) do
     if version_match?(version, requirement) and tags_match?(tags, dep_tags) do
       true
@@ -804,23 +782,32 @@ defmodule NervesHub.Devices do
     end
   end
 
-  def matches_deployment?(_, _), do: false
+  def matches_deployment_group?(_, _), do: false
 
-  @spec update_deployment(Device.t(), Deployment.t()) :: Device.t()
-  def update_deployment(device, deployment) do
+  @spec update_deployment_group(Device.t(), DeploymentGroup.t()) :: Device.t()
+  def update_deployment_group(device, deployment_group) do
     device =
       device
       |> Ecto.Changeset.change()
-      |> Ecto.Changeset.put_change(:deployment_id, deployment.id)
+      |> Ecto.Changeset.put_change(:deployment_id, deployment_group.id)
       |> Repo.update!()
 
-    _ = broadcast(device, "devices/deployment-updated", %{deployment_id: deployment.id})
+    _ =
+      broadcast(device, "devices/deployment-updated", %{deployment_id: deployment_group.id})
 
-    Map.put(device, :deployment, deployment)
+    Map.put(device, :deployment_group, deployment_group)
+  end
+
+  @spec update_many_deployment_groups([non_neg_integer()], DeploymentGroup.t()) ::
+          {integer(), nil | [term()]}
+  def update_many_deployment_groups(device_ids, deployment_group) do
+    Device
+    |> where([d], d.id in ^device_ids)
+    |> Repo.update_all(set: [deployment_id: deployment_group.id])
   end
 
-  @spec clear_deployment(Device.t()) :: Device.t()
-  def clear_deployment(device) do
+  @spec clear_deployment_group(Device.t()) :: Device.t()
+  def clear_deployment_group(device) do
     device =
       device
       |> Ecto.Changeset.change()
@@ -829,25 +816,25 @@ defmodule NervesHub.Devices do
 
     _ = broadcast(device, "devices/deployment-cleared")
 
-    Map.put(device, :deployment, nil)
+    Map.put(device, :deployment_group, nil)
   end
 
-  @spec failure_threshold_met?(Device.t(), Deployment.t()) :: boolean()
-  def failure_threshold_met?(%Device{} = device, %Deployment{} = deployment) do
-    Enum.count(device.update_attempts) >= deployment.device_failure_threshold
+  @spec failure_threshold_met?(Device.t(), DeploymentGroup.t()) :: boolean()
+  def failure_threshold_met?(%Device{} = device, %DeploymentGroup{} = deployment_group) do
+    Enum.count(device.update_attempts) >= deployment_group.device_failure_threshold
   end
 
-  @spec failure_rate_met?(Device.t(), Deployment.t()) :: boolean()
-  def failure_rate_met?(%Device{} = device, %Deployment{} = deployment) do
+  @spec failure_rate_met?(Device.t(), DeploymentGroup.t()) :: boolean()
+  def failure_rate_met?(%Device{} = device, %DeploymentGroup{} = deployment_group) do
     seconds_ago =
-      Timex.shift(DateTime.utc_now(), seconds: -deployment.device_failure_rate_seconds)
+      Timex.shift(DateTime.utc_now(), seconds: -deployment_group.device_failure_rate_seconds)
 
     attempts =
       Enum.filter(device.update_attempts, fn attempt ->
         DateTime.compare(seconds_ago, attempt) == :lt
       end)
 
-    Enum.count(attempts) >= deployment.device_failure_rate_amount
+    Enum.count(attempts) >= deployment_group.device_failure_rate_amount
   end
 
   @doc """
@@ -866,16 +853,16 @@ defmodule NervesHub.Devices do
     device.updates_enabled == false || device_in_penalty_box?(device, now)
   end
 
-  def device_matches_deployment?(device, deployment) do
-    device.firmware_metadata.uuid == deployment.firmware.uuid
+  def device_matches_deployment_group?(device, deployment_group) do
+    device.firmware_metadata.uuid == deployment_group.firmware.uuid
   end
 
-  def verify_update_eligibility(device, deployment, now \\ DateTime.utc_now()) do
+  def verify_update_eligibility(device, deployment_group, now \\ DateTime.utc_now()) do
     cond do
-      not deployment.is_active ->
-        {:error, :deployment_not_active, device}
+      not deployment_group.is_active ->
+        {:error, :deployment_group_not_active, device}
 
-      device_matches_deployment?(device, deployment) ->
+      device_matches_deployment_group?(device, deployment_group) ->
         {:error, :up_to_date, device}
 
       updates_blocked?(device, now) ->
@@ -883,26 +870,26 @@ defmodule NervesHub.Devices do
 
         {:error, :updates_blocked, device}
 
-      failure_rate_met?(device, deployment) ->
+      failure_rate_met?(device, deployment_group) ->
         blocked_until =
           DateTime.utc_now()
           |> DateTime.truncate(:second)
-          |> DateTime.add(deployment.penalty_timeout_minutes * 60, :second)
+          |> DateTime.add(deployment_group.penalty_timeout_minutes * 60, :second)
 
-        DeviceTemplates.audit_firmware_upgrade_blocked(deployment, device)
+        DeviceTemplates.audit_firmware_upgrade_blocked(deployment_group, device)
         clear_inflight_update(device)
 
         {:ok, device} = update_device(device, %{updates_blocked_until: blocked_until})
 
         {:error, :updates_blocked, device}
 
-      failure_threshold_met?(device, deployment) ->
+      failure_threshold_met?(device, deployment_group) ->
         blocked_until =
           DateTime.utc_now()
           |> DateTime.truncate(:second)
-          |> DateTime.add(deployment.penalty_timeout_minutes * 60, :second)
+          |> DateTime.add(deployment_group.penalty_timeout_minutes * 60, :second)
 
-        DeviceTemplates.audit_firmware_upgrade_blocked(deployment, device)
+        DeviceTemplates.audit_firmware_upgrade_blocked(deployment_group, device)
         clear_inflight_update(device)
 
         {:ok, device} = update_device(device, %{updates_blocked_until: blocked_until})
@@ -954,7 +941,7 @@ defmodule NervesHub.Devices do
 
     _ =
       if inflight_update do
-        Deployment
+        DeploymentGroup
         |> where([d], d.id == ^inflight_update.deployment_id)
         |> Repo.update_all(inc: [current_updated_devices: 1])
 
@@ -1013,27 +1000,28 @@ defmodule NervesHub.Devices do
     :ok
   end
 
-  def up_to_date_count(%Deployment{} = deployment) do
+  def up_to_date_count(%DeploymentGroup{} = deployment_group) do
     Device
-    |> where([d], d.deployment_id == ^deployment.id)
-    |> where([d], d.firmware_metadata["uuid"] == ^deployment.firmware.uuid)
+    |> where([d], d.deployment_id == ^deployment_group.id)
+    |> where([d], d.firmware_metadata["uuid"] == ^deployment_group.firmware.uuid)
     |> Repo.aggregate(:count)
   end
 
-  @spec updating_count(Deployment.t()) :: term() | nil
-  def updating_count(%Deployment{id: id}) do
+  @spec updating_count(DeploymentGroup.t()) :: term() | nil
+  def updating_count(%DeploymentGroup{id: id}) do
     InflightUpdate
     |> where([ifu], ifu.deployment_id == ^id)
     |> Repo.aggregate(:count)
   end
 
-  @spec waiting_for_update_count(Deployment.t()) :: term() | nil
-  def waiting_for_update_count(%Deployment{} = deployment) do
+  @spec waiting_for_update_count(DeploymentGroup.t()) :: term() | nil
+  def waiting_for_update_count(%DeploymentGroup{} = deployment_group) do
     Device
-    |> where([d], d.deployment_id == ^deployment.id)
+    |> where([d], d.deployment_id == ^deployment_group.id)
     |> where(
       [d],
-      is_nil(d.firmware_metadata) or d.firmware_metadata["uuid"] != ^deployment.firmware.uuid
+      is_nil(d.firmware_metadata) or
+        d.firmware_metadata["uuid"] != ^deployment_group.firmware.uuid
     )
     |> Repo.aggregate(:count)
   end
@@ -1199,11 +1187,11 @@ defmodule NervesHub.Devices do
     update_device(device, %{updates_blocked_until: blocked_until})
   end
 
-  @spec move_many_to_deployment([integer()], integer()) ::
+  @spec move_many_to_deployment_group([integer()], integer()) ::
           {:ok, %{updated: non_neg_integer(), ignored: non_neg_integer()}}
-  def move_many_to_deployment(device_ids, deployment_id) do
+  def move_many_to_deployment_group(device_ids, deployment_id) do
     %{firmware: firmware} =
-      Deployment |> where(id: ^deployment_id) |> preload(:firmware) |> Repo.one()
+      DeploymentGroup |> where(id: ^deployment_id) |> preload(:firmware) |> Repo.one()
 
     {devices_updated_count, _} =
       Device
@@ -1388,11 +1376,11 @@ defmodule NervesHub.Devices do
     Version.match?(version, requirement)
   end
 
-  defp tags_match?(nil, deployment_tags), do: tags_match?([], deployment_tags)
+  defp tags_match?(nil, deployment_group_tags), do: tags_match?([], deployment_group_tags)
   defp tags_match?(device_tags, nil), do: tags_match?(device_tags, [])
 
-  defp tags_match?(device_tags, deployment_tags) do
-    Enum.all?(deployment_tags, fn tag -> tag in device_tags end)
+  defp tags_match?(device_tags, deployment_group_tags) do
+    Enum.all?(deployment_group_tags, fn tag -> tag in device_tags end)
   end
 
   def maybe_copy_firmware_keys(%{firmware_metadata: %{uuid: uuid}, org_id: source}, %Org{
@@ -1432,37 +1420,37 @@ defmodule NervesHub.Devices do
   @doc """
   Deployment orchestrator told a device to update
   """
-  @spec told_to_update(Device.t() | integer(), Deployment.t()) ::
+  @spec told_to_update(Device.t() | integer(), DeploymentGroup.t()) ::
           {:ok, InflightUpdate.t()} | :error
-  def told_to_update(%Device{id: id}, deployment) do
-    told_to_update(id, deployment)
+  def told_to_update(%Device{id: id}, deployment_group) do
+    told_to_update(id, deployment_group)
   end
 
-  def told_to_update(device_id, deployment) do
+  def told_to_update(device_id, deployment_group) do
     expires_at =
       DateTime.utc_now()
-      |> DateTime.add(60 * deployment.inflight_update_expiration_minutes, :second)
+      |> DateTime.add(60 * deployment_group.inflight_update_expiration_minutes, :second)
       |> DateTime.truncate(:second)
 
     %{
       device_id: device_id,
-      deployment_id: deployment.id,
-      firmware_id: deployment.firmware_id,
-      firmware_uuid: deployment.firmware.uuid,
+      deployment_id: deployment_group.id,
+      firmware_id: deployment_group.firmware_id,
+      firmware_uuid: deployment_group.firmware.uuid,
       expires_at: expires_at
     }
     |> InflightUpdate.create_changeset()
     |> Repo.insert()
     |> case do
       {:ok, inflight_update} ->
-        broadcast_update_request(device_id, inflight_update, deployment)
+        broadcast_update_request(device_id, inflight_update, deployment_group)
 
         {:ok, inflight_update}
 
       {:error, _changeset} ->
         # TODO this logic doesn't feel right. We should revise this approach.
         # Device already has an inflight update, fetch it
-        case Repo.get_by(InflightUpdate, device_id: device_id, deployment_id: deployment.id) do
+        case Repo.get_by(InflightUpdate, device_id: device_id, deployment_id: deployment_group.id) do
           nil ->
             Logger.error(
               "An inflight update could not be created or found for the device (#{device_id})"
@@ -1471,7 +1459,7 @@ defmodule NervesHub.Devices do
             :error
 
           inflight_update ->
-            broadcast_update_request(device_id, inflight_update, deployment)
+            broadcast_update_request(device_id, inflight_update, deployment_group)
 
             {:ok, inflight_update}
         end
@@ -1492,7 +1480,7 @@ defmodule NervesHub.Devices do
 
   def update_started!(inflight_update, device, deployment, reference_id) do
     Repo.transaction(fn ->
-      DeviceTemplates.audit_device_deployment_update_triggered(
+      DeviceTemplates.audit_device_deployment_group_update_triggered(
         device,
         deployment,
         reference_id
@@ -1505,16 +1493,16 @@ defmodule NervesHub.Devices do
     end)
   end
 
-  def inflight_updates_for(%Deployment{} = deployment) do
+  def inflight_updates_for(%DeploymentGroup{} = deployment_group) do
     InflightUpdate
-    |> where([iu], iu.deployment_id == ^deployment.id)
+    |> where([iu], iu.deployment_id == ^deployment_group.id)
     |> preload([:device])
     |> Repo.all()
   end
 
-  def count_inflight_updates_for(%Deployment{} = deployment) do
+  def count_inflight_updates_for(%DeploymentGroup{} = deployment_group) do
     InflightUpdate
-    |> where([iu], iu.deployment_id == ^deployment.id)
+    |> where([iu], iu.deployment_id == ^deployment_group.id)
     |> Repo.aggregate(:count)
   end
 
@@ -1551,18 +1539,18 @@ defmodule NervesHub.Devices do
     |> Repo.preload(:product)
   end
 
-  defp broadcast_update_request(device_id, inflight_update, deployment) do
+  defp broadcast_update_request(device_id, inflight_update, deployment_group) do
     _ =
-      if deployment.orchestrator_strategy == :distributed do
-        {:ok, url} = Firmwares.get_firmware_url(deployment.firmware)
-        {:ok, meta} = Firmwares.metadata_from_firmware(deployment.firmware)
+      if deployment_group.orchestrator_strategy == :distributed do
+        {:ok, url} = Firmwares.get_firmware_url(deployment_group.firmware)
+        {:ok, meta} = Firmwares.metadata_from_firmware(deployment_group.firmware)
 
         update_payload = %UpdatePayload{
           update_available: true,
           firmware_url: url,
           firmware_meta: meta,
-          deployment: deployment,
-          deployment_id: deployment.id
+          deployment_group: deployment_group,
+          deployment_id: deployment_group.id
         }
 
         payload = %{inflight_update: inflight_update, update_payload: update_payload}
diff --git a/lib/nerves_hub/devices/device.ex b/lib/nerves_hub/devices/device.ex
index b6618c09c..c84cb76d1 100644
--- a/lib/nerves_hub/devices/device.ex
+++ b/lib/nerves_hub/devices/device.ex
@@ -4,13 +4,13 @@ defmodule NervesHub.Devices.Device do
   import Ecto.Changeset
 
   alias NervesHub.Accounts.Org
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices.DeviceCertificate
   alias NervesHub.Devices.DeviceConnection
   alias NervesHub.Devices.DeviceHealth
   alias NervesHub.Devices.DeviceMetric
   alias NervesHub.Extensions.DeviceExtensionsSetting
   alias NervesHub.Firmwares.FirmwareMetadata
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Products.Product
 
   alias __MODULE__
@@ -36,7 +36,7 @@ defmodule NervesHub.Devices.Device do
   schema "devices" do
     belongs_to(:org, Org)
     belongs_to(:product, Product)
-    belongs_to(:deployment, Deployment)
+    belongs_to(:deployment_group, DeploymentGroup, foreign_key: :deployment_id)
     belongs_to(:latest_connection, DeviceConnection, type: :binary_id)
     belongs_to(:latest_health, DeviceHealth)
 
diff --git a/lib/nerves_hub/devices/inflight_update.ex b/lib/nerves_hub/devices/inflight_update.ex
index 70e964226..5e09b2b78 100644
--- a/lib/nerves_hub/devices/inflight_update.ex
+++ b/lib/nerves_hub/devices/inflight_update.ex
@@ -3,18 +3,17 @@ defmodule NervesHub.Devices.InflightUpdate do
 
   import Ecto.Changeset
 
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.InflightUpdate
   alias NervesHub.Firmwares.Firmware
-
-  @required_params [:device_id, :deployment_id, :firmware_id, :firmware_uuid, :expires_at]
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   @type t :: %__MODULE__{}
+  @required_params [:device_id, :deployment_id, :firmware_id, :firmware_uuid, :expires_at]
 
   schema "inflight_updates" do
     belongs_to(:device, Device)
-    belongs_to(:deployment, Deployment)
+    belongs_to(:deployment_group, DeploymentGroup, foreign_key: :deployment_id)
     belongs_to(:firmware, Firmware)
 
     field(:firmware_uuid, Ecto.UUID)
diff --git a/lib/nerves_hub/devices/update_payload.ex b/lib/nerves_hub/devices/update_payload.ex
index 0c4948693..e9bbd750e 100644
--- a/lib/nerves_hub/devices/update_payload.ex
+++ b/lib/nerves_hub/devices/update_payload.ex
@@ -3,8 +3,8 @@ defmodule NervesHub.Devices.UpdatePayload do
   This struct represents the payload that gets dispatched to devices
   """
 
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Firmwares.FirmwareMetadata
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   @derive {Jason.Encoder,
            only: [
@@ -17,7 +17,7 @@ defmodule NervesHub.Devices.UpdatePayload do
   defstruct update_available: false,
             firmware_url: nil,
             firmware_meta: nil,
-            deployment: nil,
+            deployment_group: nil,
             deployment_id: nil
 
   @type t ::
@@ -25,14 +25,14 @@ defmodule NervesHub.Devices.UpdatePayload do
             update_available: false,
             firmware_meta: nil,
             firmware_url: nil,
-            deployment: nil,
+            deployment_group: nil,
             deployment_id: nil
           }
           | %__MODULE__{
               update_available: true,
               firmware_meta: FirmwareMetadata.t(),
               firmware_url: String.t(),
-              deployment: Deployment.t(),
+              deployment_group: DeploymentGroup.t(),
               deployment_id: non_neg_integer()
             }
 end
diff --git a/lib/nerves_hub/firmwares.ex b/lib/nerves_hub/firmwares.ex
index 6f4c8676c..2100d90e9 100644
--- a/lib/nerves_hub/firmwares.ex
+++ b/lib/nerves_hub/firmwares.ex
@@ -107,13 +107,13 @@ defmodule NervesHub.Firmwares do
 
   defp sort_firmware(query, sort), do: order_by(query, ^sort)
 
-  def get_firmwares_for_deployment(deployment) do
-    deployment = Repo.preload(deployment, [:firmware])
+  def get_firmwares_for_deployment_group(deployment_group) do
+    deployment_group = Repo.preload(deployment_group, [:firmware])
 
     Firmware
-    |> where([f], f.product_id == ^deployment.product_id)
-    |> where([f], f.platform == ^deployment.firmware.platform)
-    |> where([f], f.architecture == ^deployment.firmware.architecture)
+    |> where([f], f.product_id == ^deployment_group.product_id)
+    |> where([f], f.platform == ^deployment_group.firmware.platform)
+    |> where([f], f.architecture == ^deployment_group.firmware.architecture)
     |> order_by([f], [fragment("? collate numeric desc", f.version), desc: :inserted_at])
     |> with_product()
     |> Repo.all()
diff --git a/lib/nerves_hub/firmwares/firmware.ex b/lib/nerves_hub/firmwares/firmware.ex
index 563f79928..981330599 100644
--- a/lib/nerves_hub/firmwares/firmware.ex
+++ b/lib/nerves_hub/firmwares/firmware.ex
@@ -5,7 +5,7 @@ defmodule NervesHub.Firmwares.Firmware do
 
   alias NervesHub.Accounts.Org
   alias NervesHub.Accounts.OrgKey
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Products.Product
 
   alias __MODULE__
@@ -46,7 +46,7 @@ defmodule NervesHub.Firmwares.Firmware do
     belongs_to(:org, Org, where: [deleted_at: nil])
     belongs_to(:product, Product, where: [deleted_at: nil])
     belongs_to(:org_key, OrgKey)
-    has_many(:deployments, Deployment)
+    has_many(:deployment_groups, DeploymentGroup)
 
     field(:architecture, :string)
     field(:author, :string)
@@ -70,7 +70,7 @@ defmodule NervesHub.Firmwares.Firmware do
     |> cast(params, @required_params ++ @optional_params)
     |> validate_required(@required_params)
     |> unique_constraint(:uuid, name: :firmwares_product_id_uuid_index)
-    |> foreign_key_constraint(:deployments, name: :deployments_firmware_id_fkey)
+    |> foreign_key_constraint(:deployment_groups, name: :deployment_groups_firmware_id_fkey)
   end
 
   def update_changeset(%Firmware{} = firmware, params) do
@@ -78,12 +78,12 @@ defmodule NervesHub.Firmwares.Firmware do
     |> cast(params, @required_params ++ @optional_params)
     |> validate_required(@required_params)
     |> unique_constraint(:uuid, name: :firmwares_product_id_uuid_index)
-    |> foreign_key_constraint(:deployments, name: :deployments_firmware_id_fkey)
+    |> foreign_key_constraint(:deployment_groups, name: :deployment_groups_firmware_id_fkey)
   end
 
   def delete_changeset(%Firmware{} = firmware, params) do
     firmware
     |> cast(params, @required_params ++ @optional_params)
-    |> no_assoc_constraint(:deployments, message: "Firmware has associated deployments")
+    |> no_assoc_constraint(:deployment_groups, message: "Firmware has associated deployments")
   end
 end
diff --git a/lib/nerves_hub/logger.ex b/lib/nerves_hub/logger.ex
index b63bd4dca..3c86e09e3 100644
--- a/lib/nerves_hub/logger.ex
+++ b/lib/nerves_hub/logger.ex
@@ -33,9 +33,9 @@ defmodule NervesHub.Logger do
       [:nerves_hub, :devices, :duplicate_connection],
       [:nerves_hub, :devices, :update, :automatic],
       [:nerves_hub, :devices, :update, :successful],
-      [:nerves_hub, :deployments, :set_deployment, :none_found],
-      [:nerves_hub, :deployments, :set_deployment, :one_found],
-      [:nerves_hub, :deployments, :set_deployment, :multiple_found]
+      [:nerves_hub, :managed_deployments, :set_deployment_group, :none_found],
+      [:nerves_hub, :managed_deployments, :set_deployment_group, :one_found],
+      [:nerves_hub, :managed_deployments, :set_deployment_group, :multiple_found]
     ]
 
     Enum.each(events, fn event ->
@@ -120,24 +120,39 @@ defmodule NervesHub.Logger do
     )
   end
 
-  def log_event([:nerves_hub, :deployments, :set_deployment, :none_found], _, metadata, _) do
-    Logger.info("No matching deployments",
-      event: "nerves_hub.deployments.set_deployment.none_found",
+  def log_event(
+        [:nerves_hub, :managed_deployments, :set_deployment_group, :none_found],
+        _,
+        metadata,
+        _
+      ) do
+    Logger.info("No matching deployment groups",
+      event: "nerves_hub.managed_deployments.set_deployment_group.none_found",
       identifier: metadata[:device].identifier
     )
   end
 
-  def log_event([:nerves_hub, :deployments, :set_deployment, :one_found], _, metadata, _) do
+  def log_event(
+        [:nerves_hub, :managed_deployments, :set_deployment_group, :one_found],
+        _,
+        metadata,
+        _
+      ) do
     Logger.info("Deployment match found",
-      event: "nerves_hub.deployments.set_deployment.one_found",
+      event: "nerves_hub.managed_deployments.set_deployment_group.one_found",
       identifier: metadata[:device].identifier,
       deployment_id: metadata[:deployment].id
     )
   end
 
-  def log_event([:nerves_hub, :deployments, :set_deployment, :multiple_found], _, metadata, _) do
+  def log_event(
+        [:nerves_hub, :managed_deployments, :set_deployment_group, :multiple_found],
+        _,
+        metadata,
+        _
+      ) do
     Logger.info("More than one deployment match found, setting to the first",
-      event: "nerves_hub.deployments.set_deployment.multiple_found",
+      event: "nerves_hub.managed_deployments.set_deployment_group.multiple_found",
       identifier: metadata[:device].identifier,
       deployment_id: metadata[:deployment].id
     )
diff --git a/lib/nerves_hub/deployments.ex b/lib/nerves_hub/managed_deployments.ex
similarity index 57%
rename from lib/nerves_hub/deployments.ex
rename to lib/nerves_hub/managed_deployments.ex
index c8fd956b1..2abb86e34 100644
--- a/lib/nerves_hub/deployments.ex
+++ b/lib/nerves_hub/managed_deployments.ex
@@ -1,15 +1,16 @@
-defmodule NervesHub.Deployments do
+defmodule NervesHub.ManagedDeployments do
   import Ecto.Query
 
   require Logger
 
-  alias NervesHub.AuditLogs.DeploymentTemplates
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.AuditLogs.DeviceTemplates
-  alias NervesHub.Deployments.Deployment
-  alias NervesHub.Deployments.Distributed.Orchestrator, as: DistributedOrchestrator
   alias NervesHub.Deployments.InflightDeploymentCheck
   alias NervesHub.Devices
   alias NervesHub.Devices.Device
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+  alias NervesHub.ManagedDeployments.Distributed.Orchestrator, as: DistributedOrchestrator
+  alias NervesHub.ManagedDeployments.InflightDeploymentCheck
   alias NervesHub.Products.Product
   alias NervesHub.Workers.FirmwareDeltaBuilder
 
@@ -17,14 +18,14 @@ defmodule NervesHub.Deployments do
 
   alias Ecto.Changeset
 
-  @spec all() :: [Deployment.t()]
+  @spec all() :: [DeploymentGroup.t()]
   def all() do
-    Repo.all(Deployment)
+    Repo.all(DeploymentGroup)
   end
 
-  @spec should_run_in_distributed_orchestrator() :: [Deployment.t()]
+  @spec should_run_in_distributed_orchestrator() :: [DeploymentGroup.t()]
   def should_run_in_distributed_orchestrator() do
-    Deployment
+    DeploymentGroup
     |> where(is_active: true)
     |> where(orchestrator_strategy: :distributed)
     |> Repo.all()
@@ -53,38 +54,38 @@ defmodule NervesHub.Deployments do
       |> Repo.exclude_deleted()
       |> group_by([d], d.deployment_id)
 
-    Deployment
+    DeploymentGroup
     |> join(:left, [d], dev in subquery(subquery), on: dev.deployment_id == d.id)
     |> join(:left, [d], f in assoc(d, :firmware))
     |> where([d], d.product_id == ^product.id)
-    |> sort_deployments(sort_opts)
+    |> sort_deployment_groups(sort_opts)
     |> preload([_d, _dev, f], firmware: f)
     |> select_merge([_f, dev], %{device_count: dev.device_count})
     |> Flop.run(flop)
   end
 
-  defp sort_deployments(query, {direction, :platform}) do
+  defp sort_deployment_groups(query, {direction, :platform}) do
     order_by(query, [_d, _dev, f], {^direction, f.platform})
   end
 
-  defp sort_deployments(query, {direction, :architecture}) do
+  defp sort_deployment_groups(query, {direction, :architecture}) do
     order_by(query, [_d, _dev, f], {^direction, f.architecture})
   end
 
-  defp sort_deployments(query, {direction, :device_count}) do
+  defp sort_deployment_groups(query, {direction, :device_count}) do
     order_by(query, [_d, dev], {^direction, dev.device_count})
   end
 
-  defp sort_deployments(query, {direction, :firmware_version}) do
+  defp sort_deployment_groups(query, {direction, :firmware_version}) do
     order_by(query, [_d, _dev, f], {^direction, f.version})
   end
 
-  defp sort_deployments(query, sort), do: order_by(query, ^sort)
+  defp sort_deployment_groups(query, sort), do: order_by(query, ^sort)
 
-  @spec get_deployments_by_product(Product.t()) :: [Deployment.t()]
-  def get_deployments_by_product(%Product{id: product_id}) do
+  @spec get_deployment_groups_by_product(Product.t()) :: [DeploymentGroup.t()]
+  def get_deployment_groups_by_product(%Product{id: product_id}) do
     from(
-      d in Deployment,
+      d in DeploymentGroup,
       join: f in assoc(d, :firmware),
       where: f.product_id == ^product_id,
       preload: [{:firmware, :product}]
@@ -103,35 +104,36 @@ defmodule NervesHub.Deployments do
     |> Map.new()
   end
 
-  @spec get_device_count(Deployment.t()) :: term() | nil
-  def get_device_count(%Deployment{id: id}) do
+  @spec get_device_count(DeploymentGroup.t()) :: term() | nil
+  def get_device_count(%DeploymentGroup{id: id}) do
     Device
     |> where([d], d.deployment_id == ^id)
     |> Repo.exclude_deleted()
     |> Repo.aggregate(:count)
   end
 
-  @spec get_deployments_by_firmware(integer()) :: [Deployment.t()]
-  def get_deployments_by_firmware(firmware_id) do
-    Deployment
+  @spec get_deployment_groups_by_firmware(integer()) :: [DeploymentGroup.t()]
+  def get_deployment_groups_by_firmware(firmware_id) do
+    DeploymentGroup
     |> where([d], d.firmware_id == ^firmware_id)
     |> Repo.all()
   end
 
-  @spec get(integer()) :: {:ok, Deployment.t()} | {:error, :not_found}
+  @spec get(integer()) :: {:ok, DeploymentGroup.t()} | {:error, :not_found}
   def get(id) when is_integer(id) do
-    case Repo.get(Deployment, id) do
+    case Repo.get(DeploymentGroup, id) do
       nil ->
         {:error, :not_found}
 
-      deployment ->
-        {:ok, deployment}
+      deployment_group ->
+        {:ok, deployment_group}
     end
   end
 
-  @spec get_deployment_for_device(Device.t()) :: {:ok, Deployment.t()} | {:error, :not_found}
-  def get_deployment_for_device(%Device{deployment_id: deployment_id}) do
-    Deployment
+  @spec get_deployment_group_for_device(Device.t()) ::
+          {:ok, DeploymentGroup.t()} | {:error, :not_found}
+  def get_deployment_group_for_device(%Device{deployment_id: deployment_id}) do
+    DeploymentGroup
     |> where([d], d.id == ^deployment_id)
     |> join(:left, [d], f in assoc(d, :firmware))
     |> preload([d, f], firmware: f)
@@ -140,35 +142,36 @@ defmodule NervesHub.Deployments do
       nil ->
         {:error, :not_found}
 
-      deployment ->
-        {:ok, deployment}
+      deployment_group ->
+        {:ok, deployment_group}
     end
   end
 
-  @spec get_deployment(Product.t(), String.t()) :: {:ok, Deployment.t()} | {:error, :not_found}
-  def get_deployment(%Product{id: product_id}, deployment_id) do
+  @spec get_deployment_group(Product.t(), String.t()) ::
+          {:ok, DeploymentGroup.t()} | {:error, :not_found}
+  def get_deployment_group(%Product{id: product_id}, deployment_id) do
     from(
-      d in Deployment,
+      d in DeploymentGroup,
       where: d.id == ^deployment_id,
       join: f in assoc(d, :firmware),
       where: f.product_id == ^product_id,
       preload: [{:firmware, :product}]
     )
-    |> Deployment.with_firmware()
+    |> DeploymentGroup.with_firmware()
     |> Repo.one()
     |> case do
       nil ->
         {:error, :not_found}
 
-      deployment ->
-        {:ok, deployment}
+      deployment_group ->
+        {:ok, deployment_group}
     end
   end
 
-  def get_deployment(%Deployment{id: id}), do: get_deployment(id)
+  def get_deployment_group(%DeploymentGroup{id: id}), do: get_deployment_group(id)
 
-  def get_deployment(deployment_id) do
-    Deployment
+  def get_deployment_group(deployment_id) do
+    DeploymentGroup
     |> where([d], d.id == ^deployment_id)
     |> join(:left, [d], f in assoc(d, :firmware), as: :firmware)
     |> preload([firmware: f], firmware: f)
@@ -182,7 +185,7 @@ defmodule NervesHub.Deployments do
     end
   end
 
-  @spec get_by_product_and_name!(Product.t(), String.t(), boolean()) :: Deployment.t()
+  @spec get_by_product_and_name!(Product.t(), String.t(), boolean()) :: DeploymentGroup.t()
   def get_by_product_and_name!(product, name, with_device_count \\ false)
 
   def get_by_product_and_name!(product, name, true) do
@@ -206,9 +209,9 @@ defmodule NervesHub.Deployments do
     |> Repo.one!()
   end
 
-  @spec get_by_product_and_platform(Product.t(), binary()) :: [Deployment.t()]
+  @spec get_by_product_and_platform(Product.t(), binary()) :: [DeploymentGroup.t()]
   def get_by_product_and_platform(product, platform) do
-    Deployment
+    DeploymentGroup
     |> where(product_id: ^product.id)
     |> join(:left, [d], f in assoc(d, :firmware))
     |> where([_d, f], f.platform == ^platform)
@@ -216,22 +219,22 @@ defmodule NervesHub.Deployments do
     |> Repo.all()
   end
 
-  @spec get_deployment_by_name(Product.t(), String.t()) ::
-          {:ok, Deployment.t()} | {:error, :not_found}
-  def get_deployment_by_name(product, name) do
+  @spec get_deployment_group_by_name(Product.t(), String.t()) ::
+          {:ok, DeploymentGroup.t()} | {:error, :not_found}
+  def get_deployment_group_by_name(product, name) do
     get_by_product_and_name_query(product, name)
     |> Repo.one()
     |> case do
       nil ->
         {:error, :not_found}
 
-      deployment ->
-        {:ok, deployment}
+      deployment_group ->
+        {:ok, deployment_group}
     end
   end
 
   defp get_by_product_and_name_query(%Product{id: product_id}, name) do
-    Deployment
+    DeploymentGroup
     |> where(name: ^name)
     |> where(product_id: ^product_id)
     |> join(:left, [d], f in assoc(d, :firmware))
@@ -240,19 +243,20 @@ defmodule NervesHub.Deployments do
     |> preload([d, f, a, p], firmware: f, archive: a, product: p)
   end
 
-  @spec delete_deployment(Deployment.t()) :: {:ok, Deployment.t()} | {:error, :not_found}
-  def delete_deployment(%Deployment{id: deployment_id}) do
-    Deployment
+  @spec delete_deployment_group(DeploymentGroup.t()) ::
+          {:ok, DeploymentGroup.t()} | {:error, :not_found}
+  def delete_deployment_group(%DeploymentGroup{id: deployment_id}) do
+    DeploymentGroup
     |> Repo.get!(deployment_id)
     |> Repo.delete()
     |> case do
       {:error, _changeset} ->
         {:error, :not_found}
 
-      {:ok, deployment} ->
-        _ = deployment_deleted_event(deployment)
+      {:ok, deployment_group} ->
+        _ = deployment_deleted_event(deployment_group)
 
-        {:ok, deployment}
+        {:ok, deployment_group}
     end
   end
 
@@ -261,29 +265,30 @@ defmodule NervesHub.Deployments do
 
   - Records audit logs depending on changes
   """
-  @spec update_deployment(Deployment.t(), map) :: {:ok, Deployment.t()} | {:error, Changeset.t()}
-  def update_deployment(deployment, params) do
+  @spec update_deployment_group(DeploymentGroup.t(), map) ::
+          {:ok, DeploymentGroup.t()} | {:error, Changeset.t()}
+  def update_deployment_group(deployment_group, params) do
     result =
       Repo.transaction(fn ->
         device_count =
           Device
           |> select([d], count(d))
-          |> where([d], d.deployment_id == ^deployment.id)
+          |> where([d], d.deployment_id == ^deployment_group.id)
           |> Repo.one()
 
         changeset =
-          deployment
-          |> Deployment.with_firmware()
-          |> Deployment.changeset(params)
+          deployment_group
+          |> DeploymentGroup.with_firmware()
+          |> DeploymentGroup.changeset(params)
           |> Ecto.Changeset.put_change(:total_updating_devices, device_count)
 
         case Repo.update(changeset) do
-          {:ok, deployment} ->
-            deployment = Repo.preload(deployment, [:firmware], force: true)
+          {:ok, deployment_group} ->
+            deployment_group = Repo.preload(deployment_group, [:firmware], force: true)
 
-            audit_changes!(deployment, changeset)
+            audit_changes!(deployment_group, changeset)
 
-            {deployment, changeset}
+            {deployment_group, changeset}
 
           {:error, changeset} ->
             Repo.rollback(changeset)
@@ -291,66 +296,74 @@ defmodule NervesHub.Deployments do
       end)
 
     case result do
-      {:ok, {deployment, changeset}} ->
-        _ = maybe_trigger_delta_generation(deployment, changeset)
-        :ok = broadcast(deployment, "deployments/update")
+      {:ok, {deployment_group, changeset}} ->
+        _ = maybe_trigger_delta_generation(deployment_group, changeset)
+        :ok = broadcast(deployment_group, "deployments/update")
 
         if Map.has_key?(changeset.changes, :is_active) do
-          if deployment.is_active do
-            deployment_activated_event(deployment)
+          if deployment_group.is_active do
+            deployment_activated_event(deployment_group)
           else
-            deployment_deactivated_event(deployment)
+            deployment_deactivated_event(deployment_group)
           end
         end
 
         if Map.has_key?(changeset.changes, :orchestrator_strategy) do
-          if deployment.orchestrator_strategy == :distributed do
-            start_deployments_distributed_orchestrator_event(deployment)
+          if deployment_group.orchestrator_strategy == :distributed do
+            start_deployments_distributed_orchestrator_event(deployment_group)
           else
-            shutdown_deployments_distributed_orchestrator_event(deployment)
+            shutdown_deployments_distributed_orchestrator_event(deployment_group)
           end
         end
 
-        {:ok, deployment}
+        {:ok, deployment_group}
 
       {:error, changeset} ->
         {:error, changeset}
     end
   end
 
-  defp audit_changes!(deployment, changeset) do
+  defp audit_changes!(deployment_group, changeset) do
     Enum.each(changeset.changes, fn
       {:archive_id, archive_id} ->
         # Trigger the new archive to get downloaded by devices
         payload = %{archive_id: archive_id}
-        _ = broadcast(deployment, "archives/updated", payload)
+        _ = broadcast(deployment_group, "archives/updated", payload)
 
-        DeploymentTemplates.audit_deployment_change(deployment, "has a new archive")
+        DeploymentGroupTemplates.audit_deployment_group_change(
+          deployment_group,
+          "has a new archive"
+        )
 
       {:conditions, _new_conditions} ->
-        DeploymentTemplates.audit_deployment_change(deployment, "conditions changed")
+        DeploymentGroupTemplates.audit_deployment_group_change(
+          deployment_group,
+          "conditions changed"
+        )
 
       {:is_active, is_active} when is_active != true ->
-        DeploymentTemplates.audit_deployment_change(deployment, "is inactive")
+        DeploymentGroupTemplates.audit_deployment_group_change(deployment_group, "is inactive")
 
       _ ->
         :ignore
     end)
   end
 
-  defp maybe_trigger_delta_generation(deployment, changeset) do
+  defp maybe_trigger_delta_generation(deployment_group, changeset) do
     # Firmware changed on active deployment
-    if deployment.is_active and Map.has_key?(changeset.changes, :firmware_id) do
-      deployment = Repo.preload(deployment, :product, force: true)
+    if deployment_group.is_active and Map.has_key?(changeset.changes, :firmware_id) do
+      deployment_group = Repo.preload(deployment_group, :product, force: true)
 
-      if deployment.product.delta_updatable do
-        trigger_delta_generation_for_deployment(deployment)
+      if deployment_group.product.delta_updatable do
+        trigger_delta_generation_for_deployment_group(deployment_group)
       end
     end
   end
 
-  defp trigger_delta_generation_for_deployment(deployment) do
-    NervesHub.Devices.get_device_firmware_for_delta_generation_by_deployment(deployment.id)
+  defp trigger_delta_generation_for_deployment_group(deployment_group) do
+    NervesHub.Devices.get_device_firmware_for_delta_generation_by_deployment_group(
+      deployment_group.id
+    )
     |> Enum.uniq()
     |> Enum.each(fn {source_id, target_id} ->
       FirmwareDeltaBuilder.start(source_id, target_id)
@@ -360,43 +373,38 @@ defmodule NervesHub.Deployments do
   @doc """
   Delete any matching inflight deployment checks for devices
   """
-  @spec delete_inflight_checks(Deployment.t()) :: :ok
-  def delete_inflight_checks(deployment) do
+  @spec delete_inflight_checks(DeploymentGroup.t()) :: :ok
+  def delete_inflight_checks(deployment_group) do
     _ =
       InflightDeploymentCheck
-      |> where([idc], idc.deployment_id == ^deployment.id)
+      |> where([idc], idc.deployment_id == ^deployment_group.id)
       |> Repo.delete_all()
 
     :ok
   end
 
-  @spec new_deployment() :: Changeset.t()
-  def new_deployment() do
-    Ecto.Changeset.change(%Deployment{})
-  end
-
-  @spec change_deployment(Deployment.t(), map()) :: Changeset.t()
-  def change_deployment(deployment, params) do
-    Deployment.changeset(deployment, params)
+  @spec new_deployment_group() :: Changeset.t()
+  def new_deployment_group() do
+    Ecto.Changeset.change(%DeploymentGroup{})
   end
 
-  @spec create_deployment(map()) :: {:ok, Deployment.t()} | {:error, Changeset.t()}
-  def create_deployment(params) do
-    changeset = Deployment.creation_changeset(%Deployment{}, params)
+  @spec create_deployment_group(map()) :: {:ok, DeploymentGroup.t()} | {:error, Changeset.t()}
+  def create_deployment_group(params) do
+    changeset = DeploymentGroup.creation_changeset(%DeploymentGroup{}, params)
 
     case Repo.insert(changeset) do
-      {:ok, deployment} ->
-        deployment_created_event(deployment)
+      {:ok, deployment_group} ->
+        deployment_created_event(deployment_group)
 
-        {:ok, deployment}
+        {:ok, deployment_group}
 
       {:error, changeset} ->
         {:error, changeset}
     end
   end
 
-  @spec broadcast(Deployment.t() | atom(), String.t(), map()) :: :ok | {:error, term()}
-  def broadcast(deployment, event, payload \\ %{})
+  @spec broadcast(DeploymentGroup.t() | atom(), String.t(), map()) :: :ok | {:error, term()}
+  def broadcast(deployment_group, event, payload \\ %{})
 
   def broadcast(:none, event, payload) do
     Phoenix.Channel.Server.broadcast(
@@ -416,7 +424,7 @@ defmodule NervesHub.Deployments do
     )
   end
 
-  def broadcast(%Deployment{id: id}, event, payload) do
+  def broadcast(%DeploymentGroup{id: id}, event, payload) do
     Phoenix.Channel.Server.broadcast(
       NervesHub.PubSub,
       "deployment:#{id}",
@@ -448,25 +456,27 @@ defmodule NervesHub.Deployments do
     Version.match?(device.firmware_metadata.version, version)
   end
 
-  defp version_match?(_device, _deployment), do: true
+  defp version_match?(_device, _deployment_group), do: true
 
-  @spec verify_deployment_membership(Device.t()) :: Device.t()
-  def verify_deployment_membership(
+  @spec verify_deployment_group_membership(Device.t()) :: Device.t()
+  def verify_deployment_group_membership(
         %Device{deployment_id: deployment_id, firmware_metadata: %{version: device_version}} =
           device
       )
       when not is_nil(deployment_id) do
-    {:ok, deployment} = get_deployment_for_device(device)
+    {:ok, deployment_group} = get_deployment_group_for_device(device)
 
     bad_version =
-      if deployment.conditions["version"] != "" do
-        !Version.match?(device_version, deployment.conditions["version"])
+      if deployment_group.conditions["version"] != "" do
+        !Version.match?(device_version, deployment_group.conditions["version"])
       else
         false
       end
 
-    bad_platform = device.firmware_metadata.platform != deployment.firmware.platform
-    bad_architecture = device.firmware_metadata.architecture != deployment.firmware.architecture
+    bad_platform = device.firmware_metadata.platform != deployment_group.firmware.platform
+
+    bad_architecture =
+      device.firmware_metadata.architecture != deployment_group.firmware.architecture
 
     reason =
       cond do
@@ -489,7 +499,7 @@ defmodule NervesHub.Deployments do
         |> Ecto.Changeset.change(%{deployment_id: nil})
         |> Repo.update!()
 
-      DeploymentTemplates.audit_deployment_mismatch(device, deployment, reason)
+      DeploymentGroupTemplates.audit_deployment_mismatch(device, deployment_group, reason)
 
       device
     else
@@ -497,42 +507,42 @@ defmodule NervesHub.Deployments do
     end
   end
 
-  def verify_deployment_membership(device), do: device
+  def verify_deployment_group_membership(device), do: device
 
   @doc """
-  If the device is missing a deployment, find a matching deployment
+  If the device is missing a deployment group, find a matching deployment group
 
-  Do nothing if a deployment is already set
+  Do nothing if a deployment group is already set
   """
-  @spec set_deployment(Device.t()) :: Device.t()
-  def set_deployment(%{deployment_id: nil} = device) do
-    case matching_deployments(device, [true]) do
+  @spec set_deployment_group(Device.t()) :: Device.t()
+  def set_deployment_group(%{deployment_id: nil} = device) do
+    case matching_deployment_groups(device, [true]) do
       [] ->
-        set_deployment_telemetry(:none_found, device)
+        set_deployment_group_telemetry(:none_found, device)
 
-        %{device | deployment: nil}
+        %{device | deployment_group: nil}
 
       [deployment] ->
-        set_deployment_telemetry(:one_found, device, deployment)
+        set_deployment_group_telemetry(:one_found, device, deployment)
 
         DeviceTemplates.audit_set_deployment(device, deployment, :one_found)
 
-        Devices.update_deployment(device, deployment)
+        Devices.update_deployment_group(device, deployment)
 
       [deployment | _] ->
-        set_deployment_telemetry(:multiple_found, device, deployment)
+        set_deployment_group_telemetry(:multiple_found, device, deployment)
 
         DeviceTemplates.audit_set_deployment(device, deployment, :multiple_found)
 
-        Devices.update_deployment(device, deployment)
+        Devices.update_deployment_group(device, deployment)
     end
   end
 
-  def set_deployment(device) do
+  def set_deployment_group(device) do
     preload_with_firmware_and_archive(device)
   end
 
-  defp set_deployment_telemetry(result, device, deployment \\ nil) do
+  defp set_deployment_group_telemetry(result, device, deployment \\ nil) do
     metadata = %{device: device}
 
     metadata =
@@ -543,38 +553,38 @@ defmodule NervesHub.Deployments do
       end
 
     :telemetry.execute(
-      [:nerves_hub, :deployments, :set_deployment, result],
+      [:nerves_hub, :managed_deployments, :set_deployment_group, result],
       %{count: 1},
       metadata
     )
   end
 
-  @spec preload_firmware_and_archive(Deployment.t()) :: Deployment.t()
-  def preload_firmware_and_archive(deployment) do
-    %Deployment{} = Repo.preload(deployment, [:archive, :firmware])
+  @spec preload_firmware_and_archive(DeploymentGroup.t()) :: DeploymentGroup.t()
+  def preload_firmware_and_archive(deployment_group) do
+    %DeploymentGroup{} = Repo.preload(deployment_group, [:archive, :firmware])
   end
 
   @spec preload_with_firmware_and_archive(Device.t(), boolean()) :: Device.t()
   def preload_with_firmware_and_archive(device, force \\ false) do
-    %Device{} = Repo.preload(device, [deployment: [:archive, :firmware]], force: force)
+    %Device{} = Repo.preload(device, [deployment_group: [:archive, :firmware]], force: force)
   end
 
   @doc """
-  Find all potential deployments for a device
+  Find all potential deployment groups for a device
 
   Based on the product, firmware platform, firmware architecture, and device tags
   """
-  @spec matching_deployments(Device.t(), [boolean()]) :: [Deployment.t()]
-  def matching_deployments(device, active \\ [true, false])
-  def matching_deployments(%Device{firmware_metadata: nil}, _active), do: []
+  @spec matching_deployment_groups(Device.t(), [boolean()]) :: [DeploymentGroup.t()]
+  def matching_deployment_groups(device, active \\ [true, false])
+  def matching_deployment_groups(%Device{firmware_metadata: nil}, _active), do: []
 
-  def matching_deployments(device, active) do
-    Deployment
+  def matching_deployment_groups(device, active) do
+    DeploymentGroup
     |> join(:inner, [d], assoc(d, :firmware), as: :firmware)
     |> preload([_, firmware: f], firmware: f)
     |> where([d], d.product_id == ^device.product_id)
     |> where([d], d.is_active in ^active)
-    |> ignore_same_deployment(device)
+    |> ignore_same_deployment_group(device)
     |> where([d, firmware: f], f.platform == ^device.firmware_metadata.platform)
     |> where([d, firmware: f], f.architecture == ^device.firmware_metadata.architecture)
     |> where([d], fragment("?->'tags' <@ to_jsonb(?::text[])", d.conditions, ^device.tags))
@@ -592,24 +602,24 @@ defmodule NervesHub.Deployments do
     )
   end
 
-  defp ignore_same_deployment(query, %{deployment_id: nil}), do: query
+  defp ignore_same_deployment_group(query, %{deployment_id: nil}), do: query
 
-  defp ignore_same_deployment(query, %{deployment_id: deployment_id}) do
+  defp ignore_same_deployment_group(query, %{deployment_id: deployment_id}) do
     where(query, [d], d.id != ^deployment_id)
   end
 
   @doc """
-  Find all eligible deployments for a device, based on the firmware platform,
+  Find all eligible deployment groups for a device, based on the firmware platform,
   firmware architecture, and product.
 
-  This is purposefully less-strict then Deployments.matching_deployments/2
+  This is purposefully less-strict then Deployments.matching_deployment_groups/2
   and should only be used when a human is choosing the deployment for a device.
   """
-  @spec eligible_deployments(Device.t()) :: [Deployment.t()]
-  def eligible_deployments(%Device{firmware_metadata: nil}), do: []
+  @spec eligible_deployment_groups(Device.t()) :: [DeploymentGroup.t()]
+  def eligible_deployment_groups(%Device{firmware_metadata: nil}), do: []
 
-  def eligible_deployments(device) do
-    Deployment
+  def eligible_deployment_groups(device) do
+    DeploymentGroup
     |> join(:inner, [d], assoc(d, :firmware), as: :firmware)
     |> preload([_, firmware: f], firmware: f)
     |> where([d, _], d.product_id == ^device.product_id)
@@ -618,18 +628,18 @@ defmodule NervesHub.Deployments do
     |> Repo.all()
   end
 
-  def deployment_created_event(deployment) do
+  def deployment_created_event(deployment_group) do
     # the old orchestrator
-    _ = broadcast(:monitor, "deployments/new", %{deployment_id: deployment.id})
+    _ = broadcast(:monitor, "deployments/new", %{deployment_id: deployment_group.id})
 
     # the new orchestrator
-    _ = DistributedOrchestrator.start_orchestrator(deployment)
+    _ = DistributedOrchestrator.start_orchestrator(deployment_group)
 
     :ok
   end
 
-  def start_deployments_distributed_orchestrator_event(deployment) do
-    _ = DistributedOrchestrator.start_orchestrator(deployment)
+  def start_deployments_distributed_orchestrator_event(deployment_group) do
+    _ = DistributedOrchestrator.start_orchestrator(deployment_group)
 
     :ok
   end
@@ -646,17 +656,17 @@ defmodule NervesHub.Deployments do
     :ok
   end
 
-  def deployment_activated_event(deployment) do
-    _ = DistributedOrchestrator.start_orchestrator(deployment)
+  def deployment_activated_event(deployment_group) do
+    _ = DistributedOrchestrator.start_orchestrator(deployment_group)
 
     :ok
   end
 
-  def deployment_deactivated_event(deployment) do
+  def deployment_deactivated_event(deployment_group) do
     _ =
       Phoenix.Channel.Server.broadcast(
         NervesHub.PubSub,
-        "orchestrator:deployment:#{deployment.id}",
+        "orchestrator:deployment:#{deployment_group.id}",
         "deactivated",
         %{}
       )
@@ -664,13 +674,13 @@ defmodule NervesHub.Deployments do
     :ok
   end
 
-  def deployment_deleted_event(deployment) do
+  def deployment_deleted_event(deployment_group) do
     _ =
-      if deployment.orchestrator_strategy == :distributed do
-        broadcast(deployment, "deleted")
+      if deployment_group.orchestrator_strategy == :distributed do
+        broadcast(deployment_group, "deleted")
       end
 
-    _ = broadcast(:monitor, "deployments/delete", %{deployment_id: deployment.id})
+    _ = broadcast(:monitor, "deployments/delete", %{deployment_id: deployment_group.id})
 
     :ok
   end
diff --git a/lib/nerves_hub/deployments/deployment.ex b/lib/nerves_hub/managed_deployments/deployment_group.ex
similarity index 79%
rename from lib/nerves_hub/deployments/deployment.ex
rename to lib/nerves_hub/managed_deployments/deployment_group.ex
index b5f4f7549..0a033759f 100644
--- a/lib/nerves_hub/deployments/deployment.ex
+++ b/lib/nerves_hub/managed_deployments/deployment_group.ex
@@ -1,4 +1,4 @@
-defmodule NervesHub.Deployments.Deployment do
+defmodule NervesHub.ManagedDeployments.DeploymentGroup do
   use Ecto.Schema
 
   import Ecto.Changeset
@@ -9,6 +9,7 @@ defmodule NervesHub.Deployments.Deployment do
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.InflightUpdate
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments.DeploymentRelease
   alias NervesHub.Products.Product
   alias NervesHub.Repo
 
@@ -49,8 +50,9 @@ defmodule NervesHub.Deployments.Deployment do
     belongs_to(:org, Org, where: [deleted_at: nil])
     belongs_to(:archive, Archive)
 
-    has_many(:inflight_updates, InflightUpdate)
-    has_many(:devices, Device, on_delete: :nilify_all)
+    has_many(:inflight_updates, InflightUpdate, foreign_key: :deployment_id)
+    has_many(:devices, Device, foreign_key: :deployment_id, on_delete: :nilify_all)
+    has_many(:deployment_releases, DeploymentRelease)
 
     field(:conditions, :map)
     field(:device_failure_threshold, :integer, default: 3)
@@ -83,7 +85,7 @@ defmodule NervesHub.Deployments.Deployment do
     timestamps()
   end
 
-  def creation_changeset(%Deployment{} = deployment, params) do
+  def creation_changeset(%DeploymentGroup{} = deployment, params) do
     # set product_id by getting it from firmware
     with_product_id = handle_product_id(deployment, params)
 
@@ -104,27 +106,27 @@ defmodule NervesHub.Deployments.Deployment do
     end
   end
 
-  defp handle_product_id(%Deployment{}, %{firmware: %Firmware{product_id: p_id}} = params) do
+  defp handle_product_id(%DeploymentGroup{}, %{firmware: %Firmware{product_id: p_id}} = params) do
     params |> Map.put(:product_id, p_id)
   end
 
-  defp handle_product_id(%Deployment{firmware: %Firmware{product_id: p_id}}, params) do
+  defp handle_product_id(%DeploymentGroup{firmware: %Firmware{product_id: p_id}}, params) do
     params |> Map.put(:product_id, p_id)
   end
 
-  defp handle_product_id(%Deployment{} = d, %{firmware_id: f_id} = params) do
+  defp handle_product_id(%DeploymentGroup{} = d, %{firmware_id: f_id} = params) do
     handle_product_id(d, params |> Map.put(:firmware, Firmware |> Repo.get!(f_id)))
   end
 
-  defp handle_product_id(%Deployment{firmware_id: nil}, params) do
+  defp handle_product_id(%DeploymentGroup{firmware_id: nil}, params) do
     params
   end
 
-  defp handle_product_id(%Deployment{} = d, params) do
+  defp handle_product_id(%DeploymentGroup{} = d, params) do
     handle_product_id(d |> with_firmware(), params)
   end
 
-  def changeset(%Deployment{} = deployment, params) do
+  def changeset(%DeploymentGroup{} = deployment, params) do
     deployment
     |> cast(params, @required_fields ++ @optional_fields)
     |> validate_required(@required_fields)
@@ -139,29 +141,23 @@ defmodule NervesHub.Deployments.Deployment do
     |> validate_conditions()
   end
 
-  def with_firmware(%Deployment{firmware: %Firmware{}} = d), do: d
+  def with_firmware(%DeploymentGroup{firmware: %Firmware{}} = d), do: d
 
-  def with_firmware(%Deployment{} = d) do
+  def with_firmware(%DeploymentGroup{} = d) do
     d
     |> Repo.preload(:firmware)
   end
 
-  def with_firmware(deployment_query) do
-    deployment_query
-    |> preload(:firmware)
-  end
+  def with_firmware(query), do: preload(query, :firmware)
 
-  def with_product(%Deployment{product: %Product{}} = d), do: d
+  def with_product(%DeploymentGroup{product: %Product{}} = d), do: d
 
-  def with_product(%Deployment{} = d) do
+  def with_product(%DeploymentGroup{} = d) do
     d
     |> Repo.preload(:product)
   end
 
-  def with_product(deployment_query) do
-    deployment_query
-    |> preload(:product)
-  end
+  def with_product(query), do: preload(query, :product)
 
   defp validate_conditions(changeset, _options \\ []) do
     validate_change(changeset, :conditions, fn :conditions, conditions ->
diff --git a/lib/nerves_hub/managed_deployments/deployment_release.ex b/lib/nerves_hub/managed_deployments/deployment_release.ex
new file mode 100644
index 000000000..0d96f11be
--- /dev/null
+++ b/lib/nerves_hub/managed_deployments/deployment_release.ex
@@ -0,0 +1,39 @@
+defmodule NervesHub.ManagedDeployments.DeploymentRelease do
+  use Ecto.Schema
+
+  import Ecto.Changeset
+
+  alias NervesHub.Accounts.User
+  alias NervesHub.Archives.Archive
+  alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+
+  alias __MODULE__
+
+  @type t :: %__MODULE__{}
+
+  @required_fields [
+    :deployment_group_id,
+    :firmware_id,
+    :archive_id,
+    :created_by_id,
+    :status
+  ]
+
+  @optional_fields [:archive_id]
+
+  schema "deployment_releases" do
+    belongs_to(:deployment_group, DeploymentGroup)
+    belongs_to(:firmware, Firmware)
+    belongs_to(:archive, Archive)
+    belongs_to(:user, User, foreign_key: :created_by_id)
+
+    timestamps()
+  end
+
+  def changeset(%DeploymentRelease{} = deployment_release, params) do
+    deployment_release
+    |> cast(params, @required_fields ++ @optional_fields)
+    |> validate_required(@required_fields)
+  end
+end
diff --git a/lib/nerves_hub/deployments/distributed/orchestrator.ex b/lib/nerves_hub/managed_deployments/distributed/orchestrator.ex
similarity index 59%
rename from lib/nerves_hub/deployments/distributed/orchestrator.ex
rename to lib/nerves_hub/managed_deployments/distributed/orchestrator.ex
index fae692d10..a9ba23ee2 100644
--- a/lib/nerves_hub/deployments/distributed/orchestrator.ex
+++ b/lib/nerves_hub/managed_deployments/distributed/orchestrator.ex
@@ -1,4 +1,4 @@
-defmodule NervesHub.Deployments.Distributed.Orchestrator do
+defmodule NervesHub.ManagedDeployments.Distributed.Orchestrator do
   @moduledoc """
   Orchestration process to handle passing out updates to devices
 
@@ -12,10 +12,10 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
 
   require Logger
 
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices
   alias NervesHub.Devices.Device
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   alias Phoenix.PubSub
   alias Phoenix.Socket.Broadcast
@@ -23,51 +23,53 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
   @maybe_trigger_interval 3_000
 
   defmodule State do
-    defstruct deployment: nil,
+    defstruct deployment_group: nil,
               rate_limit?: true,
               timer_ref: nil,
               should_run?: false
 
     @type t ::
             %__MODULE__{
-              deployment: Deployment.t(),
+              deployment_group: DeploymentGroup.t(),
               rate_limit?: boolean(),
               timer_ref: reference() | nil,
               should_run?: boolean()
             }
   end
 
-  def child_spec(deployment, rate_limit \\ true) do
+  def child_spec(deployment_group, rate_limit \\ true) do
     %{
-      id: :"distributed_orchestrator_#{deployment.id}",
-      start: {__MODULE__, :start_link, [deployment, rate_limit]},
+      id: :"distributed_orchestrator_#{deployment_group.id}",
+      start: {__MODULE__, :start_link, [deployment_group, rate_limit]},
       restart: :transient
     }
   end
 
-  def start_link(deployment, rate_limit) do
-    GenServer.start_link(__MODULE__, {deployment, rate_limit})
+  def start_link(deployment_group, rate_limit) do
+    GenServer.start_link(__MODULE__, {deployment_group, rate_limit})
   end
 
-  def start_link(deployment) do
-    start_link(deployment, true)
+  def start_link(deployment_group) do
+    start_link(deployment_group, true)
   end
 
-  @decorate with_span("Deployments.Distributed.Orchestrator.init")
-  def init({deployment, rate_limit}) do
-    :ok = PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment.id}")
-    :ok = PubSub.subscribe(NervesHub.PubSub, "orchestrator:deployment:#{deployment.id}")
+  @decorate with_span("ManagedDeployments.Distributed.Orchestrator.init")
+  def init({deployment_group, rate_limit}) do
+    :ok = PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment_group.id}")
+
+    :ok =
+      PubSub.subscribe(NervesHub.PubSub, "orchestrator:deployment:#{deployment_group.id}")
 
     # trigger every two minutes, plus a jitter between 1 and 10 seconds, as a back up
     interval = :timer.seconds(120 + :rand.uniform(20))
     _ = :timer.send_interval(interval, :trigger_interval)
 
-    {:ok, deployment} = Deployments.get_deployment(deployment)
+    {:ok, deployment_group} = ManagedDeployments.get_deployment_group(deployment_group)
 
     send(self(), :maybe_trigger)
 
     state = %State{
-      deployment: deployment,
+      deployment_group: deployment_group,
       rate_limit?: rate_limit,
       timer_ref: nil,
       should_run?: true
@@ -93,21 +95,21 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
   As devices update and reconnect, the new orchestrator is told that the update
   was successful, and the process is repeated.
   """
-  @decorate with_span("Deployments.Distributed.Orchestrator.trigger_update#noop")
-  def trigger_update(%Deployment{is_active: false}) do
+  @decorate with_span("ManagedDeployments.Distributed.Orchestrator.trigger_update#noop")
+  def trigger_update(%DeploymentGroup{is_active: false}) do
     :ok
   end
 
-  @decorate with_span("Deployments.Distributed.Orchestrator.trigger_update")
-  def trigger_update(deployment) do
-    :telemetry.execute([:nerves_hub, :deployment, :trigger_update], %{count: 1})
+  @decorate with_span("ManagedDeployments.Distributed.Orchestrator.trigger_update")
+  def trigger_update(deployment_group) do
+    :telemetry.execute([:nerves_hub, :deployment_group, :trigger_update], %{count: 1})
 
-    slots = available_slots(deployment)
+    slots = available_slots(deployment_group)
 
     if slots > 0 do
-      available = Devices.available_for_update(deployment, slots)
+      available = Devices.available_for_update(deployment_group, slots)
 
-      updated_count = schedule_devices!(available, deployment)
+      updated_count = schedule_devices!(available, deployment_group)
 
       if length(available) != updated_count do
         # rerun the deployment check since some devices were skipped
@@ -120,10 +122,10 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
   Determine how many devices should update based on
   the deployment update limit and the number currently updating
   """
-  @spec available_slots(Deployment.t()) :: non_neg_integer()
-  def available_slots(deployment) do
+  @spec available_slots(DeploymentGroup.t()) :: non_neg_integer()
+  def available_slots(deployment_group) do
     # Just in case inflight goes higher than concurrent, limit it to 0
-    (deployment.concurrent_updates - Devices.count_inflight_updates_for(deployment))
+    (deployment_group.concurrent_updates - Devices.count_inflight_updates_for(deployment_group))
     |> max(0)
     |> round()
   end
@@ -134,31 +136,31 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
 
   Returns the number of devices that were allowed to update.
   """
-  @spec schedule_devices!([Device.t()], Deployment.t()) :: non_neg_integer()
-  def schedule_devices!(available, deployment) do
+  @spec schedule_devices!([Device.t()], DeploymentGroup.t()) :: non_neg_integer()
+  def schedule_devices!(available, deployment_group) do
     Enum.count(available, fn device ->
-      case can_device_update?(device, deployment) do
+      case can_device_update?(device, deployment_group) do
         true ->
-          tell_device_to_update(device.id, deployment)
+          tell_device_to_update(device.id, deployment_group)
 
         false ->
-          _ = Devices.update_blocked_until(device, deployment)
+          _ = Devices.update_blocked_until(device, deployment_group)
           false
       end
     end)
   end
 
-  @spec can_device_update?(Device.t(), Deployment.t()) :: boolean()
-  defp can_device_update?(device, deployment) do
-    not (Devices.failure_rate_met?(device, deployment) or
-           Devices.failure_threshold_met?(device, deployment))
+  @spec can_device_update?(Device.t(), DeploymentGroup.t()) :: boolean()
+  defp can_device_update?(device, deployment_group) do
+    not (Devices.failure_rate_met?(device, deployment_group) or
+           Devices.failure_threshold_met?(device, deployment_group))
   end
 
-  @spec tell_device_to_update(integer(), Deployment.t()) :: boolean()
-  defp tell_device_to_update(device_id, deployment) do
-    :telemetry.execute([:nerves_hub, :deployment, :trigger_update, :device], %{count: 1})
+  @spec tell_device_to_update(integer(), DeploymentGroup.t()) :: boolean()
+  defp tell_device_to_update(device_id, deployment_group) do
+    :telemetry.execute([:nerves_hub, :deployment_group, :trigger_update, :device], %{count: 1})
 
-    case Devices.told_to_update(device_id, deployment) do
+    case Devices.told_to_update(device_id, deployment_group) do
       {:ok, _} -> true
       _ -> false
     end
@@ -166,14 +168,14 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
 
   # if rate limiting isn't enabled, run `trigger_update`
   defp maybe_trigger_update(%State{rate_limit?: false} = state) do
-    trigger_update(state.deployment)
+    trigger_update(state.deployment_group)
 
     {:noreply, state}
   end
 
   # if there is no "delay" timer set, run `trigger_update`
   defp maybe_trigger_update(%State{timer_ref: nil} = state) do
-    trigger_update(state.deployment)
+    trigger_update(state.deployment_group)
 
     timer_ref = Process.send_after(self(), :maybe_trigger, @maybe_trigger_interval)
 
@@ -188,7 +190,7 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
 
   # if we don't have a `timer_ref` we can run `trigger_update`
   def handle_info(:trigger_interval, %State{timer_ref: nil} = state) do
-    trigger_update(state.deployment)
+    trigger_update(state.deployment_group)
 
     {:noreply, state}
   end
@@ -201,13 +203,13 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
   # if the 'run again' boolean in the state is `true`, which indicates that indicates
   # that previous call has been skipped, then run `trigger_update` now
   def handle_info(:maybe_trigger, %State{rate_limit?: false} = state) do
-    trigger_update(state.deployment)
+    trigger_update(state.deployment_group)
 
     {:noreply, state}
   end
 
   def handle_info(:maybe_trigger, %State{should_run?: true} = state) do
-    trigger_update(state.deployment)
+    trigger_update(state.deployment_group)
 
     timer_ref = Process.send_after(self(), :maybe_trigger, @maybe_trigger_interval)
 
@@ -220,7 +222,9 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
     {:noreply, %{state | timer_ref: nil}}
   end
 
-  @decorate with_span("Deployments.Distributed.Orchestrator.handle_info:deployment/device-online")
+  @decorate with_span(
+              "ManagedDeployments.Distributed.Orchestrator.handle_info:deployment/device-online"
+            )
   def handle_info(
         %Broadcast{
           topic: "orchestrator:deployment:" <> _rest,
@@ -229,14 +233,16 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
         },
         state
       ) do
-    if should_trigger?(payload, state.deployment) do
+    if should_trigger?(payload, state.deployment_group) do
       maybe_trigger_update(state)
     else
       {:noreply, state}
     end
   end
 
-  @decorate with_span("Deployments.Distributed.Orchestrator.handle_info:deployment/device-update")
+  @decorate with_span(
+              "ManagedDeployments.Distributed.Orchestrator.handle_info:deployment/device-update"
+            )
   def handle_info(
         %Broadcast{topic: "orchestrator:deployment:" <> _, event: "device-updated"},
         state
@@ -244,16 +250,18 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
     maybe_trigger_update(state)
   end
 
-  @decorate with_span("Deployments.Distributed.Orchestrator.handle_info:deployments/update")
+  @decorate with_span(
+              "ManagedDeployments.Distributed.Orchestrator.handle_info:deployments/update"
+            )
   def handle_info(
         %Broadcast{topic: "deployment:" <> _, event: "deployments/update"},
         state
       ) do
-    {:ok, deployment} = Deployments.get_deployment(state.deployment)
+    {:ok, deployment_group} = ManagedDeployments.get_deployment_group(state.deployment_group)
 
     # shutdown the orchestrator if the deployment is updated to use the old `:multi` strategy
-    if deployment.orchestrator_strategy == :distributed do
-      maybe_trigger_update(%{state | deployment: deployment})
+    if deployment_group.orchestrator_strategy == :distributed do
+      maybe_trigger_update(%{state | deployment_group: deployment_group})
     else
       {:stop, :normal, state}
     end
@@ -263,11 +271,14 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
     {:stop, :normal, state}
   end
 
-  def handle_info(%Broadcast{topic: "orchestrator:deployment:" <> _, event: "deactivated"}, state) do
+  def handle_info(
+        %Broadcast{topic: "orchestrator:deployment:" <> _, event: "deactivated"},
+        state
+      ) do
     {:stop, :normal, state}
   end
 
-  # Catch all for unknown broadcasts on a deployment
+  # Catch all for unknown broadcasts on a deployment_group
   def handle_info(%Broadcast{topic: "deployment:" <> _}, state) do
     {:noreply, state}
   end
@@ -277,7 +288,7 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
   end
 
   def start_orchestrator(
-        %Deployment{is_active: true, orchestrator_strategy: :distributed} = deployment
+        %DeploymentGroup{is_active: true, orchestrator_strategy: :distributed} = deployment
       ) do
     if Application.get_env(:nerves_hub, :deploy_env) != "test" do
       ProcessHub.start_child(:deployment_orchestrators, child_spec(deployment))
@@ -288,12 +299,12 @@ defmodule NervesHub.Deployments.Distributed.Orchestrator do
     :ok
   end
 
-  defp should_trigger?(payload, deployment) do
-    not (firmware_match?(payload, deployment) or updates_blocked?(payload))
+  defp should_trigger?(payload, deployment_group) do
+    not (firmware_match?(payload, deployment_group) or updates_blocked?(payload))
   end
 
-  defp firmware_match?(payload, deployment) do
-    payload.firmware_uuid == deployment.firmware.uuid
+  defp firmware_match?(payload, deployment_group) do
+    payload.firmware_uuid == deployment_group.firmware.uuid
   end
 
   defp updates_blocked?(payload) do
diff --git a/lib/nerves_hub/deployments/distributed/orchestrator_registration.ex b/lib/nerves_hub/managed_deployments/distributed/orchestrator_registration.ex
similarity index 76%
rename from lib/nerves_hub/deployments/distributed/orchestrator_registration.ex
rename to lib/nerves_hub/managed_deployments/distributed/orchestrator_registration.ex
index f427b7673..4ae779c62 100644
--- a/lib/nerves_hub/deployments/distributed/orchestrator_registration.ex
+++ b/lib/nerves_hub/managed_deployments/distributed/orchestrator_registration.ex
@@ -1,4 +1,4 @@
-defmodule NervesHub.Deployments.Distributed.OrchestratorRegistration do
+defmodule NervesHub.ManagedDeployments.Distributed.OrchestratorRegistration do
   @moduledoc """
   Registers deployment orchestrators with `ProcessHub`.
 
@@ -7,8 +7,8 @@ defmodule NervesHub.Deployments.Distributed.OrchestratorRegistration do
 
   use GenServer
 
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Distributed.Orchestrator
+  alias NervesHub.ManagedDeployments.Distributed.Orchestrator
+  alias NervesHub.ManagedDeployments
 
   def child_spec(_) do
     %{
@@ -31,7 +31,7 @@ defmodule NervesHub.Deployments.Distributed.OrchestratorRegistration do
   @impl GenServer
   def handle_info(:start_orchestrators, _) do
     _ =
-      Deployments.should_run_in_distributed_orchestrator()
+      ManagedDeployments.should_run_in_distributed_orchestrator()
       |> Enum.map(fn deployment ->
         Orchestrator.child_spec(deployment)
       end)
diff --git a/lib/nerves_hub/managed_deployments/inflight_deployment_check.ex b/lib/nerves_hub/managed_deployments/inflight_deployment_check.ex
new file mode 100644
index 000000000..0078317c2
--- /dev/null
+++ b/lib/nerves_hub/managed_deployments/inflight_deployment_check.ex
@@ -0,0 +1,15 @@
+defmodule NervesHub.ManagedDeployments.InflightDeploymentCheck do
+  use Ecto.Schema
+
+  @timestamps_opts updated_at: false
+
+  alias NervesHub.Devices.Device
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+
+  schema "inflight_deployment_checks" do
+    belongs_to(:device, Device)
+    belongs_to(:deployment_group, DeploymentGroup, foreign_key: :deployment_id)
+
+    timestamps()
+  end
+end
diff --git a/lib/nerves_hub/managed_deployments/monitor.ex b/lib/nerves_hub/managed_deployments/monitor.ex
new file mode 100644
index 000000000..a4b34ab8c
--- /dev/null
+++ b/lib/nerves_hub/managed_deployments/monitor.ex
@@ -0,0 +1,66 @@
+defmodule NervesHub.ManagedDeployments.Monitor do
+  @moduledoc """
+  Deployment Monitor starts a deployment orchestrator per deployment
+
+  Listens for new deployment groups and starts as necessary
+  """
+
+  use GenServer
+
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeploymentDynamicSupervisor
+  alias NervesHub.ManagedDeployments.Orchestrator
+  alias Phoenix.PubSub
+  alias Phoenix.Socket.Broadcast
+
+  defmodule State do
+    defstruct [:deployment_groups]
+  end
+
+  def start_link(_) do
+    GenServer.start_link(__MODULE__, [])
+  end
+
+  def init(_) do
+    _ = PubSub.subscribe(NervesHub.PubSub, "deployment_group:monitor")
+
+    {:ok, %State{}, {:continue, :boot}}
+  end
+
+  def handle_continue(:boot, state) do
+    deployment_groups =
+      Enum.into(ManagedDeployments.all(), %{}, fn deployment_group ->
+        {:ok, orchestrator_pid} =
+          DynamicSupervisor.start_child(
+            ManagedDeploymentDynamicSupervisor,
+            {ManagedDeployments.Orchestrator, deployment_group}
+          )
+
+        {deployment_group.id, %{orchestrator_pid: orchestrator_pid}}
+      end)
+
+    {:noreply, %{state | deployment_groups: deployment_groups}}
+  end
+
+  def handle_info(%Broadcast{event: "deployments/new", payload: payload}, state) do
+    {:ok, deployment_group} = ManagedDeployments.get(payload.deployment_id)
+
+    {:ok, orchestrator_pid} =
+      DynamicSupervisor.start_child(
+        ManagedDeploymentDynamicSupervisor,
+        {ManagedDeployments.Orchestrator, deployment_group}
+      )
+
+    deployment_groups =
+      Map.put(state.deployments, deployment_group.id, %{orchestrator_pid: orchestrator_pid})
+
+    {:noreply, %{state | deployment_groups: deployment_groups}}
+  end
+
+  def handle_info(%Broadcast{event: "deployments/delete", payload: payload}, state) do
+    pid = GenServer.whereis(Orchestrator.name(payload.deployment_id))
+    _ = DynamicSupervisor.terminate_child(ManagedDeploymentDynamicSupervisor, pid)
+    deployment_groups = Map.delete(state.deployments, payload.deployment_id)
+    {:noreply, %{state | deployment_groups: deployment_groups}}
+  end
+end
diff --git a/lib/nerves_hub/deployments/orchestrator.ex b/lib/nerves_hub/managed_deployments/orchestrator.ex
similarity index 57%
rename from lib/nerves_hub/deployments/orchestrator.ex
rename to lib/nerves_hub/managed_deployments/orchestrator.ex
index a7e0c8663..39334a43b 100644
--- a/lib/nerves_hub/deployments/orchestrator.ex
+++ b/lib/nerves_hub/managed_deployments/orchestrator.ex
@@ -1,4 +1,4 @@
-defmodule NervesHub.Deployments.Orchestrator do
+defmodule NervesHub.ManagedDeployments.Orchestrator do
   @moduledoc """
   Orchestration process to handle passing out updates to devices
 
@@ -13,25 +13,25 @@ defmodule NervesHub.Deployments.Orchestrator do
 
   require Logger
 
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices
   alias NervesHub.Devices.Device
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   alias NervesHub.Repo
 
   alias Phoenix.PubSub
   alias Phoenix.Socket.Broadcast
 
-  def start_link(deployment) do
-    GenServer.start_link(__MODULE__, deployment, name: name(deployment))
+  def start_link(deployment_group) do
+    GenServer.start_link(__MODULE__, deployment_group, name: name(deployment_group))
   end
 
   def name(deployment_id) when is_integer(deployment_id) do
-    {:via, Registry, {Deployments, deployment_id}}
+    {:via, Registry, {ManagedDeployments, deployment_id}}
   end
 
-  def name(deployment), do: name(deployment.id)
+  def name(deployment_group), do: name(deployment_group.id)
 
   def device_updated(deployment_id) do
     GenServer.cast(name(deployment_id), :trigger)
@@ -44,7 +44,7 @@ defmodule NervesHub.Deployments.Orchestrator do
 
   - the deployment
   - not updating
-  - not using the deployment's current firmware
+  - not using the deployment group's current firmware
 
   If there is space for the device based on the concurrent allowed updates
   the device is told to update. This is not guaranteed to be at or under the
@@ -53,25 +53,24 @@ defmodule NervesHub.Deployments.Orchestrator do
   As devices update and reconnect, the new orchestrator is told that the update
   was successful, and the process is repeated.
   """
-  @decorate with_span("Deployments.Orchestrator.trigger_update#noop")
-  def trigger_update(%Deployment{is_active: false}) do
+  @decorate with_span("ManagedDeployments.Orchestrator.trigger_update#noop")
+  def trigger_update(%DeploymentGroup{is_active: false}) do
     :ok
   end
 
-  @decorate with_span("Deployments.Orchestrator.trigger_update#noop")
-  def trigger_update(%Deployment{orchestrator_strategy: strategy}) when strategy != :multi do
+  @decorate with_span("ManagedDeployments.Orchestrator.trigger_update#noop")
+  def trigger_update(%DeploymentGroup{orchestrator_strategy: strategy}) when strategy != :multi do
     :ok
   end
 
-  @decorate with_span("Deployments.Orchestrator.trigger_update")
-  def trigger_update(deployment) do
-    :telemetry.execute([:nerves_hub, :deployment, :trigger_update], %{count: 1})
+  @decorate with_span("ManagedDeployments.Orchestrator.trigger_update")
+  def trigger_update(deployment_group) do
+    :telemetry.execute([:nerves_hub, :deployment_group, :trigger_update], %{count: 1})
 
     match_conditions = [
-      {:and, {:==, {:map_get, :deployment_id, :"$1"}, deployment.id},
+      {:and, {:==, {:map_get, :deployment_id, :"$1"}, deployment_group.id},
        {:==, {:map_get, :updating, :"$1"}, false},
-       {:==, {:map_get, :updates_enabled, :"$1"}, true},
-       {:"/=", {:map_get, :firmware_uuid, :"$1"}, deployment.firmware.uuid}}
+       {:==, {:map_get, :updates_enabled, :"$1"}, true}}
     ]
 
     match_return = %{
@@ -86,7 +85,9 @@ defmodule NervesHub.Deployments.Orchestrator do
       ])
 
     # Get a rough count of devices to update
-    count = deployment.concurrent_updates - Devices.count_inflight_updates_for(deployment)
+    count =
+      deployment_group.concurrent_updates - Devices.count_inflight_updates_for(deployment_group)
+
     # Just in case inflight goes higher than concurrent, limit it to 0
     count = max(count, 0)
 
@@ -96,13 +97,14 @@ defmodule NervesHub.Deployments.Orchestrator do
     devices
     |> Enum.take(count)
     |> Enum.each(fn %{device_id: device_id, pid: pid} ->
-      :telemetry.execute([:nerves_hub, :deployment, :trigger_update, :device], %{count: 1})
+      :telemetry.execute([:nerves_hub, :deployment_group, :trigger_update, :device], %{count: 1})
 
       device = %Device{id: device_id}
 
       # Check again because other nodes are processing at the same time
-      if Devices.count_inflight_updates_for(deployment) < deployment.concurrent_updates do
-        case Devices.told_to_update(device, deployment) do
+      if Devices.count_inflight_updates_for(deployment_group) <
+           deployment_group.concurrent_updates do
+        case Devices.told_to_update(device, deployment_group) do
           {:ok, inflight_update} ->
             send(pid, {"deployments/update", inflight_update})
 
@@ -118,48 +120,43 @@ defmodule NervesHub.Deployments.Orchestrator do
     end)
   end
 
-  def init(deployment) do
-    {:ok, deployment, {:continue, :boot}}
+  def init(deployment_group) do
+    {:ok, deployment_group, {:continue, :boot}}
   end
 
-  @decorate with_span("Deployments.Orchestrator.boot")
-  def handle_continue(:boot, deployment) do
-    _ = PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment.id}")
+  @decorate with_span("ManagedDeployments.Orchestrator.boot")
+  def handle_continue(:boot, deployment_group) do
+    _ = PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment_group.id}")
 
     # trigger every 10 minutes, plus a jitter between 1 and 5 seconds, as a back up
     interval = (10 + :rand.uniform(10)) * 60 * 1000
     _ = :timer.send_interval(interval, :trigger)
 
-    deployment =
-      deployment
-      |> Repo.reload()
-      |> Repo.preload([:firmware], force: true)
+    deployment_group = Repo.reload(deployment_group)
 
-    {:noreply, deployment}
+    {:noreply, deployment_group}
   end
 
-  def handle_cast(:trigger, deployment) do
-    trigger_update(deployment)
-    {:noreply, deployment}
+  def handle_cast(:trigger, deployment_group) do
+    trigger_update(deployment_group)
+    {:noreply, deployment_group}
   end
 
-  @decorate with_span("Deployments.Orchestrator.handle_info:deployments/update")
-  def handle_info(%Broadcast{event: "deployments/update"}, deployment) do
-    deployment =
-      deployment
-      |> Repo.reload()
-      |> Repo.preload([:firmware], force: true)
+  @decorate with_span("ManagedDeployments.Orchestrator.handle_info:deployments/update")
+  def handle_info(%Broadcast{event: "deployments/update"}, deployment_group) do
+    deployment_group = Repo.reload(deployment_group)
 
-    trigger_update(deployment)
+    trigger_update(deployment_group)
 
-    {:noreply, deployment}
+    {:noreply, deployment_group}
   end
 
   # Catch all for unknown broadcasts on a deployment
-  def handle_info(%Broadcast{topic: "deployment:" <> _}, deployment), do: {:noreply, deployment}
+  def handle_info(%Broadcast{topic: "deployment:" <> _}, deployment_group),
+    do: {:noreply, deployment_group}
 
-  def handle_info(:trigger, deployment) do
-    trigger_update(deployment)
-    {:noreply, deployment}
+  def handle_info(:trigger, deployment_group) do
+    trigger_update(deployment_group)
+    {:noreply, deployment_group}
   end
 end
diff --git a/lib/nerves_hub/managed_deployments/supervisor.ex b/lib/nerves_hub/managed_deployments/supervisor.ex
new file mode 100644
index 000000000..ee94eed48
--- /dev/null
+++ b/lib/nerves_hub/managed_deployments/supervisor.ex
@@ -0,0 +1,20 @@
+defmodule NervesHub.ManagedDeployments.Supervisor do
+  @moduledoc false
+
+  use Supervisor
+
+  def start_link(_) do
+    Supervisor.start_link(__MODULE__, [], name: __MODULE__)
+  end
+
+  def init(_) do
+    children = [
+      {Registry, keys: :unique, name: NervesHub.ManagedDeployments},
+      NervesHub.ManagedDeployments.Monitor,
+      {DynamicSupervisor,
+       strategy: :one_for_one, name: NervesHub.ManagedDeploymentDynamicSupervisor}
+    ]
+
+    Supervisor.init(children, strategy: :one_for_one)
+  end
+end
diff --git a/lib/nerves_hub/products/product.ex b/lib/nerves_hub/products/product.ex
index df356a746..8f99f51e1 100644
--- a/lib/nerves_hub/products/product.ex
+++ b/lib/nerves_hub/products/product.ex
@@ -4,11 +4,11 @@ defmodule NervesHub.Products.Product do
 
   alias NervesHub.Accounts.Org
   alias NervesHub.Archives.Archive
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Devices.CACertificate
   alias NervesHub.Devices.Device
   alias NervesHub.Extensions.ProductExtensionsSetting
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Products.SharedSecretAuth
   alias NervesHub.Scripts.Script
 
@@ -23,7 +23,7 @@ defmodule NervesHub.Products.Product do
     has_many(:jitp, CACertificate.JITP)
     has_many(:archives, Archive)
     has_many(:scripts, Script)
-    has_many(:deployments, Deployment)
+    has_many(:deployments, DeploymentGroup)
 
     has_many(:shared_secret_auths, SharedSecretAuth,
       preload_order: [desc: :deactivated_at, asc: :id]
diff --git a/lib/nerves_hub/types.ex b/lib/nerves_hub/types.ex
index 89f64d073..9f0fc5447 100644
--- a/lib/nerves_hub/types.ex
+++ b/lib/nerves_hub/types.ex
@@ -73,6 +73,8 @@ defmodule NervesHub.Types do
       [
         "Elixir.NervesHub.Accounts.Org",
         "Elixir.NervesHub.Accounts.User",
+        "Elixir.NervesHub.ManagedDeployments.DeploymentGroup",
+        # TODO: (nshoes) remove after migrating audit_logs actor/resource type
         "Elixir.NervesHub.Deployments.Deployment",
         "Elixir.NervesHub.Devices.Device",
         "Elixir.NervesHub.Firmwares.Firmware",
diff --git a/lib/nerves_hub/workers/firmware_delta_builder.ex b/lib/nerves_hub/workers/firmware_delta_builder.ex
index 6572eda2c..e8cac4fed 100644
--- a/lib/nerves_hub/workers/firmware_delta_builder.ex
+++ b/lib/nerves_hub/workers/firmware_delta_builder.ex
@@ -7,7 +7,7 @@ defmodule NervesHub.Workers.FirmwareDeltaBuilder do
       states: [:available, :scheduled, :executing]
     ]
 
-  alias NervesHub.Deployments
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Firmwares
 
   @impl Oban.Worker
@@ -17,8 +17,8 @@ defmodule NervesHub.Workers.FirmwareDeltaBuilder do
 
     {:ok, _firmware_delta} = maybe_create_firmware_delta(source, target)
 
-    Enum.each(Deployments.get_deployments_by_firmware(target_id), fn deployment ->
-      Deployments.broadcast(deployment, "deployments/update")
+    Enum.each(ManagedDeployments.get_deployment_groups_by_firmware(target_id), fn deployment ->
+      ManagedDeployments.broadcast(deployment, "deployments/update")
     end)
 
     :ok
diff --git a/lib/nerves_hub_web.ex b/lib/nerves_hub_web.ex
index 6d3e17373..9f44e68ee 100644
--- a/lib/nerves_hub_web.ex
+++ b/lib/nerves_hub_web.ex
@@ -106,6 +106,10 @@ defmodule NervesHubWeb do
 
       def page_title(socket, page_title), do: assign(socket, :page_title, page_title)
 
+      @spec sidebar_tab(
+              Phoenix.Socket.t(),
+              :archives | :firmware | :deployments | :devices | :settings | :support_scripts
+            ) :: Phoenix.Socket.t()
       def sidebar_tab(socket, tab) do
         socket
         |> assign(:sidebar_tab, tab)
diff --git a/lib/nerves_hub_web/channels/console_channel.ex b/lib/nerves_hub_web/channels/console_channel.ex
index 4ae5dd1d7..21e669d0b 100644
--- a/lib/nerves_hub_web/channels/console_channel.ex
+++ b/lib/nerves_hub_web/channels/console_channel.ex
@@ -73,10 +73,9 @@ defmodule NervesHubWeb.ConsoleChannel do
     # now that the console is connected, push down the device's elixir, line by line
     device = socket.assigns.device
     device = Repo.preload(device, [:deployment])
-    deployment = device.deployment
 
-    if deployment && deployment.connecting_code do
-      device.deployment.connecting_code
+    if device.deployment_group && device.deployment_group.connecting_code do
+      device.deployment_group.connecting_code
       |> String.graphemes()
       |> Enum.each(fn character ->
         push(socket, "dn", %{"data" => character})
diff --git a/lib/nerves_hub_web/channels/device_channel.ex b/lib/nerves_hub_web/channels/device_channel.ex
index 004c416cf..e76fae53c 100644
--- a/lib/nerves_hub_web/channels/device_channel.ex
+++ b/lib/nerves_hub_web/channels/device_channel.ex
@@ -12,12 +12,12 @@ defmodule NervesHubWeb.DeviceChannel do
 
   alias NervesHub.Archives
   alias NervesHub.AuditLogs.DeviceTemplates
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Connections
   alias NervesHub.Devices.Device
   alias NervesHub.Firmwares
   alias NervesHub.Helpers.Logging
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Repo
   alias Phoenix.Socket.Broadcast
 
@@ -47,8 +47,8 @@ defmodule NervesHubWeb.DeviceChannel do
   def handle_info({:after_join, params}, %{assigns: %{device: device}} = socket) do
     device =
       device
-      |> Deployments.verify_deployment_membership()
-      |> Deployments.set_deployment()
+      |> ManagedDeployments.verify_deployment_group_membership()
+      |> ManagedDeployments.set_deployment_group()
       |> Map.put(:deployment, nil)
 
     maybe_send_public_keys(device, socket, params)
@@ -60,6 +60,9 @@ defmodule NervesHubWeb.DeviceChannel do
 
     send(self(), :device_registration)
 
+    # Get device extension capabilities
+    push(socket, "extensions:get", %{})
+
     socket =
       socket
       |> assign(:device, device)
@@ -133,7 +136,10 @@ defmodule NervesHubWeb.DeviceChannel do
   end
 
   @decorate with_span("Channels.DeviceChannel.handle_info:deployments/update")
-  def handle_info({"deployments/update", inflight_update}, %{assigns: %{device: device}} = socket) do
+  def handle_info(
+        {"deployments/update", inflight_update},
+        %{assigns: %{device: device}} = socket
+      ) do
     payload = Devices.resolve_update(device)
 
     case payload.update_available do
@@ -147,7 +153,7 @@ defmodule NervesHubWeb.DeviceChannel do
           Devices.update_started!(
             inflight_update,
             device,
-            payload.deployment,
+            payload.deployment_group,
             socket.assigns.reference_id
           )
 
@@ -176,7 +182,7 @@ defmodule NervesHubWeb.DeviceChannel do
       Devices.update_started!(
         inflight_update,
         device,
-        update_payload.deployment,
+        update_payload.deployment_group,
         socket.assigns.reference_id
       )
 
@@ -205,9 +211,12 @@ defmodule NervesHubWeb.DeviceChannel do
     {:noreply, update_device(socket, device)}
   end
 
-  @decorate with_span("Channels.DeviceChannel.handle_info:deployment-updated")
+  @decorate with_span("Channels.DeviceChannel.handle_info:deployment-group-updated")
   def handle_info(
-        %Broadcast{event: "devices/deployment-updated", payload: %{deployment_id: deployment_id}},
+        %Broadcast{
+          event: "devices/deployment-updated",
+          payload: %{deployment_id: deployment_id}
+        },
         %{assigns: %{device: device}} = socket
       ) do
     device = %{device | deployment_id: deployment_id}
@@ -500,10 +509,10 @@ defmodule NervesHubWeb.DeviceChannel do
   defp update_device(socket, device) do
     socket
     |> assign(:device, device)
-    |> update_deployment_subscription(device)
+    |> update_deployment_group_subscription(device)
   end
 
-  defp update_deployment_subscription(socket, device) do
+  defp update_deployment_group_subscription(socket, device) do
     deployment_channel = deployment_channel(device)
 
     if deployment_channel != socket.assigns.deployment_channel do
@@ -530,7 +539,7 @@ defmodule NervesHubWeb.DeviceChannel do
     version_match = Version.match?(socket.assigns.device_api_version, ">= 2.0.0")
 
     if updates_enabled && version_match do
-      if archive = Archives.archive_for_deployment(device.deployment_id) do
+      if archive = Archives.archive_for_deployment_group(device.deployment_id) do
         if opts[:audit_log],
           do:
             DeviceTemplates.audit_device_archive_update_triggered(
diff --git a/lib/nerves_hub_web/components/deployment_page/activity.ex b/lib/nerves_hub_web/components/deployment_group_page/activity.ex
similarity index 92%
rename from lib/nerves_hub_web/components/deployment_page/activity.ex
rename to lib/nerves_hub_web/components/deployment_group_page/activity.ex
index 472e7d9e1..73681a57a 100644
--- a/lib/nerves_hub_web/components/deployment_page/activity.ex
+++ b/lib/nerves_hub_web/components/deployment_group_page/activity.ex
@@ -1,4 +1,4 @@
-defmodule NervesHubWeb.Components.DeploymentPage.Activity do
+defmodule NervesHubWeb.Components.DeploymentGroupPage.Activity do
   use NervesHubWeb, :live_component
 
   alias NervesHub.AuditLogs
@@ -14,7 +14,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Activity do
 
   defp logs_and_pager_assigns(socket, page_number \\ 1, page_size \\ 25) do
     {logs, audit_pager} =
-      AuditLogs.logs_for_feed(socket.assigns.deployment, %{
+      AuditLogs.logs_for_feed(socket.assigns.deployment_group, %{
         page: page_number,
         page_size: page_size
       })
@@ -35,7 +35,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Activity do
             <div class="text-base text-neutral-50 font-medium">Latest activity</div>
 
             <div class="p-1.5 rounded bg-zinc-800 border border-zinc-600">
-              <.link href={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/audit_logs/download"}>
+              <.link href={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/audit_logs/download"}>
                 <svg class="w-5 h-5" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
                   <path
                     d="M2.5 11.6666V14.1666C2.5 15.0871 3.24619 15.8333 4.16667 15.8333H15.8333C16.7538 15.8333 17.5 15.0871 17.5 14.1666V11.6666M10 4.16663V12.5M10 12.5L13.3333 9.16663M10 12.5L6.66667 9.16663"
@@ -91,7 +91,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Activity do
     params = %{"page_size" => page_size, "page_number" => 1}
 
     url =
-      ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/devices/#{socket.assigns.deployment.name}/activity?#{params}"
+      ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/devices/#{socket.assigns.deployment_group.name}/activity?#{params}"
 
     socket
     |> logs_and_pager_assigns(1, String.to_integer(page_size))
@@ -103,7 +103,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Activity do
     params = %{"page_size" => socket.assigns.audit_pager.page_size, "page_number" => page_num}
 
     url =
-      ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/devices/#{socket.assigns.deployment.name}/activity?#{params}"
+      ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/devices/#{socket.assigns.deployment_group.name}/activity?#{params}"
 
     socket
     |> logs_and_pager_assigns(
diff --git a/lib/nerves_hub_web/components/deployment_page/release_history.ex b/lib/nerves_hub_web/components/deployment_group_page/release_history.ex
similarity index 82%
rename from lib/nerves_hub_web/components/deployment_page/release_history.ex
rename to lib/nerves_hub_web/components/deployment_group_page/release_history.ex
index a89146f05..2f5eb084f 100644
--- a/lib/nerves_hub_web/components/deployment_page/release_history.ex
+++ b/lib/nerves_hub_web/components/deployment_group_page/release_history.ex
@@ -1,4 +1,4 @@
-defmodule NervesHubWeb.Components.DeploymentPage.ReleaseHistory do
+defmodule NervesHubWeb.Components.DeploymentGroupPage.ReleaseHistory do
   use NervesHubWeb, :live_component
 
   def update(assigns, socket) do
diff --git a/lib/nerves_hub_web/components/deployment_page/settings.ex b/lib/nerves_hub_web/components/deployment_group_page/settings.ex
similarity index 87%
rename from lib/nerves_hub_web/components/deployment_page/settings.ex
rename to lib/nerves_hub_web/components/deployment_group_page/settings.ex
index a2bc41475..2a77e31d7 100644
--- a/lib/nerves_hub_web/components/deployment_page/settings.ex
+++ b/lib/nerves_hub_web/components/deployment_group_page/settings.ex
@@ -1,25 +1,25 @@
-defmodule NervesHubWeb.Components.DeploymentPage.Settings do
+defmodule NervesHubWeb.Components.DeploymentGroupPage.Settings do
   use NervesHubWeb, :live_component
 
   alias NervesHub.Archives
   alias NervesHub.AuditLogs
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.Firmwares
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   @impl Phoenix.LiveComponent
   def update(assigns, socket) do
-    archives = Archives.all_by_product(assigns.deployment.product)
-    firmwares = Firmwares.get_firmwares_for_deployment(assigns.deployment)
+    archives = Archives.all_by_product(assigns.deployment_group.product)
+    firmwares = Firmwares.get_firmwares_for_deployment_group(assigns.deployment_group)
 
-    changeset = Deployment.changeset(assigns.deployment, %{})
+    changeset = DeploymentGroup.changeset(assigns.deployment_group, %{})
 
     socket
     |> assign(assigns)
     |> assign(:archives, archives)
-    |> assign(:firmware, assigns.deployment.firmware)
+    |> assign(:firmware, assigns.deployment_group.firmware)
     |> assign(:firmwares, firmwares)
     |> assign(:form, to_form(changeset))
     |> assign(
@@ -33,7 +33,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
   def render(assigns) do
     ~H"""
     <div class="flex flex-col items-start justify-between gap-4 p-6">
-      <.form for={@form} class="w-full flex flex-col gap-4" phx-submit="update-deployment" phx-target={@myself}>
+      <.form for={@form} class="w-full flex flex-col gap-4" phx-submit="update-deployment-group" phx-target={@myself}>
         <div class="w-2/3 flex flex-col bg-zinc-900 border border-zinc-700 rounded">
           <div class="flex justify-between items-center h-14 px-4 border-b border-zinc-700">
             <div class="text-base text-neutral-50 font-medium">General settings</div>
@@ -83,7 +83,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
           <div class="flex flex-col p-6 gap-6">
             <div class="flex flex-col gap-3">
               <p class="text-sm text-zinc-400 w-2/3">
-                These conditions are used for matching devices which don't have a configured deployment.
+                These conditions are used for matching devices which don't have a configured deployment group.
               </p>
               <p class="text-sm text-zinc-400 w-2/3">
                 The matching is undertaken when a device connects to the platform.
@@ -279,12 +279,12 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
             <.button
               type="link"
               style="danger"
-              phx-click="delete-deployment"
+              phx-click="delete-deployment-group"
               phx-target={@myself}
               aria-label="Delete"
               data-confirm={[
-                "Are you sure you want to delete this deployment?",
-                @deployment.device_count > 0 && " All devices assigned to this deployment will be assigned a new deployment when they reconnect. ",
+                "Are you sure you want to delete this deployment group?",
+                @deployment_group.device_count > 0 && " All devices assigned to this deployment group will be assigned a new deployment when they reconnect. ",
                 "This cannot be undone."
               ]}
             >
@@ -298,54 +298,62 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
   end
 
   @impl Phoenix.LiveComponent
-  def handle_event("update-deployment", %{"deployment" => params}, socket) do
-    %{org_user: org_user, org: org, product: product, user: user, deployment: deployment} =
+  def handle_event("update-deployment-group", %{"deployment_group" => params}, socket) do
+    %{
+      org_user: org_user,
+      org: org,
+      product: product,
+      user: user,
+      deployment_group: deployment_group
+    } =
       socket.assigns
 
-    authorized!(:"deployment:update", org_user)
+    authorized!(:"deployment_group:update", org_user)
 
     params = inject_conditions_map(params)
 
-    case Deployments.update_deployment(deployment, params) do
+    case ManagedDeployments.update_deployment_group(deployment_group, params) do
       {:ok, updated} ->
         # Use original deployment so changes will get
         # marked in audit log
         AuditLogs.audit!(
           user,
           updated,
-          "User #{user.name} updated deployment #{updated.name}"
+          "User #{user.name} updated deployment group #{updated.name}"
         )
 
         # TODO: if we move away from slugs with deployment names we won't need
         # to use `push_navigate` here.
         socket
-        |> LiveToast.put_toast(:info, "Deployment updated")
-        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments/#{updated.name}")
+        |> LiveToast.put_toast(:info, "Deployment group updated")
+        |> push_navigate(
+          to: ~p"/org/#{org.name}/#{product.name}/deployment_groups/#{updated.name}"
+        )
         |> noreply()
 
       {:error, changeset} ->
         socket
         |> send_toast(
           :error,
-          "An error occurred while updating the Deployment. Please check the form for errors."
+          "An error occurred while updating the deployment group. Please check the form for errors."
         )
         |> assign(:form, to_form(changeset))
         |> noreply()
     end
   end
 
-  def handle_event("delete-deployment", _params, socket) do
-    authorized!(:"deployment:delete", socket.assigns.org_user)
+  def handle_event("delete-deployment-group", _params, socket) do
+    authorized!(:"deployment_group:delete", socket.assigns.org_user)
 
-    %{deployment: deployment, org: org, product: product, user: user} = socket.assigns
+    %{deployment_group: deployment_group, org: org, product: product, user: user} = socket.assigns
 
-    {:ok, _} = Deployments.delete_deployment(deployment)
+    {:ok, _} = ManagedDeployments.delete_deployment_group(deployment_group)
 
-    DeploymentTemplates.audit_deployment_deleted(user, deployment)
+    DeploymentGroupTemplates.audit_deployment_deleted(user, deployment_group)
 
     socket
-    |> put_flash(:info, "Deployment successfully deleted")
-    |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments")
+    |> put_flash(:info, "Deployment group successfully deleted")
+    |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployment_groups")
     |> noreply()
   end
 
@@ -388,8 +396,8 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
     |> Enum.map(&[value: &1.id, key: firmware_display_name(&1)])
   end
 
-  def archive_dropdown_options(acrhives) do
-    acrhives
+  def archive_dropdown_options(archives) do
+    archives
     |> Enum.sort_by(
       fn archive ->
         case Version.parse(archive.version) do
@@ -412,16 +420,16 @@ defmodule NervesHubWeb.Components.DeploymentPage.Settings do
   defp help_message_for(field) do
     case field do
       :failure_threshold ->
-        "Maximum number of target devices from this deployment that can be in an unhealthy state before marking the deployment unhealthy."
+        "Maximum number of target devices from this deployment group that can be in an unhealthy state before marking the deployment group unhealthy."
 
       :failure_rate ->
-        "Maximum number of device install failures from this deployment within X seconds before being marked unhealthy."
+        "Maximum number of device install failures from this deployment group within X seconds before being marked unhealthy."
 
       :device_failure_rate ->
-        "Maximum number of device failures within X seconds a device can have for this deployment before being marked unhealthy."
+        "Maximum number of device failures within X seconds a device can have for this deployment group before being marked unhealthy."
 
       :device_failure_threshold ->
-        "Maximum number of install attempts and/or failures a device can have for this deployment before being marked unhealthy."
+        "Maximum number of install attempts and/or failures a device can have for this deployment group before being marked unhealthy."
 
       :penalty_timeout_minutes ->
         "Number of minutes a device is placed in the penalty box for reaching the failure rate and threshold."
diff --git a/lib/nerves_hub_web/components/deployment_page/summary.ex b/lib/nerves_hub_web/components/deployment_group_page/summary.ex
similarity index 72%
rename from lib/nerves_hub_web/components/deployment_page/summary.ex
rename to lib/nerves_hub_web/components/deployment_group_page/summary.ex
index 80bb818ea..b1d6cbc6a 100644
--- a/lib/nerves_hub_web/components/deployment_page/summary.ex
+++ b/lib/nerves_hub_web/components/deployment_group_page/summary.ex
@@ -1,18 +1,18 @@
-defmodule NervesHubWeb.Components.DeploymentPage.Summary do
+defmodule NervesHubWeb.Components.DeploymentGroupPage.Summary do
   use NervesHubWeb, :live_component
 
   alias NervesHub.Devices
 
   def update(%{update_inflight_info: true}, socket) do
-    deployment = socket.assigns.deployment
+    deployment_group = socket.assigns.deployment_group
 
-    inflight_updates = Devices.inflight_updates_for(deployment)
+    inflight_updates = Devices.inflight_updates_for(deployment_group)
 
     socket
     |> assign(:inflight_updates, inflight_updates)
-    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment))
-    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment))
-    |> assign(:updating_count, Devices.updating_count(deployment))
+    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment_group))
+    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment_group))
+    |> assign(:updating_count, Devices.updating_count(deployment_group))
     |> ok()
   end
 
@@ -31,12 +31,12 @@ defmodule NervesHubWeb.Components.DeploymentPage.Summary do
 
       <div :if={@waiting_for_update_count > 0} class="w-full h-24 box-content flex items-center justify-center rounded border border-zinc-700 bg-zinc-900">
         <div class="relative sticky top-0 w-full items-center justify-center rounded overflow-visible z-20">
-          <div class="z-40 absolute -top-px border-t rounded-tl border-success-500" role="progressbar" style={"width: #{deployment_percentage(@up_to_date_count, @deployment)}%"}>
+          <div class="z-40 absolute -top-px border-t rounded-tl border-success-500" role="progressbar" style={"width: #{deployment_group_percentage(@up_to_date_count, @deployment_group)}%"}>
             <div class="animate-pulse bg-progress-glow w-full h-16" />
           </div>
 
           <div class="flex flex-col gap-1 items-center justify-center my-1 py-2 px-2 bg-base-900/20 text-sm font-medium">
-            <div class="text-base">{deployment_percentage(@up_to_date_count, @deployment)}% of devices updated</div>
+            <div class="text-base">{deployment_group_percentage(@up_to_date_count, @deployment_group)}% of devices updated</div>
             <div>{@updating_count} device(s) updating - {@waiting_for_update_count} device(s) waiting</div>
           </div>
         </div>
@@ -52,21 +52,21 @@ defmodule NervesHubWeb.Components.DeploymentPage.Summary do
               <span class="text-sm text-nerves-gray-500 w-16">Firmware:</span>
 
               <.link
-                navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{@deployment.firmware.uuid}"}
+                navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{@deployment_group.firmware.uuid}"}
                 class="flex items-center gap-1 pl-1.5 pr-2.5 py-0.5 border border-zinc-700 rounded-full bg-zinc-800"
               >
-                <span class="text-xs text-zinc-300 tracking-tight">{@deployment.firmware.version} ({String.slice(@deployment.firmware.uuid, 0..7)})</span>
+                <span class="text-xs text-zinc-300 tracking-tight">{@deployment_group.firmware.version} ({String.slice(@deployment_group.firmware.uuid, 0..7)})</span>
               </.link>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500 w-16">Archive:</span>
 
               <.link
-                :if={@deployment.archive}
-                navigate={~p"/org/#{@org.name}/#{@product.name}/archives/#{@deployment.archive.uuid}"}
+                :if={@deployment_group.archive}
+                navigate={~p"/org/#{@org.name}/#{@product.name}/archives/#{@deployment_group.archive.uuid}"}
                 class="flex items-center gap-1 pl-1.5 pr-2.5 py-0.5 border border-zinc-700 rounded-full bg-zinc-800"
               >
-                <span class="text-xs text-zinc-300 tracking-tight">{@deployment.archive.version} ({String.slice(@deployment.archive.uuid, 0..7)})</span>
+                <span class="text-xs text-zinc-300 tracking-tight">{@deployment_group.archive.version} ({String.slice(@deployment_group.archive.uuid, 0..7)})</span>
               </.link>
               <span :if={is_nil(@deployment.archive)} class="pl-1 text-xs text-nerves-gray-500">No archive configured</span>
             </div>
@@ -101,46 +101,46 @@ defmodule NervesHubWeb.Components.DeploymentPage.Summary do
 
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500">Concurrent device updates:</span>
-              <span class="text-sm text-zinc-300">{@deployment.concurrent_updates}</span>
+              <span class="text-sm text-zinc-300">{@deployment_group.concurrent_updates}</span>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500">Minutes before expiring updates:</span>
-              <span class="text-sm text-zinc-300">{@deployment.inflight_update_expiration_minutes}</span>
+              <span class="text-sm text-zinc-300">{@deployment_group.inflight_update_expiration_minutes}</span>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500">Failure rate:</span>
               <span class="text-sm text-zinc-300">
-                <span class="font-bold">{@deployment.failure_rate_amount}</span> failures per <span class="font-bold">{@deployment.failure_rate_seconds}</span> seconds
+                <span class="font-bold">{@deployment_group.failure_rate_amount}</span> failures per <span class="font-bold">{@deployment_group.failure_rate_seconds}</span> seconds
               </span>
             </div>
 
             <div class="flex gap-4 items-center pb-6">
               <span class="text-sm text-nerves-gray-500">Failure threshold:</span>
-              <span class="text-sm text-zinc-300">{@deployment.failure_threshold}</span>
+              <span class="text-sm text-zinc-300">{@deployment_group.failure_threshold}</span>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500">Device failure rate:</span>
               <span class="text-sm text-zinc-300">
-                <span class="font-bold">{@deployment.device_failure_rate_amount}</span> failures per <span class="font-bold">{@deployment.device_failure_rate_seconds}</span> seconds
+                <span class="font-bold">{@deployment_group.device_failure_rate_amount}</span> failures per <span class="font-bold">{@deployment_group.device_failure_rate_seconds}</span> seconds
               </span>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500 w-40">Device failure threshold:</span>
-              <span class="text-sm text-zinc-300">{@deployment.device_failure_threshold}</span>
+              <span class="text-sm text-zinc-300">{@deployment_group.device_failure_threshold}</span>
             </div>
             <div class="flex gap-4 items-center pb-6">
               <span class="text-sm text-nerves-gray-500">Device penalty box timeout:</span>
-              <span class="text-sm text-zinc-300">{@deployment.penalty_timeout_minutes}</span>
+              <span class="text-sm text-zinc-300">{@deployment_group.penalty_timeout_minutes}</span>
             </div>
 
-            <div :if={!@deployment.connecting_code} class="flex gap-4 items-center">
+            <div :if={!@deployment_group.connecting_code} class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500">Code sent on device connection:</span>
               <span class="text-sm text-zinc-300">No code configured</span>
             </div>
-            <div :if={@deployment.connecting_code} class="flex gap-2 items-start">
+            <div :if={@deployment_group.connecting_code} class="flex gap-2 items-start">
               <span class="text-sm text-nerves-gray-500">Code sent on device connection:</span>
-              <pre :if={!@deployment.connecting_code} class="text-sm text-zinc-300">
-    {@deployment.connecting_code}
+              <pre :if={!@deployment_group.connecting_code} class="text-sm text-zinc-300">
+    {@deployment_group.connecting_code}
               </pre>
             </div>
           </div>
@@ -151,14 +151,14 @@ defmodule NervesHubWeb.Components.DeploymentPage.Summary do
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500 w-36">Tag selection:</span>
-              <span :if={Enum.empty?(@deployment.conditions["tags"])} class="text-sm text-nerves-gray-500">No tags configured</span>
-              <span :if={Enum.any?(@deployment.conditions["tags"])} class="flex gap-1">
-                <span :for={tag <- @deployment.conditions["tags"]} class="text-sm text-zinc-300 px-2 py-1 border border-zinc-800 bg-zinc-800 rounded">{tag}</span>
+              <span :if={Enum.empty?(@deployment_group.conditions["tags"])} class="text-sm text-nerves-gray-500">No tags configured</span>
+              <span :if={Enum.any?(@deployment_group.conditions["tags"])} class="flex gap-1">
+                <span :for={tag <- @deployment_group.conditions["tags"]} class="text-sm text-zinc-300 px-2 py-1 border border-zinc-800 bg-zinc-800 rounded">{tag}</span>
               </span>
             </div>
             <div class="flex gap-4 items-center">
               <span class="text-sm text-nerves-gray-500 w-36">Version requirement:</span>
-              <code class="text-sm text-zinc-300">{@deployment.conditions["version"]}</code>
+              <code class="text-sm text-zinc-300">{@deployment_group.conditions["version"]}</code>
             </div>
           </div>
         </div>
@@ -167,7 +167,7 @@ defmodule NervesHubWeb.Components.DeploymentPage.Summary do
     """
   end
 
-  defp deployment_percentage(up_to_date_count, deployment) do
-    floor(up_to_date_count / deployment.device_count * 100)
+  defp deployment_group_percentage(up_to_date_count, deployment_group) do
+    floor(up_to_date_count / deployment_group.device_count * 100)
   end
 end
diff --git a/lib/nerves_hub_web/components/device_page/details.ex b/lib/nerves_hub_web/components/device_page/details.ex
index afe05c193..2b5a5568f 100644
--- a/lib/nerves_hub_web/components/device_page/details.ex
+++ b/lib/nerves_hub_web/components/device_page/details.ex
@@ -4,13 +4,13 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
   require Logger
 
   alias NervesHub.AuditLogs.DeviceTemplates
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Alarms
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.Metrics
   alias NervesHub.Devices.UpdatePayload
   alias NervesHub.Firmwares
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Scripts
 
   alias NervesHub.Repo
@@ -35,7 +35,7 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
   def update(assigns, socket) do
     socket
     |> assign(assigns)
-    |> assign(:device, Repo.preload(assigns.device, :deployment))
+    |> assign(:device, Repo.preload(assigns.device, :deployment_group))
     |> assign(:device, Repo.preload(assigns.device, :latest_health))
     |> assign_support_scripts()
     |> assign(:firmwares, Firmwares.get_firmware_for_device(assigns.device))
@@ -44,7 +44,7 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
     |> assign(:alarms, Alarms.get_current_alarms_for_device(assigns.device))
     |> assign(:extension_overrides, extension_overrides(assigns.device, assigns.product))
     |> assign_metadata()
-    |> assign_deployments()
+    |> assign_deployment_groups()
     |> ok()
   end
 
@@ -66,11 +66,14 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
     assign(socket, :support_scripts, scripts)
   end
 
-  defp assign_deployments(%{assigns: %{device: %{status: :provisioned} = device}} = socket),
-    do: assign(socket, deployments: Deployments.eligible_deployments(device))
+  defp assign_deployment_groups(%{assigns: %{device: %{status: :provisioned} = device}} = socket),
+    do: assign(socket, deployment_groups: ManagedDeployments.eligible_deployment_groups(device))
 
-  defp assign_deployments(%{assigns: %{product: product}} = socket),
-    do: assign(socket, deployments: Deployments.get_deployments_by_product(product))
+  defp assign_deployment_groups(%{assigns: %{product: product}} = socket),
+    do:
+      assign(socket,
+        deployment_groups: ManagedDeployments.get_deployment_groups_by_product(product)
+      )
 
   def render(assigns) do
     ~H"""
@@ -275,27 +278,27 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
           </div>
 
           <div class="flex pt-2 px-4 pb-6 gap-4 items-center">
-            <span class="text-sm text-nerves-gray-500">Assigned deployment:</span>
-            <span :if={is_nil(@device.deployment)} class="text-sm text-nerves-gray-500">No assigned deployment</span>
+            <span class="text-sm text-nerves-gray-500">Assigned deployment group:</span>
+            <span :if={is_nil(@device.deployment_group)} class="text-sm text-nerves-gray-500">No assigned deployment group</span>
             <.link
-              :if={@device.deployment}
-              navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@device.deployment.name}"}
+              :if={@device.deployment_group}
+              navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@device.deployment_group.name}"}
               class="flex items-center gap-1 pl-1.5 pr-2.5 py-0.5 border border-zinc-700 rounded-full bg-zinc-800"
             >
               <svg class="w-1.5 h-1.5" viewBox="0 0 6 6" fill="none" xmlns="http://www.w3.org/2000/svg">
                 <circle cx="3" cy="3" r="3" fill="#10B981" />
               </svg>
-              <span class="text-xs text-zinc-300 tracking-tight" class="">{@device.deployment.name}</span>
+              <span class="text-xs text-zinc-300 tracking-tight" class="">{@device.deployment_group.name}</span>
             </.link>
 
             <button
-              :if={@device.deployment}
+              :if={@device.deployment_group}
               class="p-1 border border-red-500 rounded-full bg-zinc-800"
               data-confirm="Are you sure you want to remove the device from the deployment?"
-              aria-label="Remove device from the assigned deployment"
+              aria-label="Remove device from the assigned deployment group"
               type="button"
               phx-target={@myself}
-              phx-click="remove-from-deployment"
+              phx-click="remove-from-deployment-group"
             >
               <svg class="w-3 h-3" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
                 <path
@@ -309,22 +312,24 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
             </button>
           </div>
           <div :if={@device.status == :registered && @device.deployment_id} class="flex pt-2 px-4 pb-6 gap-4 items-center">
-            <span class="text-sm text-nerves-gray-500">Please note: The device will be removed from the deployment upon connection if the aarch and platform don't match.</span>
+            <span class="text-sm text-nerves-gray-500">Please note: The device will be removed from the deployment group upon connection if the arch and platform don't match.</span>
           </div>
 
-          <div :if={is_nil(@device.deployment) && Enum.any?(@deployments)} class="flex p-4 gap-4 items-center border-t border-zinc-700">
-            <form phx-target={@myself} phx-submit="set-deployment" class="flex gap-2 items-center w-full">
+          <div :if={is_nil(@device.deployment_group) && Enum.any?(@deployment_groups)} class="flex p-4 gap-4 items-center border-t border-zinc-700">
+            <form phx-target={@myself} phx-submit="set-deployment-group" class="flex gap-2 items-center w-full">
               <div class="grow grid grid-cols-1">
                 <select
                   name="deployment_id"
                   class="col-start-1 row-start-1 appearance-none border rounded border-zinc-600 bg-zinc-900 py-1.5 pl-3 pr-8 text-sm text-zinc-400 focus:outline focus:outline-1 focus:-outline-offset-1 focus:outline-indigo-500"
                 >
                   <option value="">Select a deployment</option>
-                  <option :for={deployment <- @deployments} value={deployment.id}>{deployment.name} - ({deployment.firmware.platform}, {deployment.firmware.architecture})</option>
+                  <option :for={deployment_group <- @deployment_groups} value={deployment_group.id}>
+                    {deployment_group.name} - ({deployment_group.firmware.platform}, {deployment_group.firmware.architecture})
+                  </option>
                 </select>
               </div>
               <.button type="submit" aria-label="Add to deployment" data-confirm="Are you sure you want to add the device to the deployment?">
-                Add to deployment
+                Add to deployment group
               </.button>
             </form>
             <div>
@@ -343,7 +348,7 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
           <div :if={@update_information.update_available && @device.deployment_id} class="flex p-4 gap-4 items-center justify-between border-t border-zinc-700">
             <div class="flex flex-col">
               <span>Update available</span>
-              <span class="text-sm text-nerves-gray-500">An update is available in the assigned deployment.</span>
+              <span class="text-sm text-nerves-gray-500">An update is available in the assigned deployment group.</span>
             </div>
 
             <.button
@@ -495,20 +500,20 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
     |> noreply()
   end
 
-  def handle_event("set-deployment", %{"deployment_id" => deployment_id}, socket) do
-    %{user: user, device: device, deployments: deployments} = socket.assigns
+  def handle_event("set-deployment-group", %{"deployment_id" => deployment_id}, socket) do
+    %{user: user, device: device, deployments_groups: deployment_groups} = socket.assigns
 
-    authorized!(:"device:set-deployment", socket.assigns.org_user)
+    authorized!(:"device:set-deployment-group", socket.assigns.org_user)
 
-    deployment = Enum.find(deployments, &(&1.id == String.to_integer(deployment_id)))
-    device = Devices.update_deployment(device, deployment)
-    _ = DeviceTemplates.audit_device_deployment_update(user, device, deployment)
+    deployment = Enum.find(deployment_groups, &(&1.id == String.to_integer(deployment_id)))
+    device = Devices.update_deployment_group(device, deployment)
+    _ = DeviceTemplates.audit_device_deployment_group_update(user, device, deployment)
 
     send(self(), :reload_device)
 
     socket
     |> assign(:device, device)
-    |> send_toast(:info, "Device successfully added to Deployment.")
+    |> send_toast(:info, "Device successfully added to Deployment Group.")
     |> noreply()
   end
 
@@ -517,11 +522,11 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
 
     %{device: device, user: user} = socket.assigns
 
-    deployment = NervesHub.Repo.preload(device.deployment, :firmware)
+    deployment_group = NervesHub.Repo.preload(device.deployment_group, :firmware)
 
-    case Devices.told_to_update(device, deployment) do
+    case Devices.told_to_update(device, deployment_group) do
       {:ok, _inflight_update} ->
-        DeviceTemplates.audit_pushed_available_update(user, device, deployment)
+        DeviceTemplates.audit_pushed_available_update(user, device, deployment_group)
 
         socket
         |> send_toast(:info, "Pushing available firmware update.")
@@ -573,14 +578,14 @@ defmodule NervesHubWeb.Components.DevicePage.Details do
     |> noreply()
   end
 
-  def handle_event("remove-from-deployment", _, %{assigns: %{device: device}} = socket) do
-    device = Devices.clear_deployment(device)
+  def handle_event("remove-from-deployment-group", _, %{assigns: %{device: device}} = socket) do
+    device = Devices.clear_deployment_group(device)
 
     send(self(), :reload_device)
 
     socket
     |> assign(:device, device)
-    |> send_toast(:info, "Device successfully removed from the deployment")
+    |> send_toast(:info, "Device successfully removed from the deployment group")
     |> noreply()
   end
 
diff --git a/lib/nerves_hub_web/components/navigation.ex b/lib/nerves_hub_web/components/navigation.ex
index 4e629739c..e20243ef4 100644
--- a/lib/nerves_hub_web/components/navigation.ex
+++ b/lib/nerves_hub_web/components/navigation.ex
@@ -23,7 +23,7 @@ defmodule NervesHubWeb.Components.Navigation do
           stroke-linejoin="round"
         />
       </.nav_link>
-      <.nav_link label="Deployments" path={~p"/org/#{@org.name}/#{@product.name}/deployments"} selected={:deployments == @selected_tab}>
+      <.nav_link label="Deployments" path={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"} selected={:deployments == @selected_tab}>
         <path
           d="M9.99992 2.5L14.1666 6.66667M9.99992 2.5L5.83325 6.66667M9.99992 2.5V10.8333M11.6667 15.8333C11.6667 16.7538 10.9205 17.5 10 17.5C9.07955 17.5 8.33335 16.7538 8.33335 15.8333C8.33335 14.9129 9.07955 14.1667 10 14.1667C10.9205 14.1667 11.6667 14.9129 11.6667 15.8333Z"
           stroke-width="1.2"
@@ -347,7 +347,7 @@ defmodule NervesHubWeb.Components.Navigation do
       %{
         title: "Deployments",
         active: "",
-        href: ~p"/org/#{assigns.org.name}/#{assigns.product.name}/deployments"
+        href: ~p"/org/#{assigns.org.name}/#{assigns.product.name}/deployment_groups"
       },
       %{
         title: "Scripts",
diff --git a/lib/nerves_hub_web/controllers/api/deployment_controller.ex b/lib/nerves_hub_web/controllers/api/deployment_group_controller.ex
similarity index 52%
rename from lib/nerves_hub_web/controllers/api/deployment_controller.ex
rename to lib/nerves_hub_web/controllers/api/deployment_group_controller.ex
index 2c0860459..3de5a083b 100644
--- a/lib/nerves_hub_web/controllers/api/deployment_controller.ex
+++ b/lib/nerves_hub_web/controllers/api/deployment_group_controller.ex
@@ -1,10 +1,10 @@
-defmodule NervesHubWeb.API.DeploymentController do
+defmodule NervesHubWeb.API.DeploymentGroupController do
   use NervesHubWeb, :api_controller
 
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.Firmwares
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   action_fallback(NervesHubWeb.API.FallbackController)
 
@@ -14,8 +14,8 @@ defmodule NervesHubWeb.API.DeploymentController do
   @whitelist_fields [:name, :org_id, :firmware_id, :conditions, :is_active]
 
   def index(%{assigns: %{product: product}} = conn, _params) do
-    deployments = Deployments.get_deployments_by_product(product)
-    render(conn, "index.json", deployments: deployments)
+    deployment_groups = ManagedDeployments.get_deployment_groups_by_product(product)
+    render(conn, "index.json", deployment_groups: deployment_groups)
   end
 
   def create(%{assigns: %{org: org, product: product, user: user}} = conn, params) do
@@ -28,44 +28,55 @@ defmodule NervesHubWeb.API.DeploymentController do
              params <- Map.put(params, "firmware_id", firmware.id),
              params <- Map.put(params, "org_id", org.id),
              params <- whitelist(params, @whitelist_fields),
-             {:ok, deployment} <- Deployments.create_deployment(params) do
-          DeploymentTemplates.audit_deployment_created(user, deployment)
+             {:ok, deployment_group} <- ManagedDeployments.create_deployment_group(params) do
+          DeploymentGroupTemplates.audit_deployment_created(user, deployment_group)
 
           conn
           |> put_status(:created)
           |> put_resp_header(
             "location",
-            Routes.api_deployment_path(conn, :show, org.name, product.name, deployment.name)
+            Routes.api_deployment_group_path(
+              conn,
+              :show,
+              org.name,
+              product.name,
+              deployment_group.name
+            )
           )
-          |> render("show.json", deployment: %{deployment | firmware: firmware})
+          |> render("show.json", deployment_group: %{deployment_group | firmware: firmware})
         end
     end
   end
 
   def show(%{assigns: %{org: _org, product: product}} = conn, %{"name" => name}) do
-    with {:ok, deployment} <- Deployments.get_deployment_by_name(product, name) do
-      render(conn, "show.json", deployment: deployment)
+    with {:ok, deployment_group} <- ManagedDeployments.get_deployment_group_by_name(product, name) do
+      render(conn, "show.json", deployment_group: deployment_group)
     end
   end
 
   def update(%{assigns: %{product: product, user: user}} = conn, %{
         "name" => name,
-        "deployment" => deployment_params
+        "deployment" => deployment_group_params
       }) do
-    with {:ok, deployment} <- Deployments.get_deployment_by_name(product, name),
-         {:ok, deployment_params} <- update_params(product, deployment_params),
-         deployment_params <- whitelist(deployment_params, @whitelist_fields),
-         {:ok, %Deployment{} = updated_deployment} <-
-           Deployments.update_deployment(deployment, deployment_params) do
-      DeploymentTemplates.audit_deployment_updated(user, deployment)
-
-      render(conn, "show.json", deployment: updated_deployment)
+    with {:ok, deployment_group} <-
+           ManagedDeployments.get_deployment_group_by_name(product, name),
+         {:ok, deployment_group_params} <- update_params(product, deployment_group_params),
+         deployment_group_params <- whitelist(deployment_group_params, @whitelist_fields),
+         {:ok, %DeploymentGroup{} = updated_deployment_group} <-
+           ManagedDeployments.update_deployment_group(
+             deployment_group,
+             deployment_group_params
+           ) do
+      DeploymentGroupTemplates.audit_deployment_updated(user, deployment_group)
+
+      render(conn, "show.json", deployment_group: updated_deployment_group)
     end
   end
 
   def delete(%{assigns: %{product: product}} = conn, %{"name" => name}) do
-    with {:ok, deployment} <- Deployments.get_deployment_by_name(product, name),
-         {:ok, _deployment} <- Deployments.delete_deployment(deployment) do
+    with {:ok, deployment_group} <-
+           ManagedDeployments.get_deployment_group_by_name(product, name),
+         {:ok, _deployment_group} <- ManagedDeployments.delete_deployment_group(deployment_group) do
       send_resp(conn, :no_content, "")
     end
   end
diff --git a/lib/nerves_hub_web/controllers/api/device_controller.ex b/lib/nerves_hub_web/controllers/api/device_controller.ex
index 01339bd76..0071db598 100644
--- a/lib/nerves_hub_web/controllers/api/device_controller.ex
+++ b/lib/nerves_hub_web/controllers/api/device_controller.ex
@@ -40,7 +40,7 @@ defmodule NervesHubWeb.API.DeviceController do
       |> Map.put("product_id", product.id)
 
     with {:ok, device} <- Devices.create_device(params) do
-      device = Repo.preload(device, [:org, :product, deployment: [:firmware]])
+      device = Repo.preload(device, [:org, :product, deployment_group: [:firmware]])
 
       conn
       |> put_status(:created)
@@ -85,7 +85,8 @@ defmodule NervesHubWeb.API.DeviceController do
   def update(%{assigns: %{org: org}} = conn, %{"identifier" => identifier} = params) do
     with {:ok, device} <- Devices.get_device_by_identifier(org, identifier),
          {:ok, updated_device} <- Devices.update_device(device, params) do
-      updated_device = Repo.preload(updated_device, [:org, :product, deployment: [:firmware]])
+      updated_device =
+        Repo.preload(updated_device, [:org, :product, deployment_group: [:firmware]])
 
       conn
       |> put_status(201)
@@ -99,7 +100,7 @@ defmodule NervesHubWeb.API.DeviceController do
          {:ok, %DeviceCertificate{device_id: device_id}} <-
            Devices.get_device_certificate_by_x509(cert),
          {:ok, device} <- Devices.get_device_by_org(org, device_id) do
-      device = Repo.preload(device, [:org, :product, deployment: [:firmware]])
+      device = Repo.preload(device, [:org, :product, deployment_group: [:firmware]])
 
       conn
       |> put_status(200)
diff --git a/lib/nerves_hub_web/controllers/api/fallback_controller.ex b/lib/nerves_hub_web/controllers/api/fallback_controller.ex
index e3caa123f..a6945f4e0 100644
--- a/lib/nerves_hub_web/controllers/api/fallback_controller.ex
+++ b/lib/nerves_hub_web/controllers/api/fallback_controller.ex
@@ -51,6 +51,6 @@ defmodule NervesHubWeb.API.FallbackController do
   end
 
   defp conflict_error?(error) do
-    error in [:deployments, :firmwares, :devices]
+    error in [:deployment_groups, :firmwares, :devices]
   end
 end
diff --git a/lib/nerves_hub_web/controllers/deployment_controller.ex b/lib/nerves_hub_web/controllers/deployment_group_controller.ex
similarity index 54%
rename from lib/nerves_hub_web/controllers/deployment_controller.ex
rename to lib/nerves_hub_web/controllers/deployment_group_controller.ex
index 22a166637..495158865 100644
--- a/lib/nerves_hub_web/controllers/deployment_controller.ex
+++ b/lib/nerves_hub_web/controllers/deployment_group_controller.ex
@@ -1,8 +1,8 @@
-defmodule NervesHubWeb.DeploymentController do
+defmodule NervesHubWeb.DeploymentGroupController do
   use NervesHubWeb, :controller
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
+  alias NervesHub.ManagedDeployments
 
   plug(:validate_role, org: :view)
 
@@ -10,18 +10,21 @@ defmodule NervesHubWeb.DeploymentController do
         %{assigns: %{org: org, product: product}} = conn,
         %{"name" => deployment_name}
       ) do
-    {:ok, deployment} = Deployments.get_deployment_by_name(product, deployment_name)
+    {:ok, deployment_group} =
+      ManagedDeployments.get_deployment_group_by_name(product, deployment_name)
 
-    case AuditLogs.logs_for(deployment) do
+    case AuditLogs.logs_for(deployment_group) do
       [] ->
         conn
-        |> put_flash(:error, "No audit logs exist for this deployment.")
-        |> redirect(to: ~p"/org/#{org.name}/#{product.name}/deployments")
+        |> put_flash(:error, "No audit logs exist for this deployment group.")
+        |> redirect(to: ~p"/org/#{org.name}/#{product.name}/deployment_groups")
 
       audit_logs ->
         audit_logs = AuditLogs.format_for_csv(audit_logs)
 
-        send_download(conn, {:binary, audit_logs}, filename: "#{deployment.name}-audit-logs.csv")
+        send_download(conn, {:binary, audit_logs},
+          filename: "#{deployment_group.name}-audit-logs.csv"
+        )
     end
   end
 end
diff --git a/lib/nerves_hub_web/helpers/authorization.ex b/lib/nerves_hub_web/helpers/authorization.ex
index 3f171b839..ba3755319 100644
--- a/lib/nerves_hub_web/helpers/authorization.ex
+++ b/lib/nerves_hub_web/helpers/authorization.ex
@@ -30,7 +30,10 @@ defmodule NervesHubWeb.Helpers.Authorization do
 
   def authorized?(:"device:create", %OrgUser{role: role}), do: role_check(:manage, role)
   def authorized?(:"device:update", %OrgUser{role: role}), do: role_check(:manage, role)
-  def authorized?(:"device:set-deployment", %OrgUser{role: role}), do: role_check(:manage, role)
+
+  def authorized?(:"device:set-deployment-group", %OrgUser{role: role}),
+    do: role_check(:manage, role)
+
   def authorized?(:"device:push-update", %OrgUser{role: role}), do: role_check(:manage, role)
   def authorized?(:"device:toggle-updates", %OrgUser{role: role}), do: role_check(:manage, role)
   def authorized?(:"device:clear-penalty-box", %OrgUser{role: ur}), do: role_check(:manage, ur)
@@ -47,10 +50,10 @@ defmodule NervesHubWeb.Helpers.Authorization do
   def authorized?(:"archive:upload", %OrgUser{role: role}), do: role_check(:manage, role)
   def authorized?(:"archive:delete", %OrgUser{role: role}), do: role_check(:manage, role)
 
-  def authorized?(:"deployment:create", %OrgUser{role: role}), do: role_check(:manage, role)
-  def authorized?(:"deployment:update", %OrgUser{role: role}), do: role_check(:manage, role)
-  def authorized?(:"deployment:toggle", %OrgUser{role: role}), do: role_check(:manage, role)
-  def authorized?(:"deployment:delete", %OrgUser{role: role}), do: role_check(:manage, role)
+  def authorized?(:"deployment_group:create", %OrgUser{role: role}), do: role_check(:manage, role)
+  def authorized?(:"deployment_group:update", %OrgUser{role: role}), do: role_check(:manage, role)
+  def authorized?(:"deployment_group:toggle", %OrgUser{role: role}), do: role_check(:manage, role)
+  def authorized?(:"deployment_group:delete", %OrgUser{role: role}), do: role_check(:manage, role)
 
   def authorized?(:"support_script:create", %OrgUser{role: role}), do: role_check(:manage, role)
   def authorized?(:"support_script:update", %OrgUser{role: role}), do: role_check(:manage, role)
diff --git a/lib/nerves_hub_web/live/dashboard/index.ex b/lib/nerves_hub_web/live/dashboard/index.ex
index a05f37951..3e39292c4 100644
--- a/lib/nerves_hub_web/live/dashboard/index.ex
+++ b/lib/nerves_hub_web/live/dashboard/index.ex
@@ -1,8 +1,8 @@
 defmodule NervesHubWeb.Live.Dashboard.Index do
   use NervesHubWeb, :updated_live_view
 
-  alias NervesHub.Deployments
   alias NervesHub.Devices
+  alias NervesHub.ManagedDeployments
 
   alias Phoenix.Socket.Broadcast
 
@@ -91,9 +91,9 @@ defmodule NervesHubWeb.Live.Dashboard.Index do
       devices = Devices.get_minimal_device_location_by_product(product)
 
       latest_firmwares =
-        Deployments.get_deployments_by_product(product)
-        |> Enum.reduce(%{}, fn deployment, acc ->
-          Map.put(acc, deployment.firmware.uuid, deployment.firmware.platform)
+        ManagedDeployments.get_deployment_groups_by_product(product)
+        |> Enum.reduce(%{}, fn deployment_group, acc ->
+          Map.put(acc, deployment_group.firmware.uuid, deployment_group.firmware.platform)
         end)
 
       map_markers =
diff --git a/lib/nerves_hub_web/live/deployments/edit.ex b/lib/nerves_hub_web/live/deployment_groups/edit.ex
similarity index 65%
rename from lib/nerves_hub_web/live/deployments/edit.ex
rename to lib/nerves_hub_web/live/deployment_groups/edit.ex
index e54664893..27e8e4804 100644
--- a/lib/nerves_hub_web/live/deployments/edit.ex
+++ b/lib/nerves_hub_web/live/deployment_groups/edit.ex
@@ -1,56 +1,64 @@
-defmodule NervesHubWeb.Live.Deployments.Edit do
+defmodule NervesHubWeb.Live.DeploymentGroups.Edit do
   use NervesHubWeb, :updated_live_view
 
   alias NervesHub.Archives
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.Firmwares
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   @impl Phoenix.LiveView
   def mount(params, _session, socket) do
     %{"name" => name} = params
     %{product: product} = socket.assigns
 
-    deployment = Deployments.get_by_product_and_name!(product, name)
+    deployment_group = ManagedDeployments.get_by_product_and_name!(product, name)
 
-    current_device_count = Deployments.get_device_count(deployment)
+    current_device_count = ManagedDeployments.get_device_count(deployment_group)
 
-    archives = Archives.all_by_product(deployment.product)
-    firmwares = Firmwares.get_firmwares_for_deployment(deployment)
+    archives = Archives.all_by_product(deployment_group.product)
+    firmwares = Firmwares.get_firmwares_for_deployment_group(deployment_group)
 
-    changeset = Deployment.changeset(deployment, %{}) |> tags_to_string()
+    changeset = DeploymentGroup.changeset(deployment_group, %{}) |> tags_to_string()
 
     socket
     |> assign(:archives, archives)
     |> sidebar_tab(:deployments)
-    |> assign(:deployment, deployment)
+    |> assign(:deployment_group, deployment_group)
     |> assign(:current_device_count, current_device_count)
-    |> assign(:firmware, deployment.firmware)
+    |> assign(:firmware, deployment_group.firmware)
     |> assign(:firmwares, firmwares)
     |> assign(:form, to_form(changeset))
     |> ok()
   end
 
   @impl Phoenix.LiveView
-  def handle_event("update-deployment", %{"deployment" => params}, socket) do
-    %{org_user: org_user, org: org, product: product, user: user, deployment: deployment} =
+  def handle_event("update-deployment-group", %{"deployment_group" => params}, socket) do
+    %{
+      org_user: org_user,
+      org: org,
+      product: product,
+      user: user,
+      deployment_group: deployment_group
+    } =
       socket.assigns
 
-    authorized!(:"deployment:update", org_user)
+    authorized!(:"deployment_group:update", org_user)
 
     params = inject_conditions_map(params)
 
-    case Deployments.update_deployment(deployment, params) do
+    case ManagedDeployments.update_deployment_group(deployment_group, params) do
       {:ok, updated} ->
         # Use original deployment so changes will get
         # marked in audit log
-        DeploymentTemplates.audit_deployment_updated(user, updated)
+        DeploymentGroupTemplates.audit_deployment_updated(user, updated)
 
         socket
-        |> put_flash(:info, "Deployment updated")
-        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments/#{updated.name}")
+        |> put_flash(:info, "Deployment Group updated")
+        |> push_navigate(
+          to: ~p"/org/#{org.name}/#{product.name}/deployment_groups/#{updated.name}"
+        )
         |> noreply()
 
       {:error, changeset} ->
@@ -97,8 +105,8 @@ defmodule NervesHubWeb.Live.Deployments.Edit do
     |> Enum.map(&[value: &1.id, key: firmware_display_name(&1)])
   end
 
-  def archive_dropdown_options(acrhives) do
-    acrhives
+  def archive_dropdown_options(archives) do
+    archives
     |> Enum.sort_by(
       fn archive ->
         case Version.parse(archive.version) do
@@ -121,16 +129,16 @@ defmodule NervesHubWeb.Live.Deployments.Edit do
   defp help_message_for(field) do
     case field do
       :failure_threshold ->
-        "Maximum number of target devices from this deployment that can be in an unhealthy state before marking the deployment unhealthy"
+        "Maximum number of target devices from this deployment group that can be in an unhealthy state before deployment group is marked unhealthy"
 
       :failure_rate ->
-        "Maximum number of device install failures from this deployment within X seconds before being marked unhealthy"
+        "Maximum number of device install failures from this deployment group within X seconds before being marked unhealthy"
 
       :device_failure_rate ->
-        "Maximum number of device failures within X seconds a device can have for this deployment before being marked unhealthy"
+        "Maximum number of device failures within X seconds a device can have for this deployment group before being marked unhealthy"
 
       :device_failure_threshold ->
-        "Maximum number of install attempts and/or failures a device can have for this deployment before being marked unhealthy"
+        "Maximum number of install attempts and/or failures a device can have for this deployment group before being marked unhealthy"
 
       :penalty_timeout_minutes ->
         "Number of minutes a device is placed in the penalty box for reaching the failure rate and threshold"
diff --git a/lib/nerves_hub_web/live/deployments/edit.html.heex b/lib/nerves_hub_web/live/deployment_groups/edit.html.heex
similarity index 95%
rename from lib/nerves_hub_web/live/deployments/edit.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/edit.html.heex
index 209fd81d6..344b98ffc 100644
--- a/lib/nerves_hub_web/live/deployments/edit.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/edit.html.heex
@@ -1,7 +1,7 @@
-<.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}"} class="back-link">
-  Back to Deployment
+<.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}"} class="back-link">
+  Back to Deployment Group
 </.link>
-<h1>Edit Deployment</h1>
+<h1>Edit Deployment Group</h1>
 
 <h5 class="mb-2">Firmware version details</h5>
 <div class="x5-grid">
@@ -34,11 +34,11 @@
 
 <div class="divider"></div>
 
-<.form :let={f} for={@form} phx-submit="update-deployment">
+<.form :let={f} for={@form} phx-submit="update-deployment-group">
   {hidden_input(f, :firmware_id, value: @firmware.id)}
 
   <div class="form-group">
-    <label for="name_input">Deployment name</label>
+    <label for="name_input">Deployment Group name</label>
     {text_input(f, :name, class: "form-control", id: "name_input")}
     <div class="has-error">{error_tag(f, :name)}</div>
   </div>
@@ -66,7 +66,7 @@
   </div>
 
   <h3 class="mb-2">Device matching conditions</h3>
-  <p>These conditions are used for matching devices which don't have a configured deployment. The matching is undertaken when a device connects to the platform.</p>
+  <p>These conditions are used for matching devices which don't have a configured deployment group. The matching is undertaken when a device connects to the platform.</p>
   <div class="form-group">
     <label for="tags_input" class="tooltip-label">
       Tag(s) distributed to
@@ -124,7 +124,7 @@
     Show Advanced Options
   </button>
 
-  <div class="x2-grid deployment-form collapse" id="advancedOptionsToggle">
+  <div class="x2-grid deployment-group-form collapse" id="advancedOptionsToggle">
     <div class="form-group">
       <label for="failure_rate_amount" class="tooltip-label">
         <span>Failure rate</span>
diff --git a/lib/nerves_hub_web/live/deployments/index-new.html.heex b/lib/nerves_hub_web/live/deployment_groups/index-new.html.heex
similarity index 82%
rename from lib/nerves_hub_web/live/deployments/index-new.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/index-new.html.heex
index 4824a2de7..6653e97cf 100644
--- a/lib/nerves_hub_web/live/deployments/index-new.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/index-new.html.heex
@@ -15,17 +15,17 @@
 
 <div class="h-0 flex-1 overflow-y-auto">
   <div class="flex items-center h-[90px] gap-4 px-6 py-7 border-b border-[#3F3F46] text-sm font-medium">
-    <h1 class="text-xl leading-[30px] font-semibold text-neutral-50">All Deployments</h1>
+    <h1 class="text-xl leading-[30px] font-semibold text-neutral-50">All Deployment Groups</h1>
     <div class="rounded-sm bg-zinc-800 text-xs text-zinc-300 px-1.5 py-0.5 mr-auto">{@pager_meta.total_count}</div>
-    <.button type="link" navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/newz"} aria-label="Add a new deployment">
-      <.icon name="add" /> Create Deployment
+    <.button type="link" navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/newz"} aria-label="Add a new deployment group">
+      <.icon name="add" /> Create Deployment Group
     </.button>
   </div>
 
   <%= if Enum.empty?(@entries) do %>
     <!-- TODO: Go over empty-state with new design -->
     <div class="h-full pb-16 flex items-center justify-center">
-      <span class="text-xl font-medium text-neutral-50">{@product.name} doesn’t have any deployments configured.</span>
+      <span class="text-xl font-medium text-neutral-50">{@product.name} doesn’t have any deployment groups configured.</span>
     </div>
   <% else %>
     <div class="listing">
@@ -53,35 +53,35 @@
           </tr>
         </thead>
         <tbody>
-          <tr :for={deployment <- @entries} class={["border-b border-zinc-800"]}>
+          <tr :for={deployment_group <- @entries} class={["border-b border-zinc-800"]}>
             <td>
-              <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{deployment.name}"}>
+              <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{deployment_group.name}"}>
                 <div class="h-[40px] w-full flex gap-[8px] items-center">
-                  <svg class={["size-1.5", (deployment.is_active && "fill-emerald-500") || "fill-zinc-500"]} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 6 6">
+                  <svg class={["size-1.5", (deployment_group.is_active && "fill-emerald-500") || "fill-zinc-500"]} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 6 6">
                     <circle cx="3" cy="3" r="3" />
                   </svg>
 
-                  {deployment.name}
+                  {deployment_group.name}
                 </div>
               </.link>
             </td>
 
             <td>
-              {deployment.firmware.platform}
+              {deployment_group.firmware.platform}
             </td>
 
             <td>
-              {deployment.firmware.architecture}
+              {deployment_group.firmware.architecture}
             </td>
 
             <td>
-              {deployment.device_count}
+              {deployment_group.device_count}
             </td>
 
             <td>
               <span class="inline-block h-7 py-1 px-2 items-center rounded bg-zinc-800">
-                <.link navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{deployment.firmware.uuid}"} class="flex items-center">
-                  <span class="text-sm text-base-300 mr-1">{deployment.firmware.version} ({String.slice(deployment.firmware.uuid, 0..7)})</span>
+                <.link navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{deployment_group.firmware.uuid}"} class="flex items-center">
+                  <span class="text-sm text-base-300 mr-1">{deployment_group.firmware.version} ({String.slice(deployment_group.firmware.uuid, 0..7)})</span>
                   <svg class="w-4 h-4" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
                     <path
                       d="M8 10V8M8 6V5.99333M14 8C14 11.3137 11.3137 14 8 14C4.68629 14 2 11.3137 2 8C2 4.68629 4.68629 2 8 2C11.3137 2 14 4.68629 14 8Z"
@@ -97,8 +97,8 @@
 
             <td>
               <div class="flex items-center gap-[4px]">
-                <%= if Enum.count(tags(deployment)) > 0 do %>
-                  <%= for tag <- tags(deployment) do %>
+                <%= if Enum.count(tags(deployment_group)) > 0 do %>
+                  <%= for tag <- tags(deployment_group) do %>
                     <span class="badge">
                       {tag}
                     </span>
diff --git a/lib/nerves_hub_web/live/deployments/index.ex b/lib/nerves_hub_web/live/deployment_groups/index.ex
similarity index 77%
rename from lib/nerves_hub_web/live/deployments/index.ex
rename to lib/nerves_hub_web/live/deployment_groups/index.ex
index 836e6daab..85531fdb6 100644
--- a/lib/nerves_hub_web/live/deployments/index.ex
+++ b/lib/nerves_hub_web/live/deployment_groups/index.ex
@@ -1,9 +1,9 @@
-defmodule NervesHubWeb.Live.Deployments.Index do
+defmodule NervesHubWeb.Live.DeploymentGroups.Index do
   use NervesHubWeb, :updated_live_view
 
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   alias NervesHubWeb.Components.Pager
   alias NervesHubWeb.Components.Sorting
@@ -12,20 +12,20 @@ defmodule NervesHubWeb.Live.Deployments.Index do
 
   @impl Phoenix.LiveView
   def mount(_params, _session, %{assigns: %{product: product}} = socket) do
-    deployments = Deployments.get_deployments_by_product(product)
-    counts = Deployments.get_device_counts_by_product(product)
+    deployment_groups = ManagedDeployments.get_deployment_groups_by_product(product)
+    counts = ManagedDeployments.get_device_counts_by_product(product)
 
-    deployments =
-      deployments
+    deployment_groups =
+      deployment_groups
       |> Enum.sort_by(& &1.name)
-      |> Enum.group_by(fn deployment ->
-        deployment.firmware.platform
+      |> Enum.group_by(fn deployment_group ->
+        deployment_group.firmware.platform
       end)
 
     socket
     |> page_title("Deployments - #{product.name}")
     |> sidebar_tab(:deployments)
-    |> assign(:deployments, deployments)
+    |> assign(:deployment_groups, deployment_groups)
     |> assign(:counts, counts)
     |> ok()
   end
@@ -34,7 +34,7 @@ defmodule NervesHubWeb.Live.Deployments.Index do
   def handle_params(params, _url, socket) do
     socket
     |> assign(:params, params)
-    |> assign_deployments_with_pagination()
+    |> assign_deployment_groups_with_pagination()
     |> noreply()
   end
 
@@ -82,7 +82,7 @@ defmodule NervesHubWeb.Live.Deployments.Index do
     |> noreply()
   end
 
-  defp assign_deployments_with_pagination(socket) do
+  defp assign_deployment_groups_with_pagination(socket) do
     %{assigns: %{product: product, params: params}} = socket
 
     pagination_opts = Map.take(params, @pagination_opts)
@@ -94,7 +94,7 @@ defmodule NervesHubWeb.Live.Deployments.Index do
       sort_direction: pagination_opts["sort_direction"]
     }
 
-    {entries, pager_meta} = Deployments.filter(product, opts)
+    {entries, pager_meta} = ManagedDeployments.filter(product, opts)
 
     socket
     |> assign(:current_sort, opts.sort)
@@ -112,7 +112,7 @@ defmodule NervesHubWeb.Live.Deployments.Index do
       stringify_keys(new_params)
       |> Enum.into(current_params)
 
-    ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/deployments?#{params}"
+    ~p"/org/#{socket.assigns.org.name}/#{socket.assigns.product.name}/deployment_groups?#{params}"
   end
 
   defp stringify_keys(params) do
@@ -129,8 +129,8 @@ defmodule NervesHubWeb.Live.Deployments.Index do
     "#{f.version} #{f.uuid}"
   end
 
-  defp version(%Deployment{conditions: %{"version" => ""}}), do: "-"
-  defp version(%Deployment{conditions: %{"version" => version}}), do: version
+  defp version(%DeploymentGroup{conditions: %{"version" => ""}}), do: "-"
+  defp version(%DeploymentGroup{conditions: %{"version" => version}}), do: version
 
-  defp tags(%Deployment{conditions: %{"tags" => tags}}), do: tags
+  defp tags(%DeploymentGroup{conditions: %{"tags" => tags}}), do: tags
 end
diff --git a/lib/nerves_hub_web/live/deployments/index.html.heex b/lib/nerves_hub_web/live/deployment_groups/index.html.heex
similarity index 74%
rename from lib/nerves_hub_web/live/deployments/index.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/index.html.heex
index 509763b0e..90e5dbab0 100644
--- a/lib/nerves_hub_web/live/deployments/index.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/index.html.heex
@@ -1,4 +1,4 @@
-<%= if Enum.empty?(@deployments) do %>
+<%= if Enum.empty?(@deployment_groups) do %>
   <div class="no-results-blowup-wrapper">
     <img src="/images/deployment.svg" alt="No deployments" />
     <h3 style="margin-top: 2.75rem">{@product.name} doesn’t have any deployments configured</h3>
@@ -11,14 +11,14 @@
   </div>
 <% else %>
   <div class="action-row">
-    <h1>Deployments</h1>
+    <h1>Deployment Groups</h1>
     <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/new"} class="btn btn-outline-light btn-action" aria-label="Create deployment">
       <span class="button-icon add"></span>
       <span class="action-text">Create Deployment</span>
     </.link>
   </div>
 
-  <%= for {platform, deployments} <- @deployments do %>
+  <%= for {platform, deployment_groups} <- @deployment_groups do %>
     <h3 class="mt-4">{platform}</h3>
 
     <table class="table table-sm table-hover">
@@ -32,31 +32,31 @@
           <th>Version requirement</th>
         </tr>
       </thead>
-      <tr :for={deployment <- deployments} class="item">
+      <tr :for={deployment_group <- deployment_groups} class="item">
         <td>
           <div class="mobile-label help-text">Name</div>
           <div>
-            <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{deployment.name}"}>{deployment.name}</.link>
+            <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{deployment_group.name}"}>{deployment_group.name}</.link>
           </div>
         </td>
         <td>
           <div class="mobile-label help-text">State</div>
-          <div class={"deployment-state state-#{if deployment.is_active, do: "on", else: "off"}"}>
-            {if deployment.is_active, do: "On", else: "Off"}
+          <div class={"deployment-group-state state-#{if deployment_group.is_active, do: "on", else: "off"}"}>
+            {if deployment_group.is_active, do: "On", else: "Off"}
           </div>
         </td>
         <td>
           <div class="mobile-label help-text">Devices</div>
           <div>
-            {@counts[deployment.id]}
+            {@counts[deployment_group.id]}
           </div>
         </td>
         <td>
           <div class="mobile-label help-text">Firmware version</div>
           <div>
-            <.link navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{deployment.firmware.uuid}"}>
+            <.link navigate={~p"/org/#{@org.name}/#{@product.name}/firmware/#{deployment_group.firmware.uuid}"}>
               <span class="badge ff-m">
-                {firmware_simple_display_name(deployment.firmware)}
+                {firmware_simple_display_name(deployment_group.firmware)}
               </span>
             </.link>
           </div>
@@ -64,8 +64,8 @@
         <td>
           <div class="mobile-label help-text">Distributed to</div>
           <div>
-            <%= if Enum.count(tags(deployment)) > 0 do %>
-              <%= for tag <- tags(deployment) do %>
+            <%= if Enum.count(tags(deployment_group)) > 0 do %>
+              <%= for tag <- tags(deployment_group) do %>
                 <span class="badge">
                   {tag}
                 </span>
@@ -77,17 +77,17 @@
         </td>
         <td>
           <div class="mobile-label help-text">Version requirement</div>
-          {version(deployment)}
+          {version(deployment_group)}
         </td>
         <td class="actions">
           <div class="mobile-label help-text">Actions</div>
           <div class="dropdown options">
-            <a class="dropdown-toggle options" href="#" id={"deployment-#{deployment.id}"} data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+            <a class="dropdown-toggle options" href="#" id={"deployment-#{deployment_group.id}"} data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
               <div class="mobile-label pr-2">Open</div>
               <img src="/images/icons/more.svg" alt="options" />
             </a>
             <div class="dropdown-menu dropdown-menu-right">
-              <a class="dropdown-item" aria-label="Download Audit Logs" href={~p"/org/#{@org.name}/#{@product.name}/deployments/#{deployment.name}/audit_logs/download"}>
+              <a class="dropdown-item" aria-label="Download Audit Logs" href={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{deployment_group.name}/audit_logs/download"}>
                 <div class="button-icon download"></div>
                 <span class="action-text">Download Audit Logs</span>
               </a>
diff --git a/lib/nerves_hub_web/live/deployments/new.ex b/lib/nerves_hub_web/live/deployment_groups/new.ex
similarity index 79%
rename from lib/nerves_hub_web/live/deployments/new.ex
rename to lib/nerves_hub_web/live/deployment_groups/new.ex
index dd3ddf112..2469fb20e 100644
--- a/lib/nerves_hub_web/live/deployments/new.ex
+++ b/lib/nerves_hub_web/live/deployment_groups/new.ex
@@ -1,11 +1,11 @@
-defmodule NervesHubWeb.Live.Deployments.New do
+defmodule NervesHubWeb.Live.DeploymentGroups.New do
   use NervesHubWeb, :updated_live_view
 
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.Firmwares
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   @impl Phoenix.LiveView
   def mount(_params, _session, %{assigns: %{org: org, product: product}} = socket) do
@@ -13,7 +13,10 @@ defmodule NervesHubWeb.Live.Deployments.New do
 
     if Enum.empty?(firmware) do
       socket
-      |> put_flash(:error, "You must upload a firmware version before creating a deployment")
+      |> put_flash(
+        :error,
+        "You must upload a firmware version before creating a Deployment Group"
+      )
       |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/firmware/upload")
       |> ok()
     else
@@ -27,14 +30,14 @@ defmodule NervesHubWeb.Live.Deployments.New do
       |> sidebar_tab(:deployments)
       |> assign(:platforms, platforms)
       |> assign(:platform, nil)
-      |> assign(:form, to_form(Ecto.Changeset.change(%Deployment{})))
+      |> assign(:form, to_form(Ecto.Changeset.change(%DeploymentGroup{})))
       |> ok()
     end
   end
 
   @impl Phoenix.LiveView
   def handle_event("select-platform", %{"platform" => platform}, socket) do
-    authorized!(:"deployment:create", socket.assigns.org_user)
+    authorized!(:"deployment_group:create", socket.assigns.org_user)
 
     %{product: product} = socket.assigns
 
@@ -47,14 +50,14 @@ defmodule NervesHubWeb.Live.Deployments.New do
 
     socket
     |> assign(:firmwares, firmwares)
-    |> assign(:form, to_form(Ecto.Changeset.change(%Deployment{})))
+    |> assign(:form, to_form(Ecto.Changeset.change(%DeploymentGroup{})))
     |> assign(:platform, platform)
     |> noreply()
   end
 
   # @impl Phoenix.LiveView
-  def handle_event("create-deployment", %{"deployment" => params}, socket) do
-    authorized!(:"deployment:create", socket.assigns.org_user)
+  def handle_event("create-deployment-group", %{"deployment_group" => params}, socket) do
+    authorized!(:"deployment_group:create", socket.assigns.org_user)
 
     %{user: user, org: org, product: product} = socket.assigns
 
@@ -69,7 +72,7 @@ defmodule NervesHubWeb.Live.Deployments.New do
     |> Firmwares.get_firmware(params[:firmware_id])
     |> case do
       {:ok, firmware} ->
-        {firmware, Deployments.create_deployment(params)}
+        {firmware, ManagedDeployments.create_deployment_group(params)}
 
       {:error, :not_found} ->
         {:error, :not_found}
@@ -80,12 +83,12 @@ defmodule NervesHubWeb.Live.Deployments.New do
         |> put_flash(:error, "Invalid firmware selected")
         |> noreply()
 
-      {_, {:ok, deployment}} ->
-        DeploymentTemplates.audit_deployment_created(user, deployment)
+      {_, {:ok, deployment_group}} ->
+        DeploymentGroupTemplates.audit_deployment_created(user, deployment_group)
 
         socket
-        |> put_flash(:info, "Deployment created")
-        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments")
+        |> put_flash(:info, "Deployment Group created")
+        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployment_groups")
         |> noreply()
 
       {_firmware, {:error, changeset}} ->
diff --git a/lib/nerves_hub_web/live/deployments/new.html.heex b/lib/nerves_hub_web/live/deployment_groups/new.html.heex
similarity index 86%
rename from lib/nerves_hub_web/live/deployments/new.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/new.html.heex
index eea2684c6..0af3840d2 100644
--- a/lib/nerves_hub_web/live/deployments/new.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/new.html.heex
@@ -1,4 +1,4 @@
-<h1>Create Deployment</h1>
+<h1>Create Deployment Group</h1>
 
 <%= unless @platform do %>
   <.form :let={f} for={%{}} phx-change="select-platform">
@@ -14,15 +14,15 @@
     </div>
 
     <div class="button-submit-wrapper">
-      <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments"} class="btn btn-secondary">
+      <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"} class="btn btn-secondary">
         Cancel
       </.link>
     </div>
   </.form>
 <% else %>
-  <.form :let={f} for={@form} phx-submit="create-deployment">
+  <.form :let={f} for={@form} phx-submit="create-deployment-group">
     <div class="form-group">
-      <label for="name_input">Deployment name</label>
+      <label for="name_input">Deployment Group name</label>
       {text_input(f, :name, class: "form-control", id: "name_input")}
       <div class="has-error">{error_tag(f, :name)}</div>
     </div>
@@ -33,7 +33,7 @@
           Firmware version
         </label>
         <span class="tooltip-info mb-1"></span>
-        <span class="tooltip-text">Once selected, deployments will use the same platform and architecture going forward.</span>
+        <span class="tooltip-text">Once selected, deployment groups will use the same platform and architecture going forward.</span>
       </div>
       {select(f, :firmware_id, firmware_dropdown_options(@firmwares), prompt: "Choose a firmware version", required: true, id: "firmware_id", class: "form-control")}
       <div class="select-icon"></div>
@@ -69,7 +69,7 @@
     </div>
 
     <div class="button-submit-wrapper">
-      <.link class="btn btn-secondary" navigate={~p"/org/#{@org.name}/#{@product.name}/deployments"}>Back</.link>
+      <.link class="btn btn-secondary" navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"}>Back</.link>
       {submit("Create Deployment", class: "btn btn-primary")}
     </div>
   </.form>
diff --git a/lib/nerves_hub_web/live/deployments/newz.ex b/lib/nerves_hub_web/live/deployment_groups/newz.ex
similarity index 82%
rename from lib/nerves_hub_web/live/deployments/newz.ex
rename to lib/nerves_hub_web/live/deployment_groups/newz.ex
index f4545fe53..8649b72d4 100644
--- a/lib/nerves_hub_web/live/deployments/newz.ex
+++ b/lib/nerves_hub_web/live/deployment_groups/newz.ex
@@ -1,8 +1,8 @@
-defmodule NervesHubWeb.Live.Deployments.Newz do
+defmodule NervesHubWeb.Live.DeploymentGroups.Newz do
   use NervesHubWeb, :updated_live_view
 
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Firmwares
   alias NervesHub.Firmwares.Firmware
 
@@ -24,14 +24,14 @@ defmodule NervesHubWeb.Live.Deployments.Newz do
       |> assign(:platform, nil)
       |> assign(:architecture, nil)
       |> assign(:firmwares, [])
-      |> assign(:form, to_form(Deployments.new_deployment()))
+      |> assign(:form, to_form(ManagedDeployments.new_deployment_group()))
       |> ok()
     end
   end
 
   @impl Phoenix.LiveView
   def handle_event("platform-selected", %{"deployment" => %{"platform" => platform}}, socket) do
-    authorized!(:"deployment:create", socket.assigns.org_user)
+    authorized!(:"deployment_group:create", socket.assigns.org_user)
 
     %{product: product} = socket.assigns
 
@@ -51,7 +51,7 @@ defmodule NervesHubWeb.Live.Deployments.Newz do
         %{"deployment" => %{"architecture" => architecture}},
         socket
       ) do
-    authorized!(:"deployment:create", socket.assigns.org_user)
+    authorized!(:"deployment_group:create", socket.assigns.org_user)
 
     %{product: product} = socket.assigns
 
@@ -65,8 +65,8 @@ defmodule NervesHubWeb.Live.Deployments.Newz do
   end
 
   # @impl Phoenix.LiveView
-  def handle_event("create-deployment", %{"deployment" => params}, socket) do
-    authorized!(:"deployment:create", socket.assigns.org_user)
+  def handle_event("create-deployment-group", %{"deployment_group" => params}, socket) do
+    authorized!(:"deployment_group:create", socket.assigns.org_user)
 
     %{user: user, org: org, product: product} = socket.assigns
 
@@ -81,7 +81,7 @@ defmodule NervesHubWeb.Live.Deployments.Newz do
     |> Firmwares.get_firmware(params[:firmware_id])
     |> case do
       {:ok, firmware} ->
-        {firmware, Deployments.create_deployment(params)}
+        {firmware, ManagedDeployments.create_deployment_group(params)}
 
       {:error, :not_found} ->
         {:error, :not_found}
@@ -92,12 +92,12 @@ defmodule NervesHubWeb.Live.Deployments.Newz do
         |> send_toast(:error, "Invalid firmware selected")
         |> noreply()
 
-      {_, {:ok, deployment}} ->
-        _ = DeploymentTemplates.audit_deployment_created(user, deployment)
+      {_, {:ok, deployment_group}} ->
+        _ = DeploymentGroupTemplates.audit_deployment_created(user, deployment_group)
 
         socket
-        |> LiveToast.put_toast(:info, "Deployment created")
-        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments")
+        |> LiveToast.put_toast(:info, "Deployment Group created")
+        |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployment_groups")
         |> noreply()
 
       {_firmware, {:error, changeset}} ->
diff --git a/lib/nerves_hub_web/live/deployments/newz.html.heex b/lib/nerves_hub_web/live/deployment_groups/newz.html.heex
similarity index 95%
rename from lib/nerves_hub_web/live/deployments/newz.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/newz.html.heex
index 404b1b27b..3eea0f4da 100644
--- a/lib/nerves_hub_web/live/deployments/newz.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/newz.html.heex
@@ -1,6 +1,6 @@
 <div class="h-[56px] skrink-0 flex justify-between bg-base-900 border-b border-base-700 pl-6 items-center">
   <div class="flex gap-2.5">
-    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments"} class="back-link flex gap-2.5 items-center">
+    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"} class="back-link flex gap-2.5 items-center">
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="none">
         <path d="M4.16671 10L9.16671 5M4.16671 10L9.16671 15M4.16671 10H15.8334" stroke="#A1A1AA" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" />
       </svg>
@@ -26,18 +26,18 @@
 
 <div class="h-0 flex-1 overflow-y-auto">
   <div class="flex items-center h-[90px] gap-4 px-6 py-7 border-b border-[#3F3F46] text-sm font-medium">
-    <h1 class="text-base font-semibold text-neutral-50">Add Deployment</h1>
+    <h1 class="text-base font-semibold text-neutral-50">Add Deployment Group</h1>
   </div>
 
   <div :if={@firmware_required} class="h-full pb-16 flex flex-col items-center justify-center gap-4 p-6">
-    <span class="text-xl font-medium text-neutral-50">Please upload your first firmware before creating a deployment.</span>
-    <.link class="underline underline-offset-4 decoration-dotted hover:text-neutral-50" navigate={~p"/org/#{@org.name}/#{@product.name}/firmware"} aria-label="Add a new deployment">
+    <span class="text-xl font-medium text-neutral-50">Please upload your first firmware before creating a deployment group.</span>
+    <.link class="underline underline-offset-4 decoration-dotted hover:text-neutral-50" navigate={~p"/org/#{@org.name}/#{@product.name}/firmware"} aria-label="Add a new deployment group">
       Go to the firmware page
     </.link>
   </div>
 
   <div :if={!@firmware_required} class="flex flex-col items-start justify-between gap-4 p-6">
-    <.form for={@form} class="w-full" phx-submit="create-deployment">
+    <.form for={@form} class="w-full" phx-submit="create-deployment-group">
       <div class="flex flex-col w-2/3 bg-zinc-900 border border-zinc-700 rounded">
         <div class="flex justify-between items-center h-14 px-4 border-b border-zinc-700">
           <div class="text-base text-neutral-50 font-medium">General settings</div>
@@ -76,7 +76,7 @@
               disabled={@firmwares == []}
               label="Firmware"
               prompt={(@firmwares != [] && "Choose a firmware") || "Please select a platform and architecture first"}
-              hint="This firmware will be distributed to devices assigned to this deployment."
+              hint="This firmware will be distributed to devices assigned to this deployment group."
             />
 
             <%!-- <.input field={@form[:tags]} label="Description" placeholder="eg. sensor hub at customer X" />
@@ -90,7 +90,7 @@
             <div class="text-base text-neutral-50 font-medium">Device matching conditions</div>
             <div class="flex flex-col gap-3">
               <p class="text-sm text-zinc-400">
-                These conditions are used for matching devices which don't have a configured deployment.
+                These conditions are used for matching devices which don't have a configured deployment group.
               </p>
               <p class="text-sm text-zinc-400">
                 The matching is undertaken when a device connects to the platform.
diff --git a/lib/nerves_hub_web/live/deployments/show-new.html.heex b/lib/nerves_hub_web/live/deployment_groups/show-new.html.heex
similarity index 68%
rename from lib/nerves_hub_web/live/deployments/show-new.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/show-new.html.heex
index 1e9f6831f..4fd372aea 100644
--- a/lib/nerves_hub_web/live/deployments/show-new.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/show-new.html.heex
@@ -1,23 +1,23 @@
 <div class="h-[56px] skrink-0 flex justify-end bg-base-900 border-b border-base-700 pl-6 items-center">
   <div class="flex gap-2.5">
-    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments"} class="back-link flex gap-2.5 items-center">
+    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"} class="back-link flex gap-2.5 items-center">
       <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="none">
         <path d="M4.16671 10L9.16671 5M4.16671 10L9.16671 15M4.16671 10H15.8334" stroke="#A1A1AA" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" />
       </svg>
-      <span class="text-base-400">All Deployments</span>
+      <span class="text-base-400">All Deployment Groups</span>
     </.link>
     <span class="text-base-400">/</span>
-    <span class="text-zinc-50 font-semibold">{@deployment.name}</span>
+    <span class="text-zinc-50 font-semibold">{@deployment_group.name}</span>
   </div>
   <div class="flex items-center gap-2 ml-auto mr-6">
     <.button
-      :if={authorized?(:"deployment:toggle", @org_user)}
-      aria-label={"#{(@deployment.is_active && "Pause") || "Resume"} deployment"}
+      :if={authorized?(:"deployment_group:toggle", @org_user)}
+      aria-label={"#{(@deployment_group.is_active && "Pause") || "Resume"} deployment"}
       type="button"
       phx-click="toggle"
-      data-confirm={"Are you sure you want to #{(@deployment.is_active && "pause") || "resume"} the deployment?"}
+      data-confirm={"Are you sure you want to #{(@deployment_group.is_active && "pause") || "resume"} the deployment?"}
     >
-      <.icon name="power" />{(@deployment.is_active && "Pause") || "Resume"}
+      <.icon name="power" />{(@deployment_group.is_active && "Pause") || "Resume"}
     </.button>
   </div>
   <div class="h-full border-l flex items-center justify-center border-base-700 bg-base-900">
@@ -37,11 +37,11 @@
 <div class="h-0 flex-1 overflow-y-auto flex flex-col">
   <div class="h-[90px] shrink-0 flex justify-between p-6">
     <div class="flex gap-3 items-center">
-      <svg class={["size-3", (@deployment.is_active && "fill-emerald-500") || "fill-zinc-500"]} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 6 6">
+      <svg class={["size-3", (@deployment_group.is_active && "fill-emerald-500") || "fill-zinc-500"]} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 6 6">
         <circle cx="3" cy="3" r="3" />
       </svg>
       <h1 class="text-xl font-semibold leading-[30px] text-zinc-50">
-        {@deployment.name}
+        {@deployment_group.name}
       </h1>
     </div>
 
@@ -50,14 +50,14 @@
         <span class="text-sm text-zinc-400 mr-1">Devices:</span>
 
         <div class="flex items-center">
-          <span class="text-sm text-base-300 mr-1">{@deployment.device_count || 0}</span>
+          <span class="text-sm text-base-300 mr-1">{@deployment_group.device_count || 0}</span>
         </div>
       </div>
       <div class="flex h-7 py-1 px-2 items-center rounded bg-zinc-800">
         <span class="text-sm text-zinc-400 mr-1">Arch:</span>
 
         <div class="flex items-center">
-          <span class="text-sm text-base-300 mr-1">{@deployment.firmware.architecture}</span>
+          <span class="text-sm text-base-300 mr-1">{@deployment_group.firmware.architecture}</span>
         </div>
       </div>
 
@@ -65,7 +65,7 @@
         <span class="text-sm text-zinc-400 mr-1">Platform:</span>
 
         <div class="flex items-center">
-          <span class="text-sm text-base-300 mr-1">{@deployment.firmware.platform}</span>
+          <span class="text-sm text-base-300 mr-1">{@deployment_group.firmware.platform}</span>
         </div>
       </div>
     </div>
@@ -73,16 +73,16 @@
 
   <div class="flex w-full justify-between px-6 border-b border-zinc-700">
     <div class="flex">
-      <.link class={tab_classes(@tab, :summary)} patch={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}"}>
+      <.link class={tab_classes(@tab, :summary)} patch={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}"}>
         Summary
       </.link>
-      <.link class={tab_classes(@tab, :release_history)} patch={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/releases"}>
+      <.link class={tab_classes(@tab, :release_history)} patch={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/releases"}>
         Release History
       </.link>
-      <.link class={tab_classes(@tab, :activity)} patch={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/activity"}>
+      <.link class={tab_classes(@tab, :activity)} patch={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/activity"}>
         Activity
       </.link>
-      <.link class={tab_classes(@tab, :settings)} patch={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/settings"}>
+      <.link class={tab_classes(@tab, :settings)} patch={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/settings"}>
         Settings
       </.link>
     </div>
@@ -91,8 +91,8 @@
   <.live_component
     :if={@tab == :summary}
     module={SummaryTab}
-    id="deployment_summary"
-    deployment={@deployment}
+    id="deployment_group_summary"
+    deployment={@deployment_group}
     inflight_updates={@inflight_updates}
     up_to_date_count={@up_to_date_count}
     waiting_for_update_count={@waiting_for_update_count}
@@ -103,9 +103,9 @@
     user={@user}
   />
 
-  <.live_component :if={@tab == :release_history} module={ReleaseHistoryTab} id="deployment_release_history" />
+  <.live_component :if={@tab == :release_history} module={ReleaseHistoryTab} id="deployment_group_release_history" />
 
-  <.live_component :if={@tab == :activity} module={ActivityTab} id="deployment_activity" deployment={@deployment} org={@org} product={@product} user={@user} />
+  <.live_component :if={@tab == :activity} module={ActivityTab} id="deployment_group_activity" deployment_group={@deployment_group} org={@org} product={@product} user={@user} />
 
-  <.live_component :if={@tab == :settings} module={SettingsTab} id="deployment_settings" deployment={@deployment} org={@org} product={@product} user={@user} org_user={@org_user} />
+  <.live_component :if={@tab == :settings} module={SettingsTab} id="deployment_group_settings" deployment_group={@deployment_group} org={@org} product={@product} user={@user} org_user={@org_user} />
 </div>
diff --git a/lib/nerves_hub_web/live/deployments/show.ex b/lib/nerves_hub_web/live/deployment_groups/show.ex
similarity index 52%
rename from lib/nerves_hub_web/live/deployments/show.ex
rename to lib/nerves_hub_web/live/deployment_groups/show.ex
index d1e1eba21..5d45d6810 100644
--- a/lib/nerves_hub_web/live/deployments/show.ex
+++ b/lib/nerves_hub_web/live/deployment_groups/show.ex
@@ -1,29 +1,29 @@
-defmodule NervesHubWeb.Live.Deployments.Show do
+defmodule NervesHubWeb.Live.DeploymentGroups.Show do
   use NervesHubWeb, :updated_live_view
 
   alias NervesHub.AuditLogs
-  alias NervesHub.AuditLogs.DeploymentTemplates
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.AuditLogs.DeploymentGroupTemplates
   alias NervesHub.Devices
   alias NervesHub.Firmwares.Firmware
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   alias NervesHubWeb.Components.AuditLogFeed
 
-  alias NervesHubWeb.Components.DeploymentPage.Activity, as: ActivityTab
-  alias NervesHubWeb.Components.DeploymentPage.ReleaseHistory, as: ReleaseHistoryTab
-  alias NervesHubWeb.Components.DeploymentPage.Settings, as: SettingsTab
-  alias NervesHubWeb.Components.DeploymentPage.Summary, as: SummaryTab
+  alias NervesHubWeb.Components.DeploymentGroupPage.Activity, as: ActivityTab
+  alias NervesHubWeb.Components.DeploymentGroupPage.ReleaseHistory, as: ReleaseHistoryTab
+  alias NervesHubWeb.Components.DeploymentGroupPage.Settings, as: SettingsTab
+  alias NervesHubWeb.Components.DeploymentGroupPage.Summary, as: SummaryTab
 
   @impl Phoenix.LiveView
   def mount(params, _session, socket) do
     %{"name" => name} = params
     %{product: product} = socket.assigns
 
-    deployment = Deployments.get_by_product_and_name!(product, name, true)
+    deployment_group = ManagedDeployments.get_by_product_and_name!(product, name, true)
 
     {logs, audit_pager} =
-      AuditLogs.logs_for_feed(deployment, %{
+      AuditLogs.logs_for_feed(deployment_group, %{
         page: Map.get(params, "page", 1),
         page_size: 10
       })
@@ -35,22 +35,22 @@ defmodule NervesHubWeb.Live.Deployments.Show do
       |> Map.put(:links, true)
       |> Map.put(:anchor, "latest-activity")
 
-    inflight_updates = Devices.inflight_updates_for(deployment)
-    current_device_count = Deployments.get_device_count(deployment)
-    updating_count = Devices.updating_count(deployment)
+    inflight_updates = Devices.inflight_updates_for(deployment_group)
+    current_device_count = ManagedDeployments.get_device_count(deployment_group)
+    updating_count = Devices.updating_count(deployment_group)
 
     socket
-    |> page_title("Deployment - #{deployment.name} - #{product.name}")
+    |> page_title("Deployment Group - #{deployment_group.name} - #{product.name}")
     |> sidebar_tab(:deployments)
     |> selected_tab()
-    |> assign(:deployment, deployment)
-    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment))
-    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment))
+    |> assign(:deployment_group, deployment_group)
+    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment_group))
+    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment_group))
     |> assign(:updating_count, updating_count)
     |> assign(:audit_logs, logs)
     |> assign(:audit_pager, audit_pager)
     |> assign(:inflight_updates, inflight_updates)
-    |> assign(:firmware, deployment.firmware)
+    |> assign(:firmware, deployment_group.firmware)
     |> assign(:current_device_count, current_device_count)
     |> schedule_inflight_updates_updater()
     |> ok()
@@ -74,35 +74,37 @@ defmodule NervesHubWeb.Live.Deployments.Show do
 
   @impl Phoenix.LiveView
   def handle_event("toggle", _params, socket) do
-    authorized!(:"deployment:toggle", socket.assigns.org_user)
+    authorized!(:"deployment_group:toggle", socket.assigns.org_user)
 
-    %{deployment: deployment, user: user} = socket.assigns
+    %{deployment_group: deployment_group, user: user} = socket.assigns
 
-    value = !deployment.is_active
-    {:ok, deployment} = Deployments.update_deployment(deployment, %{is_active: value})
+    value = !deployment_group.is_active
+
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{is_active: value})
 
     active_str = if value, do: "active", else: "inactive"
-    DeploymentTemplates.audit_deployment_toggle_active(user, deployment, active_str)
+    DeploymentGroupTemplates.audit_deployment_toggle_active(user, deployment_group, active_str)
 
     socket
     |> put_flash(:info, "Deployment set #{active_str}")
     |> send_toast(:info, "Deployment #{(value && "resumed") || "paused"}")
-    |> assign(:deployment, deployment)
+    |> assign(:deployment_group, deployment_group)
     |> noreply()
   end
 
   def handle_event("delete", _params, socket) do
-    authorized!(:"deployment:delete", socket.assigns.org_user)
+    authorized!(:"deployment_group:delete", socket.assigns.org_user)
 
-    %{deployment: deployment, org: org, product: product, user: user} = socket.assigns
+    %{deployment_group: deployment_group, org: org, product: product, user: user} = socket.assigns
 
-    {:ok, _} = Deployments.delete_deployment(deployment)
+    {:ok, _} = ManagedDeployments.delete_deployment_group(deployment_group)
 
-    DeploymentTemplates.audit_deployment_deleted(user, deployment)
+    DeploymentGroupTemplates.audit_deployment_deleted(user, deployment_group)
 
     socket
-    |> put_flash(:info, "Deployment successfully deleted")
-    |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployments")
+    |> put_flash(:info, "Deployment Group successfully deleted")
+    |> push_navigate(to: ~p"/org/#{org.name}/#{product.name}/deployment_groups")
     |> noreply()
   end
 
@@ -110,17 +112,17 @@ defmodule NervesHubWeb.Live.Deployments.Show do
   def handle_info(:update_inflight_updates, %{assigns: %{tab: :summary}} = socket) do
     Process.send_after(self(), :update_inflight_updates, 5000)
 
-    %{assigns: %{deployment: deployment}} = socket
+    %{assigns: %{deployment_group: deployment_group}} = socket
 
-    inflight_updates = Devices.inflight_updates_for(deployment)
+    inflight_updates = Devices.inflight_updates_for(deployment_group)
 
-    send_update(self(), SummaryTab, id: "deployment_summary", update_inflight_info: true)
+    send_update(self(), SummaryTab, id: "deployment_group_summary", update_inflight_info: true)
 
     socket
     |> assign(:inflight_updates, inflight_updates)
-    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment))
-    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment))
-    |> assign(:updating_count, Devices.updating_count(deployment))
+    |> assign(:up_to_date_count, Devices.up_to_date_count(deployment_group))
+    |> assign(:waiting_for_update_count, Devices.waiting_for_update_count(deployment_group))
+    |> assign(:updating_count, Devices.updating_count(deployment_group))
     |> noreply()
   end
 
@@ -143,33 +145,35 @@ defmodule NervesHubWeb.Live.Deployments.Show do
     end
   end
 
-  defp deployment_percentage(%{total_updating_devices: 0}), do: 100
+  defp deployment_group_percentage(%{total_updating_devices: 0}), do: 100
 
-  defp deployment_percentage(deployment) do
-    floor(deployment.current_updated_devices / deployment.total_updating_devices * 100)
+  defp deployment_group_percentage(deployment_group) do
+    floor(
+      deployment_group.current_updated_devices / deployment_group.total_updating_devices * 100
+    )
   end
 
   defp help_message_for(field) do
     case field do
       :failure_threshold ->
-        "Maximum number of target devices from this deployment that can be in an unhealthy state before marking the deployment unhealthy"
+        "Maximum number of target devices from this deployment group that can be in an unhealthy state before marking the deployment group unhealthy"
 
       :failure_rate ->
-        "Maximum number of device install failures from this deployment within X seconds before being marked unhealthy"
+        "Maximum number of device install failures from this deployment group within X seconds before being marked unhealthy"
 
       :device_failure_rate ->
-        "Maximum number of device failures within X seconds a device can have for this deployment before being marked unhealthy"
+        "Maximum number of device failures within X seconds a device can have for this deployment group before being marked unhealthy"
 
       :device_failure_threshold ->
-        "Maximum number of install attempts and/or failures a device can have for this deployment before being marked unhealthy"
+        "Maximum number of install attempts and/or failures a device can have for this deployment group before being marked unhealthy"
 
       :penalty_timeout_minutes ->
         "Number of minutes a device is placed in the penalty box for reaching the failure rate and threshold"
     end
   end
 
-  defp version(%Deployment{conditions: %{"version" => ""}}), do: "-"
-  defp version(%Deployment{conditions: %{"version" => version}}), do: version
+  defp version(%DeploymentGroup{conditions: %{"version" => ""}}), do: "-"
+  defp version(%DeploymentGroup{conditions: %{"version" => version}}), do: version
 
   defp firmware_summary(%Firmware{version: nil}) do
     ["Unknown"]
@@ -179,19 +183,20 @@ defmodule NervesHubWeb.Live.Deployments.Show do
     ["#{firmware_display_name(f)}"]
   end
 
-  defp firmware_summary(%Deployment{firmware: %Firmware{} = f}) do
+  defp firmware_summary(%DeploymentGroup{firmware: %Firmware{} = f}) do
     firmware_summary(f)
   end
 
-  defp firmware_summary(%Deployment{firmware: %Ecto.Association.NotLoaded{}} = deployment) do
-    Deployments.preload_firmware_and_archive(deployment)
-    |> firmware_summary()
+  defp firmware_summary(
+         %DeploymentGroup{firmware: %Ecto.Association.NotLoaded{}} = deployment_group
+       ) do
+    ManagedDeployments.preload_firmware_and_archive(deployment_group)
   end
 
-  defp tags(%Deployment{conditions: %{"tags" => tags}}), do: tags
+  defp tags(%DeploymentGroup{conditions: %{"tags" => tags}}), do: tags
 
-  defp opposite_status(%Deployment{is_active: true}), do: "Off"
-  defp opposite_status(%Deployment{is_active: false}), do: "On"
+  defp opposite_status(%DeploymentGroup{is_active: true}), do: "Off"
+  defp opposite_status(%DeploymentGroup{is_active: false}), do: "On"
 
   defp firmware_display_name(%Firmware{} = f) do
     "#{f.version} #{f.platform} #{f.architecture} #{f.uuid}"
diff --git a/lib/nerves_hub_web/live/deployments/show.html.heex b/lib/nerves_hub_web/live/deployment_groups/show.html.heex
similarity index 75%
rename from lib/nerves_hub_web/live/deployments/show.html.heex
rename to lib/nerves_hub_web/live/deployment_groups/show.html.heex
index bb7c47608..988d713a2 100644
--- a/lib/nerves_hub_web/live/deployments/show.html.heex
+++ b/lib/nerves_hub_web/live/deployment_groups/show.html.heex
@@ -1,14 +1,14 @@
 <div class="action-row">
-  <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments"} class="back-link">
-    All Deployments
+  <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups"} class="back-link">
+    All Deployment Groups
   </.link>
-  <div class="btn-group" role="group" aria-label="Deployment Actions">
-    <.link phx-click="toggle" class="btn btn-outline-light btn-action" aria-label={"Turn #{opposite_status(@deployment)} deployment"}>
+  <div class="btn-group" role="group" aria-label="Deployment Group Actions">
+    <.link phx-click="toggle" class="btn btn-outline-light btn-action" aria-label={"Turn #{opposite_status(@deployment_group)} deployment"}>
       <span class="button-icon power"></span>
-      <span class="action-text">Turn {opposite_status(@deployment)}</span>
+      <span class="action-text">Turn {opposite_status(@deployment_group)}</span>
     </.link>
 
-    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/edit"} class="btn btn-outline-light btn-action" aria-label="Edit">
+    <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/edit"} class="btn btn-outline-light btn-action" aria-label="Edit">
       <span class="button-icon edit"></span>
       <span class="action-text">Edit</span>
     </.link>
@@ -19,7 +19,7 @@
       aria-label="Delete"
       data-confirm={[
         "Are you sure you want to delete this deployment?",
-        @deployment.device_count > 0 && " All devices assigned to this deployment will be assigned a new deployment when they reconnect. ",
+        @deployment_group.device_count > 0 && " All devices assigned to this deployment will be assigned a new deployment when they reconnect. ",
         "This cannot be undone."
       ]}
     >
@@ -27,20 +27,25 @@
       <span class="action-text">Delete</span>
     </.link>
 
-    <.link href={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}/audit_logs/download"} class="btn btn-outline-light btn-action" aria-label="Download Audit Logs" download>
+    <.link
+      href={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}/audit_logs/download"}
+      class="btn btn-outline-light btn-action"
+      aria-label="Download Audit Logs"
+      download
+    >
       <div class="button-icon download"></div>
       <span class="action-text">Download Audit Logs</span>
     </.link>
   </div>
 </div>
 
-<h1>{@deployment.name}</h1>
+<h1>{@deployment_group.name}</h1>
 
-<div class="deployment-meta-grid">
+<div class="deployment-group-meta-grid">
   <div>
     <div class="help-text">State</div>
-    <p class={"deployment-state state-#{if @deployment.is_active, do: "on", else: "off"}"}>
-      {if @deployment.is_active, do: "On", else: "Off"}
+    <p class={"deployment-group-state state-#{if @deployment_group.is_active, do: "on", else: "off"}"}>
+      {if @deployment_group.is_active, do: "On", else: "Off"}
     </p>
   </div>
   <div>
@@ -66,7 +71,7 @@
 <div class="divider"></div>
 
 <div>
-  <h3 class="mb-2">Deployment Details</h3>
+  <h3 class="mb-2">Deployment Group Details</h3>
   <div class="display-box">
     <div class="x2-grid">
       <div class="gc-span-2">
@@ -85,7 +90,7 @@
               <span class="tooltip-info"></span>
               <span class="tooltip-text">The number of devices that will update at any given time. This is a soft limit and concurrent updates may be slightly above this number.</span>
             </div>
-            <p>{@deployment.concurrent_updates}</p>
+            <p>{@deployment_group.concurrent_updates}</p>
           </div>
           <div class="col-lg-6 mb-1">
             <div class="help-text mb-1 tooltip-label">
@@ -93,7 +98,7 @@
               <span class="tooltip-info"></span>
               <span class="tooltip-text">The number of minutes before an inflight update expires to clear the queue</span>
             </div>
-            <p>{@deployment.inflight_update_expiration_minutes}</p>
+            <p>{@deployment_group.inflight_update_expiration_minutes}</p>
           </div>
         </div>
         <div class="row">
@@ -104,7 +109,7 @@
                 <span class="tooltip-info"></span>
                 <span class="tooltip-text">{help_message_for(:failure_rate)}</span>
               </div>
-              <p>{@deployment.failure_rate_amount} devices per {@deployment.failure_rate_seconds} seconds</p>
+              <p>{@deployment_group.failure_rate_amount} devices per {@deployment_group.failure_rate_seconds} seconds</p>
             </div>
           </div>
           <div class="col-lg-6 mb-1">
@@ -114,7 +119,7 @@
                 <span class="tooltip-info"></span>
                 <span class="tooltip-text">{help_message_for(:failure_threshold)}</span>
               </div>
-              <p>{@deployment.failure_threshold}</p>
+              <p>{@deployment_group.failure_threshold}</p>
             </div>
           </div>
         </div>
@@ -126,7 +131,7 @@
                 <span class="tooltip-info"></span>
                 <span class="tooltip-text">{help_message_for(:device_failure_rate)}</span>
               </div>
-              <p>{@deployment.device_failure_rate_amount} failures per {@deployment.device_failure_rate_seconds} seconds</p>
+              <p>{@deployment_group.device_failure_rate_amount} failures per {@deployment_group.device_failure_rate_seconds} seconds</p>
             </div>
           </div>
           <div class="col-lg-6 mb-1">
@@ -136,7 +141,7 @@
                 <span class="tooltip-info"></span>
                 <span class="tooltip-text">{help_message_for(:device_failure_threshold)}</span>
               </div>
-              <p>{@deployment.device_failure_threshold}</p>
+              <p>{@deployment_group.device_failure_threshold}</p>
             </div>
           </div>
         </div>
@@ -148,14 +153,14 @@
                 <span class="tooltip-info"></span>
                 <span class="tooltip-text">{help_message_for(:penalty_timeout_minutes)}</span>
               </div>
-              <p>{@deployment.penalty_timeout_minutes} minutes</p>
+              <p>{@deployment_group.penalty_timeout_minutes} minutes</p>
             </div>
           </div>
         </div>
         <div>
           <div class="help-text mb-1">Code sent on Device Connect</div>
-          <%= if @deployment.connecting_code do %>
-            <pre><code><%= @deployment.connecting_code %></code></pre>
+          <%= if @deployment_group.connecting_code do %>
+            <pre><code><%= @deployment_group.connecting_code %></code></pre>
           <% else %>
             <p>-</p>
           <% end %>
@@ -173,8 +178,8 @@
         <div class="row">
           <div class="col-lg-6 mb-1">
             <div class="help-text mb-1">Distributed to</div>
-            <%= if Enum.count(tags(@deployment)) > 0 do %>
-              <%= for tag <- tags(@deployment) do %>
+            <%= if Enum.count(tags(@deployment_group)) > 0 do %>
+              <%= for tag <- tags(@deployment_group) do %>
                 <span class="badge">
                   {tag}
                 </span>
@@ -185,7 +190,7 @@
           </div>
           <div class="col-lg-6 mb-1">
             <div class="help-text mb-1">Version requirement</div>
-            <p>{version(@deployment)}</p>
+            <p>{version(@deployment_group)}</p>
           </div>
         </div>
       </div>
@@ -198,8 +203,8 @@
 
   <div class="help-text mt-3">Progress</div>
   <div class="progress device-show mb-3">
-    <div id="deployment-percentage" class="progress-bar" role="progressbar" style={"width: #{deployment_percentage(@deployment)}%"}>
-      {deployment_percentage(@deployment)}%
+    <div class="progress-bar" role="progressbar" style={"width: #{deployment_group_percentage(@deployment_group)}%"}>
+      {deployment_group_percentage(@deployment_group)}%
     </div>
   </div>
 
diff --git a/lib/nerves_hub_web/live/devices/index-new.html.heex b/lib/nerves_hub_web/live/devices/index-new.html.heex
index 14805e40f..16401e63a 100644
--- a/lib/nerves_hub_web/live/devices/index-new.html.heex
+++ b/lib/nerves_hub_web/live/devices/index-new.html.heex
@@ -335,8 +335,8 @@
             <label class="sidebar-label" for="deployment_id">Deployment</label>
             <select class="sidebar-select" name="deployment_id" id="deployment_id">
               <option {selected?(@current_filters, :deployment_id, "")} value="">All</option>
-              <%= for deployment <- @deployments do %>
-                <option {selected?(@current_filters, :deployment_id, deployment.id)} value={deployment.id}>{deployment.name}</option>
+              <%= for deployment_group <- @deployment_groups do %>
+                <option {selected?(@current_filters, :deployment_id, deployment_group.id)} value={deployment_group.id}>{deployment_group.name}</option>
               <% end %>
             </select>
           </div>
@@ -481,15 +481,21 @@
           </div>
         </form>
 
-        <form :if={Enum.any?(@available_deployments_for_filtered_platform)} id="deployment-move" class="flex flex-col gap-2" phx-change="target-deployment" phx-submit="move-devices-deployment">
-          <label for="move_to" class="sidebar-label">Move device(s) to deployment filtered by platform:</label>
+        <form
+          :if={Enum.any?(@available_deployment_groups_for_filtered_platform)}
+          id="deployment-move"
+          class="flex flex-col gap-2"
+          phx-change="target-deployment"
+          phx-submit="move-devices-deployment-group"
+        >
+          <label for="move_to" class="sidebar-label">Move device(s) to deployment group filtered by platform:</label>
 
           <div class="flex gap-2">
             <select name="deployment" id="move_to_deployment" class="sidebar-select">
-              <option value="">Select deployment</option>
-              <%= for deployment <- @available_deployments_for_filtered_platform do %>
-                <option value={deployment.id} {if @target_deployment && @target_deployment.id == deployment.id, do: [selected: true], else: []}>
-                  {deployment.name} - {deployment.firmware.architecture} - {deployment.firmware.platform}
+              <option value="">Select deployment group</option>
+              <%= for deployment_group <- @available_deployment_groups_for_filtered_platform do %>
+                <option value={deployment_group.id} {if @target_deployment_group && @target_deployment_group.id == deployment_group.id, do: [selected: true], else: []}>
+                  {deployment_group.name} - {deployment_group.firmware.architecture} - {deployment_group.firmware.platform}
                 </option>
               <% end %>
             </select>
@@ -497,8 +503,8 @@
             <.button
               style="primary"
               type="submit"
-              data-confirm={"This will move all selected devices to #{@target_deployment && @target_deployment.name}. Would you like to continue?"}
-              {unless @target_deployment, do: [disabled: true], else: []}
+              data-confirm={"This will move all selected devices to #{@target_deployment_group && @target_deployment_group.name}. Would you like to continue?"}
+              {unless @target_deployment_group, do: [disabled: true], else: []}
             >
               Move
             </.button>
diff --git a/lib/nerves_hub_web/live/devices/index.ex b/lib/nerves_hub_web/live/devices/index.ex
index 9ef375f7c..59f7f86b1 100644
--- a/lib/nerves_hub_web/live/devices/index.ex
+++ b/lib/nerves_hub_web/live/devices/index.ex
@@ -5,11 +5,11 @@ defmodule NervesHubWeb.Live.Devices.Index do
   require OpenTelemetry.Tracer, as: Tracer
 
   alias NervesHub.AuditLogs.DeviceTemplates
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Alarms
   alias NervesHub.Devices.Metrics
   alias NervesHub.Firmwares
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Products.Product
   alias NervesHub.Tracker
 
@@ -101,9 +101,9 @@ defmodule NervesHubWeb.Live.Devices.Index do
     |> assign(:total_entries, 0)
     |> assign(:current_alarms, Alarms.get_current_alarm_types(product.id))
     |> assign(:metrics_keys, Metrics.default_metrics())
-    |> assign(:deployments, Deployments.get_deployments_by_product(product))
-    |> assign(:available_deployments_for_filtered_platform, [])
-    |> assign(:target_deployment, nil)
+    |> assign(:deployment_groups, ManagedDeployments.get_deployment_groups_by_product(product))
+    |> assign(:available_deployment_groups_for_filtered_platform, [])
+    |> assign(:target_deployment_group, nil)
     |> subscribe_and_refresh_device_list_timer()
     |> ok()
   end
@@ -122,7 +122,7 @@ defmodule NervesHubWeb.Live.Devices.Index do
     |> assign(:currently_filtering, filters != @default_filters)
     |> assign(:params, unsigned_params)
     |> assign_display_devices()
-    |> maybe_assign_available_deployments_for_filtered_platform()
+    |> maybe_assign_available_deployment_groups_for_filtered_platform()
     |> noreply()
   end
 
@@ -253,7 +253,7 @@ defmodule NervesHubWeb.Live.Devices.Index do
 
   def handle_event("deselect-all", _, socket) do
     {:noreply,
-     assign(socket, %{selected_devices: [], available_deployments_for_filtered_platform: []})}
+     assign(socket, %{selected_devices: [], available_deployment_groups_for_filtered_platform: []})}
   end
 
   def handle_event("validate-tags", %{"tags" => tags}, socket) do
@@ -297,18 +297,18 @@ defmodule NervesHubWeb.Live.Devices.Index do
     {:noreply, assign(socket, target_product: target)}
   end
 
-  def handle_event("target-deployment", %{"deployment" => ""}, socket) do
-    {:noreply, assign(socket, target_deployment: nil)}
+  def handle_event("target-deployment-group", %{"deployment_group" => ""}, socket) do
+    {:noreply, assign(socket, target_deployment_group: nil)}
   end
 
-  def handle_event("target-deployment", %{"deployment" => deployment_id}, socket) do
-    deployment =
+  def handle_event("target-deployment-group", %{"deployment_group" => deployment_id}, socket) do
+    deployment_group =
       Enum.find(
-        socket.assigns.available_deployments_for_filtered_platform,
+        socket.assigns.available_deployment_groups_for_filtered_platform,
         &(&1.id == String.to_integer(deployment_id))
       )
 
-    {:noreply, assign(socket, target_deployment: deployment)}
+    {:noreply, assign(socket, target_deployment_group: deployment_group)}
   end
 
   def handle_event("move-devices-product", _, socket) do
@@ -329,22 +329,22 @@ defmodule NervesHubWeb.Live.Devices.Index do
   end
 
   def handle_event(
-        "move-devices-deployment",
+        "move-devices-deployment-group",
         _,
         %{
           assigns: %{
             selected_devices: selected_devices,
-            target_deployment: target_deployment
+            target_deployment_group: target_deployment_group
           }
         } = socket
       ) do
     {:ok, %{updated: updated, ignored: ignored}} =
-      Devices.move_many_to_deployment(selected_devices, target_deployment.id)
+      Devices.move_many_to_deployment_group(selected_devices, target_deployment_group.id)
 
     socket
-    |> assign(:target_deployment, nil)
+    |> assign(:target_deployment_group, nil)
     |> assign_display_devices()
-    |> update_flash_moving_devices_deployment(updated, ignored, target_deployment.name)
+    |> update_flash_for_moving_deployment_group(updated, ignored, target_deployment_group.name)
     |> noreply()
   end
 
@@ -688,11 +688,11 @@ defmodule NervesHubWeb.Live.Devices.Index do
     |> JS.hide(transition: "fade-out", to: "##{id}")
   end
 
-  defp update_flash_moving_devices_deployment(
+  defp update_flash_for_moving_deployment_group(
          socket,
          updated_count,
          ignored_count,
-         deployment_name
+         deployment_group_name
        ) do
     maybe_pluralize =
       &if &1 == 1 do
@@ -704,13 +704,13 @@ defmodule NervesHubWeb.Live.Devices.Index do
     message =
       case [updated_count, ignored_count] do
         [updated_count, 0] ->
-          "#{updated_count} #{maybe_pluralize.(updated_count, "device")} added to deployment #{deployment_name}"
+          "#{updated_count} #{maybe_pluralize.(updated_count, "device")} added to deployment #{deployment_group_name}"
 
         [0, _not_updated_count] ->
-          "No devices selected could be added to deployment #{deployment_name} because of mismatched firmware"
+          "No devices selected could be added to deployment #{deployment_group_name} because of mismatched firmware"
 
         [updated_count, not_updated_count] ->
-          "#{updated_count} #{maybe_pluralize.(updated_count, "device")} added to deployment #{deployment_name}. #{not_updated_count} #{maybe_pluralize.(not_updated_count, "device")} could not be added to deployment because of mismatched firmware"
+          "#{updated_count} #{maybe_pluralize.(updated_count, "device")} added to deployment #{deployment_group_name}. #{not_updated_count} #{maybe_pluralize.(not_updated_count, "device")} could not be added to deployment because of mismatched firmware"
       end
 
     socket
@@ -731,17 +731,17 @@ defmodule NervesHubWeb.Live.Devices.Index do
     """
   end
 
-  defp maybe_assign_available_deployments_for_filtered_platform(
+  defp maybe_assign_available_deployment_groups_for_filtered_platform(
          %{assigns: %{product: product, current_filters: %{platform: platform}}} = socket
        )
        when platform != "" do
     assign(
       socket,
-      :available_deployments_for_filtered_platform,
-      Deployments.get_by_product_and_platform(product, platform)
+      :available_deployment_groups_for_filtered_platform,
+      ManagedDeployments.get_by_product_and_platform(product, platform)
     )
   end
 
-  defp maybe_assign_available_deployments_for_filtered_platform(socket),
-    do: assign(socket, :available_deployments_for_filtered_platform, [])
+  defp maybe_assign_available_deployment_groups_for_filtered_platform(socket),
+    do: assign(socket, :available_deployment_groups_for_filtered_platform, [])
 end
diff --git a/lib/nerves_hub_web/live/devices/index.html.heex b/lib/nerves_hub_web/live/devices/index.html.heex
index 6bbe3efb3..145ca11db 100644
--- a/lib/nerves_hub_web/live/devices/index.html.heex
+++ b/lib/nerves_hub_web/live/devices/index.html.heex
@@ -83,11 +83,11 @@
           </div>
         </div>
         <div class="form-group">
-          <label for="deployment_id">Deployment</label>
+          <label for="deployment_id">Deployment Group</label>
           <select name="deployment_id" id="deployment_id" class="form-control">
             <option {selected?(@current_filters, :deployment_id, "")} value="">All</option>
-            <%= for deployment <- @deployments do %>
-              <option {selected?(@current_filters, :deployment_id, deployment.id)} value={deployment.id}>{deployment.name}</option>
+            <%= for deployment_group <- @deployment_groups do %>
+              <option {selected?(@current_filters, :deployment_id, deployment_group.id)} value={deployment_group.id}>{deployment_group.name}</option>
             <% end %>
           </select>
         </div>
@@ -243,14 +243,16 @@
           <div class={if @valid_tags, do: "hidden"}><span class="has-error"> Tags Cannot Contain Spaces </span></div>
         </form>
 
-        <form :if={Enum.any?(@available_deployments_for_filtered_platform)} id="move-deployment" class="col-lg-4" phx-change="target-deployment" phx-submit="move-devices-deployment">
-          <label for="move_to_deployment">Move device(s) to deployment:</label>
+        <form :if={Enum.any?(@available_deployment_groups_for_filtered_platform)} id="move-deployment" class="col-lg-4" phx-change="target-deployment-group" phx-submit="move-devices-deployment-group">
+          <label for="move_to_deployment_group">Move device(s) to deployment group:</label>
           <div class="flex-row align-items-center">
             <div class="flex-grow pos-rel">
-              <select name="deployment" id="move_to_deployment" class="form-control">
+              <select name="deployment_group" id="move_to_deployment_group" class="form-control">
                 <option value=""></option>
-                <%= for deployment <- @available_deployments_for_filtered_platform do %>
-                  <option value={deployment.id} {if @target_deployment && @target_deployment.id == deployment.id, do: [selected: true], else: []}>{deployment.name}</option>
+                <%= for deployment_group <- @available_deployment_groups_for_filtered_platform do %>
+                  <option value={deployment_group.id} {if @target_deployment_group && @target_deployment_group.id == deployment_group.id, do: [selected: true], else: []}>
+                    {deployment_group.name}
+                  </option>
                 <% end %>
               </select>
               <div class="select-icon"></div>
@@ -259,9 +261,9 @@
             <button
               class="btn btn-outline-light btn-action btn-primary ml-1"
               type="submit"
-              data-confirm={"This will move all selected devices to #{@target_deployment && @target_deployment.name}. Continue?"}
-              id="move-deployment-submit"
-              {unless @target_deployment, do: [disabled: true], else: []}
+              data-confirm={"This will move all selected devices to #{@target_deployment_group && @target_deployment_group.name}. Continue?"}
+              id="move-deployment-group-submit"
+              {unless @target_deployment_group, do: [disabled: true], else: []}
             >
               Move
             </button>
diff --git a/lib/nerves_hub_web/live/devices/show.ex b/lib/nerves_hub_web/live/devices/show.ex
index 9df83fa7f..38b07a170 100644
--- a/lib/nerves_hub_web/live/devices/show.ex
+++ b/lib/nerves_hub_web/live/devices/show.ex
@@ -5,7 +5,6 @@ defmodule NervesHubWeb.Live.Devices.Show do
 
   alias NervesHub.AuditLogs
   alias NervesHub.AuditLogs.DeviceTemplates
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Alarms
   alias NervesHub.Devices.Connections
@@ -13,6 +12,7 @@ defmodule NervesHubWeb.Live.Devices.Show do
   alias NervesHub.Devices.UpdatePayload
   alias NervesHub.Extensions.Health
   alias NervesHub.Firmwares
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Repo
   alias NervesHub.Scripts
   alias NervesHub.Tracker
@@ -59,7 +59,7 @@ defmodule NervesHubWeb.Live.Devices.Show do
     |> assign(:page_size, 5)
     |> assign(:pinned?, Devices.device_pinned?(user.id, device.id))
     |> audit_log_assigns()
-    |> assign_deployments()
+    |> assign_deployment_groups()
     |> ok()
   end
 
@@ -105,7 +105,7 @@ defmodule NervesHubWeb.Live.Devices.Show do
     device =
       device
       |> Repo.reload()
-      |> Repo.preload([:deployment, :latest_connection])
+      |> Repo.preload([:deployment_group, :latest_connection])
 
     {:noreply, general_assigns(socket, device)}
   end
@@ -344,19 +344,19 @@ defmodule NervesHubWeb.Live.Devices.Show do
   end
 
   def handle_event(
-        "set-deployment",
+        "set-deployment-group",
         %{"deployment_id" => deployment_id},
-        %{assigns: %{user: user, device: device, deployments: deployments}} =
+        %{assigns: %{user: user, device: device, deployment_groups: deployment_groups}} =
           socket
       ) do
-    deployment = Enum.find(deployments, &(&1.id == String.to_integer(deployment_id)))
-    device = Devices.update_deployment(device, deployment)
-    _ = DeviceTemplates.audit_device_deployment_update(user, device, deployment)
+    deployment_group = Enum.find(deployment_groups, &(&1.id == String.to_integer(deployment_id)))
+    device = Devices.update_deployment_group(device, deployment_group)
+    _ = DeviceTemplates.audit_device_deployment_group_update(user, device, deployment_group)
 
     socket
     |> assign(:device, device)
-    |> assign(:deployment, deployment)
-    |> put_flash(:info, "Deployment successfully updated")
+    |> assign(:deployment_group, deployment_group)
+    |> put_flash(:info, "Deployment Group successfully updated")
     |> noreply()
   end
 
@@ -389,13 +389,13 @@ defmodule NervesHubWeb.Live.Devices.Show do
   def handle_event("push-available-update", _, socket) do
     authorized!(:"device:push-update", socket.assigns.org_user)
 
-    %{device: device, deployment: deployment, user: user} = socket.assigns
+    %{device: device, deployment_group: deployment_group, user: user} = socket.assigns
 
-    deployment = NervesHub.Repo.preload(deployment, :firmware)
+    deployment_group = NervesHub.Repo.preload(deployment_group, :firmware)
 
-    case Devices.told_to_update(device, deployment) do
+    case Devices.told_to_update(device, deployment_group) do
       {:ok, inflight_update} ->
-        DeviceTemplates.audit_pushed_available_update(user, device, deployment)
+        DeviceTemplates.audit_pushed_available_update(user, device, deployment_group)
 
         _ =
           NervesHubWeb.Endpoint.broadcast(
@@ -448,19 +448,19 @@ defmodule NervesHubWeb.Live.Devices.Show do
   end
 
   def handle_event(
-        "remove-from-deployment",
+        "remove-from-deployment-group",
         _,
         %{assigns: %{device: device}} = socket
       ) do
     device =
       device
-      |> Devices.clear_deployment()
-      |> Repo.preload(:deployment)
+      |> Devices.clear_deployment_group()
+      |> Repo.preload(:deployment_group)
 
     socket
     |> assign(:device, device)
-    |> assign(:deployment, nil)
-    |> assign_deployments()
+    |> assign(:deployment_group, nil)
+    |> assign_deployment_groups()
     |> put_flash(:info, "Device successfully removed from the deployment")
     |> noreply()
   end
@@ -557,16 +557,19 @@ defmodule NervesHubWeb.Live.Devices.Show do
     |> assign(:audit_pager, audit_pager)
   end
 
-  defp assign_deployments(%{assigns: %{device: %{status: :provisioned} = device}} = socket),
-    do: assign(socket, deployments: Deployments.eligible_deployments(device))
+  defp assign_deployment_groups(%{assigns: %{device: %{status: :provisioned} = device}} = socket),
+    do: assign(socket, deployment_groups: ManagedDeployments.eligible_deployment_groups(device))
 
-  defp assign_deployments(%{assigns: %{product: product}} = socket),
-    do: assign(socket, deployments: Deployments.get_deployments_by_product(product))
+  defp assign_deployment_groups(%{assigns: %{product: product}} = socket),
+    do:
+      assign(socket,
+        deployment_groups: ManagedDeployments.get_deployment_groups_by_product(product)
+      )
 
   defp connecting_code(device) do
-    if device.deployment && device.deployment.connecting_code do
+    if device.deployment_group && device.deployment_group.connecting_code do
       """
-      #{device.deployment.connecting_code}
+      #{device.deployment_group.connecting_code}
       #{device.connecting_code}
       """
     else
@@ -611,7 +614,7 @@ defmodule NervesHubWeb.Live.Devices.Show do
     |> assign(:firmwares, Firmwares.get_firmware_for_device(device))
     |> assign(:alarms, Alarms.get_current_alarms_for_device(device))
     |> assign(:latest_metrics, Metrics.get_latest_metric_set(device.id))
-    |> assign(:deployment, device.deployment)
+    |> assign(:deployment_group, device.deployment_group)
     |> assign(:device_connection, device.latest_connection)
     |> assign(:device, device)
   end
diff --git a/lib/nerves_hub_web/live/devices/show.html.heex b/lib/nerves_hub_web/live/devices/show.html.heex
index faabea71d..0b004b864 100644
--- a/lib/nerves_hub_web/live/devices/show.html.heex
+++ b/lib/nerves_hub_web/live/devices/show.html.heex
@@ -221,45 +221,45 @@
       <div class="display-box">
         <div :if={@device.deployment_id}>
           <div class="help-text mb-1">
-            Assigned Deployment
+            Assigned Deployment Group
           </div>
-          <div :if={@deployment} class="d-flex flex-row">
+          <div :if={@deployment_group} class="d-flex flex-row">
             <div class="mr-1">
-              <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployments/#{@deployment.name}"} class="badge">
-                <div class={"deployment-state state-#{if @deployment.is_active, do: "on", else: "off"}"}>{@deployment.name}</div>
+              <.link navigate={~p"/org/#{@org.name}/#{@product.name}/deployment_groups/#{@deployment_group.name}"} class="badge">
+                <div class={"deployment-group-state state-#{if @deployment_group.is_active, do: "on", else: "off"}"}>{@deployment_group.name}</div>
               </.link>
             </div>
             <div>
               <button
                 class="btn btn-sm btn-primary btn-action help-text tooltip-label help-tooltip mt-1 mb-1 pt-1 pb-1"
-                phx-click="remove-from-deployment"
+                phx-click="remove-from-deployment-group"
                 data-confirm="Are you sure you want to remove this device from its deployment?"
               >
                 <span class="button-icon delete"></span>
-                <span class="tooltip-text ml-1">Remove this device from the assigned Deployment.</span>
+                <span class="tooltip-text ml-1">Remove this device from the assigned Deployment Group.</span>
               </button>
             </div>
           </div>
           <div :if={@device.status == :registered} class="mt-1">
-            Device will be removed from the deployment upon connection if the aarch and platform doesn't match.
+            Device will be removed from the deployment group upon connection if the arch and platform doesn't match.
           </div>
-          <span :if={is_nil(@deployment)} class="color-white-50">No Assigned Deployment</span>
+          <span :if={is_nil(@deployment_group)} class="color-white-50">No Assigned Deployment Group</span>
         </div>
 
-        <div :if={Enum.empty?(@deployments) && is_nil(@device.deployment_id) && @device.status == :provisioned}>
-          No Eligible Deployments
+        <div :if={Enum.empty?(@deployment_groups) && is_nil(@device.deployment_id) && @device.status == :provisioned}>
+          No Eligible Deployment Groups
         </div>
 
-        <div :if={Enum.any?(@deployments) && is_nil(@device.deployment_id)}>
+        <div :if={Enum.any?(@deployment_groups) && is_nil(@device.deployment_id)}>
           <div class="help-text mb-1">
-            {if @device.status == :provisioned, do: "Eligible Deployments", else: "Product Deployments"}
+            {if @device.status == :provisioned, do: "Eligible Deployment Groups", else: "Product Deployment Groups"}
           </div>
-          <form phx-submit="set-deployment">
+          <form phx-submit="set-deployment-group">
             <div class="flex-row justify-content-between">
               <select name="deployment_id" class="form-control">
                 <option value="">Select a deployment</option>
-                <%= for deployment <- @deployments do %>
-                  <option value={deployment.id}>{deployment.name} - {deployment.firmware.platform}, {deployment.firmware.architecture}</option>
+                <%= for deployment_group <- @deployment_groups do %>
+                  <option value={deployment_group.id}>{deployment_group.name} - {deployment_group.firmware.platform}, {deployment_group.firmware.architecture}</option>
                 <% end %>
               </select>
               <button class="btn btn-secondary ml-2">Set</button>
@@ -271,7 +271,7 @@
           <div class="help-text mb-1 tooltip-label help-tooltip">
             <span>Update available</span>
             <span class="tooltip-info"></span>
-            <span class="tooltip-text">An update is available in the assigned deployment. You can skip the queue by clicking "Send available update".</span>
+            <span class="tooltip-text">An update is available in the assigned deployment group. You can skip the queue by clicking "Send available update".</span>
           </div>
           <form id="available_update_form" phx-submit="push-available-update">
             <div class="flex-row justify-content-between">
diff --git a/lib/nerves_hub_web/router.ex b/lib/nerves_hub_web/router.ex
index 5b87ff1c4..77a4765ca 100644
--- a/lib/nerves_hub_web/router.ex
+++ b/lib/nerves_hub_web/router.ex
@@ -164,12 +164,12 @@ defmodule NervesHubWeb.Router do
                 delete("/:uuid", FirmwareController, :delete)
               end
 
-              scope "/deployments" do
-                get("/", DeploymentController, :index)
-                post("/", DeploymentController, :create)
-                get("/:name", DeploymentController, :show)
-                put("/:name", DeploymentController, :update)
-                delete("/:name", DeploymentController, :delete)
+              scope "/deployment_groups" do
+                get("/", DeploymentGroupController, :index)
+                post("/", DeploymentGroupController, :create)
+                get("/:name", DeploymentGroupController, :show)
+                put("/:name", DeploymentGroupController, :update)
+                delete("/:name", DeploymentGroupController, :delete)
               end
             end
           end
@@ -213,7 +213,12 @@ defmodule NervesHubWeb.Router do
 
     get("/archives/:uuid/download", DownloadController, :archive)
     get("/firmware/:uuid/download", DownloadController, :firmware)
-    get("/deployments/:name/audit_logs/download", DeploymentController, :export_audit_logs)
+
+    get(
+      "/deployment_groups/:name/audit_logs/download",
+      DeploymentGroupController,
+      :export_audit_logs
+    )
   end
 
   scope "/", NervesHubWeb do
@@ -323,30 +328,38 @@ defmodule NervesHubWeb.Router do
       live("/org/:org_name/:product_name/archives/upload", Live.Archives, :upload)
       live("/org/:org_name/:product_name/archives/:archive_uuid", Live.Archives, :show)
 
-      live("/org/:org_name/:product_name/deployments", Live.Deployments.Index)
-      live("/org/:org_name/:product_name/deployments/new", Live.Deployments.New)
-      live("/org/:org_name/:product_name/deployments/newz", Live.Deployments.Newz)
-      live("/org/:org_name/:product_name/deployments/:name", Live.Deployments.Show, :summary)
+      live("/org/:org_name/:product_name/deployment_groups", Live.DeploymentGroups.Index)
+      live("/org/:org_name/:product_name/deployments/new", Live.DeploymentGroups.New)
+      live("/org/:org_name/:product_name/deployments/newz", Live.DeploymentGroups.Newz)
+
+      live(
+        "/org/:org_name/:product_name/deployment_groups/:name",
+        Live.DeploymentGroups.Show,
+        :summary
+      )
 
       live(
-        "/org/:org_name/:product_name/deployments/:name/releases",
-        Live.Deployments.Show,
+        "/org/:org_name/:product_name/deployment_groups/:name/releases",
+        Live.DeploymentGroups.Show,
         :release_history
       )
 
       live(
-        "/org/:org_name/:product_name/deployments/:name/activity",
-        Live.Deployments.Show,
+        "/org/:org_name/:product_name/deployment_groups/:name/activity",
+        Live.DeploymentGroups.Show,
         :activity
       )
 
       live(
-        "/org/:org_name/:product_name/deployments/:name/settings",
-        Live.Deployments.Show,
+        "/org/:org_name/:product_name/deployment_groups/:name/settings",
+        Live.DeploymentGroups.Show,
         :settings
       )
 
-      live("/org/:org_name/:product_name/deployments/:name/edit", Live.Deployments.Edit)
+      live(
+        "/org/:org_name/:product_name/deployment_groups/:name/edit",
+        Live.DeploymentGroups.Edit
+      )
 
       live("/org/:org_name/:product_name/scripts", Live.SupportScripts.Index)
       live("/org/:org_name/:product_name/scripts/new", Live.SupportScripts.New)
diff --git a/lib/nerves_hub_web/views/api/deployment_group_view.ex b/lib/nerves_hub_web/views/api/deployment_group_view.ex
new file mode 100644
index 000000000..cbcfb1905
--- /dev/null
+++ b/lib/nerves_hub_web/views/api/deployment_group_view.ex
@@ -0,0 +1,23 @@
+defmodule NervesHubWeb.API.DeploymentGroupView do
+  use NervesHubWeb, :api_view
+
+  alias NervesHubWeb.API.DeploymentGroupView
+
+  def render("index.json", %{deployment_groups: deployment_groups}) do
+    %{data: render_many(deployment_groups, DeploymentGroupView, "deployment_group.json")}
+  end
+
+  def render("show.json", %{deployment_group: deployment_group}) do
+    %{data: render_one(deployment_group, DeploymentGroupView, "deployment_group.json")}
+  end
+
+  def render("deployment_group.json", %{deployment_group: deployment_group}) do
+    %{
+      name: deployment_group.name,
+      is_active: deployment_group.is_active,
+      state: if(deployment_group.is_active, do: "on", else: "off"),
+      firmware_uuid: deployment_group.firmware.uuid,
+      conditions: deployment_group.conditions
+    }
+  end
+end
diff --git a/lib/nerves_hub_web/views/api/deployment_view.ex b/lib/nerves_hub_web/views/api/deployment_view.ex
deleted file mode 100644
index f5c07a13b..000000000
--- a/lib/nerves_hub_web/views/api/deployment_view.ex
+++ /dev/null
@@ -1,23 +0,0 @@
-defmodule NervesHubWeb.API.DeploymentView do
-  use NervesHubWeb, :api_view
-
-  alias NervesHubWeb.API.DeploymentView
-
-  def render("index.json", %{deployments: deployments}) do
-    %{data: render_many(deployments, DeploymentView, "deployment.json")}
-  end
-
-  def render("show.json", %{deployment: deployment}) do
-    %{data: render_one(deployment, DeploymentView, "deployment.json")}
-  end
-
-  def render("deployment.json", %{deployment: deployment}) do
-    %{
-      name: deployment.name,
-      is_active: deployment.is_active,
-      state: if(deployment.is_active, do: "on", else: "off"),
-      firmware_uuid: deployment.firmware.uuid,
-      conditions: deployment.conditions
-    }
-  end
-end
diff --git a/lib/nerves_hub_web/views/api/device_view.ex b/lib/nerves_hub_web/views/api/device_view.ex
index c450a6c6d..541c0e3ea 100644
--- a/lib/nerves_hub_web/views/api/device_view.ex
+++ b/lib/nerves_hub_web/views/api/device_view.ex
@@ -28,7 +28,10 @@ defmodule NervesHubWeb.API.DeviceView do
       last_communication: connection_last_seen_at(device),
       description: device.description,
       firmware_metadata: device.firmware_metadata,
-      deployment: render_one(device.deployment, __MODULE__, "deployment.json", as: :deployment),
+      deployment_group:
+        render_one(device.deployment_group, __MODULE__, "deployment_group.json",
+          as: :deployment_group
+        ),
       updates_enabled: device.updates_enabled,
       updates_blocked_until: device.updates_blocked_until,
       org_name: device.org.name,
@@ -36,12 +39,12 @@ defmodule NervesHubWeb.API.DeviceView do
     }
   end
 
-  def render("deployment.json", %{deployment: deployment}) do
+  def render("deployment_group.json", %{deployment_group: deployment_group}) do
     %{
-      firmware_uuid: deployment.firmware.uuid,
-      firmware_version: deployment.firmware.version,
-      is_active: deployment.is_active,
-      name: deployment.name
+      firmware_uuid: deployment_group.firmware.uuid,
+      firmware_version: deployment_group.firmware.version,
+      is_active: deployment_group.is_active,
+      name: deployment_group.name
     }
   end
 
diff --git a/lib/nerves_hub_web/views/layout_view.ex b/lib/nerves_hub_web/views/layout_view.ex
index 3ed3dc436..6baa89bb8 100644
--- a/lib/nerves_hub_web/views/layout_view.ex
+++ b/lib/nerves_hub_web/views/layout_view.ex
@@ -232,7 +232,7 @@ defmodule NervesHubWeb.LayoutView do
       %{
         title: "Deployments",
         active: "",
-        href: ~p"/org/#{conn.assigns.org.name}/#{conn.assigns.product.name}/deployments"
+        href: ~p"/org/#{conn.assigns.org.name}/#{conn.assigns.product.name}/deployment_groups"
       },
       %{
         title: "Scripts",
diff --git a/priv/repo/add_org_id.exs b/priv/repo/add_org_id.exs
index ec56fadac..073b3e07c 100644
--- a/priv/repo/add_org_id.exs
+++ b/priv/repo/add_org_id.exs
@@ -1,7 +1,7 @@
 alias NervesHub.Repo
 alias NervesHub.Firmwares.Firmware
 alias NervesHub.Devices.DeviceCertificate
-alias NervesHub.Deployments.Deployment
+alias NervesHub.ManagedDeployments.DeploymentGroup
 alias NervesHub.AuditLogs.AuditLog
 
 import Ecto.Query
@@ -54,16 +54,16 @@ IO.puts "\n"
 {success, errors} =
   from(d in Deployment, where: is_nil(d.org_id), preload: [:product])
   |> Repo.all()
-  |> Enum.reduce({[], []}, fn deployment, {success, errors} ->
-    Deployment.creation_changeset(deployment, %{org_id: deployment.product.org_id})
+  |> Enum.reduce({[], []}, fn deployment_group, {success, errors} ->
+    DeploymentGroup.creation_changeset(deployment_group, %{org_id: deployment_group.product.org_id})
     |> Repo.update()
     |> case do
-      {:ok, deployment} ->
+      {:ok, deployment_group} ->
         IO.write("#{green()}.#{default_color()}")
-        {[deployment | success], errors}
-      {:error, deployment} ->
+        {[deployment_group | success], errors}
+      {:error, deployment_group} ->
         IO.write("#{red()}.#{default_color()}")
-        {success, [deployment | errors]}
+        {success, [deployment_group | errors]}
     end
   end)
 
diff --git a/priv/repo/migrations/20250213215925_set_default_deployment_orchestrator_strategy.exs b/priv/repo/migrations/20250213215925_set_default_deployment_orchestrator_strategy.exs
index dba03ce58..00dfbff76 100644
--- a/priv/repo/migrations/20250213215925_set_default_deployment_orchestrator_strategy.exs
+++ b/priv/repo/migrations/20250213215925_set_default_deployment_orchestrator_strategy.exs
@@ -1,10 +1,10 @@
 defmodule NervesHub.Repo.Migrations.SetDefaultDeploymentOrchestratorStrategy do
   use Ecto.Migration
 
-  alias NervesHub.Deployments.Deployment
+  alias NervesHub.ManagedDeployments.DeploymentGroup
   alias NervesHub.Repo
 
   def change do
-    Repo.update_all(Deployment, set: [orchestrator_strategy: "distributed"])
+    Repo.update_all(DeploymentGroup, set: [orchestrator_strategy: "distributed"])
   end
 end
diff --git a/priv/repo/migrations/20250213215926_create_deployment_releases.exs b/priv/repo/migrations/20250213215926_create_deployment_releases.exs
new file mode 100644
index 000000000..d3c82baa2
--- /dev/null
+++ b/priv/repo/migrations/20250213215926_create_deployment_releases.exs
@@ -0,0 +1,14 @@
+defmodule NervesHub.Repo.Migrations.CreateDeploymentReleases do
+  use Ecto.Migration
+
+  def change do
+    create table(:deployment_releases) do
+      add(:deployment_group_id, references(:deployments), null: false)
+      add(:firmware_id, references(:firmwares), null: false)
+      add(:archive_id, references(:archives))
+      add(:created_by_id, references(:users), null: false)
+
+      timestamps()
+    end
+  end
+end
diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs
index 572c56bf5..68bddb342 100644
--- a/priv/repo/seeds.exs
+++ b/priv/repo/seeds.exs
@@ -39,7 +39,7 @@ defmodule NervesHub.SeedHelpers do
 
     firmwares = firmwares |> List.to_tuple()
 
-    Fixtures.deployment_fixture(org_with_keys_and_users, firmwares |> elem(2), %{
+    Fixtures.deployment_group_fixture(org_with_keys_and_users, firmwares |> elem(2), %{
       conditions: %{"version" => "< 1.0.0", "tags" => ["beta"]}
     })
 
diff --git a/test/nerves_hub/accounts/remove_account_test.exs b/test/nerves_hub/accounts/remove_account_test.exs
index 1113e1ea9..3fe2cced8 100644
--- a/test/nerves_hub/accounts/remove_account_test.exs
+++ b/test/nerves_hub/accounts/remove_account_test.exs
@@ -11,7 +11,7 @@ defmodule NervesHub.Accounts.RemoveAccountTest do
     org_key = Fixtures.org_key_fixture(org, user)
     product = Fixtures.product_fixture(user, org)
     firmware = Fixtures.firmware_fixture(org_key, product)
-    Fixtures.deployment_fixture(org, firmware)
+    Fixtures.deployment_group_fixture(org, firmware)
 
     RemoveAccount.remove_account(user.id)
 
@@ -42,7 +42,7 @@ defmodule NervesHub.Accounts.RemoveAccountTest do
     org2_key = Fixtures.org_key_fixture(org2, org_user.user)
     org2_product = Fixtures.product_fixture(org_user.user, org2)
     org2_firmware = Fixtures.firmware_fixture(org2_key, org2_product)
-    Fixtures.deployment_fixture(org, org2_firmware)
+    Fixtures.deployment_group_fixture(org, org2_firmware)
 
     firmware2 = Fixtures.firmware_fixture(org_key, product)
     Fixtures.firmware_delta_fixture(firmware1, firmware2)
@@ -51,7 +51,7 @@ defmodule NervesHub.Accounts.RemoveAccountTest do
     org3_key = Fixtures.org_key_fixture(org3, org_user.user)
     org3_product = Fixtures.product_fixture(org_user.user, org3)
     org3_firmware = Fixtures.firmware_fixture(org3_key, org3_product)
-    Fixtures.deployment_fixture(org, org3_firmware)
+    Fixtures.deployment_group_fixture(org, org3_firmware)
 
     RemoveAccount.remove_account(user.id)
 
diff --git a/test/nerves_hub/devices/distributed/orchestrator_test.exs b/test/nerves_hub/devices/distributed/orchestrator_test.exs
index 691937977..3bd551ceb 100644
--- a/test/nerves_hub/devices/distributed/orchestrator_test.exs
+++ b/test/nerves_hub/devices/distributed/orchestrator_test.exs
@@ -3,12 +3,11 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
 
   use Mimic
 
-  alias NervesHub.Deployments.Distributed.Orchestrator
-
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Connections
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.Distributed.Orchestrator
 
   alias Phoenix.Socket.Broadcast
 
@@ -25,8 +24,8 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
       :ok
     end)
 
-    deployment =
-      Fixtures.deployment_fixture(org, firmware, %{
+    deployment_group =
+      Fixtures.deployment_group_fixture(org, firmware, %{
         is_active: true,
         orchestrator_strategy: :distributed
       })
@@ -44,29 +43,32 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
        device: device,
        device2: device2,
        device3: device3,
-       deployment: deployment,
+       deployment_group: deployment_group,
        product: product
      }}
   end
 
   test "the concurrent_limit is respected", %{
     product: product,
-    deployment: deployment,
+    deployment_group: deployment_group,
     org_key: org_key,
     device: device1,
     device2: device2,
     device3: device3
   } do
-    # setup deployment, listen for broadcasts, and start the orchestrator
+    # setup deployment group, listen for broadcasts, and start the orchestrator
     firmware = Fixtures.firmware_fixture(org_key, product)
 
-    {:ok, deployment} =
-      Deployments.update_deployment(deployment, %{concurrent_updates: 2, firmware_id: firmware.id})
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{
+        concurrent_updates: 2,
+        firmware_id: firmware.id
+      })
 
     {:ok, _pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
@@ -74,22 +76,22 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     topic1 = "device:#{device1.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, topic1)
 
-    device1 = Devices.update_deployment(device1, deployment)
+    device1 = Devices.update_deployment_group(device1, deployment_group)
     {:ok, connection} = Connections.device_connecting(device1.id)
     :ok = Connections.device_connected(connection.id)
     Devices.deployment_device_online(device1)
 
-    # sent when a device is a assigned a deployment
+    # sent when a device is a assigned a deployment group
     assert_receive %Broadcast{topic: ^topic1, event: "devices/deployment-updated"}, 500
 
     # check that the first device was told to update
     assert_receive %Broadcast{topic: ^topic1, event: "update-scheduled"}, 500
 
-    # assign a second device to the deployment and mark it as connected
+    # assign a second device to the deployment group and mark it as connected
     topic2 = "device:#{device2.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, topic2)
 
-    device2 = Devices.update_deployment(device2, deployment)
+    device2 = Devices.update_deployment_group(device2, deployment_group)
     {:ok, connection} = Connections.device_connecting(device2.id)
     :ok = Connections.device_connected(connection.id)
     Devices.deployment_device_online(device2)
@@ -97,11 +99,11 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     # and check that device2 was told to update
     assert_receive %Broadcast{topic: ^topic2, event: "update-scheduled"}, 500
 
-    # and now assign a third device to the deployment and mark it as connected
+    # and now assign a third device to the deployment group and mark it as connected
     topic3 = "device:#{device3.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, topic3)
 
-    device3 = Devices.update_deployment(device3, deployment)
+    device3 = Devices.update_deployment_group(device3, deployment_group)
     {:ok, connection} = Connections.device_connecting(device3.id)
     :ok = Connections.device_connected(connection.id)
     Devices.deployment_device_online(device3)
@@ -112,19 +114,20 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
 
   test "finds another device to update when a device finishes updating", %{
     product: product,
-    deployment: deployment,
+    deployment_group: deployment_group,
     org_key: org_key,
     device: device,
     device2: device2
   } do
     # only allow for 1 update at a time
-    {:ok, deployment} = Deployments.update_deployment(deployment, %{concurrent_updates: 1})
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{concurrent_updates: 1})
 
-    device = Devices.update_deployment(device, deployment)
+    device = Devices.update_deployment_group(device, deployment_group)
     {:ok, connection} = Connections.device_connecting(device.id)
     :ok = Connections.device_connected(connection.id)
 
-    device2 = Devices.update_deployment(device2, deployment)
+    device2 = Devices.update_deployment_group(device2, deployment_group)
     {:ok, connection} = Connections.device_connecting(device2.id)
     :ok = Connections.device_connected(connection.id)
 
@@ -134,26 +137,27 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     topic2 = "device:#{device2.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, topic2)
 
-    deployment_topic = "orchestrator:deployment:#{deployment.id}"
-    Phoenix.PubSub.subscribe(NervesHub.PubSub, deployment_topic)
+    deployment_group_topic = "orchestrator:deployment:#{deployment_group.id}"
+    Phoenix.PubSub.subscribe(NervesHub.PubSub, deployment_group_topic)
 
     {:ok, _pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
-    # create new firmware and update the deployment with it
+    # create new firmware and update the deployment group with it
     firmware = Fixtures.firmware_fixture(org_key, product)
 
-    {:ok, _deployment} = Deployments.update_deployment(deployment, %{firmware_id: firmware.id})
+    {:ok, _deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{firmware_id: firmware.id})
 
     # check that the first device was told to update
     assert_receive %Broadcast{topic: ^topic1, event: "update-scheduled"}, 500
 
     # bring the second device 'online'
-    Devices.update_deployment(device2, deployment)
+    Devices.update_deployment_group(device2, deployment_group)
     {:ok, connection} = Connections.device_connecting(device2.id)
     :ok = Connections.device_connected(connection.id)
 
@@ -169,15 +173,15 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     # sent by the device after its updated
     assert_receive %Broadcast{topic: ^topic1, event: "devices/updated"}, 500
 
-    # check that the orchestractor was told about the successful update
-    assert_receive %Broadcast{topic: ^deployment_topic, event: "device-updated"}, 500
+    # check that the orchestrator was told about the successful update
+    assert_receive %Broadcast{topic: ^deployment_group_topic, event: "device-updated"}, 500
 
     # and that device2 was told to update
     assert_receive %Broadcast{topic: ^topic2, event: "update-scheduled"}, 500
   end
 
   test "the orchestrator doesn't 'trigger' if the device that came online is up-to-date", %{
-    deployment: deployment,
+    deployment_group: deployment_group,
     org_key: org_key,
     product: product,
     device: device1,
@@ -189,52 +193,53 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     # - once for when an out of date device comes online
     # - and nooooo more times after that
     Devices
-    |> expect(:available_for_update, 1, fn _deployment, _slots ->
+    |> expect(:available_for_update, 1, fn _deployment_group, _slots ->
       []
     end)
-    |> expect(:available_for_update, 1, fn _deployment, _slots ->
+    |> expect(:available_for_update, 1, fn _deployment_group, _slots ->
       [device1]
     end)
     |> reject(:available_for_update, 2)
 
     firmware = Fixtures.firmware_fixture(org_key, product)
 
-    {:ok, deployment} =
-      Deployments.update_deployment(deployment, %{
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{
         concurrent_updates: 2,
         firmware_id: firmware.id
       })
 
-    deployment_topic = "orchestrator:deployment:#{deployment.id}"
-    Phoenix.PubSub.subscribe(NervesHub.PubSub, deployment_topic)
+    deployment_group_topic = "orchestrator:deployment:#{deployment_group.id}"
+    Phoenix.PubSub.subscribe(NervesHub.PubSub, deployment_group_topic)
 
     {:ok, pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
-    # only one device in this test isn't using the same firmware as the deployment
+    # only one device in this test isn't using the same firmware as the deployment group
     # the `Devices.available_for_update/2` function should only be called once by device1
 
-    # assign device1 to the deployment and mark it as 'connected'
+    # assign device1 to the deployment group and mark it as 'connected'
     # this device will be told to update
     device1_topic = "device:#{device1.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, device1_topic)
 
-    device1 = Devices.update_deployment(device1, deployment)
+    device1 = Devices.update_deployment_group(device1, deployment_group)
 
     {:ok, connection} = Connections.device_connecting(device1.id)
     :ok = Connections.device_connected(connection.id)
 
     Devices.deployment_device_online(device1)
 
-    # sent when a device is assigned a deployment
-    assert_receive %Broadcast{topic: ^device1_topic, event: "devices/deployment-updated"}, 500
+    # sent when a device is assigned a deployment group
+    assert_receive %Broadcast{topic: ^device1_topic, event: "devices/deployment-updated"},
+                   500
 
     # the orchestrator is told that a device assigned to it is online
-    assert_receive %Broadcast{topic: ^deployment_topic, event: "device-online"}, 500
+    assert_receive %Broadcast{topic: ^deployment_group_topic, event: "device-online"}, 500
 
     # and then a device is told to schedule an update
     assert_receive %Broadcast{topic: ^device1_topic, event: "update-scheduled"}, 1_000
@@ -250,12 +255,12 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     {:ok, device2} =
       Devices.update_device(device2, %{firmware_metadata: %{"uuid" => firmware.uuid}})
 
-    device2 = Devices.update_deployment(device2, deployment)
+    device2 = Devices.update_deployment_group(device2, deployment_group)
     {:ok, connection} = Connections.device_connecting(device2.id)
     :ok = Connections.device_connected(connection.id)
     Devices.deployment_device_online(device2)
 
-    assert_receive %Broadcast{topic: ^deployment_topic, event: "device-online"}, 500
+    assert_receive %Broadcast{topic: ^deployment_group_topic, event: "device-online"}, 500
     refute_receive %Broadcast{topic: ^device2_topic, event: "update-scheduled"}, 500
 
     # allows for db connections to finish and close
@@ -264,35 +269,35 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
 
   test "the orchestrator is 'triggered' when a device is reenabled to accept updates", %{
     user: user,
-    deployment: deployment,
+    deployment_group: deployment_group,
     org_key: org_key,
     product: product,
     device: device1
   } do
     firmware = Fixtures.firmware_fixture(org_key, product)
 
-    {:ok, deployment} =
-      Deployments.update_deployment(deployment, %{
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{
         concurrent_updates: 2,
         firmware_id: firmware.id
       })
 
-    deployment_topic = "orchestrator:deployment:#{deployment.id}"
+    deployment_topic = "orchestrator:deployment:#{deployment_group.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, deployment_topic)
 
     {:ok, pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
-    # assign device1 to the deployment and mark it as 'connected'
+    # assign device1 to the deployment group and mark it as 'connected'
     # this device will be told to update
     device1_topic = "device:#{device1.id}"
     Phoenix.PubSub.subscribe(NervesHub.PubSub, device1_topic)
 
-    device1 = Devices.update_deployment(device1, deployment)
+    device1 = Devices.update_deployment_group(device1, deployment_group)
     {:ok, device1} = Devices.update_device(device1, %{updates_enabled: false})
 
     {:ok, connection} = Connections.device_connecting(device1.id)
@@ -300,8 +305,9 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
 
     Devices.deployment_device_online(device1)
 
-    # sent when a device is assigned a deployment
-    assert_receive %Broadcast{topic: ^device1_topic, event: "devices/deployment-updated"}, 500
+    # sent when a device is assigned a deployment group
+    assert_receive %Broadcast{topic: ^device1_topic, event: "devices/deployment-updated"},
+                   500
 
     # the orchestrator is told that a device assigned to it is online
     assert_receive %Broadcast{topic: ^deployment_topic, event: "device-online"}, 500
@@ -319,32 +325,34 @@ defmodule NervesHub.Devices.Distributed.OrchestratorTest do
     _state = :sys.get_state(pid)
   end
 
-  test "shuts down if the deployment is no longer active", %{deployment: deployment} do
+  test "shuts down if the deployment group is no longer active", %{
+    deployment_group: deployment_group
+  } do
     {:ok, pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
     Process.monitor(pid)
 
-    Deployments.deployment_deactivated_event(deployment)
+    ManagedDeployments.deployment_deactivated_event(deployment_group)
 
     assert_receive {:DOWN, _reference, :process, ^pid, :normal}, 500
   end
 
-  test "shuts down if the deployment deleted", %{deployment: deployment} do
+  test "shuts down if the deployment deleted", %{deployment_group: deployment_group} do
     {:ok, pid} =
       start_supervised(%{
-        id: "Orchestrator##{deployment.id}",
-        start: {Orchestrator, :start_link, [deployment, false]},
+        id: "Orchestrator##{deployment_group.id}",
+        start: {Orchestrator, :start_link, [deployment_group, false]},
         restart: :temporary
       })
 
     Process.monitor(pid)
 
-    Deployments.delete_deployment(deployment)
+    ManagedDeployments.delete_deployment_group(deployment_group)
 
     assert_receive {:DOWN, _reference, :process, ^pid, :normal}, 3_000
   end
diff --git a/test/nerves_hub/devices_test.exs b/test/nerves_hub/devices_test.exs
index faa1efd15..37b6987d1 100644
--- a/test/nerves_hub/devices_test.exs
+++ b/test/nerves_hub/devices_test.exs
@@ -4,7 +4,6 @@ defmodule NervesHub.DevicesTest do
   alias Ecto.Changeset
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.CACertificate
   alias NervesHub.Devices.Device
@@ -24,7 +23,7 @@ defmodule NervesHub.DevicesTest do
     product = Fixtures.product_fixture(user, org)
     org_key = Fixtures.org_key_fixture(org, user)
     firmware = Fixtures.firmware_fixture(org_key, product)
-    deployment = Fixtures.deployment_fixture(org, firmware, %{is_active: true})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware, %{is_active: true})
     device = Fixtures.device_fixture(org, product, firmware, %{status: :provisioned})
     device2 = Fixtures.device_fixture(org, product, firmware)
     device3 = Fixtures.device_fixture(org, product, firmware)
@@ -47,7 +46,7 @@ defmodule NervesHub.DevicesTest do
        device: device,
        device2: device2,
        device3: device3,
-       deployment: deployment,
+       deployment_group: deployment_group,
        product: product
      }}
   end
@@ -377,146 +376,13 @@ defmodule NervesHub.DevicesTest do
     assert {:error, :not_found} = Devices.get_device_by_identifier(org, "non existing identifier")
   end
 
-  test "get_eligible_deployments returns proper deployments", %{
-    org: org,
-    org_key: org_key,
-    firmware: firmware,
-    product: product
-  } do
-    device =
-      Fixtures.device_fixture(org, product, firmware, %{
-        identifier: "new identifier",
-        tags: ["beta", "beta-edge"]
-      })
-
-    new_firmware = Fixtures.firmware_fixture(org_key, product, %{version: "1.0.1"})
-    Fixtures.firmware_delta_fixture(firmware, new_firmware)
-
-    params = %{
-      org_id: org.id,
-      firmware_id: new_firmware.id,
-      name: "my deployment",
-      conditions: %{
-        "version" => "< 1.0.1",
-        "tags" => ["beta", "beta-edge"]
-      },
-      is_active: false
-    }
-
-    {:ok, deployment} =
-      Deployments.create_deployment(params)
-      |> elem(1)
-      |> Deployments.update_deployment(%{is_active: true})
-
-    {:ok, device_with_firmware} = Devices.get_device_by_org(org, device.id)
-
-    [%Deployments.Deployment{id: dep_id} | _] =
-      Devices.get_eligible_deployments(device_with_firmware)
-
-    assert dep_id == deployment.id
-  end
-
-  test "get_eligible_deployment does not return incorrect devices", %{
-    org: org,
-    org_key: org_key,
-    firmware: firmware,
-    product: product
-  } do
-    incorrect_params = [
-      {%{version: "1.0.0"}, %{identifier: "foo"}},
-      {%{}, %{identifier: "foobar", tags: ["beta"]}},
-      {%{}, %{identifier: "foobarbaz", architecture: "foo"}},
-      {%{}, %{identifier: "foobarbazbang", platform: "foo"}}
-    ]
-
-    for {f_params, d_params} <- incorrect_params do
-      device = Fixtures.device_fixture(org, product, firmware, d_params)
-      new_firmware = Fixtures.firmware_fixture(org_key, product, f_params)
-
-      params = %{
-        org_id: org.id,
-        firmware_id: new_firmware.id,
-        name: "my deployment #{d_params.identifier}",
-        conditions: %{
-          "version" => "< 1.0.0",
-          "tags" => ["beta", "beta-edge"]
-        },
-        is_active: false
-      }
-
-      {:ok, _deployment} =
-        Deployments.create_deployment(params)
-        |> elem(1)
-        |> Deployments.update_deployment(%{is_active: true})
-
-      {:ok, device_with_firmware} = Devices.get_device_by_org(org, device.id)
-
-      assert [] == Devices.get_eligible_deployments(device_with_firmware)
-    end
-  end
-
-  test "deployments limit deploying by product", %{
-    user: user,
-    org: org,
-    org_key: org_key,
-    firmware: firmware,
-    product: product
-  } do
-    old_deployment =
-      Fixtures.deployment_fixture(org, firmware, %{
-        name: "a different name",
-        conditions: %{"tags" => ["beta", "beta-edge"], "version" => ""}
-      })
-
-    firmware1 = Fixtures.firmware_fixture(org_key, product, %{version: "2.0.0"})
-
-    Deployments.update_deployment(old_deployment, %{firmware_id: firmware1.id, is_active: true})
-
-    device =
-      Fixtures.device_fixture(org, product, firmware, %{
-        identifier: "new identifier",
-        tags: ["beta", "beta-edge"]
-      })
-
-    product2 = Fixtures.product_fixture(user, org, %{name: "other product"})
-    firmware2 = Fixtures.firmware_fixture(org_key, product2)
-
-    params = %{
-      org_id: org.id,
-      firmware_id: firmware2.id,
-      name: "my deployment",
-      conditions: %{
-        "version" => "",
-        "tags" => ["beta", "beta-edge"]
-      },
-      is_active: false
-    }
-
-    {:ok, _deployment2} =
-      Deployments.create_deployment(params)
-      |> elem(1)
-      |> Deployments.update_deployment(%{is_active: true})
-
-    {:ok, device_with_firmware} = Devices.get_device_by_org(org, device.id)
-
-    deployments =
-      Devices.get_eligible_deployments(device_with_firmware)
-      |> NervesHub.Repo.preload(:firmware)
-
-    assert length(deployments) == 1
-
-    for deployment <- deployments do
-      assert deployment.firmware.product_id == product.id
-    end
-  end
-
   test "delta_updatable?", %{
     firmware: source,
     product: product,
-    deployment: deployment
+    deployment_group: deployment_group
   } do
     fwup_version = @valid_fwup_version
-    %{firmware: target} = Repo.preload(deployment, :firmware)
+    %{firmware: target} = Repo.preload(deployment_group, :firmware)
 
     assert Devices.delta_updatable?(source, target, product, fwup_version) == false
 
@@ -533,20 +399,20 @@ defmodule NervesHub.DevicesTest do
     assert Devices.delta_updatable?(nil, target, product, fwup_version) == false
   end
 
-  test "matches_deployment? works when device and/or deployment tags are nil", %{
-    deployment: deployment,
+  test "matches_deployment_group? works when device and/or deployment tags are nil", %{
+    deployment_group: deployment_group,
     device: device
   } do
-    # There is a verion check before the tags, so load both versions
+    # There is a version check before the tags, so load both versions
     # here to ensure they match and we get to the tag check
     device = put_in(device.firmware_metadata.version, "1.0.0")
-    deployment = put_in(deployment.conditions["version"], "1.0.0")
+    deployment_group = put_in(deployment_group.conditions["version"], "1.0.0")
 
-    nil_tags_deployment = put_in(deployment.conditions["tags"], nil)
+    nil_tags_deployment_group = put_in(deployment_group.conditions["tags"], nil)
 
-    refute Devices.matches_deployment?(%{device | tags: nil}, deployment)
-    assert Devices.matches_deployment?(%{device | tags: nil}, nil_tags_deployment)
-    assert Devices.matches_deployment?(device, nil_tags_deployment)
+    refute Devices.matches_deployment_group?(%{device | tags: nil}, deployment_group)
+    assert Devices.matches_deployment_group?(%{device | tags: nil}, nil_tags_deployment_group)
+    assert Devices.matches_deployment_group?(device, nil_tags_deployment_group)
   end
 
   test "create shared secret auth with associated product shared secret auth", context do
@@ -587,9 +453,12 @@ defmodule NervesHub.DevicesTest do
       assert Enum.empty?(device.update_attempts)
     end
 
-    test "clears an inflight update if it matches", %{device: device, deployment: deployment} do
-      deployment = Repo.preload(deployment, [:firmware])
-      {:ok, inflight_update} = Devices.told_to_update(device, deployment)
+    test "clears an inflight update if it matches", %{
+      device: device,
+      deployment_group: deployment_group
+    } do
+      deployment_group = Repo.preload(deployment_group, [:firmware])
+      {:ok, inflight_update} = Devices.told_to_update(device, deployment_group)
 
       {:ok, _device} = Devices.firmware_update_successful(device)
 
@@ -597,26 +466,29 @@ defmodule NervesHub.DevicesTest do
       assert is_nil(inflight_update)
     end
 
-    test "increments the deployment's updated count", %{device: device, deployment: deployment} do
-      deployment = Repo.preload(deployment, [:firmware])
-      assert deployment.current_updated_devices == 0
+    test "increments the deployment's updated count", %{
+      device: device,
+      deployment_group: deployment_group
+    } do
+      deployment_group = Repo.preload(deployment_group, [:firmware])
+      assert deployment_group.current_updated_devices == 0
 
-      {:ok, _inflight_update} = Devices.told_to_update(device, deployment)
+      {:ok, _inflight_update} = Devices.told_to_update(device, deployment_group)
 
       {:ok, _device} = Devices.firmware_update_successful(device)
 
-      deployment = Repo.reload(deployment)
-      assert deployment.current_updated_devices == 1
+      deployment_group = Repo.reload(deployment_group)
+      assert deployment_group.current_updated_devices == 1
     end
 
-    test "device updates successfully", %{device: device, deployment: deployment} do
-      deployment = Repo.preload(deployment, [:firmware])
+    test "device updates successfully", %{device: device, deployment_group: deployment_group} do
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
 
       {:ok, device} = Devices.update_attempted(device)
 
-      {:ok, device} = Devices.verify_update_eligibility(device, deployment)
+      {:ok, device} = Devices.verify_update_eligibility(device, deployment_group)
 
       assert device.updates_enabled
       refute device.updates_blocked_until
@@ -624,25 +496,31 @@ defmodule NervesHub.DevicesTest do
 
     test "device updates successfully after a few attempts", %{
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
-      deployment = Repo.preload(deployment, [:firmware])
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
 
       {:ok, device} = Devices.update_attempted(device)
       {:ok, device} = Devices.update_attempted(device)
 
-      {:ok, device} = Devices.verify_update_eligibility(device, deployment)
+      {:ok, device} = Devices.verify_update_eligibility(device, deployment_group)
 
       assert device.updates_enabled
       refute device.updates_blocked_until
     end
 
     test "device updates successfully after a few attempts over a long period of time", state do
-      %{device: device, deployment: deployment} = state
-      deployment = %{deployment | device_failure_threshold: 6, device_failure_rate_amount: 3}
-      deployment = Repo.preload(deployment, [:firmware])
+      %{device: device, deployment_group: deployment_group} = state
+
+      deployment_group = %{
+        deployment_group
+        | device_failure_threshold: 6,
+          device_failure_rate_amount: 3
+      }
+
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
 
@@ -652,27 +530,27 @@ defmodule NervesHub.DevicesTest do
       {:ok, device} = Devices.update_attempted(device, DateTime.add(now, -1200, :second))
       {:ok, device} = Devices.update_attempted(device, now)
 
-      {:ok, device} = Devices.verify_update_eligibility(device, deployment)
+      {:ok, device} = Devices.verify_update_eligibility(device, deployment_group)
 
       assert device.updates_enabled
       refute device.updates_blocked_until
     end
 
     test "device already matches the firmware of the deployment", state do
-      %{device: device, deployment: deployment} = state
-      deployment = Repo.preload(deployment, [:firmware])
+      %{device: device, deployment_group: deployment_group} = state
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
-      {:error, :up_to_date, _device} = Devices.verify_update_eligibility(device, deployment)
+      {:error, :up_to_date, _device} = Devices.verify_update_eligibility(device, deployment_group)
     end
 
     test "device should be rejected for updates based on threshold rate and have it's inflight updates cleared",
          state do
-      %{device: device, deployment: deployment} = state
-      deployment = Repo.preload(deployment, [:firmware])
-      deployment = %{deployment | device_failure_threshold: 6}
+      %{device: device, deployment_group: deployment_group} = state
+      deployment_group = Repo.preload(deployment_group, [:firmware])
+      deployment_group = %{deployment_group | device_failure_threshold: 6}
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
-      {:ok, _inflight_update} = Devices.told_to_update(device, deployment)
+      {:ok, _inflight_update} = Devices.told_to_update(device, deployment_group)
 
       now = DateTime.utc_now()
 
@@ -683,19 +561,20 @@ defmodule NervesHub.DevicesTest do
       {:ok, device} = Devices.update_attempted(device, DateTime.add(now, -500, :second))
       {:ok, device} = Devices.update_attempted(device, now)
 
-      {:error, :updates_blocked, device} = Devices.verify_update_eligibility(device, deployment)
+      {:error, :updates_blocked, device} =
+        Devices.verify_update_eligibility(device, deployment_group)
 
       assert device.updates_blocked_until
-      assert Devices.count_inflight_updates_for(deployment) == 0
+      assert Devices.count_inflight_updates_for(deployment_group) == 0
     end
 
     test "device should be rejected for updates based on attempt rate and have it's inflight updates cleared",
          state do
-      %{device: device, deployment: deployment} = state
-      deployment = Repo.preload(deployment, [:firmware])
+      %{device: device, deployment_group: deployment_group} = state
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
-      {:ok, _inflight_update} = Devices.told_to_update(device, deployment)
+      {:ok, _inflight_update} = Devices.told_to_update(device, deployment_group)
 
       now = DateTime.utc_now()
 
@@ -705,16 +584,17 @@ defmodule NervesHub.DevicesTest do
       {:ok, device} = Devices.update_attempted(device, DateTime.add(now, -2, :second))
       {:ok, device} = Devices.update_attempted(device, now)
 
-      {:error, :updates_blocked, device} = Devices.verify_update_eligibility(device, deployment)
+      {:error, :updates_blocked, device} =
+        Devices.verify_update_eligibility(device, deployment_group)
 
       assert device.updates_blocked_until
-      assert Devices.count_inflight_updates_for(deployment) == 0
+      assert Devices.count_inflight_updates_for(deployment_group) == 0
     end
 
     test "device in penalty box should be rejected for updates and have it's inflight updates cleared",
          state do
-      %{device: device, deployment: deployment} = state
-      deployment = Repo.preload(deployment, [:firmware])
+      %{device: device, deployment_group: deployment_group} = state
+      deployment_group = Repo.preload(deployment_group, [:firmware])
 
       {:ok, device} = update_firmware_uuid(device, Ecto.UUID.generate())
 
@@ -722,27 +602,27 @@ defmodule NervesHub.DevicesTest do
 
       # future time
       device = %{device | updates_blocked_until: DateTime.add(now, 1, :second)}
-      {:ok, _inflight_update} = Devices.told_to_update(device, deployment)
+      {:ok, _inflight_update} = Devices.told_to_update(device, deployment_group)
 
       {:error, :updates_blocked, _device} =
-        Devices.verify_update_eligibility(device, deployment, now)
+        Devices.verify_update_eligibility(device, deployment_group, now)
 
-      assert Devices.count_inflight_updates_for(deployment) == 0
+      assert Devices.count_inflight_updates_for(deployment_group) == 0
 
       # now
       device = %{device | updates_blocked_until: now}
-      {:ok, _device} = Devices.verify_update_eligibility(device, deployment, now)
+      {:ok, _device} = Devices.verify_update_eligibility(device, deployment_group, now)
 
       # past time
       device = %{device | updates_blocked_until: DateTime.add(now, -1, :second)}
-      {:ok, _device} = Devices.verify_update_eligibility(device, deployment, now)
+      {:ok, _device} = Devices.verify_update_eligibility(device, deployment_group, now)
     end
   end
 
   describe "inflight updates" do
-    test "clears expired inflight updates", %{device: device, deployment: deployment} do
-      deployment = Repo.preload(deployment, :firmware)
-      Fixtures.inflight_update(device, deployment)
+    test "clears expired inflight updates", %{device: device, deployment_group: deployment_group} do
+      deployment_group = Repo.preload(deployment_group, :firmware)
+      Fixtures.inflight_update(device, deployment_group)
       assert {0, _} = Devices.delete_expired_inflight_updates()
 
       Devices.clear_inflight_update(device)
@@ -752,7 +632,7 @@ defmodule NervesHub.DevicesTest do
         |> DateTime.shift(hour: -1)
         |> DateTime.truncate(:second)
 
-      Fixtures.inflight_update(device, deployment, %{"expires_at" => expires_at})
+      Fixtures.inflight_update(device, deployment_group, %{"expires_at" => expires_at})
       assert {1, _} = Devices.delete_expired_inflight_updates()
     end
   end
@@ -783,30 +663,30 @@ defmodule NervesHub.DevicesTest do
     end
   end
 
-  describe "update_deployment/2" do
+  describe "update_deployment_group/2" do
     test "updates deployment and broadcasts 'devices/deployment-updated'", %{
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       refute device.deployment_id
 
       NervesHubWeb.Endpoint.subscribe("device:#{device.id}")
-      device = Devices.update_deployment(device, deployment)
+      device = Devices.update_deployment_group(device, deployment_group)
 
-      assert device.deployment_id == deployment.id
+      assert device.deployment_id == deployment_group.id
       assert_receive %{event: "devices/deployment-updated"}
     end
   end
 
-  describe "clear_deployment1/2" do
+  describe "clear_deployment_group/2" do
     test "clears deployment and broadcasts 'devices/deployment-cleared'", %{
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
-      device = Devices.update_deployment(device, deployment)
+      device = Devices.update_deployment_group(device, deployment_group)
 
       NervesHubWeb.Endpoint.subscribe("device:#{device.id}")
-      device = Devices.clear_deployment(device)
+      device = Devices.clear_deployment_group(device)
 
       refute device.deployment_id
       assert_receive %{event: "devices/deployment-cleared"}
diff --git a/test/nerves_hub/firmwares_test.exs b/test/nerves_hub/firmwares_test.exs
index 25cd5454d..8cfc69efa 100644
--- a/test/nerves_hub/firmwares_test.exs
+++ b/test/nerves_hub/firmwares_test.exs
@@ -18,7 +18,6 @@ defmodule NervesHub.FirmwaresTest do
     product = Fixtures.product_fixture(user, org)
     org_key = Fixtures.org_key_fixture(org, user)
     firmware = Fixtures.firmware_fixture(org_key, product)
-    deployment = Fixtures.deployment_fixture(org, firmware)
     device = Fixtures.device_fixture(org, product, firmware)
 
     {:ok,
@@ -27,7 +26,6 @@ defmodule NervesHub.FirmwaresTest do
        org: org,
        org_key: org_key,
        firmware: firmware,
-       deployment: deployment,
        matching_device: device,
        product: product
      }}
@@ -80,7 +78,7 @@ defmodule NervesHub.FirmwaresTest do
     firmware = Fixtures.firmware_fixture(org_key, product)
     assert File.exists?(firmware.upload_metadata[:local_path])
 
-    Fixtures.deployment_fixture(org, firmware, %{name: "a deployment"})
+    Fixtures.deployment_group_fixture(org, firmware, %{name: "a deployment"})
 
     assert {:error, %Changeset{}} = Firmwares.delete_firmware(firmware)
   end
diff --git a/test/nerves_hub/deployments_test.exs b/test/nerves_hub/managed_deployments_test.exs
similarity index 61%
rename from test/nerves_hub/deployments_test.exs
rename to test/nerves_hub/managed_deployments_test.exs
index b2b7c4ce6..5ec0c2e19 100644
--- a/test/nerves_hub/deployments_test.exs
+++ b/test/nerves_hub/managed_deployments_test.exs
@@ -1,15 +1,15 @@
-defmodule NervesHub.DeploymentsTest do
+defmodule NervesHub.ManagedDeploymentsTest do
   use NervesHub.DataCase, async: false
   use Mimic
 
   import Phoenix.ChannelTest
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Distributed.Orchestrator, as: DistributedOrchestrator
   alias NervesHub.Devices
   alias NervesHub.Devices.Device
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.Distributed.Orchestrator, as: DistributedOrchestrator
 
   alias Ecto.Changeset
   alias Phoenix.Socket.Broadcast
@@ -20,32 +20,30 @@ defmodule NervesHub.DeploymentsTest do
     product = Fixtures.product_fixture(user, org)
     org_key = Fixtures.org_key_fixture(org, user)
     firmware = Fixtures.firmware_fixture(org_key, product)
-    deployment = Fixtures.deployment_fixture(org, firmware)
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
 
     user2 = Fixtures.user_fixture(%{email: "user2@test.com"})
     org2 = Fixtures.org_fixture(user2, %{name: "org2"})
     product2 = Fixtures.product_fixture(user2, org2)
     org_key2 = Fixtures.org_key_fixture(org2, user2)
     firmware2 = Fixtures.firmware_fixture(org_key2, product2)
-    deployment2 = Fixtures.deployment_fixture(org2, firmware2)
 
     {:ok,
      %{
        org: org,
        org_key: org_key,
        firmware: firmware,
-       deployment: deployment,
+       deployment_group: deployment_group,
        product: product,
        org2: org2,
        org_key2: org_key2,
        firmware2: firmware2,
-       deployment2: deployment2,
        product2: product2
      }}
   end
 
   describe "create deployment" do
-    test "create_deployment with valid parameters", %{
+    test "create_deployment_group with valid parameters", %{
       org: org,
       firmware: firmware
     } do
@@ -60,20 +58,21 @@ defmodule NervesHub.DeploymentsTest do
         is_active: false
       }
 
-      {:ok, %Deployments.Deployment{} = deployment} = Deployments.create_deployment(params)
+      {:ok, %ManagedDeployments.DeploymentGroup{} = deployment_group} =
+        ManagedDeployments.create_deployment_group(params)
 
       for key <- Map.keys(params) do
-        assert Map.get(deployment, key) == Map.get(params, key)
+        assert Map.get(deployment_group, key) == Map.get(params, key)
       end
     end
 
     test "deployments have unique names wrt product", %{
       org: org,
       firmware: firmware,
-      deployment: existing_deployment
+      deployment_group: existing_deployment_group
     } do
       params = %{
-        name: existing_deployment.name,
+        name: existing_deployment_group.name,
         org_id: org.id,
         firmware_id: firmware.id,
         conditions: %{
@@ -84,10 +83,10 @@ defmodule NervesHub.DeploymentsTest do
       }
 
       assert {:error, %Ecto.Changeset{errors: [name: {"has already been taken", _}]}} =
-               Deployments.create_deployment(params)
+               ManagedDeployments.create_deployment_group(params)
     end
 
-    test "create_deployment with invalid parameters" do
+    test "create_deployment_group with invalid parameters" do
       params = %{
         name: "my deployment",
         conditions: %{
@@ -97,11 +96,11 @@ defmodule NervesHub.DeploymentsTest do
         is_active: true
       }
 
-      assert {:error, %Changeset{}} = Deployments.create_deployment(params)
+      assert {:error, %Changeset{}} = ManagedDeployments.create_deployment_group(params)
     end
   end
 
-  describe "update_deployment" do
+  describe "update_deployment_group" do
     test "updating firmware sends an update message", %{
       org: org,
       org_key: org_key,
@@ -123,38 +122,44 @@ defmodule NervesHub.DeploymentsTest do
         is_active: false
       }
 
-      {:ok, deployment} = Deployments.create_deployment(params)
+      {:ok, deployment_group} = ManagedDeployments.create_deployment_group(params)
 
-      Phoenix.PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment.id}")
+      Phoenix.PubSub.subscribe(NervesHub.PubSub, "deployment:#{deployment_group.id}")
 
-      {:ok, _deployment} = Deployments.update_deployment(deployment, %{is_active: true})
+      {:ok, _deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{is_active: true})
 
       assert_broadcast("deployments/update", %{}, 500)
     end
 
     test "starts distributed orchestrator if deployment updates to active from inactive and the strategy is to :distributed",
          %{
-           deployment: deployment
+           deployment_group: deployment_group
          } do
-      refute deployment.is_active
+      refute deployment_group.is_active
 
-      :ok = Phoenix.PubSub.subscribe(NervesHub.PubSub, "orchestrator:deployment:#{deployment.id}")
+      :ok =
+        Phoenix.PubSub.subscribe(
+          NervesHub.PubSub,
+          "orchestrator:deployment:#{deployment_group.id}"
+        )
 
       stub(
         DistributedOrchestrator,
         :start_orchestrator,
-        fn _deployment -> :ok end
+        fn _deployment_group -> :ok end
       )
 
-      {:ok, deployment} =
-        Deployments.update_deployment(deployment, %{
+      {:ok, deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{
           is_active: true,
           orchestrator_strategy: :distributed
         })
 
-      {:ok, _deployment} = Deployments.update_deployment(deployment, %{is_active: false})
+      {:ok, _deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{is_active: false})
 
-      topic = "orchestrator:deployment:#{deployment.id}"
+      topic = "orchestrator:deployment:#{deployment_group.id}"
       assert_receive %Broadcast{topic: ^topic, event: "deactivated"}, 500
     end
   end
@@ -163,19 +168,19 @@ defmodule NervesHub.DeploymentsTest do
     test "finds all matching deployments", state do
       %{org: org, product: product, firmware: firmware} = state
 
-      %{id: beta_deployment_id} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      %{id: beta_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "beta",
           conditions: %{"tags" => ["beta"]}
         })
 
-      %{id: rpi_deployment_id} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      %{id: rpi_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "rpi",
           conditions: %{"tags" => ["rpi"]}
         })
 
-      Fixtures.deployment_fixture(org, firmware, %{
+      Fixtures.deployment_group_fixture(org, firmware, %{
         name: "rpi0",
         conditions: %{"tags" => ["rpi0"]}
       })
@@ -183,9 +188,9 @@ defmodule NervesHub.DeploymentsTest do
       device = Fixtures.device_fixture(org, product, firmware, %{tags: ["beta", "rpi"]})
 
       assert [
-               %{id: ^beta_deployment_id},
-               %{id: ^rpi_deployment_id}
-             ] = Deployments.matching_deployments(device)
+               %{id: ^beta_deployment_group_id},
+               %{id: ^rpi_deployment_group_id}
+             ] = ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "finds matching deployments including the platform", state do
@@ -194,20 +199,21 @@ defmodule NervesHub.DeploymentsTest do
       rpi_firmware = Fixtures.firmware_fixture(org_key, product, %{platform: "rpi"})
       rpi0_firmware = Fixtures.firmware_fixture(org_key, product, %{platform: "rpi0"})
 
-      %{id: rpi_deployment_id} =
-        Fixtures.deployment_fixture(org, rpi_firmware, %{
+      %{id: rpi_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, rpi_firmware, %{
           name: "rpi",
           conditions: %{"tags" => ["rpi"]}
         })
 
-      Fixtures.deployment_fixture(org, rpi0_firmware, %{
+      Fixtures.deployment_group_fixture(org, rpi0_firmware, %{
         name: "rpi0",
         conditions: %{"tags" => ["rpi"]}
       })
 
       device = Fixtures.device_fixture(org, product, rpi_firmware, %{tags: ["beta", "rpi"]})
 
-      assert [%{id: ^rpi_deployment_id}] = Deployments.matching_deployments(device)
+      assert [%{id: ^rpi_deployment_group_id}] =
+               ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "finds matching deployments including the architecture", state do
@@ -216,51 +222,53 @@ defmodule NervesHub.DeploymentsTest do
       rpi_firmware = Fixtures.firmware_fixture(org_key, product, %{architecture: "rpi"})
       rpi0_firmware = Fixtures.firmware_fixture(org_key, product, %{architecture: "rpi0"})
 
-      %{id: rpi_deployment_id} =
-        Fixtures.deployment_fixture(org, rpi_firmware, %{
+      %{id: rpi_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, rpi_firmware, %{
           name: "rpi",
           conditions: %{"tags" => ["rpi"]}
         })
 
-      Fixtures.deployment_fixture(org, rpi0_firmware, %{
+      Fixtures.deployment_group_fixture(org, rpi0_firmware, %{
         name: "rpi0",
         conditions: %{"tags" => ["rpi"]}
       })
 
       device = Fixtures.device_fixture(org, product, rpi_firmware, %{tags: ["beta", "rpi"]})
 
-      assert [%{id: ^rpi_deployment_id}] = Deployments.matching_deployments(device)
+      assert [%{id: ^rpi_deployment_group_id}] =
+               ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "finds matching deployments including the version", state do
       %{org: org, product: product, firmware: firmware} = state
 
-      %{id: low_deployment_id} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      %{id: low_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "rpi",
           conditions: %{"tags" => ["rpi"], "version" => "~> 1.0"}
         })
 
-      Fixtures.deployment_fixture(org, firmware, %{
+      Fixtures.deployment_group_fixture(org, firmware, %{
         name: "rpi0",
         conditions: %{"tags" => ["rpi"], "version" => "~> 2.0"}
       })
 
       device = Fixtures.device_fixture(org, product, firmware, %{tags: ["beta", "rpi"]})
 
-      assert [%{id: ^low_deployment_id}] = Deployments.matching_deployments(device)
+      assert [%{id: ^low_deployment_group_id}] =
+               ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "finds matching deployments including pre versions", state do
       %{org: org, org_key: org_key, product: product, firmware: firmware} = state
 
-      %{id: low_deployment_id} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      %{id: low_deployment_group_id} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "rpi",
           conditions: %{"tags" => ["rpi"], "version" => "~> 1.0"}
         })
 
-      Fixtures.deployment_fixture(org, firmware, %{
+      Fixtures.deployment_group_fixture(org, firmware, %{
         name: "rpi0",
         conditions: %{"tags" => ["rpi"], "version" => "~> 2.0"}
       })
@@ -269,7 +277,8 @@ defmodule NervesHub.DeploymentsTest do
 
       device = Fixtures.device_fixture(org, product, firmware, %{tags: ["beta", "rpi"]})
 
-      assert [%{id: ^low_deployment_id}] = Deployments.matching_deployments(device)
+      assert [%{id: ^low_deployment_group_id}] =
+               ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "finds the newest firmware version including pre-releases", state do
@@ -286,25 +295,25 @@ defmodule NervesHub.DeploymentsTest do
       v101_fw = Fixtures.firmware_fixture(org_key, product, %{version: "1.0.1"})
 
       %{id: v100_deployment_id} =
-        Fixtures.deployment_fixture(org, v100_firmware, %{
+        Fixtures.deployment_group_fixture(org, v100_firmware, %{
           name: v100_firmware.version,
           conditions: %{"version" => "", "tags" => ["next"]}
         })
 
       %{id: v100rc1_deployment_id} =
-        Fixtures.deployment_fixture(org, v100rc1_fw, %{
+        Fixtures.deployment_group_fixture(org, v100rc1_fw, %{
           name: v100rc1_fw.version,
           conditions: %{"version" => "", "tags" => ["next"]}
         })
 
       %{id: v100rc2_deployment_id} =
-        Fixtures.deployment_fixture(org, v100rc2_fw, %{
+        Fixtures.deployment_group_fixture(org, v100rc2_fw, %{
           name: v100rc2_fw.version,
           conditions: %{"version" => "", "tags" => ["next"]}
         })
 
       %{id: v101_deployment_id} =
-        Fixtures.deployment_fixture(org, v101_fw, %{
+        Fixtures.deployment_group_fixture(org, v101_fw, %{
           name: v101_fw.version,
           conditions: %{"version" => "", "tags" => ["next"]}
         })
@@ -316,17 +325,25 @@ defmodule NervesHub.DeploymentsTest do
                %{id: ^v100_deployment_id},
                %{id: ^v100rc2_deployment_id},
                %{id: ^v100rc1_deployment_id}
-             ] = Deployments.matching_deployments(device)
+             ] = ManagedDeployments.matching_deployment_groups(device)
     end
 
     test "ignores device without firmware metadata" do
-      assert [] == Deployments.matching_deployments(%Device{firmware_metadata: nil})
-      assert [] == Deployments.matching_deployments(%Device{firmware_metadata: nil}, [true])
-      assert [] == Deployments.matching_deployments(%Device{firmware_metadata: nil}, [false])
+      assert [] == ManagedDeployments.matching_deployment_groups(%Device{firmware_metadata: nil})
+
+      assert [] ==
+               ManagedDeployments.matching_deployment_groups(%Device{firmware_metadata: nil}, [
+                 true
+               ])
+
+      assert [] ==
+               ManagedDeployments.matching_deployment_groups(%Device{firmware_metadata: nil}, [
+                 false
+               ])
     end
   end
 
-  describe "verify_deployment_membership/1" do
+  describe "verify_deployment_group_membership/1" do
     setup %{org: org, product: product, firmware: firmware} = context do
       Map.merge(context, %{
         device: Fixtures.device_fixture(org, product, firmware, %{tags: ["beta", "rpi"]})
@@ -335,69 +352,70 @@ defmodule NervesHub.DeploymentsTest do
 
     test "does nothing when device has no deployment", %{device: device} do
       refute device.deployment_id
-      device = Deployments.verify_deployment_membership(device)
+      device = ManagedDeployments.verify_deployment_group_membership(device)
       refute device.deployment_id
     end
 
     test "does nothing when device has deployment and meets matching conditions", %{
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
-      device = Devices.update_deployment(device, deployment)
+      device = Devices.update_deployment_group(device, deployment_group)
       assert device.deployment_id
 
-      device = Deployments.verify_deployment_membership(device)
+      device = ManagedDeployments.verify_deployment_group_membership(device)
       assert device.deployment_id
     end
 
-    test "removes device from deployment and creates audit log when platforms don't match", %{
-      device: device,
-      deployment: deployment
-    } do
+    test "removes device from deployment group and creates audit log when platforms don't match",
+         %{
+           device: device,
+           deployment_group: deployment_group
+         } do
       {:ok, device} =
         device
-        |> Devices.update_deployment(deployment)
+        |> Devices.update_deployment_group(deployment_group)
         |> Devices.update_firmware_metadata(%{"platform" => "foobar"})
 
-      device = Deployments.verify_deployment_membership(device)
+      device = ManagedDeployments.verify_deployment_group_membership(device)
       refute device.deployment_id
 
-      [audit_log] = AuditLogs.logs_for(deployment)
+      [audit_log] = AuditLogs.logs_for(deployment_group)
       assert audit_log.description =~ "no longer matches deployment"
     end
 
-    test "removes device from deployment and creates audit log when architecture doesn't match",
+    test "removes device from deployment group and creates audit log when architecture doesn't match",
          %{
            device: device,
-           deployment: deployment
+           deployment_group: deployment_group
          } do
       {:ok, device} =
         device
-        |> Devices.update_deployment(deployment)
+        |> Devices.update_deployment_group(deployment_group)
         |> Devices.update_firmware_metadata(%{"architecture" => "foobar"})
 
-      device = Deployments.verify_deployment_membership(device)
+      device = ManagedDeployments.verify_deployment_group_membership(device)
       refute device.deployment_id
 
-      [audit_log] = AuditLogs.logs_for(deployment)
-      assert audit_log.description =~ "no longer matches deployment"
+      [audit_log] = AuditLogs.logs_for(deployment_group)
+      assert audit_log.description =~ "no longer matches deployment group"
     end
 
-    test "removes device from deployment and creates audit log when versions don't match",
+    test "removes device from deployment group and creates audit log when versions don't match",
          %{
            device: device,
-           deployment: deployment
+           deployment_group: deployment_group
          } do
       {:ok, device} =
         device
-        |> Devices.update_deployment(deployment)
+        |> Devices.update_deployment_group(deployment_group)
         |> Devices.update_firmware_metadata(%{"version" => "1.0.1"})
 
-      device = Deployments.verify_deployment_membership(device)
+      device = ManagedDeployments.verify_deployment_group_membership(device)
       refute device.deployment_id
 
-      [audit_log] = AuditLogs.logs_for(deployment)
-      assert audit_log.description =~ "no longer matches deployment"
+      [audit_log] = AuditLogs.logs_for(deployment_group)
+      assert audit_log.description =~ "no longer matches deployment group"
     end
   end
 end
diff --git a/test/nerves_hub_web/channels/device_channel_test.exs b/test/nerves_hub_web/channels/device_channel_test.exs
index fcab824ca..3b851904f 100644
--- a/test/nerves_hub_web/channels/device_channel_test.exs
+++ b/test/nerves_hub_web/channels/device_channel_test.exs
@@ -14,7 +14,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "extensions are requested from device if version is above 2.2.0" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -37,7 +37,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "presence connection information" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     subscribe_for_updates(device)
@@ -53,7 +53,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "fwup_public_keys requested on connect" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     params =
@@ -79,7 +79,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "archive_public_keys requested on connect" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     params =
@@ -170,7 +170,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "the first fwup_progress marks an update as happening" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -193,7 +193,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "set connection types for the device" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -216,8 +216,8 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "deployment information is updated when the deployment is cleared" do
     user = Fixtures.user_fixture()
-    {device, _firmware, deployment} = device_fixture(user, %{identifier: "123"})
-    Devices.update_deployment(device, deployment)
+    {device, _firmware, deployment_group} = device_fixture(user, %{identifier: "123"})
+    Devices.update_deployment_group(device, deployment_group)
 
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
@@ -232,7 +232,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
     refute is_nil(device_channel.assigns.device.deployment_id)
     refute is_nil(device_channel.assigns.deployment_channel)
 
-    Devices.clear_deployment(device)
+    Devices.clear_deployment_group(device)
 
     # we need to let the channel process all messages before we can
     # check the state of the device's connection types
@@ -246,8 +246,8 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
   test "deployment information is updated when the device joins a new deployment" do
     user = Fixtures.user_fixture()
-    {device, firmware, deployment} = device_fixture(user, %{identifier: "123"})
-    Devices.update_deployment(device, deployment)
+    {device, firmware, deployment_group} = device_fixture(user, %{identifier: "123"})
+    Devices.update_deployment_group(device, deployment_group)
 
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
@@ -257,21 +257,21 @@ defmodule NervesHubWeb.DeviceChannelTest do
     {:ok, _join_reply, device_channel} =
       subscribe_and_join(socket, DeviceChannel, "device")
 
-    assert device_channel.assigns.device.deployment_id == deployment.id
+    assert device_channel.assigns.device.deployment_id == deployment_group.id
     refute is_nil(device_channel.assigns.deployment_channel)
 
     device = NervesHub.Repo.preload(device, :org)
 
-    new_deployment =
-      Fixtures.deployment_fixture(device.org, firmware, %{name: "Super Deployment"})
+    new_deployment_group =
+      Fixtures.deployment_group_fixture(device.org, firmware, %{name: "Super Deployment"})
 
-    Devices.update_deployment(device, new_deployment)
+    Devices.update_deployment_group(device, new_deployment_group)
 
     # we need to let the channel process all messages before we can
     # check the state of the device's connection types
     state = :sys.get_state(device_channel.channel_pid)
 
-    assert state.assigns.device.deployment_id == new_deployment.id
+    assert state.assigns.device.deployment_id == new_deployment_group.id
     refute is_nil(state.assigns.deployment_channel)
 
     close_cleanly(device_channel)
@@ -280,7 +280,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
   describe "unhandled messages are caught" do
     test "handle_info" do
       user = Fixtures.user_fixture()
-      {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+      {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
       %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
       subscribe_for_updates(device)
@@ -300,7 +300,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
 
     test "handle_in" do
       user = Fixtures.user_fixture()
-      {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+      {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
       %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
       {:ok, socket} =
@@ -326,7 +326,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
         version: "0.0.1"
       })
 
-    deployment = Fixtures.deployment_fixture(org, firmware)
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
 
     params = Enum.into(device_params, %{tags: ["beta", "beta-edge"]})
 
@@ -338,7 +338,7 @@ defmodule NervesHubWeb.DeviceChannelTest do
         params
       )
 
-    {device, firmware, deployment}
+    {device, firmware, deployment_group}
   end
 
   defp archive_setup() do
@@ -348,10 +348,10 @@ defmodule NervesHubWeb.DeviceChannelTest do
     org_key = Fixtures.org_key_fixture(org, user)
     archive = %{uuid: archive_uuid} = Fixtures.archive_fixture(org_key, product)
     firmware = Fixtures.firmware_fixture(org_key, product, %{dir: System.tmp_dir()})
-    deployment = Fixtures.deployment_fixture(org, firmware, %{archive_id: archive.id})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware, %{archive_id: archive.id})
 
-    {device, _firmware, _deployment} =
-      device_fixture(user, %{identifier: "123", deployment_id: deployment.id})
+    {device, _firmware, _deployment_group} =
+      device_fixture(user, %{identifier: "123", deployment_id: deployment_group.id})
 
     %{db_cert: certificate} = Fixtures.device_certificate_fixture(device)
 
diff --git a/test/nerves_hub_web/channels/extensions_channel_test.exs b/test/nerves_hub_web/channels/extensions_channel_test.exs
index 73baa8f66..d92e4bd29 100644
--- a/test/nerves_hub_web/channels/extensions_channel_test.exs
+++ b/test/nerves_hub_web/channels/extensions_channel_test.exs
@@ -13,7 +13,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "joining device channel works without understanding extensions" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -81,7 +81,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "joining extensions channel suggests attaching geo and health" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -109,7 +109,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "joining extensions channel with unknown extensions is fine" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -182,7 +182,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "product with extensions disabled does not suggest attaching anything" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     product = Products.get_product!(device.product_id)
     Products.disable_extension_setting(product, "health")
     Products.disable_extension_setting(product, "geo")
@@ -210,7 +210,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "product with only health suggests only health" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     product = Products.get_product!(device.product_id)
     Products.disable_extension_setting(product, "geo")
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
@@ -237,7 +237,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "attached health extension will receive request for health report" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -262,7 +262,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "attached geo extension will receive request for location update" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -287,7 +287,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "attached extensions will receive detach events on disabling at product level" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -324,7 +324,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
 
   test "disabled extensions can be re-attached" do
     user = Fixtures.user_fixture()
-    {device, _firmware, _deployment} = device_fixture(user, %{identifier: "123"})
+    {device, _firmware, _deployment_group} = device_fixture(user, %{identifier: "123"})
     %{db_cert: certificate, cert: _cert} = Fixtures.device_certificate_fixture(device)
 
     {:ok, socket} =
@@ -373,7 +373,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
         version: "0.0.1"
       })
 
-    deployment = Fixtures.deployment_fixture(org, firmware)
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
 
     params = Enum.into(device_params, %{tags: ["beta", "beta-edge"]})
 
@@ -385,7 +385,7 @@ defmodule NervesHubWeb.ExtensionsChannelTest do
         params
       )
 
-    {device, firmware, deployment}
+    {device, firmware, deployment_group}
   end
 
   def dummy_health_report() do
diff --git a/test/nerves_hub_web/channels/websocket_test.exs b/test/nerves_hub_web/channels/websocket_test.exs
index 4d8b7a34c..1733a9921 100644
--- a/test/nerves_hub_web/channels/websocket_test.exs
+++ b/test/nerves_hub_web/channels/websocket_test.exs
@@ -5,13 +5,13 @@ defmodule NervesHubWeb.WebsocketTest do
 
   alias NervesHub.AuditLogs
   alias NervesHub.AuditLogs.AuditLog
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Distributed.Orchestrator
   alias NervesHub.Devices
   alias NervesHub.Devices.Connections
   alias NervesHub.Devices.Device
   alias NervesHub.Devices.DeviceConnection
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.Distributed.Orchestrator
   alias NervesHub.Products
   alias NervesHub.Repo
   alias NervesHub.Support.Utils
@@ -650,22 +650,26 @@ defmodule NervesHubWeb.WebsocketTest do
         })
         |> Repo.preload([:product])
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "a different name",
           conditions: %{
             "version" => "<= 1.0.0",
             "tags" => ["beta"]
           }
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
           org,
           product,
           firmware,
-          %{tags: ["beta", "beta-edge"], identifier: @valid_serial, deployment_id: deployment.id}
+          %{
+            tags: ["beta", "beta-edge"],
+            identifier: @valid_serial,
+            deployment_id: deployment_group.id
+          }
         )
 
       Fixtures.device_certificate_fixture(device)
@@ -680,13 +684,13 @@ defmodule NervesHubWeb.WebsocketTest do
       new_firmware =
         Fixtures.firmware_fixture(org_key, firmware.product, %{version: "0.0.2", dir: tmp_dir})
 
-      {:ok, deployment} =
-        Deployments.update_deployment(deployment, %{
+      {:ok, deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{
           firmware_id: new_firmware.id
         })
 
       # This is what the orchestrator process will do
-      Orchestrator.trigger_update(deployment)
+      Orchestrator.trigger_update(deployment_group)
 
       message = SocketClient.wait_update(socket)
 
@@ -732,7 +736,7 @@ defmodule NervesHubWeb.WebsocketTest do
       close_socket_cleanly(socket)
     end
 
-    test "removes device from deployment and creates audit log if firmware doesn't match",
+    test "removes device from deployment and sets reason if firmware doesn't match",
          %{
            user: user,
            tmp_dir: tmp_dir
@@ -747,15 +751,15 @@ defmodule NervesHubWeb.WebsocketTest do
           dir: tmp_dir
         })
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "Every Device",
           conditions: %{
             "version" => "<= 1.0.0",
             "tags" => ["beta", "beta-edge"]
           }
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
@@ -763,7 +767,7 @@ defmodule NervesHubWeb.WebsocketTest do
           product,
           firmware,
           %{
-            deployment_id: deployment.id,
+            deployment_id: deployment_group.id,
             tags: ["beta", "beta-edge"],
             identifier: @valid_serial,
             product: @valid_product
@@ -795,7 +799,7 @@ defmodule NervesHubWeb.WebsocketTest do
       [log, _, _] = AuditLogs.logs_by(device)
 
       assert log.description ==
-               "Device no longer matches deployment Every Device's requirements because of mismatched platform"
+               "Device no longer matches deployment group Every Device's requirements because of mismatched platform"
 
       close_socket_cleanly(socket)
     end
@@ -814,15 +818,15 @@ defmodule NervesHubWeb.WebsocketTest do
           dir: tmp_dir
         })
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "a different name",
           conditions: %{
             "version" => "<= 1.0.0",
             "tags" => ["beta", "beta-edge"]
           }
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
@@ -830,7 +834,7 @@ defmodule NervesHubWeb.WebsocketTest do
           product,
           firmware,
           %{
-            deployment_id: deployment.id,
+            deployment_id: deployment_group.id,
             tags: ["beta", "beta-edge"],
             identifier: @valid_serial,
             product: @valid_product
@@ -910,7 +914,7 @@ defmodule NervesHubWeb.WebsocketTest do
       close_socket_cleanly(socket)
     end
 
-    test "vaild certificate expired signer can connect", %{user: user, tmp_dir: tmp_dir} do
+    test "valid certificate expired signer can connect", %{user: user, tmp_dir: tmp_dir} do
       org = Fixtures.org_fixture(user, %{name: "custom_ca_test"})
       {device, _firmware} = device_fixture(tmp_dir, user, %{identifier: @valid_serial}, org)
 
@@ -1043,8 +1047,8 @@ defmodule NervesHubWeb.WebsocketTest do
 
       archive = Fixtures.archive_fixture(org_key, product, %{dir: tmp_dir})
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "beta",
           conditions: %{
             "version" => "<= 1.0.0",
@@ -1052,14 +1056,18 @@ defmodule NervesHubWeb.WebsocketTest do
           },
           archive_id: archive.id
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
           org,
           product,
           firmware,
-          %{tags: ["beta", "beta-edge"], identifier: @valid_serial, deployment_id: deployment.id}
+          %{
+            tags: ["beta", "beta-edge"],
+            identifier: @valid_serial,
+            deployment_id: deployment_group.id
+          }
         )
 
       Fixtures.device_certificate_fixture(device)
@@ -1093,8 +1101,8 @@ defmodule NervesHubWeb.WebsocketTest do
 
       archive = Fixtures.archive_fixture(org_key, product, %{dir: tmp_dir})
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "beta",
           conditions: %{
             "version" => "<= 1.0.0",
@@ -1102,14 +1110,18 @@ defmodule NervesHubWeb.WebsocketTest do
           },
           archive_id: archive.id
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
           org,
           product,
           firmware,
-          %{tags: ["beta", "beta-edge"], identifier: @valid_serial, deployment_id: deployment.id}
+          %{
+            tags: ["beta", "beta-edge"],
+            identifier: @valid_serial,
+            deployment_id: deployment_group.id
+          }
         )
 
       Fixtures.device_certificate_fixture(device)
@@ -1147,22 +1159,26 @@ defmodule NervesHubWeb.WebsocketTest do
         })
         |> Repo.preload([:product])
 
-      {:ok, deployment} =
-        Fixtures.deployment_fixture(org, firmware, %{
+      {:ok, deployment_group} =
+        Fixtures.deployment_group_fixture(org, firmware, %{
           name: "beta",
           conditions: %{
             "version" => "<= 1.0.0",
             "tags" => ["beta"]
           }
         })
-        |> Deployments.update_deployment(%{is_active: true})
+        |> ManagedDeployments.update_deployment_group(%{is_active: true})
 
       device =
         Fixtures.device_fixture(
           org,
           product,
           firmware,
-          %{tags: ["beta", "beta-edge"], identifier: @valid_serial, deployment_id: deployment.id}
+          %{
+            tags: ["beta", "beta-edge"],
+            identifier: @valid_serial,
+            deployment_id: deployment_group.id
+          }
         )
 
       archive = Fixtures.archive_fixture(org_key, product, %{dir: tmp_dir})
@@ -1177,7 +1193,8 @@ defmodule NervesHubWeb.WebsocketTest do
       assert_connection_change()
       assert_online_and_available(device)
 
-      {:ok, _deployment} = Deployments.update_deployment(deployment, %{archive_id: archive.id})
+      {:ok, _deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{archive_id: archive.id})
 
       archive = SocketClient.wait_archive(socket)
       assert %{"url" => _, "version" => _} = archive
diff --git a/test/nerves_hub_web/controllers/api/deployment_controller_test.exs b/test/nerves_hub_web/controllers/api/deployment_controller_test.exs
index 45a7012cc..fc572c0c0 100644
--- a/test/nerves_hub_web/controllers/api/deployment_controller_test.exs
+++ b/test/nerves_hub_web/controllers/api/deployment_controller_test.exs
@@ -1,18 +1,18 @@
-defmodule NervesHubWeb.API.DeploymentControllerTest do
+defmodule NervesHubWeb.API.DeploymentGroupControllerTest do
   use NervesHubWeb.APIConnCase, async: true
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
   describe "index" do
     test "lists all deployments", %{conn: conn, org: org, product: product} do
-      conn = get(conn, Routes.api_deployment_path(conn, :index, org.name, product.name))
+      conn = get(conn, Routes.api_deployment_group_path(conn, :index, org.name, product.name))
       assert json_response(conn, 200)["data"] == []
     end
   end
 
-  describe "create deployment" do
+  describe "create deployment group" do
     setup context do
       org_key = Fixtures.org_key_fixture(context.org, context.user)
       firmware = Fixtures.firmware_fixture(org_key, context.product)
@@ -32,17 +32,26 @@ defmodule NervesHubWeb.API.DeploymentControllerTest do
       [params: params, firmware: firmware, org_key: org_key]
     end
 
-    test "renders deployment when data is valid", %{
+    test "renders deployment group when data is valid", %{
       conn: conn,
       org: org,
       params: params,
       product: product
     } do
-      conn = post(conn, Routes.api_deployment_path(conn, :create, org.name, product.name), params)
+      conn =
+        post(
+          conn,
+          Routes.api_deployment_group_path(conn, :create, org.name, product.name),
+          params
+        )
+
       assert json_response(conn, 201)["data"]
 
       conn =
-        get(conn, Routes.api_deployment_path(conn, :show, org.name, product.name, params.name))
+        get(
+          conn,
+          Routes.api_deployment_group_path(conn, :show, org.name, product.name, params.name)
+        )
 
       assert json_response(conn, 200)["data"]["name"] == params.name
     end
@@ -54,88 +63,153 @@ defmodule NervesHubWeb.API.DeploymentControllerTest do
       product: product,
       user: user
     } do
-      conn = post(conn, Routes.api_deployment_path(conn, :create, org.name, product.name), params)
+      conn =
+        post(
+          conn,
+          Routes.api_deployment_group_path(conn, :create, org.name, product.name),
+          params
+        )
+
       assert json_response(conn, 201)["data"]
 
       [audit_log] = AuditLogs.logs_by(user)
-      assert audit_log.resource_type == Deployment
+      assert audit_log.resource_type == DeploymentGroup
     end
 
     test "renders errors when data is invalid", %{conn: conn, org: org, product: product} do
-      conn = post(conn, Routes.api_deployment_path(conn, :create, org.name, product.name))
+      conn = post(conn, Routes.api_deployment_group_path(conn, :create, org.name, product.name))
       assert json_response(conn, 500)["errors"] != %{}
     end
   end
 
-  describe "update deployment" do
-    setup [:create_deployment]
+  describe "update deployment group" do
+    setup [:create_deployment_group]
 
-    test "renders deployment when data is valid", %{
+    test "renders deployment group when data is valid", %{
       conn: conn,
-      deployment: deployment,
+      deployment_group: deployment_group,
       org: org,
       product: product
     } do
-      path = Routes.api_deployment_path(conn, :update, org.name, product.name, deployment.name)
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :update,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
       conn = put(conn, path, deployment: %{"is_active" => true})
       assert %{"is_active" => true} = json_response(conn, 200)["data"]
 
-      path = Routes.api_deployment_path(conn, :show, org.name, product.name, deployment.name)
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :show,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
       conn = get(conn, path)
       assert json_response(conn, 200)["data"]["is_active"]
     end
 
     test "can use state to set is_active", %{
       conn: conn,
-      deployment: deployment,
+      deployment_group: deployment_group,
       org: org,
       product: product
     } do
-      path = Routes.api_deployment_path(conn, :update, org.name, product.name, deployment.name)
-      refute deployment.is_active
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :update,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
+      refute deployment_group.is_active
       conn = put(conn, path, deployment: %{"state" => "on"})
       assert %{"is_active" => true, "state" => "on"} = json_response(conn, 200)["data"]
 
-      path = Routes.api_deployment_path(conn, :show, org.name, product.name, deployment.name)
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :show,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
       conn = get(conn, path)
       assert json_response(conn, 200)["data"]["is_active"]
       assert json_response(conn, 200)["data"]["state"] == "on"
     end
 
-    test "audits on success", %{conn: conn, deployment: deployment, org: org, product: product} do
-      path = Routes.api_deployment_path(conn, :update, org.name, product.name, deployment.name)
+    test "audits on success", %{
+      conn: conn,
+      deployment_group: deployment_group,
+      org: org,
+      product: product
+    } do
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :update,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
       conn = put(conn, path, deployment: %{"is_active" => true})
       assert json_response(conn, 200)["data"]
 
-      [audit_log] = AuditLogs.logs_for(deployment)
-      assert audit_log.resource_type == Deployment
+      [audit_log] = AuditLogs.logs_for(deployment_group)
+      assert audit_log.resource_type == DeploymentGroup
     end
 
     test "renders errors when data is invalid", %{
       conn: conn,
-      deployment: deployment,
+      deployment_group: deployment_group,
       org: org,
       product: product
     } do
-      path = Routes.api_deployment_path(conn, :update, org.name, product.name, deployment.name)
+      path =
+        Routes.api_deployment_group_path(
+          conn,
+          :update,
+          org.name,
+          product.name,
+          deployment_group.name
+        )
+
       conn = put(conn, path, deployment: %{is_active: "1234"})
       assert json_response(conn, 422)["errors"] != %{}
     end
   end
 
-  describe "delete deployment" do
-    setup [:create_deployment]
+  describe "delete deployment group" do
+    setup [:create_deployment_group]
 
-    test "deletes chosen deployment", %{
+    test "deletes chosen deployment group", %{
       conn: conn,
       org: org,
       product: product,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       conn =
         delete(
           conn,
-          Routes.api_deployment_path(conn, :delete, org.name, product.name, deployment.name)
+          Routes.api_deployment_group_path(
+            conn,
+            :delete,
+            org.name,
+            product.name,
+            deployment_group.name
+          )
         )
 
       assert response(conn, 204)
@@ -143,17 +217,23 @@ defmodule NervesHubWeb.API.DeploymentControllerTest do
       conn =
         get(
           conn,
-          Routes.api_deployment_path(conn, :show, org.name, product.name, deployment.name)
+          Routes.api_deployment_group_path(
+            conn,
+            :show,
+            org.name,
+            product.name,
+            deployment_group.name
+          )
         )
 
       assert response(conn, 404)
     end
   end
 
-  defp create_deployment(%{user: user, org: org, product: product}) do
+  defp create_deployment_group(%{user: user, org: org, product: product}) do
     org_key = Fixtures.org_key_fixture(org, user)
     firmware = Fixtures.firmware_fixture(org_key, product)
-    deployment = Fixtures.deployment_fixture(org, firmware)
-    {:ok, %{deployment: deployment}}
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+    {:ok, %{deployment_group: deployment_group}}
   end
 end
diff --git a/test/nerves_hub_web/controllers/api/firmware_controller_test.exs b/test/nerves_hub_web/controllers/api/firmware_controller_test.exs
index 4242a8d4c..437d350c7 100644
--- a/test/nerves_hub_web/controllers/api/firmware_controller_test.exs
+++ b/test/nerves_hub_web/controllers/api/firmware_controller_test.exs
@@ -69,7 +69,7 @@ defmodule NervesHubWeb.API.FirmwareControllerTest do
       product: product,
       firmware: firmware
     } do
-      Fixtures.deployment_fixture(org, firmware)
+      Fixtures.deployment_group_fixture(org, firmware)
 
       conn =
         delete(
diff --git a/test/nerves_hub_web/live/deployment_groups/edit_test.exs b/test/nerves_hub_web/live/deployment_groups/edit_test.exs
new file mode 100644
index 000000000..4e2bccd3d
--- /dev/null
+++ b/test/nerves_hub_web/live/deployment_groups/edit_test.exs
@@ -0,0 +1,75 @@
+defmodule NervesHubWeb.Live.DeploymentGroups.EditTest do
+  use NervesHubWeb.ConnCase.Browser, async: true
+
+  alias NervesHub.AuditLogs
+  alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+  alias NervesHub.ManagedDeployments.DeploymentGroup
+
+  test "update the chosen resource, and adds an audit log", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+
+    conn =
+      conn
+      |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}/edit")
+      |> assert_has("h1", text: "Edit Deployment Group")
+      |> assert_has("a", text: product.name)
+      |> fill_in("Deployment Group name", with: "Moussaka")
+      |> fill_in("Tag(s) distributed to", with: "josh, lars")
+      |> fill_in("Version requirement", with: "4.3.2")
+      |> select(firmware.uuid, from: "Firmware version", exact_option: false)
+      |> click_button("Save Change")
+
+    {:ok, reloaded_deployment_group} =
+      ManagedDeployments.get_deployment_group(product, deployment_group.id)
+
+    conn
+    |> assert_path(
+      URI.encode(
+        "/org/#{org.name}/#{product.name}/deployment_groups/#{reloaded_deployment_group.name}"
+      )
+    )
+    |> assert_has("div", text: "Deployment Group updated")
+
+    assert reloaded_deployment_group.name == "Moussaka"
+    assert reloaded_deployment_group.conditions["version"] == "4.3.2"
+    assert Enum.sort(reloaded_deployment_group.conditions["tags"]) == Enum.sort(~w(josh lars))
+
+    [audit_log_one, audit_log_two] = AuditLogs.logs_for(reloaded_deployment_group)
+
+    assert audit_log_one.resource_type == DeploymentGroup
+    assert audit_log_two.description =~ ~r/conditions changed/
+  end
+
+  test "failed update shows errors", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}/edit")
+    |> assert_has("h1", text: "Edit Deployment Group")
+    |> assert_has("a", text: product.name)
+    |> fill_in("Tag(s) distributed to", with: "")
+    |> fill_in("Version requirement", with: "")
+    |> click_button("Save Change")
+    |> assert_path(
+      "/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}/edit"
+    )
+    |> assert_has("div", text: "should have at least 1 item(s)")
+  end
+end
diff --git a/test/nerves_hub_web/live/deployment_groups/index_test.exs b/test/nerves_hub_web/live/deployment_groups/index_test.exs
new file mode 100644
index 000000000..920c8de8a
--- /dev/null
+++ b/test/nerves_hub_web/live/deployment_groups/index_test.exs
@@ -0,0 +1,58 @@
+defmodule NervesHubWeb.Live.DeploymentGroups.IndexTest do
+  use NervesHubWeb.ConnCase.Browser, async: true
+
+  alias NervesHub.Devices
+  alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+
+  test "no deployment groups", %{conn: conn, user: user, org: org} do
+    product = Fixtures.product_fixture(user, org, %{name: "Spaghetti"})
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups")
+    |> assert_has("h3", text: "#{product.name} doesn’t have any deployments configured")
+  end
+
+  test "has deployment groups", %{
+    conn: conn,
+    org: org,
+    product: product,
+    deployment_group: deployment_group
+  } do
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups")
+    |> assert_has("h1", text: "Deployment Groups")
+    |> assert_has("a", text: deployment_group.name)
+    |> assert_has("td div", text: "0")
+  end
+
+  test "device counts don't include deleted devices", %{
+    conn: conn,
+    org: org,
+    product: product,
+    deployment_group: deployment_group,
+    device: device
+  } do
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups")
+    |> assert_has("h1", text: "Deployment Groups")
+    |> assert_has("a", text: deployment_group.name)
+    |> assert_has("td div", text: "0")
+
+    ManagedDeployments.set_deployment_group(device)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups")
+    |> assert_has("h1", text: "Deployment Groups")
+    |> assert_has("a", text: deployment_group.name)
+    |> assert_has("td div", text: "1")
+
+    Devices.delete_device(device)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups")
+    |> assert_has("h1", text: "Deployment Groups")
+    |> assert_has("a", text: deployment_group.name)
+    |> assert_has("td div", text: "0")
+  end
+end
diff --git a/test/nerves_hub_web/live/deployments/new_test.exs b/test/nerves_hub_web/live/deployment_groups/new_test.exs
similarity index 80%
rename from test/nerves_hub_web/live/deployments/new_test.exs
rename to test/nerves_hub_web/live/deployment_groups/new_test.exs
index 38e630235..17b86cc82 100644
--- a/test/nerves_hub_web/live/deployments/new_test.exs
+++ b/test/nerves_hub_web/live/deployment_groups/new_test.exs
@@ -1,11 +1,11 @@
-defmodule NervesHubWeb.Live.Deployments.NewTest do
+defmodule NervesHubWeb.Live.DeploymentGroups.NewTest do
   use NervesHubWeb.ConnCase.Browser, async: true
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments.Deployment
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments.DeploymentGroup
 
-  describe "new deployment" do
+  describe "new deployment group" do
     test "the happy path, with an audit log", %{
       conn: conn,
       user: user,
@@ -20,19 +20,19 @@ defmodule NervesHubWeb.Live.Deployments.NewTest do
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/deployments/new")
-      |> assert_has("h1", text: "Create Deployment")
+      |> assert_has("h1", text: "Create Deployment Group")
       |> assert_has("option", text: "Choose a platform")
       |> select(firmware.platform, from: "Platform")
-      |> fill_in("Deployment name", with: "Moussaka")
+      |> fill_in("Deployment Group name", with: "Moussaka")
       |> fill_in("Tag(s) distributed to", with: "josh, lars")
       |> select(firmware.uuid, from: "Firmware version", exact_option: false)
       |> click_button("Create Deployment")
-      |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployments"))
-      |> assert_has("h1", text: "Deployments")
-      |> assert_has("div", text: "Deployment created")
+      |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployment_groups"))
+      |> assert_has("h1", text: "Deployment Groups")
+      |> assert_has("div", text: "Deployment Group created")
       |> assert_has("a", text: "Moussaka")
 
-      [%{resource_type: Deployment}] = AuditLogs.logs_by(user)
+      [%{resource_type: DeploymentGroup}] = AuditLogs.logs_by(user)
     end
 
     test "error message displayed if invalid firmware is selected", %{
@@ -53,7 +53,7 @@ defmodule NervesHubWeb.Live.Deployments.NewTest do
       |> unwrap(fn view ->
         view
         |> element("form")
-        |> render_submit(%{deployment: %{"firmware_id" => -1}})
+        |> render_submit(%{deployment_group: %{"firmware_id" => -1}})
       end)
       |> assert_path("/org/#{org.name}/#{product.name}/deployments/new")
       |> assert_has("div", text: "Invalid firmware selected")
@@ -74,7 +74,7 @@ defmodule NervesHubWeb.Live.Deployments.NewTest do
       |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/firmware/upload"))
       |> assert_has("h1", text: "Add Firmware")
       |> assert_has("div",
-        text: "You must upload a firmware version before creating a deployment"
+        text: "You must upload a firmware version before creating a Deployment Group"
       )
     end
   end
diff --git a/test/nerves_hub_web/live/deployment_groups/show_test.exs b/test/nerves_hub_web/live/deployment_groups/show_test.exs
new file mode 100644
index 000000000..48a7c5446
--- /dev/null
+++ b/test/nerves_hub_web/live/deployment_groups/show_test.exs
@@ -0,0 +1,170 @@
+defmodule NervesHubWeb.Live.DeploymentGroups.ShowTest do
+  use NervesHubWeb.ConnCase.Browser, async: true
+
+  alias NervesHub.AuditLogs
+  alias NervesHub.Devices
+  alias NervesHub.Devices.Device
+  alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
+
+  alias NervesHub.Repo
+
+  test "shows the deployment group", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> assert_has("h1", text: deployment_group.name)
+    |> assert_has("p.deployment-group-state", text: "Off")
+    |> assert_has("div#device-count p", text: "0")
+    |> then(fn conn ->
+      for tag <- deployment_group.conditions["tags"] do
+        assert_has(conn, "span", text: tag)
+      end
+
+      conn
+    end)
+  end
+
+  test "shows the deployment group with device count", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    device: device,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+    %Device{} = Devices.update_deployment_group(device, deployment_group)
+
+    # deleted devices shouldn't be included in the count
+    device_2 = Fixtures.device_fixture(org, product, firmware, %{deleted_at: DateTime.utc_now()})
+    %Device{} = Devices.update_deployment_group(device_2, deployment_group)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> assert_has("h1", text: deployment_group.name)
+    |> assert_has("p.deployment-group-state", text: "Off")
+    |> assert_has("div#device-count p", text: "1")
+    |> then(fn conn ->
+      for tag <- deployment_group.conditions["tags"] do
+        assert_has(conn, "span", text: tag)
+      end
+
+      conn
+    end)
+  end
+
+  test "you can delete a deployment group with no devices attached to it", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> assert_has("h1", text: deployment_group.name)
+    |> click_link("Delete")
+    |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployment_groups"))
+    |> assert_has("div", text: "Deployment Group successfully deleted")
+
+    assert ManagedDeployments.get_deployment_group(product, deployment_group.id) ==
+             {:error, :not_found}
+
+    logs = AuditLogs.logs_for(deployment_group)
+
+    assert List.last(logs).description =~ ~r/deleted deployment/
+  end
+
+  test "you can delete a deployment group with devices attached to it", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+    device = Fixtures.device_fixture(org, product, firmware)
+
+    device = Devices.update_deployment_group(device, deployment_group)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> assert_has("h1", text: deployment_group.name)
+    |> click_link("Delete")
+    |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployment_groups"))
+    |> assert_has("div", text: "Deployment Group successfully deleted")
+
+    assert ManagedDeployments.get_deployment_group(product, deployment_group.id) ==
+             {:error, :not_found}
+
+    logs = AuditLogs.logs_for(deployment_group)
+
+    assert List.last(logs).description =~ ~r/deleted deployment/
+
+    device = Repo.reload(device)
+    assert device.deployment_id == nil
+    assert device.deleted_at == nil
+  end
+
+  test "you can toggle the deployment group being on or off", %{
+    conn: conn,
+    user: user,
+    org: org,
+    org_key: org_key,
+    tmp_dir: tmp_dir
+  } do
+    product = Fixtures.product_fixture(user, org)
+    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
+    deployment_group = Fixtures.deployment_group_fixture(org, firmware)
+
+    conn
+    |> visit("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> assert_has("h1", text: deployment_group.name)
+    |> click_link("Turn On")
+    |> assert_path("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> then(fn conn ->
+      {:ok, reloaded_deployment_group} =
+        ManagedDeployments.get_deployment_group(product, deployment_group.id)
+
+      assert reloaded_deployment_group.is_active
+      assert_has(conn, "span", text: "Turn Off")
+
+      logs = AuditLogs.logs_for(deployment_group)
+      assert Enum.count(logs) == 1
+      assert List.last(logs).description =~ ~r/marked deployment/
+      conn
+    end)
+    |> click_link("Turn Off")
+    |> assert_path("/org/#{org.name}/#{product.name}/deployment_groups/#{deployment_group.name}")
+    |> then(fn conn ->
+      {:ok, reloaded_deployment_group} =
+        ManagedDeployments.get_deployment_group(product, deployment_group.id)
+
+      refute reloaded_deployment_group.is_active
+      assert_has(conn, "span", text: "Turn On")
+
+      logs = AuditLogs.logs_for(reloaded_deployment_group)
+      assert Enum.count(logs) == 3
+      assert List.last(logs).description =~ ~r/marked deployment/
+      conn
+    end)
+  end
+end
diff --git a/test/nerves_hub_web/live/deployments/edit_test.exs b/test/nerves_hub_web/live/deployments/edit_test.exs
deleted file mode 100644
index 5d4e5c3f4..000000000
--- a/test/nerves_hub_web/live/deployments/edit_test.exs
+++ /dev/null
@@ -1,70 +0,0 @@
-defmodule NervesHubWeb.Live.Deployments.EditTest do
-  use NervesHubWeb.ConnCase.Browser, async: true
-
-  alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
-  alias NervesHub.Deployments.Deployment
-  alias NervesHub.Fixtures
-
-  test "update the chosen resource, and adds an audit log", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-
-    conn =
-      conn
-      |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}/edit")
-      |> assert_has("h1", text: "Edit Deployment")
-      |> assert_has("a", text: product.name)
-      |> fill_in("Deployment name", with: "Moussaka")
-      |> fill_in("Tag(s) distributed to", with: "josh, lars")
-      |> fill_in("Version requirement", with: "4.3.2")
-      |> select(firmware.uuid, from: "Firmware version", exact_option: false)
-      |> click_button("Save Change")
-
-    {:ok, reloaded_deployment} = Deployments.get_deployment(product, deployment.id)
-
-    conn
-    |> assert_path(
-      URI.encode("/org/#{org.name}/#{product.name}/deployments/#{reloaded_deployment.name}")
-    )
-    |> assert_has("div", text: "Deployment updated")
-
-    assert reloaded_deployment.name == "Moussaka"
-    assert reloaded_deployment.conditions["version"] == "4.3.2"
-    assert Enum.sort(reloaded_deployment.conditions["tags"]) == Enum.sort(~w(josh lars))
-
-    [audit_log_one, audit_log_two] = AuditLogs.logs_for(deployment)
-
-    assert audit_log_one.resource_type == Deployment
-    assert audit_log_two.description =~ ~r/conditions changed/
-  end
-
-  test "failed update shows errors", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}/edit")
-    |> assert_has("h1", text: "Edit Deployment")
-    |> assert_has("a", text: product.name)
-    |> fill_in("Tag(s) distributed to", with: "")
-    |> fill_in("Version requirement", with: "")
-    |> click_button("Save Change")
-    |> assert_path("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}/edit")
-    |> assert_has("div", text: "should have at least 1 item(s)")
-  end
-end
diff --git a/test/nerves_hub_web/live/deployments/index_test.exs b/test/nerves_hub_web/live/deployments/index_test.exs
deleted file mode 100644
index 352807455..000000000
--- a/test/nerves_hub_web/live/deployments/index_test.exs
+++ /dev/null
@@ -1,53 +0,0 @@
-defmodule NervesHubWeb.Live.Deployments.IndexTest do
-  use NervesHubWeb.ConnCase.Browser, async: true
-
-  alias NervesHub.Deployments
-  alias NervesHub.Devices
-  alias NervesHub.Fixtures
-
-  test "no deployments", %{conn: conn, user: user, org: org} do
-    product = Fixtures.product_fixture(user, org, %{name: "Spaghetti"})
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments")
-    |> assert_has("h3", text: "#{product.name} doesn’t have any deployments configured")
-  end
-
-  test "has deployments", %{conn: conn, org: org, product: product, deployment: deployment} do
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments")
-    |> assert_has("h1", text: "Deployments")
-    |> assert_has("a", text: deployment.name)
-    |> assert_has("td div", text: "0")
-  end
-
-  test "device counts don't include deleted devices", %{
-    conn: conn,
-    org: org,
-    product: product,
-    deployment: deployment,
-    device: device
-  } do
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments")
-    |> assert_has("h1", text: "Deployments")
-    |> assert_has("a", text: deployment.name)
-    |> assert_has("td div", text: "0")
-
-    Deployments.set_deployment(device)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments")
-    |> assert_has("h1", text: "Deployments")
-    |> assert_has("a", text: deployment.name)
-    |> assert_has("td div", text: "1")
-
-    Devices.delete_device(device)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments")
-    |> assert_has("h1", text: "Deployments")
-    |> assert_has("a", text: deployment.name)
-    |> assert_has("td div", text: "0")
-  end
-end
diff --git a/test/nerves_hub_web/live/deployments/show_test.exs b/test/nerves_hub_web/live/deployments/show_test.exs
deleted file mode 100644
index ea6608e46..000000000
--- a/test/nerves_hub_web/live/deployments/show_test.exs
+++ /dev/null
@@ -1,166 +0,0 @@
-defmodule NervesHubWeb.Live.Deployments.ShowTest do
-  use NervesHubWeb.ConnCase.Browser, async: true
-
-  alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
-  alias NervesHub.Devices
-  alias NervesHub.Devices.Device
-  alias NervesHub.Fixtures
-
-  alias NervesHub.Repo
-
-  test "shows the deployment", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> assert_has("h1", text: deployment.name)
-    |> assert_has("p.deployment-state", text: "Off")
-    |> assert_has("div#device-count p", text: "0")
-    |> then(fn conn ->
-      for tag <- deployment.conditions["tags"] do
-        assert_has(conn, "span", text: tag)
-      end
-
-      conn
-    end)
-  end
-
-  test "shows the deployment with device count", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    device: device,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-    %Device{} = Devices.update_deployment(device, deployment)
-
-    # deleted devices shouldn't be included in the count
-    device_2 = Fixtures.device_fixture(org, product, firmware, %{deleted_at: DateTime.utc_now()})
-    %Device{} = Devices.update_deployment(device_2, deployment)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> assert_has("h1", text: deployment.name)
-    |> assert_has("p.deployment-state", text: "Off")
-    |> assert_has("div#device-count p", text: "1")
-    |> then(fn conn ->
-      for tag <- deployment.conditions["tags"] do
-        assert_has(conn, "span", text: tag)
-      end
-
-      conn
-    end)
-  end
-
-  test "you can delete a deployment with no devices attached to it", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> assert_has("h1", text: deployment.name)
-    |> click_link("Delete")
-    |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployments"))
-    |> assert_has("div", text: "Deployment successfully deleted")
-
-    assert Deployments.get_deployment(product, deployment.id) == {:error, :not_found}
-
-    logs = AuditLogs.logs_for(deployment)
-
-    assert List.last(logs).description =~ ~r/deleted deployment/
-  end
-
-  test "you can delete a deployment with devices attached to it", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-    device = Fixtures.device_fixture(org, product, firmware)
-
-    device = Devices.update_deployment(device, deployment)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> assert_has("h1", text: deployment.name)
-    |> click_link("Delete")
-    |> assert_path(URI.encode("/org/#{org.name}/#{product.name}/deployments"))
-    |> assert_has("div", text: "Deployment successfully deleted")
-
-    assert Deployments.get_deployment(product, deployment.id) == {:error, :not_found}
-
-    logs = AuditLogs.logs_for(deployment)
-
-    assert List.last(logs).description =~ ~r/deleted deployment/
-
-    device = Repo.reload(device)
-    assert device.deployment_id == nil
-    assert device.deleted_at == nil
-  end
-
-  test "you can toggle the deployment being on or off", %{
-    conn: conn,
-    user: user,
-    org: org,
-    org_key: org_key,
-    tmp_dir: tmp_dir
-  } do
-    product = Fixtures.product_fixture(user, org)
-    firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
-    deployment = Fixtures.deployment_fixture(org, firmware)
-
-    conn
-    |> visit("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> assert_has("h1", text: deployment.name)
-    |> click_link("Turn On")
-    |> assert_path("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> then(fn conn ->
-      {:ok, reloaded_deployment} = Deployments.get_deployment(product, deployment.id)
-
-      assert reloaded_deployment.is_active
-      assert_has(conn, "span", text: "Turn Off")
-
-      logs = AuditLogs.logs_for(deployment)
-      assert Enum.count(logs) == 1
-      assert List.last(logs).description =~ ~r/marked deployment/
-      conn
-    end)
-    |> click_link("Turn Off")
-    |> assert_path("/org/#{org.name}/#{product.name}/deployments/#{deployment.name}")
-    |> then(fn conn ->
-      {:ok, reloaded_deployment} = Deployments.get_deployment(product, deployment.id)
-
-      refute reloaded_deployment.is_active
-      assert_has(conn, "span", text: "Turn On")
-
-      logs = AuditLogs.logs_for(deployment)
-      assert Enum.count(logs) == 3
-      assert List.last(logs).description =~ ~r/marked deployment/
-      conn
-    end)
-  end
-end
diff --git a/test/nerves_hub_web/live/devices/index_test.exs b/test/nerves_hub_web/live/devices/index_test.exs
index caef32dfa..132847b99 100644
--- a/test/nerves_hub_web/live/devices/index_test.exs
+++ b/test/nerves_hub_web/live/devices/index_test.exs
@@ -232,16 +232,22 @@ defmodule NervesHubWeb.Live.Devices.IndexTest do
     end
 
     test "filters devices by deployment_id", %{conn: conn, fixture: fixture} do
-      %{device: device, firmware: firmware, org: org, product: product, deployment: deployment} =
+      %{
+        device: device,
+        firmware: firmware,
+        org: org,
+        product: product,
+        deployment_group: deployment_group
+      } =
         fixture
 
       device2 = Fixtures.device_fixture(org, product, firmware)
 
-      Repo.update!(Ecto.Changeset.change(device, deployment_id: deployment.id))
+      Repo.update!(Ecto.Changeset.change(device, deployment_id: deployment_group.id))
 
       {:ok, view, _html} = live(conn, device_index_path(fixture))
 
-      change = render_change(view, "update-filters", %{"deployment_id" => deployment.id})
+      change = render_change(view, "update-filters", %{"deployment_id" => deployment_group.id})
       assert change =~ device.identifier
       refute change =~ device2.identifier
       assert change =~ "1 devices found"
@@ -305,7 +311,7 @@ defmodule NervesHubWeb.Live.Devices.IndexTest do
         org: org,
         product: product,
         firmware: firmware,
-        deployment: deployment
+        deployment_group: deployment_group
       } = fixture
 
       device2 = Fixtures.device_fixture(org, product, firmware)
@@ -316,16 +322,18 @@ defmodule NervesHubWeb.Live.Devices.IndexTest do
 
       conn
       |> visit(
-        "/org/#{org.name}/#{product.name}/devices?platform=#{deployment.firmware.platform}"
+        "/org/#{org.name}/#{product.name}/devices?platform=#{deployment_group.firmware.platform}"
       )
       |> unwrap(fn view ->
         render_change(view, "select-all", %{"id" => device.id})
       end)
       |> assert_has("span", text: "2 selected")
       |> unwrap(fn view ->
-        render_change(view, "target-deployment", %{"deployment" => to_string(deployment.id)})
+        render_change(view, "target-deployment-group", %{
+          "deployment_group" => to_string(deployment_group.id)
+        })
       end)
-      |> click_button("#move-deployment-submit", "Move")
+      |> click_button("#move-deployment-group-submit", "Move")
       |> assert_has("div", text: "2 devices added to deployment")
 
       assert_receive %{event: "devices/updated"}
diff --git a/test/nerves_hub_web/live/devices/show_test.exs b/test/nerves_hub_web/live/devices/show_test.exs
index fd66b17ec..c9ef72d24 100644
--- a/test/nerves_hub_web/live/devices/show_test.exs
+++ b/test/nerves_hub_web/live/devices/show_test.exs
@@ -5,11 +5,11 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
   import Phoenix.ChannelTest
 
   alias NervesHub.AuditLogs
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.Connections
   alias NervesHub.Devices.Metrics
   alias NervesHub.Fixtures
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Repo
   alias NervesHubWeb.Endpoint
 
@@ -107,14 +107,15 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       conn: conn,
       fixture: fixture,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
-      {:ok, deployment} = Deployments.update_deployment(deployment, %{is_active: true})
+      {:ok, deployment_group} =
+        ManagedDeployments.update_deployment_group(deployment_group, %{is_active: true})
 
-      # Set device status to :provisioned for deployment eligibility
+      # Set device status to :provisioned for deployment group eligibility
       %{status: :provisioned} = Devices.set_as_provisioned!(device)
 
-      # mismatch device and deployment firmware so "Send Update" form doesn't display
+      # mismatch device and deployment group firmware so "Send Update" form doesn't display
       original_firmware_platform = device.firmware_metadata.platform
 
       updated_firmware_metadata =
@@ -126,7 +127,7 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
 
       conn
       |> visit(device_show_path(fixture))
-      |> refute_has("div", text: "Assigned Deployment")
+      |> refute_has("div", text: "Assigned Deployment Group")
       |> refute_has("span", text: "Update available")
       |> refute_has("option", text: "Select a version")
       |> assert_has("a.disabled", text: "Console")
@@ -144,14 +145,14 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
 
         {:ok, device} = Devices.update_firmware_metadata(device, restored_firmware_metadata)
 
-        _device = Devices.update_deployment(device, deployment)
+        _device = Devices.update_deployment_group(device, deployment_group)
 
         {:ok, _} = Metrics.save_metrics(device.id, %{"cpu_usage_percent" => 22})
 
         send(view.pid, %Broadcast{event: "connection:status", payload: %{status: "online"}})
         render(view)
       end)
-      |> assert_has("div", text: "Assigned Deployment")
+      |> assert_has("div", text: "Assigned Deployment Group")
       |> assert_has("span", text: "Update available")
       |> assert_has("option", text: "Select a version")
       |> refute_has("a.disabled", text: "Console")
@@ -455,11 +456,11 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       device =
         device
-        |> Ecto.Changeset.change(%{deployment_id: deployment.id})
+        |> Ecto.Changeset.change(%{deployment_id: deployment_group.id})
         |> Repo.update!()
 
       conn
@@ -473,18 +474,18 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment,
+      deployment_group: deployment_group,
       org_key: org_key,
       tmp_dir: tmp_dir
     } do
       device =
         device
-        |> Ecto.Changeset.change(%{deployment_id: deployment.id, status: :provisioned})
+        |> Ecto.Changeset.change(%{deployment_id: deployment_group.id, status: :provisioned})
         |> Repo.update!()
 
       firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
 
-      deployment
+      deployment_group
       |> Ecto.Changeset.change(%{firmware_id: firmware.id, is_active: true})
       |> Repo.update!()
 
@@ -507,18 +508,18 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment,
+      deployment_group: deployment_group,
       org_key: org_key,
       tmp_dir: tmp_dir
     } do
       device =
         device
-        |> Ecto.Changeset.change(%{deployment_id: deployment.id})
+        |> Ecto.Changeset.change(%{deployment_id: deployment_group.id})
         |> Repo.update!()
 
       firmware = Fixtures.firmware_fixture(org_key, product, %{dir: tmp_dir})
 
-      deployment
+      deployment_group
       |> Ecto.Changeset.change(%{firmware_id: firmware.id, is_active: false})
       |> Repo.update!()
 
@@ -569,19 +570,19 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       device =
         device
-        |> Ecto.Changeset.change(%{deployment_id: deployment.id, status: :provisioned})
+        |> Ecto.Changeset.change(%{deployment_id: deployment_group.id, status: :provisioned})
         |> Repo.update!()
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/devices/#{device.identifier}")
       |> unwrap(fn view ->
-        render_change(view, "remove-from-deployment")
+        render_change(view, "remove-from-deployment-group")
       end)
-      |> assert_has("div", text: "Eligible Deployments")
+      |> assert_has("div", text: "Eligible Deployment Groups")
 
       assert_receive %Phoenix.Socket.Broadcast{event: "devices/deployment-cleared"}
 
@@ -606,17 +607,17 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       conn
       |> visit("/org/#{org.name}/#{product.name}/devices/#{device.identifier}")
-      |> assert_has("div", text: "Product Deployments")
+      |> assert_has("div", text: "Product Deployment Groups")
       |> unwrap(fn view ->
-        render_change(view, "set-deployment", %{"deployment_id" => deployment.id})
+        render_change(view, "set-deployment-group", %{"deployment_id" => deployment_group.id})
       end)
       |> assert_has("div",
         text:
-          "Device will be removed from the deployment upon connection if the aarch and platform doesn't match."
+          "Device will be removed from the deployment group upon connection if the arch and platform doesn't match."
       )
     end
 
@@ -625,7 +626,7 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       # Set device status to :provisioned for deployment eligibility
       %{status: :provisioned} = Devices.set_as_provisioned!(device)
@@ -634,11 +635,11 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/devices/#{device.identifier}")
-      |> assert_has("div", text: "Eligible Deployment")
+      |> assert_has("div", text: "Eligible Deployment Group")
       |> unwrap(fn view ->
-        render_change(view, "set-deployment", %{"deployment_id" => deployment.id})
+        render_change(view, "set-deployment-group", %{"deployment_id" => deployment_group.id})
       end)
-      |> assert_has("div", text: "Assigned Deployment")
+      |> assert_has("div", text: "Assigned Deployment Group")
 
       assert Repo.reload(device) |> Map.get(:deployment_id)
       assert length(AuditLogs.logs_for(device)) == 1
@@ -649,15 +650,15 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       # Set device status to :provisioned for deployment eligibility
       %{status: :provisioned} = Devices.set_as_provisioned!(device)
-      _ = Repo.delete!(deployment)
+      _ = Repo.delete!(deployment_group)
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/devices/#{device.identifier}")
-      |> assert_has("div", text: "No Eligible Deployments")
+      |> assert_has("div", text: "No Eligible Deployment Groups")
     end
 
     test "broadcasts to devices channel", %{
@@ -665,13 +666,13 @@ defmodule NervesHubWeb.Live.Devices.ShowTest do
       org: org,
       product: product,
       device: device,
-      deployment: deployment
+      deployment_group: deployment_group
     } do
       conn
       |> visit("/org/#{org.name}/#{product.name}/devices/#{device.identifier}")
-      |> assert_has("div", text: "Product Deployments")
+      |> assert_has("div", text: "Product Deployment Groups")
       |> unwrap(fn view ->
-        render_change(view, "set-deployment", %{"deployment_id" => deployment.id})
+        render_change(view, "set-deployment-group", %{"deployment_id" => deployment_group.id})
       end)
 
       assert_receive %Phoenix.Socket.Broadcast{event: "devices/deployment-updated"}
diff --git a/test/nerves_hub_web/live/firmware_test.exs b/test/nerves_hub_web/live/firmware_test.exs
index 42db463f0..79c375bed 100644
--- a/test/nerves_hub_web/live/firmware_test.exs
+++ b/test/nerves_hub_web/live/firmware_test.exs
@@ -48,7 +48,7 @@ defmodule NervesHubWeb.Live.FirmwareTest do
       firmware = Fixtures.firmware_fixture(org_key, product)
 
       # Create a deployment from the firmware
-      Fixtures.deployment_fixture(org, firmware)
+      Fixtures.deployment_group_fixture(org, firmware)
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/firmware")
@@ -95,7 +95,7 @@ defmodule NervesHubWeb.Live.FirmwareTest do
       firmware = Fixtures.firmware_fixture(org_key, product)
 
       # Create a deployment from the firmware
-      Fixtures.deployment_fixture(org, firmware)
+      Fixtures.deployment_group_fixture(org, firmware)
 
       conn
       |> visit("/org/#{org.name}/#{product.name}/firmware/#{firmware.uuid}")
diff --git a/test/support/browser_case.ex b/test/support/browser_case.ex
index c5624423e..30ccef3e6 100644
--- a/test/support/browser_case.ex
+++ b/test/support/browser_case.ex
@@ -27,7 +27,7 @@ defmodule NervesHubWeb.ConnCase.Browser do
           user: user,
           product: product,
           device: device,
-          deployment: deployment
+          deployment_group: deployment_group
         } = fixture
 
         conn =
@@ -44,7 +44,7 @@ defmodule NervesHubWeb.ConnCase.Browser do
           org_key: org_key,
           product: product,
           device: device,
-          deployment: deployment
+          deployment_group: deployment_group
         }
       end
     end
diff --git a/test/support/fixtures.ex b/test/support/fixtures.ex
index e2b01503a..c81104b98 100644
--- a/test/support/fixtures.ex
+++ b/test/support/fixtures.ex
@@ -7,11 +7,11 @@ defmodule NervesHub.Fixtures do
   alias NervesHub.Archives
   alias NervesHub.AuditLogs.AuditLog
   alias NervesHub.Certificate
-  alias NervesHub.Deployments
   alias NervesHub.Devices
   alias NervesHub.Devices.DeviceConnection
   alias NervesHub.Devices.InflightUpdate
   alias NervesHub.Firmwares
+  alias NervesHub.ManagedDeployments
   alias NervesHub.Products
   alias NervesHub.Products.Product
   alias NervesHub.Repo
@@ -22,7 +22,7 @@ defmodule NervesHub.Fixtures do
 
   @org_params %{name: "Test-Org"}
 
-  @deployment_params %{
+  @deployment_group_params %{
     name: "Test Deployment",
     conditions: %{
       "version" => "<= 1.0.0",
@@ -215,18 +215,19 @@ defmodule NervesHub.Fixtures do
     archive
   end
 
-  def deployment_fixture(%Org{} = org, %Firmwares.Firmware{} = firmware, params \\ %{}) do
+  def deployment_group_fixture(%Org{} = org, %Firmwares.Firmware{} = firmware, params \\ %{}) do
     {is_active, params} = Map.pop(params, :is_active, false)
 
-    {:ok, deployment} =
+    {:ok, deployment_group} =
       %{org_id: org.id, firmware_id: firmware.id}
       |> Enum.into(params)
-      |> Enum.into(@deployment_params)
-      |> Deployments.create_deployment()
+      |> Enum.into(@deployment_group_params)
+      |> ManagedDeployments.create_deployment_group()
 
-    {:ok, deployment} = Deployments.update_deployment(deployment, %{is_active: is_active})
+    {:ok, deployment_group} =
+      ManagedDeployments.update_deployment_group(deployment_group, %{is_active: is_active})
 
-    deployment
+    deployment_group
   end
 
   def device_fixture(
@@ -380,7 +381,7 @@ defmodule NervesHub.Fixtures do
     %{fixture | db_cert: db_cert}
   end
 
-  def inflight_update(device, deployment, params \\ %{}) do
+  def inflight_update(device, deployment_group, params \\ %{}) do
     expires_at =
       DateTime.utc_now()
       |> DateTime.shift(hour: 1)
@@ -388,9 +389,9 @@ defmodule NervesHub.Fixtures do
 
     defaults = %{
       "device_id" => device.id,
-      "deployment_id" => deployment.id,
-      "firmware_id" => deployment.firmware_id,
-      "firmware_uuid" => deployment.firmware.uuid,
+      "deployment_id" => deployment_group.id,
+      "firmware_id" => deployment_group.firmware_id,
+      "firmware_uuid" => deployment_group.firmware.uuid,
       "expires_at" => expires_at
     }
 
@@ -425,7 +426,7 @@ defmodule NervesHub.Fixtures do
     product = product_fixture(user, org, %{name: "Hop"})
     org_key = org_key_fixture(org, user, dir)
     firmware = firmware_fixture(org_key, product, %{dir: dir})
-    deployment = deployment_fixture(org, firmware)
+    deployment_group = deployment_group_fixture(org, firmware)
     device = device_fixture(org, product, firmware)
     %{db_cert: device_certificate} = device_certificate_fixture(device)
 
@@ -436,7 +437,7 @@ defmodule NervesHub.Fixtures do
       org_key: org_key,
       user: user,
       firmware: firmware,
-      deployment: deployment,
+      deployment_group: deployment_group,
       product: product
     }
   end
diff --git a/test/test_helper.exs b/test/test_helper.exs
index 3ca3be329..f51913208 100644
--- a/test/test_helper.exs
+++ b/test/test_helper.exs
@@ -1,6 +1,6 @@
 Mimic.copy(ProcessHub)
 Mimic.copy(NervesHub.Devices)
-Mimic.copy(NervesHub.Deployments.Distributed.Orchestrator)
+Mimic.copy(NervesHub.ManagedDeployments.Distributed.Orchestrator)
 Mimic.copy(NervesHub.Firmwares.DeltaUpdater.Default)
 Mimic.copy(NervesHub.Firmwares.Upload.File)
 Mimic.copy(NervesHub.Firmwares.Upload)