diff --git a/ee/app/models/software_license_policy.rb b/ee/app/models/software_license_policy.rb
index 47a01e79cf44b5d8ddeb980b0b74401ca34536d4..c7042cdda728af8a9a70000eb38b6402a4a36403 100644
--- a/ee/app/models/software_license_policy.rb
+++ b/ee/app/models/software_license_policy.rb
@@ -42,7 +42,6 @@ class SoftwareLicensePolicy < ApplicationRecord
   scope :including_scan_result_policy_read, -> { includes(:scan_result_policy_read) }
   scope :unreachable_limit, -> { limit(1_000) }
   scope :with_scan_result_policy_read, -> { where.not(scan_result_policy_id: nil) }
-  scope :count_for_software_license, ->(software_license_id) { where(software_license_id: software_license_id).count }
 
   scope :exclusion_allowed, -> do
     joins(:scan_result_policy_read)
diff --git a/ee/app/services/software_license_policies/delete_service.rb b/ee/app/services/software_license_policies/delete_service.rb
deleted file mode 100644
index d1a8e91e89caa23b16bb61e261ee0cfd58d6c6b8..0000000000000000000000000000000000000000
--- a/ee/app/services/software_license_policies/delete_service.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module SoftwareLicensePolicies
-  class DeleteService < ::BaseService
-    def execute(software_license_policy)
-      SoftwareLicensePolicy.transaction do
-        software_license = SoftwareLicense.find(software_license_policy.software_license_id)
-
-        software_license_policy.destroy!
-
-        if software_license.spdx_identifier.nil? &&
-            SoftwareLicensePolicy.count_for_software_license(software_license.id) == 0
-          software_license.destroy!
-        end
-      end
-    end
-  end
-end
diff --git a/ee/spec/models/software_license_policy_spec.rb b/ee/spec/models/software_license_policy_spec.rb
index 821ae70c0f92a49886ef6d52305e26a616ce48df..3d159b2be546d952acbc2e83810849825f21a329 100644
--- a/ee/spec/models/software_license_policy_spec.rb
+++ b/ee/spec/models/software_license_policy_spec.rb
@@ -45,14 +45,6 @@
     it { expect(described_class.by_spdx(SecureRandom.uuid)).to be_empty }
   end
 
-  describe '.count_for_software_license' do
-    let!(:mit) { create(:software_license, :mit) }
-    let!(:mit_policy1) { create(:software_license_policy, software_license: mit) }
-    let!(:mit_policy2) { create(:software_license_policy, software_license: mit) }
-
-    it { expect(described_class.count_for_software_license(mit.id)).to eq(2) }
-  end
-
   describe '.exclusion_allowed' do
     let_it_be(:mit) { create(:software_license, :mit) }
     let_it_be(:scan_result_policy_read_with_inclusion) { create(:scan_result_policy_read, match_on_inclusion_license: true) }
diff --git a/ee/spec/services/software_license_policies/delete_service_spec.rb b/ee/spec/services/software_license_policies/delete_service_spec.rb
deleted file mode 100644
index e855b98accd77f7ebfe86f9b20b79fecaef949eb..0000000000000000000000000000000000000000
--- a/ee/spec/services/software_license_policies/delete_service_spec.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SoftwareLicensePolicies::DeleteService, feature_category: :security_policy_management do
-  subject(:service) { described_class.new(project, user) }
-
-  let_it_be(:project) { create(:project) }
-
-  let(:user) do
-    create(:user).tap do |u|
-      project.add_maintainer(u)
-    end
-  end
-
-  let(:software_license) { create(:software_license) }
-  let(:software_license_policy) { create(:software_license_policy, :denied, software_license: software_license) }
-
-  describe '#execute' do
-    context 'when software_license has one software_license_policy' do
-      it 'deletes software_license_policy and software_license' do
-        service.execute(software_license_policy)
-
-        expect { software_license_policy.reload }.to raise_error(ActiveRecord::RecordNotFound)
-        expect { software_license.reload }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context 'when software_license has spdx_identifier' do
-      let(:software_license) { create(:software_license, :mit) }
-
-      it 'deletes software_license_policy only' do
-        service.execute(software_license_policy)
-
-        expect { software_license_policy.reload }.to raise_error(ActiveRecord::RecordNotFound)
-        expect { software_license.reload }.not_to raise_error
-      end
-    end
-
-    context 'when software_license has multiple software_license_policies' do
-      before do
-        create(:software_license_policy, software_license: software_license)
-      end
-
-      it 'deletes software_license_policy only' do
-        service.execute(software_license_policy)
-
-        expect { software_license_policy.reload }.to raise_error(ActiveRecord::RecordNotFound)
-        expect { software_license.reload }.not_to raise_error
-      end
-    end
-  end
-end