Table view

Dense data stays scannable

A fast table over any resource with sorting, pagination, and per-column control, tuned for the person who reads two hundred rows a day.

Plugins

Share your extensions as gems

Package Avo customizations as plugins with hooks into the asset manager and boot process, reusable across your apps.

Seamless upgrades

Updates cost a bundle update, not a sprint

New features and fixes arrive when you bump the gem. You ride a roadmap that keeps shipping instead of stopping your product work to improve the admin.

Export to CSV

The spreadsheet ops asked for, without a console session

Export any filtered set to CSV with an action. Finance gets their file and you keep your afternoon.

Authorization

Everyone sees exactly what they're allowed to

Control access with Pundit policies, from whole resources down to individual fields and actions. The riskiest part of your stack stops being auth you wrote in a hurry.

Automatic field discovery

Start from a working screen, not a blank file

Point Avo at a model and it reads your schema and associations to build the fields for you. You edit a working resource instead of scaffolding one.

CLI

Misconfigurations caught before the browser

Lint your Avo setup from the terminal and in CI, so config problems surface next to your failing tests, not in production.

Tags field

Messy labels become clean tags

Tag records with suggestions and validation, comma or enter to commit. Works with acts-as-taggable-on out of the box.

Record previews

Triage without losing your place

Peek at a record's details from the Index view without navigating away, so working through a queue stays fast.

MCP server

AI agents work your admin, safely

Assistants read and act on your data over MCP with the same permissions your team has, not a side door you'll regret.

Global search

Any record, one search box away

One global search over your whole database. Jump to any record from anywhere in the admin.

Grid view

Visual content reads as visual content

Show media-heavy resources as cards with a cover, title, and body, so a catalog looks like a catalog instead of a spreadsheet.

Namespaced resources

A 100-resource admin that stays navigable

Group resources under namespaces so the sidebar keeps making sense as your app grows.

Menu editor

Each team sees exactly what it needs

Shape the sidebar per role with the menu editor. Group, rename, and surface what matters, hide what doesn't.

I18n

The admin speaks your team's language

The whole interface runs through Rails I18n, so a non-English team gets a fully translated tool, not a half-labeled one.

Discreet information

Important metadata without the clutter

Surface timestamps, flags, and states discreetly on records, so context is there when you look for it and invisible when you don't.

Audit logging

Who changed what, answered instantly

Every action leaves a trail. The next time an auditor, a founder, or an incident asks, the answer is a filter away.

Works with any Rails app

No rewrite to adopt it

Avo installs side by side with your app, new or legacy, large or small, and doesn't pollute it with generated files. You start where you are.

Actions

Ten thousand records changed with one button

Run custom operations on one record or your whole result set, with your own fields, confirmations, and feedback messages.

Array resources

An admin over data without a table

Put a full UI over plain arrays and hashes. Useful for config-like data that never earned a database table.

Map view

Location data on a map, not in columns

Plot records with coordinates and browse them geographically. Latitude stops being a number someone has to imagine.

Money field

Money handled like money

Display and edit monetary values with currencies and rounding already thought through, so cents never silently drift.

Filters

Slice data once, reuse it forever

Segment your data with filters you write once in Ruby, available to the whole team on every visit.

True select-all

Select all means all

Selection applies to every record matching the current query, not just the visible page. The detail most homegrown admins get wrong, and users find out the hard way.

Multi-tenancy

One tenant's data never reaches another's screen

Scope every query to the current tenant. The leak that ends customer trust is handled at the framework level, not per screen.

Kanban boards

Work moves through stages without leaving the admin

Give your team a drag-and-drop kanban board over any model, so pipelines and queues live next to the data they track.

All association types

Your whole data model, understood

belongs_to, has_many, has_one, has_and_belongs_to_many, polymorphic, through. Every Rails association type handled, not just the happy path.

Reactive fields

Forms that respond as users type

Fields update live based on what's already filled in, no full page reload and no custom JavaScript to maintain.

Meta fields

New properties without a migration

Add fields to a model from inside Avo, stored in a JSON column. No migration, no deploy, no waiting on the next release train.

Notifications

The right person finds out automatically

Notify teammates inside the admin when something needs their attention, with a link straight to the record.

Keyboard shortcuts

Power users move at power-user speed

Navigate and act on records from the keyboard, so the people who live in the admin all day never reach for the mouse.

Encryption service

Sensitive values without homemade crypto

Encrypt and decrypt data with a built-in service instead of a helper someone wrote from a blog post in 2019.

Active Storage uploads

File uploads with zero plumbing

Single and multi-file uploads, direct uploads included, wired to Active Storage. The feature every admin needs and nobody enjoys building.

Key-value field

JSON columns your team can actually edit

Edit JSON as a friendly key-value table instead of raw text one missing brace away from an incident.

Standalone forms and pages

Settings screens without fake models

Build settings pages, surveys, and one-off operational forms with the same field DSL, no database table invented just to hold a form.

Bring your own asset pipeline

Works with the asset setup you already have

Sprockets, esbuild, importmaps, webpack. Avo plugs into whatever your app uses, no pipeline migration required.

Dynamic collections

New resources without a deploy

Spin up a brand-new resource from inside the app, model and routes included. Ops gets their tracker today, not next sprint.

Branding and appearance

Looks like your product, not a bolted-on tool

Set the logo, colors, and appearance so the admin your team lives in feels like something you built on purpose.

Dashboards

The numbers that matter, on one screen

Give the team a dashboard with the metrics they check every morning, built from cards you define in Ruby.

Custom fields

Never blocked by a missing field

When the built-in fields miss your case, generate a custom one in minutes and reuse it across every resource.

Scopes

The queries you already trust, one click away

Turn the model scopes you've battle-tested into one-click segmented views with badges and counts.

Location field

Coordinates picked on a map, not typed

Edit locations by pointing at a map instead of pasting latitude and longitude into text boxes.

Dynamic filters

New views without a ticket or a deploy

Anyone on the team builds their own filter combinations on the fly. "Can you add a screen for this" stops being your job.

On-premise by design

Your data never leaves your servers

Avo runs inside your Rails app, on your infrastructure. No third-party service sits between your team and your database.

Eject views

No black box, take over any template

Eject any view into your app when you need to change what Avo renders. It's ERB in your repo, not a vendor's cloud.

Conditional fields

Forms that fit each user and record

Show, hide, or disable any field per view, per record, or per user, with a lambda when the rule is yours. Admins see everything, support sees what's safe.

Code-driven configuration

An admin you can code-review

Your whole admin is plain Ruby in your repo: reviewable in a PR, versioned in git, readable by any Rails developer. No builder UI nobody can diff.

30+ field types

Almost every column covered before you write anything

Text, select, boolean, date, tags, code, progress, stars, country, and more than thirty other field types, ready before your first custom line.

Media library

Upload once, reuse everywhere

Manage every uploaded asset in one media library and attach files across records instead of uploading them twice.

Record reordering

Drag it where it belongs, and it sticks

Users set the order of records by dragging. Anything with a position column stops needing a form field and a prayer.

Resource tools

Custom sections where fields aren't enough

Embed fully custom UI inside a resource's views, so the one exotic screen doesn't force the whole admin off the framework.

Full mobile interface

Fix a record from your phone

The whole admin works on mobile, not a cut-down version of it. Support doesn't wait for someone to get back to a desk.

Status and badge fields

State visible at a glance

Colored badges and status fields make a record's state readable from across the room, no cell-squinting required.

Customizable controls

The right button in the right place

Add, remove, or reorder controls on any view, down to each table row, so the common operation is one click instead of three screens.

Rich text fields

Editors get a real writing experience

Trix, Tip Tap, Rhino, or Markdown fields, whichever fits your content. Nobody writes marketing copy in a bare textarea.

Resource search

Find records the way your team describes them

Search any resource with queries you define in Ruby, so "the customer with the weird email" is actually findable.

Panels, tabs, and sidebars

Forty fields, still readable

Lay out information-heavy resources with panels, tabs, and sidebars so the big records stay organized instead of becoming a scroll.

JSON API

Your admin config becomes an API

Expose the resources you already configured as a REST API, authentication and generators included. One definition, two interfaces.

CRUD interface

A working admin by this afternoon

Browse, create, edit, and delete records for any model from a few lines of Ruby. The weeks of views and controllers you'd otherwise write are already written.

Nested forms

Complex data entry in one save

Create and edit a record and its associations on one screen. An order and its line items stop being a five-page round trip.

Searchable associations

Nobody scrolls a 10,000-row dropdown

Pick associated records by typing a few characters instead of loading every row into a select.

Join table editing

Edit the data that lives between records

Display and edit fields on the join table itself, the case most homegrown admins silently drop.

Custom view types

Your data, listed your way

When table, grid, map, and kanban don't fit, build your own view type and switch between them per resource.

Agent-ready docs

Your AI assistant gets it right the first try

Avo ships llms.txt docs and conventions that coding agents follow well, so generated resource configs work instead of hallucinating APIs.

Collaboration

Conversations live where the data lives

Comment on records, mention teammates, and follow an activity timeline in place, instead of pasting record links into Slack threads that scroll away.

Custom tools

A fully custom page is one generator away

Need something completely yours? Avo generates the controller action and view, and you take it from there in plain Rails.

Stimulus integration

Your own JavaScript, the Rails way

Sprinkle behavior onto any view with the Stimulus you already know. No new frontend framework to learn or babysit.

Charts, metrics, and widgets

Metrics without standing up a BI tool

Metric cards, charts, and custom partials, composable on dashboards and resource pages. Enough insight for most teams, zero new infrastructure.

Bring your own authentication

Your login, not another one

Plug in Devise, the Rails auth generator, basic auth, or anything else. Avo asks who the user is and gets out of the way.

HTTP resources

External APIs managed like local models

Give records that live behind an HTTP API the same views, fields, and actions as your database rows. One admin for all of it.

Jun 26, 2026

Mar 25, 2026

Mar 16, 2026