diff --git a/app/controllers/report_controller.rb b/app/controllers/report_controller.rb
index 807861f2..3fd91cb2 100644
--- a/app/controllers/report_controller.rb
+++ b/app/controllers/report_controller.rb
@@ -88,7 +88,10 @@ def holds_by_source
     @list = filter_holds_by_source term_filtered
   end
 
-  def index; end
+  def index
+    @terms = Thesis.distinct.order(grad_date: :desc).limit(4).pluck(:grad_date).reverse
+    @data = Report.new.index_data(@terms)
+  end
 
   def term
     term = params[:graduation] ? params[:graduation].to_s : 'all'
diff --git a/app/models/report.rb b/app/models/report.rb
index a5a341a2..fa59ff79 100644
--- a/app/models/report.rb
+++ b/app/models/report.rb
@@ -4,7 +4,7 @@ class Report
   def card_empty_theses(collection)
     {
       'value' => collection.count,
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'no attached files'
     }
   end
@@ -13,7 +13,7 @@ def card_files(collection, term)
     subset = collection.joins(:files_attachments)
     {
       'value' => subset.pluck(:id).uniq.count,
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'files attached',
       'note' => 'Only theses with a status of "Not ready for publication" and "Publication review" will be visible ' \
                 'in the processing queue.',
@@ -35,7 +35,7 @@ def card_issues(collection)
   def card_multiple_authors(collection)
     {
       'value' => collection.joins(:authors).group('theses.id').having('COUNT(authors.id) > 1').length,
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'multiple authors'
     }
   end
@@ -43,7 +43,7 @@ def card_multiple_authors(collection)
   def card_multiple_degrees(collection)
     {
       'value' => collection.joins(:degrees).group('theses.id').having('COUNT(degrees.id) > 1').length,
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'multiple degrees'
     }
   end
@@ -51,7 +51,7 @@ def card_multiple_degrees(collection)
   def card_multiple_departments(collection)
     {
       'value' => collection.joins(:departments).group('theses.id').having('COUNT(departments.id) > 1').length,
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'multiple departments'
     }
   end
@@ -71,224 +71,132 @@ def card_overall(collection, term)
   def card_student_contributions(collection)
     {
       'value' => collection.map(&:student_contributed?).count(true),
-      'verb' => ['has', 'have'],
+      'verb' => %w[has have],
       'label' => 'had metadata contributed by students'
     }
   end
 
-  def data_category_copyright_holder
-    category = []
-    rows = populate_category(Copyright.pluck(:holder))
-    Thesis.all.joins(:copyright).group(:holder).group(:grad_date).count.each do |item|
-      rows[item[0][0]][item[0][1]] = item[1]
+  def data_category_copyright_holder(terms = nil)
+    dashboard_category_data(Copyright.pluck(:holder), terms) do |theses|
+      theses.joins(:copyright).group(:holder, :grad_date).count
     end
-    rows.each do |row|
-      category.push({
-                      label: row[0],
-                      data: pad_terms(row[1])
-                    })
-    end
-    category
   end
 
-  def data_category_department
-    category = []
-    rows = populate_category(Department.pluck(:name_dw))
-    Thesis.all.joins(:files_attachments).joins(:departments).group(:name_dw).group(:grad_date).distinct.count
-          .each do |item|
-      rows[item[0][0]][item[0][1]] = item[1]
-    end
-    rows.each do |row|
-      category.push({
-                      label: row[0],
-                      data: pad_terms(row[1])
-                    })
+  def data_category_department(terms = nil)
+    dashboard_category_data(Department.pluck(:name_dw), terms) do |theses|
+      theses.joins(:files_attachments).joins(:departments).group(:name_dw, :grad_date).distinct.count
     end
-    category
   end
 
-  def data_category_license
-    category = []
-    rows = populate_category(License.pluck(:display_description))
-    Thesis.all.joins(:license).group(:display_description).group(:grad_date).count.each do |item|
-      rows[item[0][0]][item[0][1]] = item[1]
-    end
-    rows.each do |row|
-      category.push({
-                      label: row[0],
-                      data: pad_terms(row[1])
-                    })
+  def data_category_license(terms = nil)
+    dashboard_category_data(License.pluck(:display_description), terms) do |theses|
+      theses.joins(:license).group(:display_description, :grad_date).count
     end
-    category
   end
 
-  def data_category_publication_status
-    category = []
-    rows = populate_category(Thesis.publication_statuses)
-    Thesis.all.group(:publication_status).group(:grad_date).count.each do |item|
-      rows[item[0][0]][item[0][1]] = item[1]
+  def data_category_publication_status(terms = nil)
+    dashboard_category_data(Thesis.publication_statuses, terms) do |theses|
+      theses.group(:publication_status, :grad_date).count
     end
-    rows.each do |row|
-      category.push({
-                      label: row[0],
-                      data: pad_terms(row[1])
-                    })
-    end
-    category
   end
 
-  def data_files_attached_to_theses
+  def data_files_attached_to_theses(terms = nil)
+    theses = Thesis.all
+    theses = theses.where(grad_date: terms) if terms
     {
       label: 'Files attached to theses',
-      data: pad_terms(Thesis.all.joins(:files_attachments).group(:grad_date).count)
+      data: pad_terms(theses.joins(:files_attachments).group(:grad_date).count, terms)
     }
   end
 
-  def data_issues
+  def data_issues(terms = nil)
+    theses = Thesis.all
+    theses = theses.where(grad_date: terms) if terms
     {
       label: 'Flagged with issues',
-      data: pad_terms(Thesis.all.group(:grad_date).where('issues_found = ?', true).count)
+      data: pad_terms(theses.where('issues_found = ?', true).group(:grad_date).count, terms)
     }
   end
 
-  def data_multiple_authors
-    row_data = {}
-    query = <<~SQL
-      SELECT t.grad_date, count(t.id) as pop
-      FROM (
-        SELECT theses.id, theses.grad_date, count(theses.id) as authors
-        FROM theses
-        INNER JOIN authors a on theses.id = a.thesis_id
-        GROUP BY theses.id
-        HAVING count(a.id) > 1
-      ) AS t
-      GROUP BY t.grad_date;
-    SQL
-    ActiveRecord::Base.connection.exec_query(query).each do |item|
-      row_data[Date.parse(item['grad_date'])] = item['pop']
-    end
+  def data_multiple_authors(terms = nil)
+    row_data = data_multiple_records(:authors, 'authors', terms)
     {
       label: 'Multiple authors',
-      data: pad_terms(row_data)
+      data: pad_terms(row_data, terms)
     }
   end
 
-  def data_multiple_degrees
-    row_data = {}
-    query = <<~SQL
-      SELECT t.grad_date, count(t.id) as pop
-      FROM (
-        SELECT theses.id, theses.grad_date, count(theses.id) as authors
-        FROM theses
-        INNER JOIN degree_theses link ON theses.id = link.thesis_id
-        INNER JOIN degrees d on link.degree_id = d.id
-        GROUP BY theses.id
-        HAVING count(d.id) > 1
-      ) AS t
-      GROUP BY t.grad_date;
-    SQL
-    ActiveRecord::Base.connection.exec_query(query).each do |item|
-      row_data[Date.parse(item['grad_date'])] = item['pop']
-    end
+  def data_multiple_degrees(terms = nil)
+    row_data = data_multiple_records(:degrees, 'degrees', terms)
     {
       label: 'Multiple degrees',
-      data: pad_terms(row_data)
+      data: pad_terms(row_data, terms)
     }
   end
 
-  def data_multiple_departments
-    row_data = {}
-    query = <<~SQL
-      SELECT t.grad_date, count(t.id) as pop
-      FROM (
-        SELECT theses.id, theses.grad_date, count(theses.id) as authors
-        FROM theses
-        INNER JOIN department_theses link ON theses.id = link.thesis_id
-        INNER JOIN departments d on link.department_id = d.id
-        GROUP BY theses.id
-        HAVING count(d.id) > 1
-      ) AS t
-      GROUP BY t.grad_date;
-    SQL
-    ActiveRecord::Base.connection.exec_query(query).each do |item|
-      row_data[Date.parse(item['grad_date'])] = item['pop']
-    end
+  def data_multiple_departments(terms = nil)
+    row_data = data_multiple_records(:departments, 'departments', terms)
     {
       label: 'Multiple departments',
-      data: pad_terms(row_data)
+      data: pad_terms(row_data, terms)
     }
   end
 
-  def data_student_contributions
-    row_data = {}
-    terms = Thesis.all.pluck(:grad_date).uniq.sort
-    terms.each do |term|
-      row_data[term] = Thesis.where('grad_date = ?', term).includes(:versions).map(&:student_contributed?).count(true)
-    end
+  def data_student_contributions(terms = nil)
+    terms ||= Thesis.distinct.order(:grad_date).pluck(:grad_date)
     {
       label: 'Students contributing',
-      data: pad_terms(row_data)
+      data: pad_terms(student_contribution_counts(terms), terms)
     }
   end
 
-  def data_authors_not_graduated
-    row_data = {}
-    terms = Thesis.all.pluck(:grad_date).uniq.sort
-    terms.each do |term|
-      row_data[term] =
-        Thesis.with_files.where('grad_date = ?', term).includes([:authors]).reject(&:authors_graduated?).uniq.count
-    end
+  def data_authors_not_graduated(terms = nil)
+    terms ||= Thesis.distinct.order(:grad_date).pluck(:grad_date)
+    confirmed = Author.where(graduation_confirmed: true).select(:thesis_id)
+    unconfirmed = Author.where(graduation_confirmed: false).select(:thesis_id)
+    theses = Thesis.where(grad_date: terms)
+    outstanding = theses.where(id: unconfirmed).or(theses.where.not(id: confirmed))
+    row_data = outstanding.with_files.group(:grad_date).count
     {
       label: 'Authors not graduated',
-      data: pad_terms(row_data)
+      data: pad_terms(row_data, terms)
     }
   end
 
-  def data_thesis_records
+  def data_thesis_records(terms = nil)
     {
       label: 'Thesis records',
-      data: pad_terms(Thesis.all.group(:grad_date).count)
+      data: pad_terms(dashboard_theses(terms).group(:grad_date).count, terms)
     }
   end
 
-  def data_theses_with_files
-    row_data = {}
-    query = <<~SQL
-      SELECT t.grad_date, count(distinct t.id) AS pop
-      FROM theses t
-      INNER JOIN active_storage_attachments a ON t.id = a.record_id
-      WHERE a.record_type = 'Thesis'
-      GROUP BY t.grad_date;
-    SQL
-    ActiveRecord::Base.connection.exec_query(query).each do |item|
-      row_data[Date.parse(item['grad_date'])] = item['pop']
-    end
+  def data_theses_with_files(terms = nil)
     {
       label: 'Theses with files',
-      data: pad_terms(row_data)
+      data: pad_terms(dashboard_theses(terms).joins(:files_attachments).group(:grad_date).distinct.count, terms)
     }
   end
 
-  def index_data
+  def index_data(terms = nil)
     output = {}
     output['summary'] = []
-    output['summary'].push data_thesis_records
-    output['summary'].push data_theses_with_files
-    output['summary'].push data_files_attached_to_theses
-    output['summary'].push data_issues
-    output['summary'].push data_student_contributions
-    output['summary'].push data_authors_not_graduated
-    output['summary'].push data_multiple_authors
-    output['summary'].push data_multiple_degrees
-    output['summary'].push data_multiple_departments
+    output['summary'].push data_thesis_records(terms)
+    output['summary'].push data_theses_with_files(terms)
+    output['summary'].push data_files_attached_to_theses(terms)
+    output['summary'].push data_issues(terms)
+    output['summary'].push data_student_contributions(terms)
+    output['summary'].push data_authors_not_graduated(terms)
+    output['summary'].push data_multiple_authors(terms)
+    output['summary'].push data_multiple_degrees(terms)
+    output['summary'].push data_multiple_departments(terms)
     output['publication-status'] = []
-    output['publication-status'].push(*data_category_publication_status)
+    output['publication-status'].push(*data_category_publication_status(terms))
     output['copyright'] = []
-    output['copyright'].push(*data_category_copyright_holder)
+    output['copyright'].push(*data_category_copyright_holder(terms))
     output['license'] = []
-    output['license'].push(*data_category_license)
+    output['license'].push(*data_category_license(terms))
     output['departments'] = []
-    output['departments'].push(*data_category_department)
+    output['departments'].push(*data_category_department(terms))
     output
   end
 
@@ -469,7 +377,7 @@ def term_tables(collection)
 
   private
 
-  def pad_terms(data)
+  def pad_terms(data, terms = nil)
     # Given a hash of data for a single row of the reporting table, this will compare the data to the set of all
     # terms, adding zero values where needed to the simple iterator in the view will place them accurately.
     # Sample input (missing some terms)
@@ -485,13 +393,42 @@ def pad_terms(data)
     #  Sun, 01 May 2022=>0,
     #  Thu, 01 Sep 2022=>2}
     output = {}
-    Thesis.pluck(:grad_date).uniq.sort.each do |term|
+    (terms || Thesis.pluck(:grad_date).uniq.sort).each do |term|
       output[term] = 0
       output[term] = data[term] if data.include? term
     end
     output
   end
 
+  def dashboard_category_data(values, terms)
+    rows = populate_category(values)
+    yield(dashboard_theses(terms)).each do |(label, grad_date), count|
+      rows[label][grad_date] = count
+    end
+    rows.map do |label, data|
+      { label: label, data: pad_terms(data, terms) }
+    end
+  end
+
+  def dashboard_theses(terms)
+    terms ? Thesis.where(grad_date: terms) : Thesis.all
+  end
+
+  def student_contribution_counts(terms)
+    student_ids = User.where(role: 'basic', admin: [false, nil]).reorder(nil)
+                      .select('CAST(users.id AS TEXT)')
+    PaperTrail::Version.joins('INNER JOIN theses ON theses.id = versions.item_id')
+                       .where(item_type: 'Thesis', item_id: Thesis.where(grad_date: terms).select(:id),
+                              whodunnit: student_ids)
+                       .group('theses.grad_date').distinct.count('versions.item_id')
+  end
+
+  def data_multiple_records(association, table, terms)
+    theses = dashboard_theses(terms).joins(association)
+    multiple_ids = theses.group('theses.id').having("COUNT(#{table}.id) > 1").select(:id)
+    dashboard_theses(terms).where(id: multiple_ids).group(:grad_date).count
+  end
+
   def populate_category(array)
     # This builds out the initial set of a category of rows, based on a provided array (like
     # Thesis.publication_statuses).
diff --git a/app/views/report/index.html.erb b/app/views/report/index.html.erb
index 8b23b369..1200f3f7 100644
--- a/app/views/report/index.html.erb
+++ b/app/views/report/index.html.erb
@@ -4,18 +4,31 @@
   <div class="col3q">
     <h3 class="title title-page">Report dashboard</h3>
 
-    <h4>Available reports</h4>
-    <ul>
-      <li><%= link_to("Thesis authors without confirmed graduation", report_authors_not_graduated_path) %></li>
-      <li><%= link_to("Theses without files", report_empty_theses_path) %></li>
-      <li><%= link_to("Unreleased holds which have ended", report_expired_holds_path) %></li>
-      <li><%= link_to("Files without purpose", report_files_path) %></li>
-      <li><%= link_to("Holds by source", report_holds_by_source_path) %></li>
-      <li><%= link_to("ProQuest forms", report_proquest_files_path) %></li>
-      <li><%= link_to("ProQuest opt-in status", report_proquest_status_path) %></li>
-      <li><%= link_to("Theses submitted by students", report_student_submitted_theses_path) %></li>
-      <li><%= link_to("Thesis information by term", report_term_path) %></li>
-    </ul>
+    <%= render 'shared/whodunnit_accuracy_statement' %>
+
+    <% @data.each do |table| %>
+      <table class="table table-simplified table-<%= table[0].gsub(" ", "-").downcase %>" style="margin-top: 4em;">
+        <caption class="hd-4"><%= table[0].gsub("-", " ").capitalize %></caption>
+        <thead>
+          <tr>
+            <td>&nbsp;</td>
+            <% @terms.each do |term| %>
+              <th scope="col"><%= link_to(term.in_time_zone('Eastern Time (US & Canada)').strftime('%b %Y'), report_term_path(graduation: term)) %></th>
+            <% end %>
+          </tr>
+        </thead>
+        <tbody>
+          <% table[1].each do |row| %>
+            <tr>
+              <th scope="row"><%= row[:label] %></th>
+              <% row[:data].each_value do |cell| %>
+                <td><%= cell %></td>
+              <% end %>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    <% end %>
   </div>
 
   <aside class="content-sup col1q-r">
diff --git a/app/views/shared/_report_submenu.html.erb b/app/views/shared/_report_submenu.html.erb
index f691e3c5..90edaa6b 100644
--- a/app/views/shared/_report_submenu.html.erb
+++ b/app/views/shared/_report_submenu.html.erb
@@ -11,7 +11,7 @@
       <% if can?(:empty_theses, Report) %>
         <li><%= link_to("Theses without files", report_empty_theses_path) %></li>
       <% end %>
-      <% if can?(:student_submitted_thesis, Report) %>
+      <% if can?(:student_submitted_theses, Report) %>
         <li><%= link_to("Theses submitted by students", report_student_submitted_theses_path) %></li>
       <% end %>
       <% if can?(:authors_not_graduated, Report) %>
diff --git a/db/migrate/20261029150000_add_grad_date_index_to_theses.rb b/db/migrate/20261029150000_add_grad_date_index_to_theses.rb
new file mode 100644
index 00000000..60e1ae77
--- /dev/null
+++ b/db/migrate/20261029150000_add_grad_date_index_to_theses.rb
@@ -0,0 +1,10 @@
+class AddGradDateIndexToTheses < ActiveRecord::Migration[8.1]
+  # Allow concurrent index creation to avoid blocking normal writes while postgres builds the index
+  disable_ddl_transaction!
+
+  def change
+    options = {}
+    options[:algorithm] = :concurrently if connection.adapter_name == 'PostgreSQL'
+    add_index :theses, :grad_date, **options
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 08e8f3a7..314b5a33 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,28 +10,28 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.1].define(version: 2025_06_24_182142) do
+ActiveRecord::Schema[8.1].define(version: 2026_10_29_150000) do
   create_table "active_storage_attachments", force: :cascade do |t|
-    t.string "name", null: false
-    t.string "record_type", null: false
-    t.integer "record_id", null: false
     t.integer "blob_id", null: false
     t.datetime "created_at", precision: nil, null: false
     t.text "description"
+    t.string "name", null: false
     t.integer "purpose"
+    t.integer "record_id", null: false
+    t.string "record_type", null: false
     t.index ["blob_id"], name: "index_active_storage_attachments_on_blob_id"
     t.index ["record_id", "record_type"], name: "index_active_storage_attachments_on_record_id_and_record_type"
     t.index ["record_type", "record_id", "name", "blob_id"], name: "index_active_storage_attachments_uniqueness", unique: true
   end
 
   create_table "active_storage_blobs", force: :cascade do |t|
-    t.string "key", null: false
-    t.string "filename", null: false
-    t.string "content_type"
-    t.text "metadata"
     t.integer "byte_size", null: false
     t.string "checksum"
+    t.string "content_type"
     t.datetime "created_at", precision: nil, null: false
+    t.string "filename", null: false
+    t.string "key", null: false
+    t.text "metadata"
     t.string "service_name", null: false
     t.index ["key"], name: "index_active_storage_blobs_on_key", unique: true
   end
@@ -44,154 +44,154 @@
   end
 
   create_table "advisor_theses", id: false, force: :cascade do |t|
-    t.integer "thesis_id"
     t.integer "advisor_id"
+    t.integer "thesis_id"
     t.index ["advisor_id"], name: "index_advisor_theses_on_advisor_id"
     t.index ["thesis_id"], name: "index_advisor_theses_on_thesis_id"
   end
 
   create_table "advisors", force: :cascade do |t|
-    t.string "name", null: false
     t.datetime "created_at", null: false
+    t.string "name", null: false
     t.datetime "updated_at", null: false
   end
 
   create_table "archivematica_accessions", force: :cascade do |t|
     t.string "accession_number"
     t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
     t.integer "degree_period_id", null: false
+    t.datetime "updated_at", null: false
     t.index ["accession_number"], name: "index_archivematica_accessions_on_accession_number", unique: true
     t.index ["degree_period_id"], name: "index_archivematica_accessions_on_degree_period_id", unique: true
   end
 
   create_table "archivematica_payloads", force: :cascade do |t|
-    t.integer "preservation_status", default: 0, null: false
+    t.datetime "created_at", null: false
     t.text "payload_json"
+    t.integer "preservation_status", default: 0, null: false
     t.datetime "preserved_at"
     t.integer "thesis_id", null: false
-    t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.index ["thesis_id"], name: "index_archivematica_payloads_on_thesis_id"
   end
 
   create_table "authors", force: :cascade do |t|
-    t.integer "user_id", null: false
-    t.integer "thesis_id", null: false
-    t.boolean "graduation_confirmed", default: false, null: false
     t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
+    t.boolean "graduation_confirmed", default: false, null: false
     t.boolean "proquest_allowed"
+    t.integer "thesis_id", null: false
+    t.datetime "updated_at", null: false
+    t.integer "user_id", null: false
     t.index ["thesis_id"], name: "index_authors_on_thesis_id"
     t.index ["user_id"], name: "index_authors_on_user_id"
   end
 
   create_table "copyrights", force: :cascade do |t|
-    t.text "holder", null: false
-    t.boolean "display_to_author", null: false
+    t.datetime "created_at", null: false
     t.text "display_description", null: false
+    t.boolean "display_to_author", null: false
+    t.text "holder", null: false
     t.text "statement_dspace", null: false
-    t.text "url"
-    t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.text "url"
   end
 
   create_table "degree_periods", force: :cascade do |t|
+    t.datetime "created_at", null: false
     t.string "grad_month"
     t.string "grad_year"
-    t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.index ["grad_month", "grad_year"], name: "index_degree_periods_on_grad_month_and_grad_year", unique: true
   end
 
   create_table "degree_theses", id: false, force: :cascade do |t|
-    t.integer "thesis_id"
     t.integer "degree_id"
+    t.integer "thesis_id"
     t.index ["degree_id"], name: "index_degree_theses_on_degree_id"
     t.index ["thesis_id"], name: "index_degree_theses_on_thesis_id"
   end
 
   create_table "degree_types", force: :cascade do |t|
-    t.string "name", null: false
     t.datetime "created_at", null: false
+    t.string "name", null: false
     t.datetime "updated_at", null: false
     t.index ["name"], name: "index_degree_types_on_name", unique: true
   end
 
   create_table "degrees", force: :cascade do |t|
-    t.datetime "created_at", precision: nil, null: false
-    t.datetime "updated_at", precision: nil, null: false
-    t.string "code_dw", null: false
-    t.string "name_dw"
     t.string "abbreviation"
-    t.string "name_dspace"
+    t.string "code_dw", null: false
+    t.datetime "created_at", precision: nil, null: false
     t.integer "degree_type_id"
+    t.string "name_dspace"
+    t.string "name_dw"
+    t.datetime "updated_at", precision: nil, null: false
     t.index ["code_dw"], name: "index_degrees_on_code_dw", unique: true
     t.index ["degree_type_id"], name: "index_degrees_on_degree_type_id"
   end
 
   create_table "delayed_jobs", force: :cascade do |t|
-    t.integer "priority", default: 0, null: false
     t.integer "attempts", default: 0, null: false
+    t.datetime "created_at", precision: nil
+    t.datetime "failed_at", precision: nil
     t.text "handler", null: false
     t.text "last_error"
-    t.datetime "run_at", precision: nil
     t.datetime "locked_at", precision: nil
-    t.datetime "failed_at", precision: nil
     t.string "locked_by"
+    t.integer "priority", default: 0, null: false
     t.string "queue"
-    t.datetime "created_at", precision: nil
+    t.datetime "run_at", precision: nil
     t.datetime "updated_at", precision: nil
     t.index ["priority", "run_at"], name: "delayed_jobs_priority"
   end
 
   create_table "department_theses", force: :cascade do |t|
-    t.integer "thesis_id"
     t.integer "department_id"
     t.boolean "primary", default: false, null: false
+    t.integer "thesis_id"
     t.index ["department_id", "thesis_id"], name: "department_and_thesis", unique: true
     t.index ["department_id"], name: "index_department_theses_on_department_id"
     t.index ["thesis_id"], name: "index_department_theses_on_thesis_id"
   end
 
   create_table "departments", force: :cascade do |t|
-    t.string "name_dw", null: false
-    t.datetime "created_at", precision: nil, null: false
-    t.datetime "updated_at", precision: nil, null: false
+    t.string "authority_key_dspace"
     t.string "code_dw", default: "", null: false
+    t.datetime "created_at", precision: nil, null: false
     t.string "name_dspace"
-    t.string "authority_key_dspace"
+    t.string "name_dw", null: false
+    t.datetime "updated_at", precision: nil, null: false
     t.index ["code_dw"], name: "index_departments_on_code_dw", unique: true
     t.index ["name_dw"], name: "index_departments_on_name_dw"
   end
 
   create_table "hold_sources", force: :cascade do |t|
-    t.text "source", null: false
     t.datetime "created_at", null: false
+    t.text "source", null: false
     t.datetime "updated_at", null: false
   end
 
   create_table "holds", force: :cascade do |t|
-    t.integer "thesis_id", null: false
+    t.string "case_number"
+    t.datetime "created_at", null: false
+    t.date "date_end", null: false
     t.date "date_requested", null: false
     t.date "date_start", null: false
-    t.date "date_end", null: false
     t.integer "hold_source_id", null: false
-    t.string "case_number"
-    t.integer "status", null: false
     t.text "processing_notes"
-    t.datetime "created_at", null: false
+    t.integer "status", null: false
+    t.integer "thesis_id", null: false
     t.datetime "updated_at", null: false
     t.index ["hold_source_id"], name: "index_holds_on_hold_source_id"
     t.index ["thesis_id"], name: "index_holds_on_thesis_id"
   end
 
   create_table "licenses", force: :cascade do |t|
+    t.datetime "created_at", null: false
     t.text "display_description", null: false
     t.text "license_type", null: false
-    t.text "url"
-    t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.text "url"
   end
 
   create_table "proquest_export_batches", force: :cascade do |t|
@@ -200,85 +200,86 @@
   end
 
   create_table "registrars", force: :cascade do |t|
-    t.integer "user_id", null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.integer "user_id", null: false
     t.index ["user_id"], name: "index_registrars_on_user_id"
   end
 
   create_table "submission_information_packages", force: :cascade do |t|
-    t.datetime "preserved_at", precision: nil
-    t.integer "preservation_status", default: 0, null: false
     t.string "bag_declaration"
     t.string "bag_name"
+    t.datetime "created_at", null: false
     t.text "manifest"
     t.text "metadata"
+    t.integer "preservation_status", default: 0, null: false
+    t.datetime "preserved_at", precision: nil
     t.integer "thesis_id", null: false
-    t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.index ["thesis_id"], name: "index_submission_information_packages_on_thesis_id"
   end
 
   create_table "submitters", force: :cascade do |t|
-    t.integer "user_id", null: false
-    t.integer "department_id", null: false
     t.datetime "created_at", null: false
+    t.integer "department_id", null: false
     t.datetime "updated_at", null: false
+    t.integer "user_id", null: false
     t.index ["department_id"], name: "index_submitters_on_department_id"
     t.index ["user_id"], name: "index_submitters_on_user_id"
   end
 
   create_table "theses", force: :cascade do |t|
-    t.string "title"
     t.text "abstract"
-    t.date "grad_date", null: false
-    t.datetime "created_at", precision: nil, null: false
-    t.datetime "updated_at", precision: nil, null: false
-    t.text "processor_note"
     t.text "author_note"
-    t.boolean "files_complete", default: false, null: false
-    t.boolean "metadata_complete", default: false, null: false
-    t.string "publication_status", default: "Not ready for publication", null: false
+    t.integer "authors_count"
     t.string "coauthors"
     t.integer "copyright_id"
-    t.integer "license_id"
+    t.datetime "created_at", precision: nil, null: false
     t.string "dspace_handle"
+    t.boolean "files_complete", default: false, null: false
+    t.date "grad_date", null: false
     t.boolean "issues_found", default: false, null: false
-    t.integer "authors_count"
-    t.integer "proquest_exported", default: 0, null: false
+    t.integer "license_id"
+    t.boolean "metadata_complete", default: false, null: false
+    t.text "processor_note"
     t.integer "proquest_export_batch_id"
+    t.integer "proquest_exported", default: 0, null: false
+    t.string "publication_status", default: "Not ready for publication", null: false
+    t.string "title"
+    t.datetime "updated_at", precision: nil, null: false
     t.index ["copyright_id"], name: "index_theses_on_copyright_id"
+    t.index ["grad_date"], name: "index_theses_on_grad_date"
     t.index ["license_id"], name: "index_theses_on_license_id"
     t.index ["proquest_export_batch_id"], name: "index_theses_on_proquest_export_batch_id"
   end
 
   create_table "transfers", force: :cascade do |t|
-    t.integer "user_id", null: false
+    t.datetime "created_at", null: false
     t.integer "department_id", null: false
+    t.integer "files_count", default: 0, null: false
     t.date "grad_date", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
     t.text "note"
-    t.integer "files_count", default: 0, null: false
     t.integer "unassigned_files_count", default: 0, null: false
+    t.datetime "updated_at", null: false
+    t.integer "user_id", null: false
     t.index ["department_id"], name: "index_transfers_on_department_id"
     t.index ["user_id"], name: "index_transfers_on_user_id"
   end
 
   create_table "users", force: :cascade do |t|
-    t.string "uid", null: false
-    t.string "email", null: false
     t.boolean "admin", default: false
     t.datetime "created_at", precision: nil, null: false
-    t.datetime "updated_at", precision: nil, null: false
-    t.string "role", default: "basic"
+    t.string "display_name", null: false
+    t.string "email", null: false
     t.string "given_name"
-    t.string "surname"
     t.string "kerberos_id", null: false
-    t.string "display_name", null: false
     t.string "middle_name"
-    t.string "preferred_name"
     t.string "orcid"
+    t.string "preferred_name"
+    t.string "role", default: "basic"
+    t.string "surname"
+    t.string "uid", null: false
+    t.datetime "updated_at", precision: nil, null: false
     t.index ["email"], name: "index_users_on_email", unique: true
     t.index ["kerberos_id"], name: "index_users_on_kerberos_id", unique: true
     t.index ["orcid"], name: "index_users_on_orcid", unique: true
@@ -286,14 +287,14 @@
   end
 
   create_table "versions", force: :cascade do |t|
-    t.string "item_type"
-    t.string "{:null=>false}"
-    t.integer "item_id", null: false
-    t.string "event", null: false
-    t.string "whodunnit"
     t.datetime "created_at", precision: nil
+    t.string "event", null: false
+    t.integer "item_id", null: false
+    t.string "item_type"
     t.json "object"
     t.json "object_changes"
+    t.string "whodunnit"
+    t.string "{:null=>false}"
     t.index ["item_type", "item_id"], name: "index_versions_on_item_type_and_item_id"
   end
 
diff --git a/test/controllers/report_controller_test.rb b/test/controllers/report_controller_test.rb
index 1f652adc..52cd8e5a 100644
--- a/test/controllers/report_controller_test.rb
+++ b/test/controllers/report_controller_test.rb
@@ -55,6 +55,18 @@ def create_thesis_with_whodunnit(user)
     assert_response :success
   end
 
+  test 'report dashboard shows four most recent periods in summary tables' do
+    sign_in users(:admin)
+    latest_terms = Thesis.distinct.order(:grad_date).pluck(:grad_date).last(4)
+    get report_index_path
+
+    assert_response :success
+    assert_select 'table', count: 5
+    latest_terms.each do |term|
+      assert_select 'table thead th a[href=?]', report_term_path(graduation: term), count: 5
+    end
+  end
+
   test 'anonymous users are prompted to log in by report dashboard' do
     # Note that nobody is signed in.
     get report_index_path
@@ -82,6 +94,8 @@ def create_thesis_with_whodunnit(user)
     sign_in users(:processor)
     get report_index_path
     assert_response :success
+    assert_select 'aside a[href=?]', report_student_submitted_theses_path,
+                  text: 'Theses submitted by students', count: 1
   end
 
   test 'thesis_admins can see report dashboard' do
diff --git a/test/models/report_test.rb b/test/models/report_test.rb
index 87e09415..60e118ef 100644
--- a/test/models/report_test.rb
+++ b/test/models/report_test.rb
@@ -51,6 +51,100 @@ class ReportTest < ActiveSupport::TestCase
     assert_equal result['departments'][0][:data].values, [1, 2, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0, 0]
   end
 
+  test 'dashboard data is restricted to the requested degree periods' do
+    terms = Thesis.distinct.order(:grad_date).pluck(:grad_date).last(4)
+    result = Report.new.index_data(terms)
+
+    assert_equal terms, result['summary'][0][:data].keys
+    assert_equal terms, result['summary'][5][:data].keys
+    assert_equal terms, result['publication-status'][0][:data].keys
+    assert_equal terms, result['copyright'][0][:data].keys
+    assert_equal terms, result['license'][0][:data].keys
+    assert_equal terms, result['departments'][0][:data].keys
+  end
+
+  # The Oct 2026 refactor of the report summary seeks to minimize memory usage. This test confirms
+  # that we're making calculations in SQL rather than loading ActiveRecord objects into memory.
+  test 'dashboard summaries do not instantiate database records' do
+    terms = Thesis.distinct.order(:grad_date).pluck(:grad_date).last(4)
+    instantiated = 0
+    subscriber = lambda do |*arguments|
+      instantiated += arguments.last[:record_count]
+    end
+
+    ActiveSupport::Notifications.subscribed(subscriber, 'instantiation.active_record') do
+      Report.new.index_data(terms)
+    end
+
+    assert_equal 0, instantiated
+  end
+
+  test 'student contributions count theses separately for each requested period' do
+    first_thesis = theses(:one)
+    second_thesis = theses(:two)
+    later_thesis = theses(:active)
+    first_thesis.versions.create!(event: 'update', whodunnit: users(:basic).id.to_s)
+    second_thesis.versions.create!(event: 'update', whodunnit: users(:second).id.to_s)
+    later_thesis.versions.create!(event: 'update', whodunnit: users(:basic).id.to_s)
+
+    result = Report.new.data_student_contributions([first_thesis.grad_date, later_thesis.grad_date])
+
+    assert_equal({ first_thesis.grad_date => 2, later_thesis.grad_date => 1 }, result[:data])
+  end
+
+  test 'student contributions count repeated edits to a thesis only once' do
+    thesis = theses(:one)
+    thesis.versions.create!(event: 'create', whodunnit: users(:basic).id.to_s)
+    thesis.versions.create!(event: 'update', whodunnit: users(:basic).id.to_s)
+    thesis.versions.create!(event: 'update', whodunnit: users(:second).id.to_s)
+
+    result = Report.new.data_student_contributions([thesis.grad_date])
+
+    assert_equal({ thesis.grad_date => 1 }, result[:data])
+  end
+
+  test 'student contributions exclude staff edits' do
+    thesis = theses(:one)
+    thesis.versions.create!(event: 'update', whodunnit: users(:processor).id.to_s)
+    thesis.versions.create!(event: 'update', whodunnit: users(:thesis_admin).id.to_s)
+
+    result = Report.new.data_student_contributions([thesis.grad_date])
+
+    assert_equal({ thesis.grad_date => 0 }, result[:data])
+  end
+
+  test 'student contributions exclude admin edits even with a basic role' do
+    thesis = theses(:one)
+    admin = users(:admin)
+    assert_equal 'basic', admin.role
+    thesis.versions.create!(event: 'update', whodunnit: admin.id.to_s)
+
+    result = Report.new.data_student_contributions([thesis.grad_date])
+
+    assert_equal({ thesis.grad_date => 0 }, result[:data])
+  end
+
+  test 'student contributions exclude registrar edits' do
+    thesis = theses(:one)
+    thesis.versions.create!(event: 'create', whodunnit: 'registrar')
+
+    result = Report.new.data_student_contributions([thesis.grad_date])
+
+    assert_equal({ thesis.grad_date => 0 }, result[:data])
+  end
+
+  test 'student contributions exclude theses outside the requested periods' do
+    included_thesis = theses(:active)
+    excluded_thesis = theses(:one)
+    included_thesis.versions.create!(event: 'update', whodunnit: users(:basic).id.to_s)
+    excluded_thesis.versions.create!(event: 'update', whodunnit: users(:basic).id.to_s)
+    assert_not_equal included_thesis.grad_date, excluded_thesis.grad_date
+
+    result = Report.new.data_student_contributions([included_thesis.grad_date])
+
+    assert_equal({ included_thesis.grad_date => 1 }, result[:data])
+  end
+
   test 'index includes summary data of authors not graduated' do
     thesis = theses(:bachelor)
     another_thesis = theses(:published)