alumni_lookup

Sub-Phase 9.2: Seeded Discussion Questions

Champion Portal Development Sub-Phase 9.2

Status: ✅ Complete
Completed: February 2026
Estimated Effort: 1.5 weeks
Prerequisites: Sub-Phase 9.1 Complete, Phase 3 (Discussion Boards) Complete

Related Documents:

Completion Summary

What Was Implemented

Models:

Services:

Key Constants:

Files Created:

Implementation Note:

Deferred to Phase 9.4+

Table of Contents

  1. Overview
  2. Problem Statement
  3. Solution Design
  4. Data Model
  5. Question Selection Algorithm
  6. Template Interpolation
  7. Affinity Subtype Grouping
  8. Integration with Discussion Boards
  9. User Experience
  10. Implementation Plan
  11. Testing Requirements

1. Overview

Sub-Phase 9.2 creates a seeded discussion question system that populates community boards with engaging starter questions. This transforms empty boards from ghost towns into active conversation spaces.

Core Insight

A community with zero posts feels dead. A community with one good question feels alive.

New Champions who land on an empty board have no reason to return. Seeded questions provide social proof that conversations happen here, even before organic activity takes off.

2. Problem Statement

The Empty Board Problem

When a Champion joins a new community:

┌─────────────────────────────────────────────────────────────────────────┐
│ 🎵 Music Business Discussion Board                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│                                                                         │
│                     No discussions yet.                                 │
│                                                                         │
│              Be the first to start a conversation!                      │
│                                                                         │
│                       [Start Discussion]                                │
│                                                                         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Result: Champion doesn’t post, doesn’t return, community never grows.

The Solution

┌─────────────────────────────────────────────────────────────────────────┐
│ 🎵 Music Business Discussion Board                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│ 📌 From the Engagement Team                                             │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ "What's the best career advice you've received in the              │ │
│ │  music industry?"                                                   │ │
│ │                                                                     │ │
│ │ 💬 3 replies · 12 reactions                     [Join Discussion]  │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│                                                                         │
│ Recent Discussions                                                      │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ...                                                                 │ │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Result: Champion sees activity, has a low-friction way to participate, may return.

3. Solution Design

Key Principles

  1. Rotation — Questions cycle so communities don’t show the same prompt forever
  2. Interpolation — Questions personalize with community names, seasons, etc.
  3. Affinity grouping — Questions target related affinity subtypes (all Greek chapters, all sports teams)
  4. Staff authorship — Questions display as “Engagement Team” (not a fake user)
  5. Configurable — Admins can CRUD questions without deploying code

Question Lifecycle

┌─────────────────────────────────────────────────────────────────────────┐
│                        SEEDED QUESTION LIFECYCLE                         │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  [Create Question]                                                       │
│        ↓                                                                │
│  [Active in Pool] ─────→ [Selected for Community] ────→ [Published]     │
│        ↑                         ↓                          ↓           │
│        │                  [Exposure Tracked]          [Responses]       │
│        │                         ↓                          ↓           │
│        └─────────── [Rotation Cycle] ←──── [Archived/Replaced]          │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

4. Data Model

New Model: Cp::SeededQuestion

# app/models/cp/seeded_question.rb
class Cp::SeededQuestion < ApplicationRecord
  # Enums
  enum :status, { draft: 0, active: 1, paused: 2, archived: 3 }
  enum :target_type, { 
    all_communities: 0,      # Any community
    district: 1,              # District communities only
    college: 2,               # College communities only
    major: 3,                 # Major communities only
    affinity: 4,              # Affinity communities only
    industry: 5,              # Industry communities only
    affinity_category: 6      # Specific affinity category (Greek Life, Athletics, etc.)
  }

  # Valid affinity categories (from affinities.category column)
  AFFINITY_CATEGORIES = [
    'Athletics', 'Campus Life', 'Geographic', 'Greek Life',
    'Instrumental Ensembles', 'Post Graduation', 'Spiritual Life', 'Vocal Ensembles'
  ].freeze

  # Validations
  validates :title, presence: true, length: { maximum: 280 }
  validates :body, length: { maximum: 2000 }
  validates :target_type, presence: true
  validates :affinity_category, presence: true, inclusion: { in: AFFINITY_CATEGORIES },
            if: -> { target_type == 'affinity_category' }

  # Scopes
  scope :active_for_type, ->(type) { 
    active.where(target_type: [type, 'all_communities']) 
  }
  scope :for_affinity_category, ->(category) {
    active.where(target_type: 'affinity_category', affinity_category: category)
  }
  scope :not_recently_used_in, ->(community, days: 30) {
    where.not(id: community.seeded_question_exposures
                            .where('created_at > ?', days.ago)
                            .select(:seeded_question_id))
  }

  # Associations
  has_many :exposures, class_name: 'Cp::SeededQuestionExposure', dependent: :destroy
  has_many :exposed_communities, through: :exposures, source: :community
end

New Model: Cp::SeededQuestionExposure

Tracks which questions have been shown in which communities:

# app/models/cp/seeded_question_exposure.rb
class Cp::SeededQuestionExposure < ApplicationRecord
  belongs_to :seeded_question, class_name: 'Cp::SeededQuestion'
  belongs_to :community, class_name: 'Cp::Community'
  belongs_to :board_post, class_name: 'Cp::BoardPost', optional: true

  validates :seeded_question_id, uniqueness: { scope: :community_id }

  scope :active, -> { where(archived_at: nil) }
  scope :with_engagement, -> { where('reply_count > 0 OR reaction_count > 0') }
end

Migration

# db/migrate/YYYYMMDDHHMMSS_create_cp_seeded_questions.rb
class CreateCpSeededQuestions < ActiveRecord::Migration[7.1]
  def change
    create_table :cp_seeded_questions do |t|
      t.string :title, null: false
      t.text :body
      t.integer :status, default: 0, null: false
      t.integer :target_type, default: 0, null: false
      t.string :affinity_category  # e.g., 'Greek Life', 'Athletics', 'Vocal Ensembles'
      t.integer :priority, default: 0
      t.datetime :active_from
      t.datetime :active_until
      t.jsonb :metadata, default: {}
      
      t.timestamps
    end

    add_index :cp_seeded_questions, :status
    add_index :cp_seeded_questions, :target_type
    add_index :cp_seeded_questions, :affinity_category

    create_table :cp_seeded_question_exposures do |t|
      t.references :seeded_question, null: false, foreign_key: { to_table: :cp_seeded_questions }
      t.references :community, null: false, foreign_key: { to_table: :cp_communities }
      t.references :board_post, foreign_key: { to_table: :cp_board_posts }
      t.integer :reply_count, default: 0
      t.integer :reaction_count, default: 0
      t.datetime :archived_at
      
      t.timestamps
    end

    add_index :cp_seeded_question_exposures, 
              [:seeded_question_id, :community_id], 
              unique: true, 
              name: 'idx_seeded_exposures_unique'
  end
end

5. Question Selection Algorithm

Service: Cp::SeededQuestionSelector

# app/services/cp/seeded_question_selector.rb
class Cp::SeededQuestionSelector
  ROTATION_DAYS = 30
  MAX_ACTIVE_PER_COMMUNITY = 2

  def initialize(community)
    @community = community
  end

  def call
    return nil if sufficient_organic_activity?
    return nil if at_max_active_questions?
    
    select_best_question
  end

  private

  def sufficient_organic_activity?
    # Don't seed if community has recent organic posts
    @community.board_posts
              .where(seeded_question_exposure_id: nil)
              .where('created_at > ?', 7.days.ago)
              .exists?
  end

  def at_max_active_questions?
    @community.seeded_question_exposures.active.count >= MAX_ACTIVE_PER_COMMUNITY
  end

  def select_best_question
    candidates = candidate_questions
    return nil if candidates.empty?

    # Weighted random selection favoring higher priority and freshness
    weighted_sample(candidates)
  end

  def candidate_questions
    base = Cp::SeededQuestion
      .active
      .not_recently_used_in(@community, days: ROTATION_DAYS)
      .where('active_from IS NULL OR active_from <= ?', Time.current)
      .where('active_until IS NULL OR active_until >= ?', Time.current)

    # Filter by community type
    case @community.community_type
    when 'district'
      base.active_for_type('district')
    when 'college'
      base.active_for_type('college')
    when 'major'
      base.active_for_type('major')
    when 'affinity'
      category = @community.affinity_category
      base.active_for_type('affinity')
          .or(base.for_affinity_category(category))
    when 'industry'
      base.active_for_type('industry')
    else
      base.active_for_type('all_communities')
    end
  end

  def weighted_sample(questions)
    # Higher priority = more weight
    # More recently created = more weight (freshness bonus)
    weights = questions.map do |q|
      priority_weight = (q.priority + 1) * 10
      freshness_weight = [1, 30 - ((Time.current - q.created_at) / 1.day).to_i].max
      priority_weight + freshness_weight
    end

    total = weights.sum
    random = rand * total
    
    cumulative = 0
    questions.each_with_index do |q, i|
      cumulative += weights[i]
      return q if random <= cumulative
    end
    
    questions.last
  end
end

Selection Triggers

Questions are selected and published:

  1. Community board view — If board has < 2 active seeded questions, consider adding
  2. Daily automatic posting job — Cp::SeedQuestionsJob runs at 6 AM (see below)
  3. Community activation — When community reaches activation threshold (3 members)

5.1 Automatic Daily Posting Job

CRITICAL: The system AUTOMATICALLY posts seeded discussions to communities lacking recent activity. This is not admin-triggered—it’s a daily automated process.

Cp::SeedQuestionsJob

# app/jobs/cp/seed_questions_job.rb
class Cp::SeedQuestionsJob < ApplicationJob
  queue_as :low
  
  # Run daily at 6 AM via Heroku Scheduler or sidekiq-cron
  def perform
    eligible_communities.find_each do |community|
      # Skip if community has had any organic OR seeded discussion in past X days
      next if recent_activity?(community)
      
      # Select and post a seeded question
      question = Cp::SeededQuestionSelector.new(community).select
      next unless question
      
      Cp::SeededQuestionPublisher.new(question, community).publish!
      
      Rails.logger.info "[SeedQuestionsJob] Posted seeded question #{question.id} to #{community.name}"
    end
  end
  
  private
  
  def eligible_communities
    # Only communities that have discussions enabled and meet activation threshold
    Cp::Community
      .where(discussions_enabled: true)
      .where('member_count >= ?', Cp::Community::ACTIVATION_THRESHOLD)
  end
  
  def recent_activity?(community)
    # Check for ANY recent post (organic OR seeded) in the configured window
    community.board_posts
             .where('created_at > ?', activity_threshold_days.days.ago)
             .exists?
  end
  
  def activity_threshold_days
    # Configurable: how many days without activity before auto-seeding
    ENV.fetch('SEEDED_QUESTION_ACTIVITY_THRESHOLD_DAYS', 7).to_i
  end
end

Configuration

Setting Default Description
SEEDED_QUESTION_ACTIVITY_THRESHOLD_DAYS 7 Days without any post before auto-seeding
SEEDED_QUESTION_MAX_ACTIVE_PER_COMMUNITY 2 Maximum active seeded questions per community

Behavior Summary

  1. Daily at 6 AM: Job evaluates ALL active communities with discussions enabled
  2. Activity check: For each community, checks if there’s been ANY post (organic or seeded) in the past X days (default: 7)
  3. Auto-post: If no recent activity, automatically selects and posts a seeded question
  4. One per day max: Each community gets at most one seeded question per day
  5. No duplicates: Questions already used in a community won’t be selected again (via SeededQuestionExposure)

Scheduler Setup (Heroku)

# Add to Heroku Scheduler
heroku addons:create scheduler:standard --app alumni-lookup

# Configure daily job
heroku addons:open scheduler --app alumni-lookup
# Add: "bin/rails runner 'Cp::SeedQuestionsJob.perform_now'" at 6:00 AM UTC

Monitoring

# Rails console: Check seeded question activity
Cp::SeededQuestionExposure.where('created_at > ?', 7.days.ago).count
# => 23 (seeded questions posted in last week)

# Communities without recent activity
Cp::Community.where(discussions_enabled: true)
             .where.not(id: Cp::BoardPost.where('created_at > ?', 7.days.ago)
                                         .select(:community_id))
             .count
# => 12 (communities that would receive seeded questions)

6. Template Interpolation

Supported Variables

Variable Description Example
{community_name} Community display name “Nashville Champions”
{community_type} Humanized type “your city”, “your college”
{member_count} Current member count “23”
{current_month} Current month name “January”
{current_season} Current season “winter”
{current_year} Current year “2026”

Service: Cp::QuestionInterpolator

# app/services/cp/question_interpolator.rb
class Cp::QuestionInterpolator
  SEASON_MONTHS = {
    'spring' => [3, 4, 5],
    'summer' => [6, 7, 8],
    'fall' => [9, 10, 11],
    'winter' => [12, 1, 2]
  }

  def initialize(question, community)
    @question = question
    @community = community
  end

  def interpolate_title
    interpolate(@question.title)
  end

  def interpolate_body
    return nil if @question.body.blank?
    interpolate(@question.body)
  end

  private

  def interpolate(text)
    text
      .gsub('{community_name}', @community.display_name)
      .gsub('{community_type}', humanized_type)
      .gsub('{member_count}', @community.members_count.to_s)
      .gsub('{current_month}', Date.current.strftime('%B'))
      .gsub('{current_season}', current_season)
      .gsub('{current_year}', Date.current.year.to_s)
  end

  def humanized_type
    case @community.community_type
    when 'district' then 'your city'
    when 'college' then 'your college'
    when 'major' then 'your major'
    when 'affinity' then 'your community'
    when 'industry' then 'your industry'
    else 'this community'
    end
  end

  def current_season
    month = Date.current.month
    SEASON_MONTHS.find { |_, months| months.include?(month) }&.first || 'spring'
  end
end

Example Questions with Interpolation

Template Interpolated (Nashville)
“What brought you to {community_name}?” “What brought you to Nashville Champions?”
“What’s your favorite {current_season} tradition in {community_type}?” “What’s your favorite winter tradition in your city?”
“The {community_name} community has {member_count} members. How did you first connect with Belmont?” “The Nashville Champions community has 23 members. How did you first connect with Belmont?”

7. Affinity Category Targeting

Problem

Creating unique questions for each of 50+ affinity communities is impractical. But generic questions feel hollow.

Solution: Leverage Existing Affinity Categories

The affinities table already has a category column that groups affinities into logical types. We use this existing data instead of creating duplicate grouping logic:

Category (from affinities.category) Example Affinities Example Question
Greek Life Phi Mu, Chi Omega, Sigma Chi “What’s your favorite memory from Greek Week?”
Athletics SAAC, Baseball Alumni, Soccer Alumni “How did being a Bruin athlete shape your career?”
Instrumental Ensembles Jazz Band, Orchestra, Wind Ensemble “What’s the most memorable performance you participated in?”
Vocal Ensembles Joyful Sound, Musical Theatre Ensemble “What’s the most memorable performance you participated in?”
Campus Life Bruin Buddies, SGA, Towering Traditions “How did your campus involvement shape who you are?”
Spiritual Life Belmont Missions, Chapel Band “What service or faith experience had the biggest impact on you?”
Geographic Nashville Alumni, Atlanta Alumni “What brought you to this city?”
Post Graduation Young Alumni, Senior Alumni “How has your perspective on Belmont changed over time?”

Note: These 8 categories come directly from SELECT DISTINCT category FROM affinities — no custom mapping needed.

Implementation

The Cp::Community model already has an #affinity method that returns the ::Affinity record. We simply access the category:

# app/models/cp/community.rb
class Cp::Community < ApplicationRecord
  # Existing method — returns the Affinity record for affinity-type communities
  def affinity
    return nil unless community_type == 'affinity'
    ::Affinity.find_by(affinity_code: affinity_code)
  end
  
  # New convenience method for seeded questions
  def affinity_category
    affinity&.category
  end
end

Why this approach:

8. Integration with Discussion Boards

Publishing Flow

When a seeded question is selected for a community:

# app/services/cp/seeded_question_publisher.rb
class Cp::SeededQuestionPublisher
  def initialize(question, community)
    @question = question
    @community = community
  end

  def call
    return if already_exposed?

    ActiveRecord::Base.transaction do
      post = create_board_post
      create_exposure(post)
      post
    end
  end

  private

  def already_exposed?
    Cp::SeededQuestionExposure.exists?(
      seeded_question: @question,
      community: @community
    )
  end

  def create_board_post
    interpolator = Cp::QuestionInterpolator.new(@question, @community)

    Cp::BoardPost.create!(
      community: @community,
      author_type: 'Staff',  # Signals this is "Engagement Team"
      author_id: nil,
      title: interpolator.interpolate_title,
      body: interpolator.interpolate_body,
      pinned: false,  # Seeded questions aren't pinned by default
      seeded: true    # Flag to identify seeded posts
    )
  end

  def create_exposure(post)
    Cp::SeededQuestionExposure.create!(
      seeded_question: @question,
      community: @community,
      board_post: post
    )
  end
end

BoardPost Model Changes

# Add to Cp::BoardPost
class Cp::BoardPost < ApplicationRecord
  # Existing code...
  
  # Add column
  attribute :seeded, :boolean, default: false
  
  belongs_to :seeded_question_exposure, 
             class_name: 'Cp::SeededQuestionExposure', 
             optional: true

  scope :seeded, -> { where(seeded: true) }
  scope :organic, -> { where(seeded: false) }
  
  # Existing author_display_name already returns "Engagement Team" for Staff author_type
end

Display Considerations

Seeded questions display like regular posts with visual distinction:

<% if post.seeded? %>
  <div class="bg-blue-50 border-l-4 border-belmontblue rounded-lg p-4">
    <div class="flex items-center gap-2 text-sm text-belmontblue mb-2">
      <%= heroicon "megaphone", variant: :outline, options: { class: "w-4 h-4" } %>
      <span class="font-medium">From the Engagement Team</span>
    </div>
    <!-- Post content -->
  </div>
<% else %>
  <!-- Regular post display -->
<% end %>

9. User Experience

Champion Perspective

  1. Join community → Land on board
  2. See seeded question → “What brought you to Nashville Champions?”
  3. Low barrier to respond → Question is easy to answer
  4. Engagement builds → Other members reply, reactions accumulate
  5. Organic posts follow → Community becomes self-sustaining

Engagement Team Perspective

  1. Create questions → Admin UI with preview
  2. Target appropriately → Choose community type or affinity subtype
  3. Monitor performance → See which questions get engagement
  4. Iterate → Pause underperformers, create new questions

Community Board View

┌─────────────────────────────────────────────────────────────────────────┐
│ 🎵 Music Business Discussion Board                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│ 📢 From the Engagement Team                                             │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │                                                                     │ │
│ │ "What's the best career advice you've received in the music        │ │
│ │  industry?"                                                         │ │
│ │                                                                     │ │
│ │ Share the wisdom that helped you navigate your path!               │ │
│ │                                                                     │ │
│ │ 💬 7 replies · ❤️ 15 · 👍 8 · 🎉 3             [Reply] [React]     │ │
│ │                                                                     │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│                                                                         │
│ Recent Discussions ──────────────────────────────────────────────────   │
│                                                                         │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ Sarah Champion                                             2 hours  │ │
│ │ "Anyone else headed to Summer NAMM this year?"                      │ │
│ │ 💬 3 replies · ❤️ 5                                                 │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

10. Implementation Plan

Week 1: Data Model & Core Services

Day 1-2: Models

Day 3: Selection Service

Day 4: Interpolation Service

Day 5: Publishing Service

Week 2: Integration & Polish

Day 6-7: Board Integration

Day 8: Background Job

Day 9-10: Testing & Edge Cases

11. Testing Requirements

Model Tests

File: test/models/cp/seeded_question_test.rb

class Cp::SeededQuestionTest < ActiveSupport::TestCase
  test "validates title presence" do
    question = Cp::SeededQuestion.new(title: nil)
    assert_not question.valid?
    assert_includes question.errors[:title], "can't be blank"
  end

  test "validates affinity_category when target_type is affinity_category" do
    question = Cp::SeededQuestion.new(
      title: "Test",
      target_type: 'affinity_category',
      affinity_category: nil
    )
    assert_not question.valid?
    assert_includes question.errors[:affinity_category], "can't be blank"
  end

  test "active_for_type scope includes all_communities" do
    all_q = create(:seeded_question, target_type: 'all_communities')
    district_q = create(:seeded_question, target_type: 'district')
    college_q = create(:seeded_question, target_type: 'college')

    results = Cp::SeededQuestion.active_for_type('district')
    
    assert_includes results, all_q
    assert_includes results, district_q
    assert_not_includes results, college_q
  end
end

Service Tests

File: test/services/cp/seeded_question_selector_test.rb

class Cp::SeededQuestionSelectorTest < ActiveSupport::TestCase
  setup do
    @community = cp_communities(:nashville_district)
    @question = create(:seeded_question, target_type: 'district', status: 'active')
  end

  test "selects question for community with matching type" do
    selector = Cp::SeededQuestionSelector.new(@community)
    result = selector.call
    
    assert_equal @question, result
  end

  test "returns nil when community has recent organic posts" do
    create(:board_post, community: @community, seeded: false, created_at: 1.day.ago)
    
    selector = Cp::SeededQuestionSelector.new(@community)
    assert_nil selector.call
  end

  test "excludes recently used questions" do
    create(:seeded_question_exposure, 
           seeded_question: @question, 
           community: @community,
           created_at: 10.days.ago)
    
    selector = Cp::SeededQuestionSelector.new(@community)
    assert_nil selector.call  # Only question was recently used
  end
end

File: test/services/cp/question_interpolator_test.rb

class Cp::QuestionInterpolatorTest < ActiveSupport::TestCase
  test "interpolates community_name" do
    question = Cp::SeededQuestion.new(title: "Welcome to {community_name}!")
    community = cp_communities(:nashville_district)
    
    interpolator = Cp::QuestionInterpolator.new(question, community)
    
    assert_equal "Welcome to Nashville Champions!", interpolator.interpolate_title
  end

  test "interpolates current_season correctly" do
    question = Cp::SeededQuestion.new(title: "What's your {current_season} tradition?")
    community = cp_communities(:nashville_district)
    
    travel_to Date.new(2026, 1, 15) do
      interpolator = Cp::QuestionInterpolator.new(question, community)
      assert_equal "What's your winter tradition?", interpolator.interpolate_title
    end
  end
end

Integration Tests

File: test/integration/cp/seeded_questions_flow_test.rb

class Cp::SeededQuestionsFlowTest < ActionDispatch::IntegrationTest
  test "seeded question appears on community board" do
    sign_in cp_champions(:sarah_champion)
    community = cp_communities(:music_business)
    
    # Publish a seeded question
    question = create(:seeded_question, 
                      title: "What brought you to {community_name}?",
                      target_type: 'major',
                      status: 'active')
    Cp::SeededQuestionPublisher.new(question, community).call
    
    get cp_community_board_path(community)
    
    assert_response :success
    assert_select ".seeded-question", text: /What brought you to Music Business/
    assert_select ".engagement-team-badge", text: "From the Engagement Team"
  end
end

Starter Question Bank

Initial questions to seed the system:

Universal (All Communities)

  1. “What’s your favorite Belmont memory?”
  2. “How has your Belmont experience shaped your career?”
  3. “If you could give advice to your freshman self, what would it be?”
  4. “What {current_season} traditions do you keep from your Belmont days?”

District Communities

  1. “What brought you to {community_name}?”
  2. “What’s your favorite hidden gem in {community_type}?”
  3. “Anyone else working in {community_type}? What industries are you in?”
  4. “What’s one thing you wish you’d known before moving to {community_type}?”

College Communities

  1. “How has your {community_name} degree served you?”
  2. “What professor from {community_name} had the biggest impact on you?”
  3. “What’s something unique about the {community_name} experience?”

Major Communities

  1. “What are you working on these days in {community_type}?”
  2. “What career paths have other {community_name} grads taken?”
  3. “What’s the most valuable thing you learned in {community_type}?”

Affinity: Greek

  1. “What’s your favorite memory from Greek Week?”
  2. “How has your Greek experience influenced your professional life?”
  3. “Any other {community_name} alumni in your city?”

Affinity: Athletics

  1. “How did being a Bruin athlete shape your career?”
  2. “Do you still follow Belmont athletics? Favorite recent moment?”
  3. “What lessons from competition do you still use today?”

Affinity: Music

  1. “What’s the most memorable performance you participated in at Belmont?”
  2. “How has the music industry changed since you graduated?”
  3. “Any touring/recording projects you’re working on?”

What Was Implemented

To be updated after implementation

Deferred Items

To be updated after implementation

Document created: January 2026