diff --git a/app/jobs/reports/ab_tests_report.rb b/app/jobs/reports/ab_tests_report.rb
index e96618e72cf..21adb6d6109 100644
--- a/app/jobs/reports/ab_tests_report.rb
+++ b/app/jobs/reports/ab_tests_report.rb
@@ -15,40 +15,39 @@ def initialize(report_date = nil, *args, **kwargs)
     def perform(report_date)
       @report_date = report_date
 
-      report_configs.each do |config|
-        tables_report(config).deliver_now
+      reported_ab_tests.each do |ab_test|
+        tables_report(ab_test).deliver_now
       end
     end
 
-    def tables_report(config)
-      experiment_name = config.experiment_name
+    def tables_report(ab_test)
+      experiment_name = ab_test.experiment_name
       subject = "A/B Tests Report - #{experiment_name} - #{report_date}"
-      reports = ab_tests_report(config).as_emailable_reports
+      report = ab_tests_report(ab_test)
 
       ReportMailer.tables_report(
-        email: config.email,
+        email: ab_test.report.email,
         subject:,
-        message: subject,
-        reports:,
+        message: [subject, report.participants_message].compact,
+        reports: report.as_emailable_reports,
         attachment_format: :csv,
       )
     end
 
-    def ab_tests_report(config)
+    def ab_tests_report(ab_test)
       Reporting::AbTestsReport.new(
-        queries: config.queries,
+        ab_test:,
         time_range: report_date.yesterday..report_date,
       )
     end
 
     private
 
-    def report_configs
+    def reported_ab_tests
       AbTests
         .all
         .values
         .select { |ab_test| ab_test.report&.email&.present? && ab_test.active? }
-        .map(&:report)
     end
   end
 end
diff --git a/app/mailers/report_mailer.rb b/app/mailers/report_mailer.rb
index 89bc2306e8f..4706555fc41 100644
--- a/app/mailers/report_mailer.rb
+++ b/app/mailers/report_mailer.rb
@@ -26,6 +26,7 @@ def warn_error(email:, error:, env: Rails.env)
   # @param [String] email
   # @param [String] subject
   # @param [String] env name of current deploy environment
+  # @param [String, String[]] message Message(s) to use as email prelude
   # @param [:csv,:xlsx] attachment_format
   # @param [Array<EmailableReport>] reports
   #   an array of tables (which are arrays of rows (arrays of strings))
diff --git a/app/models/ab_test_assignment.rb b/app/models/ab_test_assignment.rb
new file mode 100644
index 00000000000..52fcda0aa55
--- /dev/null
+++ b/app/models/ab_test_assignment.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AbTestAssignment < ApplicationRecord
+  class << self
+    def bucket(**)
+      find_by(**)&.bucket&.to_sym
+    end
+  end
+end
diff --git a/app/services/analytics.rb b/app/services/analytics.rb
index 214e467df0a..e62bfa0b574 100644
--- a/app/services/analytics.rb
+++ b/app/services/analytics.rb
@@ -88,6 +88,7 @@ def ab_test_attributes(event)
         session:,
         user:,
         user_session:,
+        persisted_read_only: true,
       )
       if !bucket.blank?
         obj[test_id.downcase] = {
diff --git a/app/views/report_mailer/tables_report.html.erb b/app/views/report_mailer/tables_report.html.erb
index 8bb9fc0df7f..5aeaaa39422 100644
--- a/app/views/report_mailer/tables_report.html.erb
+++ b/app/views/report_mailer/tables_report.html.erb
@@ -11,7 +11,9 @@
       ) %>
 </header>
 <hr class="height-05 margin-bottom-4 border-transparent bg-secondary">
-<%= @message %><br>
+<% [*@message].each do |message| %>
+  <p><%= message %></p>
+<% end %>
 <% @reports.each do |report| %>
   <% header, *rows = report.table %>
   <%# Allow nil title if a subtitle is set %>
diff --git a/db/primary_migrate/20250207144037_create_ab_test_assignments.rb b/db/primary_migrate/20250207144037_create_ab_test_assignments.rb
new file mode 100644
index 00000000000..adb6f78a698
--- /dev/null
+++ b/db/primary_migrate/20250207144037_create_ab_test_assignments.rb
@@ -0,0 +1,10 @@
+class CreateAbTestAssignments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :ab_test_assignments do |t|
+      t.string :experiment, null: false, comment: 'sensitive=false'
+      t.string :discriminator, null: false, comment: 'sensitive=false'
+      t.string :bucket, null: false, comment: 'sensitive=false'
+      t.index [:experiment, :discriminator], unique: true, using: :btree
+    end
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index a5f6df18193..f9da1bb4248 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,12 +10,19 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2025_01_06_232958) do
+ActiveRecord::Schema[8.0].define(version: 2025_02_07_144037) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "citext"
   enable_extension "pg_catalog.plpgsql"
   enable_extension "pg_stat_statements"
 
+  create_table "ab_test_assignments", force: :cascade do |t|
+    t.string "experiment", null: false, comment: "sensitive=false"
+    t.string "discriminator", null: false, comment: "sensitive=false"
+    t.string "bucket", null: false, comment: "sensitive=false"
+    t.index ["experiment", "discriminator"], name: "index_ab_test_assignments_on_experiment_and_discriminator", unique: true
+  end
+
   create_table "account_reset_requests", force: :cascade do |t|
     t.integer "user_id", null: false, comment: "sensitive=false"
     t.datetime "requested_at", precision: nil, comment: "sensitive=false"
diff --git a/lib/ab_test.rb b/lib/ab_test.rb
index abee04e0a13..e8aaa7d0c39 100644
--- a/lib/ab_test.rb
+++ b/lib/ab_test.rb
@@ -3,13 +3,22 @@
 class AbTest
   include ::NewRelic::Agent::MethodTracer
 
-  attr_reader :buckets, :experiment_name, :default_bucket, :should_log, :report
+  attr_reader :buckets,
+              :experiment_name,
+              :default_bucket,
+              :should_log,
+              :report,
+              :persist,
+              :max_participants
+
+  alias_method :experiment, :experiment_name
+  alias_method :persist?, :persist
 
   MAX_SHA = (16 ** 64) - 1
 
   ReportQueryConfig = Struct.new(:title, :query, :row_labels, keyword_init: true).freeze
 
-  ReportConfig = Struct.new(:experiment_name, :email, :queries, keyword_init: true) do
+  ReportConfig = Struct.new(:email, :queries, keyword_init: true) do
     def initialize(queries: [], **)
       super
       self.queries.map!(&ReportQueryConfig.method(:new))
@@ -19,6 +28,9 @@ def initialize(queries: [], **)
   # @param [Regexp,#include?,nil] should_log A list of analytics event names for which the A/B test
   #   bucket assignment should be logged, or a regular expression pattern which is tested against an
   #   analytics event name when an event is being logged.
+  # @param [Hash] report Report mailer configuration.
+  # @param [Boolean] persist Whether the test assignment should be persisted to the database.
+  # @param [Integer] max_participants The maximum number of participants allowed in the test.
   # @yieldparam [ActionDispatch::Request] request
   # @yieldparam [String,nil] service_provider Issuer string for the service provider associated with
   #                                           the current session.
@@ -30,6 +42,8 @@ def initialize(
     should_log: nil,
     default_bucket: :default,
     report: nil,
+    persist: false,
+    max_participants: Float::INFINITY,
     &discriminator
   )
     @buckets = buckets
@@ -37,7 +51,10 @@ def initialize(
     @experiment_name = experiment_name
     @default_bucket = default_bucket
     @should_log = should_log
-    @report = ReportConfig.new(experiment_name:, **report.to_h) if report
+    @report = ReportConfig.new(**report.to_h) if report
+    @persist = persist
+    raise 'max_participants requires persist to be true' if max_participants.finite? && !persist?
+    @max_participants = max_participants
     raise 'invalid bucket data structure' unless valid_bucket_data_structure?
     ensure_numeric_percentages
     raise 'bucket percentages exceed 100' unless within_100_percent?
@@ -50,7 +67,16 @@ def initialize(
   # @param [Hash] session
   # @param [User] user
   # @param [Hash] user_session
-  def bucket(request:, service_provider:, session:, user:, user_session:)
+  # @param [Boolean] persisted_read_only Avoid new bucket assignment if test is configured to be
+  #   persisted but there is no persisted value.
+  def bucket(
+    request:,
+    service_provider:,
+    session:,
+    user:,
+    user_session:,
+    persisted_read_only: false
+  )
     return nil if !active?
 
     discriminator = resolve_discriminator(
@@ -59,16 +85,28 @@ def bucket(request:, service_provider:, session:, user:, user_session:)
     )
     return nil if discriminator.blank?
 
+    persisted_value = AbTestAssignment.bucket(experiment:, discriminator:) if persist?
+    return persisted_value if persisted_value || (persist? && persisted_read_only)
+
+    return nil if maxed?
+
     user_value = percent(discriminator)
 
+    bucket = @default_bucket
+
     min = 0
     buckets.keys.each do |key|
       max = min + buckets[key]
-      return key if user_value > min && user_value <= max
+      if user_value > min && user_value <= max
+        bucket = key
+        break
+      end
       min = max
     end
 
-    @default_bucket
+    AbTestAssignment.create(experiment:, discriminator:, bucket:) if persist?
+
+    bucket
   end
 
   def include_in_analytics_event?(event_name)
@@ -87,8 +125,18 @@ def active?
     @active
   end
 
+  def participants_count
+    return if !persist?
+    AbTestAssignment.where(experiment:).count
+  end
+
   private
 
+  def maxed?
+    return false if !persist? || !max_participants.finite?
+    participants_count >= max_participants
+  end
+
   def resolve_discriminator(user:, **)
     if @discriminator
       @discriminator.call(user:, **)
diff --git a/lib/reporting/ab_tests_report.rb b/lib/reporting/ab_tests_report.rb
index 8dd45408c69..2a6144eb7ad 100644
--- a/lib/reporting/ab_tests_report.rb
+++ b/lib/reporting/ab_tests_report.rb
@@ -5,15 +5,15 @@
 
 module Reporting
   class AbTestsReport
-    attr_reader :queries, :time_range
+    attr_reader :ab_test, :time_range
 
-    # @param [Array<AbTest::ReportQueryConfig>] queries
+    # @param [AbTest] ab_test
     # @param [Range<Time>] time_range
     def initialize(
-      queries:,
+      ab_test:,
       time_range:
     )
-      @queries = queries
+      @ab_test = ab_test
       @time_range = time_range
     end
 
@@ -30,8 +30,18 @@ def as_emailable_reports
       end
     end
 
+    def participants_message
+      return unless ab_test.persist?
+      message = "Total participants: #{participants_count.to_fs(:delimited)}"
+      message += " (of #{max_participants.to_fs(:delimited)} maximum)" if max_participants.finite?
+      message
+    end
+
     private
 
+    delegate :participants_count, :max_participants, :report, to: :ab_test
+    delegate :queries, to: :report
+
     def table_for_query(query)
       query_data = fetch_results(query: query.query)
       headers = column_labels(query_data.first)
diff --git a/lib/tasks/ab_tests.rake b/lib/tasks/ab_tests.rake
new file mode 100644
index 00000000000..1b6e0a1b3a8
--- /dev/null
+++ b/lib/tasks/ab_tests.rake
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+namespace :ab_tests do
+  desc 'Deletes persisted A/B test assignments for outdated tests'
+  task :delete_outdated, [:confirm] => :environment do |_t, args|
+    args.with_defaults(confirm: false)
+
+    configured_experiments = AbTests.all.values.map(&:experiment)
+    outdated_assignments = AbTestAssignment.where.not(experiment: configured_experiments)
+
+    names = outdated_assignments.distinct.pluck(:experiment).sort
+    if names.empty?
+      warn 'No outdated test assignments to delete!'
+      next
+    end
+
+    puts 'Found outdated test assignments with experiment names:'
+    names.each { |name| puts "  - #{name}" }
+    puts ''
+
+    if args.confirm
+      deleted = log_to_stdout { outdated_assignments.in_batches.delete_all }
+      puts "\nSuccessfully deleted #{deleted} #{'record'.pluralize(deleted)}."
+    else
+      puts <<~STR
+        Re-run command with `confirm` arg to delete:
+
+          rake "ab_tests:delete_outdated[confirm]"
+
+      STR
+    end
+  end
+end
+
+def log_to_stdout
+  original_logger = ActiveRecord::Base.logger
+  stdout_logger = Logger.new(STDOUT)
+  ActiveRecord::Base.logger = ActiveSupport::BroadcastLogger.new(original_logger, stdout_logger)
+  yield
+ensure
+  ActiveRecord::Base.logger = original_logger
+end
diff --git a/spec/factories/ab_test_assignment.rb b/spec/factories/ab_test_assignment.rb
new file mode 100644
index 00000000000..2ad892a7b69
--- /dev/null
+++ b/spec/factories/ab_test_assignment.rb
@@ -0,0 +1,9 @@
+FactoryBot.define do
+  factory :ab_test_assignment do
+    ab_test = AbTests.all.values.sample
+
+    experiment { ab_test.experiment }
+    discriminator { Random.uuid }
+    bucket { [*ab_test.buckets.keys, ab_test.default_bucket].sample }
+  end
+end
diff --git a/spec/jobs/reports/ab_tests_report_spec.rb b/spec/jobs/reports/ab_tests_report_spec.rb
index caf3938cf34..1732e3da290 100644
--- a/spec/jobs/reports/ab_tests_report_spec.rb
+++ b/spec/jobs/reports/ab_tests_report_spec.rb
@@ -22,9 +22,15 @@
     {
       RECAPTCHA_SIGN_IN: AbTest.new(
         experiment_name: 'reCAPTCHA at Sign-In',
+        persist: true,
+        max_participants: 10_000,
         buckets: { sign_in_recaptcha: tested_percent },
         report: { email:, queries: },
       ),
+      UNREPORTED_EXPERIMENT: AbTest.new(
+        experiment_name: 'Unreported Experiment',
+        buckets: { group_a: 1 },
+      ),
     }
   end
 
@@ -47,12 +53,16 @@
     end
 
     let(:report) do
-      double(Reporting::AbTestsReport, as_emailable_reports: emailable_reports)
+      double(
+        Reporting::AbTestsReport,
+        as_emailable_reports: emailable_reports,
+        participants_message: 'Total participants: 0 (of 10,000 maximum)',
+      )
     end
 
     before do
       allow(Reporting::AbTestsReport).to receive(:new).with(
-        queries:,
+        ab_test: ab_tests[:RECAPTCHA_SIGN_IN],
         time_range: report_date.yesterday..report_date,
       ).and_return(report)
 
@@ -63,7 +73,10 @@
       expect(ReportMailer).to receive(:tables_report).with(
         email:,
         subject: "A/B Tests Report - reCAPTCHA at Sign-In - #{report_date}",
-        message: "A/B Tests Report - reCAPTCHA at Sign-In - #{report_date}",
+        message: [
+          "A/B Tests Report - reCAPTCHA at Sign-In - #{report_date}",
+          'Total participants: 0 (of 10,000 maximum)',
+        ],
         reports: emailable_reports,
         attachment_format: :csv,
       )
diff --git a/spec/lib/ab_test_spec.rb b/spec/lib/ab_test_spec.rb
index 172e2ffe7a7..18cd98b5774 100644
--- a/spec/lib/ab_test_spec.rb
+++ b/spec/lib/ab_test_spec.rb
@@ -35,17 +35,10 @@
 
   let(:user_session) { {} }
 
-  let(:bucket) do
-    ab_test.bucket(
-      request:,
-      service_provider:,
-      session:,
-      user:,
-      user_session:,
-    )
-  end
-
   describe '#bucket' do
+    subject(:bucket) { ab_test.bucket(**bucket_options) }
+    let(:bucket_options) { { request:, service_provider:, session:, user:, user_session: } }
+
     it 'divides random uuids into the buckets with no automatic default' do
       results = {}
       1000.times do
@@ -163,6 +156,87 @@
         expect { ab_test }.to raise_error(RuntimeError, 'invalid bucket data structure')
       end
     end
+
+    context 'with max_participants' do
+      let(:options) { super().merge(max_participants: 1, persist: true) }
+
+      it 'creates and returns new assignment' do
+        expect { bucket }.to change { AbTestAssignment.count }.by(1)
+        expect(bucket).to be_kind_of(Symbol)
+      end
+
+      context 'when maxed' do
+        before do
+          create(
+            :ab_test_assignment,
+            experiment: ab_test.experiment,
+            discriminator: 'existing-uuid',
+            bucket: 'foo',
+          )
+        end
+
+        it { is_expected.to be_nil }
+
+        it 'does not create a new assignment' do
+          expect { bucket }.not_to change { AbTestAssignment.count }
+        end
+
+        context 'with already-assigned participant' do
+          let(:discriminator) { ->(**) { 'existing-uuid' } }
+
+          it 'continues to return persisted value' do
+            expect(bucket).to eq(:foo)
+          end
+        end
+      end
+
+      context 'without persistance' do
+        let(:options) { super().merge(persist: false) }
+
+        it 'raises an error' do
+          expect { bucket }.to raise_error('max_participants requires persist to be true')
+        end
+      end
+    end
+
+    context 'with persisted ab test' do
+      let(:user) { create(:user) }
+      let(:discriminator) { nil }
+      let(:options) { super().merge(persist: true) }
+
+      context 'without existing assignment' do
+        it 'creates and returns new assignment' do
+          expect { bucket }.to change { AbTestAssignment.count }.by(1)
+          expect(bucket).to be_kind_of(Symbol)
+        end
+
+        context 'with persisted_read_only option' do
+          let(:bucket_options) { super().merge(persisted_read_only: true) }
+
+          it { is_expected.to be_nil }
+
+          it 'does not create a new assignment' do
+            expect { bucket }.not_to change { AbTestAssignment.count }
+          end
+        end
+      end
+
+      context 'with existing assignment' do
+        before do
+          create(
+            :ab_test_assignment,
+            experiment: ab_test.experiment,
+            discriminator: user.uuid,
+            bucket: 'foo',
+          )
+        end
+
+        it 'returns existing assignment without creating new' do
+          expect { bucket }.not_to change { AbTestAssignment.count }
+          expect(bucket).to eq(:foo)
+        end
+      end
+    end
   end
 
   describe '#include_in_analytics_event?' do
@@ -238,7 +312,6 @@ def include?(event_name)
 
     it 'builds struct value from given hash option' do
       expect(report).to be_a(AbTest::ReportConfig)
-      expect(report.experiment_name).to eq('test')
       expect(report.email).to eq('email@example.com')
       expect(report.queries).to all be_a(AbTest::ReportQueryConfig)
       expect(report.queries.first.title).to eq('Example Query')
@@ -256,7 +329,6 @@ def include?(event_name)
 
       it 'gracefully builds an empty struct value' do
         expect(report).to be_a(AbTest::ReportConfig)
-        expect(report.experiment_name).to eq('test')
         expect(report.email).to be_nil
         expect(report.queries).to eq([])
       end
@@ -284,4 +356,24 @@ def include?(event_name)
       it { is_expected.to be false }
     end
   end
+
+  describe '#participants_count' do
+    subject(:participants_count) { ab_test.participants_count }
+
+    context 'without persistance' do
+      let(:options) { super().merge(persist: false) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'with persistance' do
+      let(:options) { super().merge(persist: true) }
+
+      it 'returns current number of test participants' do
+        create_list(:ab_test_assignment, 2, experiment: options[:experiment_name])
+
+        expect(participants_count).to eq(2)
+      end
+    end
+  end
 end
diff --git a/spec/lib/reporting/ab_tests_report_spec.rb b/spec/lib/reporting/ab_tests_report_spec.rb
index 4b2b903982a..145a9aee969 100644
--- a/spec/lib/reporting/ab_tests_report_spec.rb
+++ b/spec/lib/reporting/ab_tests_report_spec.rb
@@ -4,21 +4,29 @@
 RSpec.describe Reporting::AbTestsReport do
   let(:time_range) { Date.new(2025, 1, 1).all_day }
   let(:options) { {} }
+  let(:ab_test_options) { {} }
 
   subject(:report) do
     Reporting::AbTestsReport.new(
-      queries: [
-        AbTest::ReportQueryConfig.new(
-          title: 'Sign in success rate by CAPTCHA validation performed',
-          query: <<~QUERY,
-            fields properties.event_properties.captcha_validation_performed as `Captcha Validation Performed`
-            | filter name = 'Email and Password Authentication'
-            | stats avg(properties.event_properties.success)*100 as `Success Percent` by `Captcha Validation Performed`
-            | sort `Captcha Validation Performed` asc
-          QUERY
-          row_labels: ['Validation Not Performed', 'Validation Performed'],
-        ),
-      ],
+      ab_test: AbTest.new(
+        experiment_name: 'reCAPTCHA at Sign-In',
+        report: {
+          email: 'email@example.com',
+          queries: [
+            {
+              title: 'Sign in success rate by CAPTCHA validation performed',
+              query: <<~QUERY,
+                fields properties.event_properties.captcha_validation_performed as `Captcha Validation Performed`
+                | filter name = 'Email and Password Authentication'
+                | stats avg(properties.event_properties.success)*100 as `Success Percent` by `Captcha Validation Performed`
+                | sort `Captcha Validation Performed` asc
+              QUERY
+              row_labels: ['Validation Not Performed', 'Validation Performed'],
+            },
+          ],
+        },
+        **ab_test_options,
+      ),
       time_range:,
       **options,
     )
@@ -60,4 +68,28 @@
       end
     end
   end
+
+  describe '#participants_message' do
+    subject(:participants_message) { report.participants_message }
+
+    context 'with unpersisted ab test' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'with persisted ab test' do
+      let(:ab_test_options) { super().merge(persist: true) }
+
+      it 'returns message with number of participants' do
+        expect(participants_message).to eq('Total participants: 0')
+      end
+
+      context 'with maximum participant ab test' do
+        let(:ab_test_options) { super().merge(max_participants: 10_000) }
+
+        it 'returns message with number of participants and maximum' do
+          expect(participants_message).to eq('Total participants: 0 (of 10,000 maximum)')
+        end
+      end
+    end
+  end
 end
diff --git a/spec/lib/tasks/ab_tests_spec.rb b/spec/lib/tasks/ab_tests_spec.rb
new file mode 100644
index 00000000000..0666626b400
--- /dev/null
+++ b/spec/lib/tasks/ab_tests_spec.rb
@@ -0,0 +1,70 @@
+require 'rails_helper'
+require 'rake'
+
+RSpec.describe 'ab tests rake tasks', type: :task do
+  before do
+    Rake.application.rake_require 'tasks/ab_tests'
+    Rake::Task.define_task(:environment)
+  end
+
+  describe 'ab_tests:delete_outdated' do
+    subject(:task) { Rake::Task['ab_tests:delete_outdated'].execute }
+
+    before { Rake::Task['ab_tests:delete_outdated'].reenable }
+
+    context 'without outdated test assignments' do
+      it 'prints message that there is nothing to do' do
+        expect { task }.to output("No outdated test assignments to delete!\n").to_stderr
+      end
+    end
+
+    context 'with outdated test assignments' do
+      before do
+        # Create multiples of an outdated test to verify that only distinct test names are shown
+        create_list(:ab_test_assignment, 2, experiment: 'outdated')
+        # Create multiple types of oudated tests to verify that all outdated test names are shown
+        create(:ab_test_assignment, experiment: 'outdated2')
+        # Create an assignment for an actively-configured test to verify that they are unaffected
+        create(:ab_test_assignment)
+      end
+
+      it 'lists outdated test assignments but does not delete them' do
+        expect { task }.to output(
+          <<~STR,
+            Found outdated test assignments with experiment names:
+              - outdated
+              - outdated2
+
+            Re-run command with `confirm` arg to delete:
+
+              rake "ab_tests:delete_outdated[confirm]"
+
+          STR
+        ).to_stdout
+
+        expect(AbTestAssignment.count).to eq(4)
+      end
+
+      context 'with confirm arg' do
+        subject(:task) { Rake.application.invoke_task('ab_tests:delete_outdated[confirm]') }
+
+        it 'deletes outdated test assignments' do
+          expect($stdout).to receive(:write).with(/AbTestAssignment Pluck/)
+          expect($stdout).to receive(:write).with(/AbTestAssignment Delete All/)
+          expect { task }.to output(
+            <<~STR,
+              Found outdated test assignments with experiment names:
+                - outdated
+                - outdated2
+
+
+              Successfully deleted 3 records.
+            STR
+          ).to_stdout
+
+          expect(AbTestAssignment.count).to eq(1)
+        end
+      end
+    end
+  end
+end
diff --git a/spec/mailers/previews/report_mailer_preview.rb b/spec/mailers/previews/report_mailer_preview.rb
index e99fea4edda..c29e6cb9c06 100644
--- a/spec/mailers/previews/report_mailer_preview.rb
+++ b/spec/mailers/previews/report_mailer_preview.rb
@@ -23,19 +23,25 @@ def warn_error
 
   def ab_tests_report
     report = Reports::AbTestsReport.new(Time.zone.now).ab_tests_report(
-      AbTest::ReportConfig.new(
-        queries: [
-          {
-            title: 'Sign in success rate by CAPTCHA validation performed',
-            query: <<~QUERY,
-              fields properties.event_properties.captcha_validation_performed as `Captcha Validation Performed`
-              | filter name = 'Email and Password Authentication'
-              | stats avg(properties.event_properties.success)*100 as `Success Percent` by `Captcha Validation Performed`
-              | sort `Captcha Validation Performed` asc
-            QUERY
-            row_labels: ['Validation Not Performed', 'Validation Performed'],
-          },
-        ],
+      AbTest.new(
+        experiment_name: 'reCAPTCHA at Sign-In',
+        persist: true,
+        max_participants: 10_000,
+        report: {
+          email: 'email@example.com',
+          queries: [
+            {
+              title: 'Sign in success rate by CAPTCHA validation performed',
+              query: <<~QUERY,
+                fields properties.event_properties.captcha_validation_performed as `Captcha Validation Performed`
+                | filter name = 'Email and Password Authentication'
+                | stats avg(properties.event_properties.success)*100 as `Success Percent` by `Captcha Validation Performed`
+                | sort `Captcha Validation Performed` asc
+              QUERY
+              row_labels: ['Validation Not Performed', 'Validation Performed'],
+            },
+          ],
+        },
       ),
     )
 
@@ -50,7 +56,10 @@ def ab_tests_report
     ReportMailer.tables_report(
       email: 'email@example.com',
       subject: "A/B Tests Report - reCAPTCHA at Sign-In - #{Time.zone.now.to_date}",
-      message: "A/B Tests Report - reCAPTCHA at Sign-In - #{Time.zone.now.to_date}",
+      message: [
+        "A/B Tests Report - reCAPTCHA at Sign-In - #{Time.zone.now.to_date}",
+        report.participants_message,
+      ].compact,
       reports: report.as_emailable_reports,
       attachment_format: :csv,
     )
diff --git a/spec/models/ab_test_assignment_spec.rb b/spec/models/ab_test_assignment_spec.rb
new file mode 100644
index 00000000000..5e8a14dab05
--- /dev/null
+++ b/spec/models/ab_test_assignment_spec.rb
@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe AbTestAssignment do
+  describe '.bucket' do
+    subject(:bucket) { AbTestAssignment.bucket(**args) }
+    let(:args) { { experiment: 'experiment', discriminator: 'discriminator' } }
+    let!(:ab_test_assignment) do
+      create(
+        :ab_test_assignment,
+        experiment: 'experiment',
+        discriminator: 'discriminator',
+        bucket: 'bucket',
+      )
+    end
+
+    it 'returns bucket for the matched record' do
+      expect(bucket).to eq(:bucket)
+    end
+
+    context 'without a matched record' do
+      let!(:ab_test_assignment) { nil }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end
diff --git a/spec/services/analytics_spec.rb b/spec/services/analytics_spec.rb
index 8ed85ac60da..5d76c390e8e 100644
--- a/spec/services/analytics_spec.rb
+++ b/spec/services/analytics_spec.rb
@@ -145,16 +145,15 @@
     end
 
     context 'with A/B tests' do
-      let(:ab_tests) do
+      let(:ab_tests) { { FOO_TEST: AbTest.new(**ab_test_configuration) } }
+      let(:ab_test_configuration) do
         {
-          FOO_TEST: AbTest.new(
-            experiment_name: 'Test 1',
-            buckets: {
-              bucket_a: 50,
-              bucket_b: 50,
-            },
-            should_log:,
-          ),
+          experiment_name: 'Test 1',
+          buckets: {
+            bucket_a: 50,
+            bucket_b: 50,
+          },
+          should_log:,
         }
       end
 
@@ -187,6 +186,17 @@
 
           analytics.track_event('Trackable Event')
         end
+
+        context 'with persisted ab test' do
+          let(:ab_test_configuration) { super().merge(persist: true) }
+
+          it 'does not create assignments for persisted ab test' do
+            expect(ahoy).to receive(:track)
+
+            expect { analytics.track_event('Trackable Event') }
+              .not_to change { AbTestAssignment.count }
+          end
+        end
       end
     end