GIVE YOUR USERS A VOICE

Alto: The Rails feedback board engine.

Collect feature requests, bug reports, and internal ideas with threaded comments, voting, image uploads, and status updates. No third-party platform required.

Try the demo Get started

Use any email to sign up. Include +admin in your email to see the admin dashboard e.g. [email protected]
Demo resets every 10 minutes, so you can play around without breaking anything

See it in action

Don't just read about Alto. Jump into the live demo and see how it feels. It's running on Heroku with full functionality.

Fully interactive demo

Take it for a spin

Create tickets, add comments, vote on stuff, manage boards, poke around the admin interface. It's all there, running in a real Rails app.

Launch demo app

What you can do:

  • • Sign up with any email (include +admin in your email to see the admin dashboard)
  • • Create and manage feedback tickets with image uploads
  • • Add threaded comments and start discussions
  • • Vote on tickets and comments
  • • Switch between card and list views
  • • Check out the admin dashboard

Demo details:

  • • Live Heroku app: Real Rails deployment
  • • Fresh data: Resets every 10 minutes
  • • No strings attached: Use any email to sign up
  • • Full features: Everything you see is what you get
  • • Mobile ready: Works on your phone too

Here's what it looks like

Quick preview, but the live demo is way more fun to play with.

Alto feedback board interface showing ticket listing, voting system, and status management in a Rails application

Alto's main interface: tickets, voting, comments, and status management. All natively integrated in your Rails app.

Why Alto?

Your feedback should live where your product lives.

Most feedback tools make you send users to some external platform. Alto gives you everything you need to collect and manage product input right inside your app.

Mountable Rails engine

Your data, your users, your app. No third-party SaaS dependency.

Multiple boards - with customizable statuses and tagging

Each board gets its own status workflow and tagging system for perfect organization.

3-level threaded comments

Rich discussions with upvoting

Flexible view modes

Card view or forum-style list view

Works with any user model

Polymorphic architecture that doesn't care what you call your users

Authentication agnostic

Devise, custom auth, or public access. Whatever you're using.

Image upload support

Upload images in tickets and comments. Works with Cloudinary, S3, or local storage.

Powerful callback hooks

Connect to Slack, webhooks, analytics, and any external service with zero config.

Admin dashboard with analytics

Manage boards, track engagement, and get insights on feedback trends.

Built for developers

Works with any auth system. Zero JavaScript required.

Alto is built for Rails devs who want full control and flexibility.

Works with any authentication

  • Devise - Works automatically
  • Custom auth - Define your own current_user
  • JWT tokens - API-first applications
  • No authentication - Public feedback boards 
# Devise works automatically
config.permission :can_create_tickets? do
  user_signed_in?
end

# Custom auth
config.permission :can_create_tickets? do
  current_user.present?
end

# Public feedback
config.permission :can_create_tickets? do
  true
end

Polymorphic user support

  • Works with any user model name
  • User, Account, Member, Customer. Your choice.
  • Flexible user display name configuration
  • Zero coupling to your user implementation 
# Configure any user model
Alto.configure do |config|
  config.user_model = "Account"

  config.user_display_name do |user_id|
    Account.find(user_id)&.full_name || "Anonymous"
  end
end

Flexible view options

Switch between card view for visual browsing and list view for a forum-like experience

Alto interface showing card view - a visual, Pinterest-style layout with ticket cards for easy browsing and quick scanning

Card view shown here. Visual, Pinterest-style layout perfect for quick scanning. Users can also switch to list view for a forum-style experience.

✨ What's included

Feature Included
Multiple boards with customizable statuses and tagging ✅
Voting system with upvotes ✅
3-level threaded comments ✅
Admin dashboard with analytics ✅
Powerful callback hook system (Slack, webhooks, custom integrations) ✅
Authentication-agnostic design (works with any auth system) ✅
Custom fields per board (dropdowns, text inputs, multiselect, etc.) ✅
Full-text search ✅
Configurable status sets ✅
Multiple view options (card & list/forum view) ✅
Polymorphic user architecture (works with any user model) ✅
Image upload support for tickets and comments (Cloudinary, S3, local storage) ✅

🎣 Powerful callback hooks

Alto's callback system gives you deep integration power. Connect to any service with zero configuration. Just define the methods you need.

📋 Available hooks

🎫 Ticket events:
  • • ticket_created(ticket, board, user)
  • • ticket_status_changed(ticket, old_status, new_status, board, user)
💬 Comment events:
  • • comment_created(comment, ticket, board, user)
  • • comment_deleted(comment, ticket, board, user)
👍 Voting events:
  • • upvote_created(upvote, votable, board, user)
  • • upvote_removed(upvote, votable, board, user)

💬 Slack notifications

def ticket_created(ticket, board, user)
  channel = board.slug == 'bugs' ? '#dev-team' : '#product'

  SlackWebhook.post(
    channel: channel,
    text: "New #{board.name}: #{ticket.title}",
    user: user&.email
  )
end

def comment_created(comment, ticket, board, user)
  SlackWebhook.post(
    channel: '#feedback',
    text: "💬 New comment on: #{ticket.title}",
    blocks: [{
      type: "section",
      text: { type: "mrkdwn", text: comment.content }
    }]
  )
end

✨ Why callback hooks?

⚡ Zero configuration - Just define the methods you need
📊 Rich context - Every callback receives full object details
🛡️ Error isolation - Callback failures don't break the main flow
🔌 Flexible integration - Works with any external service

📦 Install in minutes

Three steps to get Alto running in your Rails app

1

Add to Gemfile

Install the Alto gem from GitHub

2

Run generator

Create tables and config file

3

Mount & configure

Add to routes and customize permissions

# 1. Add to your Gemfile
gem 'alto', github: 'CG3-Media/alto'

# 2. Install and generate
bundle install
rails generate alto:install

# 3. Add to config/routes.rb
mount Alto::Engine => "/feedback"

🔧 Configure permissions (config/initializers/alto.rb)

Alto.configure do |config|
  # Works with any authentication system
  config.permission :can_access_alto? do
    user_signed_in?  # Devise
    # current_user.present?  # Custom auth
    # true  # Public access
  end

  config.permission :can_access_admin? do
    current_user&.admin?
  end

  # Enable image uploads (requires ActiveStorage)
  config.image_uploads_enabled = true

  # Customize user display
  config.user_display_name do |user_id|
    User.find(user_id)&.name || "Anonymous"
  end
end