diff --git a/.github/workflows/rspec.yml b/.github/workflows/rspec.yml
index a7b2dfba75..d5f28aa9aa 100644
--- a/.github/workflows/rspec.yml
+++ b/.github/workflows/rspec.yml
@@ -56,5 +56,7 @@ jobs:
       - run: bundle exec bootsnap precompile app/ lib/ config/ Rakefile
       - run: bundle exec rails zeitwerk:check
       - run: bundle exec rails assets:precompile
+      - run: bundle exec rails db:create
+      - run: bundle exec rails db:schema:load
       - run: bundle exec rails errbit:bootstrap
       - run: bundle exec rspec
diff --git a/.github/workflows/standard.yml b/.github/workflows/standard.yml
index ae9584f10c..fc2a3de8fa 100644
--- a/.github/workflows/standard.yml
+++ b/.github/workflows/standard.yml
@@ -45,6 +45,7 @@ jobs:
 
       - run: |
           bin/standardrb \
+            db/migrate/*.rb \
             app/controllers/users_controller.rb \
             app/controllers/unlink_githubs_controller.rb \
             app/controllers/unlink_googles_controller.rb \
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..b4e3a10a5c
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,48 @@
+# Errbit — agent guide
+
+## Project status: MongoDB → SQL port in progress
+
+Errbit is being ported from MongoDB/Mongoid to SQL/ActiveRecord on branch `claude-code-port-to-sql`.
+
+- **Old Mongoid models** live at `app/models/*.rb` (e.g. `app/models/user.rb` → `User`). They stay in place.
+- **New AR models** live under the `Errbit::` namespace at `app/models/errbit/*.rb` (e.g. `app/models/errbit/user.rb` → `Errbit::User`).
+- Both ORMs coexist during the port. Devise is wired only to `Errbit::User` (AR); the Mongoid `User` keeps its legacy fields as plain data for the migration rake task but is no longer a Devise model.
+
+## Conventions for ported models
+
+- Tables use the `errbit_` prefix via `Errbit.table_name_prefix` in `app/models/errbit.rb`.
+- AR models inherit from `Errbit::ApplicationRecord` (uses `primary_abstract_class`).
+- **Every ported table gets a `bson_id` string column with a unique index.** This stores the original Mongo BSON id so a future ETL step can link records back to their Mongo origin. Don't skip it.
+- Foreign keys use the `errbit_` prefix: `errbit_app_id`, `errbit_user_id`, etc.
+- Test infra: `database_rewinder` for cleanup (`spec/support/active_record.rb`), `shoulda-matchers` available for validation matchers.
+- Factories live under `spec/factories/errbit/`, specs under `spec/models/errbit/`. Factory names are prefixed (e.g. `:errbit_user`, `:errbit_app`, `:errbit_watcher`).
+
+## Porting a new model
+
+When asked to port the next Mongoid model:
+
+1. Add a migration `db/migrate/<timestamp>_create_errbit_<plural>.rb` — include `bson_id` + unique index, foreign keys with `errbit_` prefix, all data fields from the Mongoid model.
+2. Create `app/models/errbit/<name>.rb` — port fields/validations/callbacks/methods. Skip methods that depend on still-unported models; leave them for when the dependency is ported.
+3. If a previously-ported model has an association to this one, wire it up now (e.g. when porting `Watcher`, add `has_many :watchers` to `Errbit::App`).
+4. Add `spec/factories/errbit/<name>_factory.rb` and `spec/models/errbit/<name>_spec.rb`.
+5. Run migrations in both envs and run the spec.
+6. **Don't delete the old Mongoid model** — both must work until the full port is done.
+
+## Commands
+
+```sh
+bundle exec rails db:migrate                  # development
+RAILS_ENV=test bundle exec rails db:migrate   # test
+
+bundle exec rspec                                       # full suite
+bundle exec rspec spec/models/errbit/                   # all ported AR models
+bundle exec rspec spec/models/errbit/<name>_spec.rb     # one spec
+```
+
+Tests require a running MongoDB (the Mongoid models are still loaded on boot). The user runs mongo via Docker.
+
+## Things to check before running tests
+
+- `bundle install` after Gemfile changes.
+- Run migrations in **both** `development` and `test` envs — they're separate sqlite files (`storage/development.sqlite3`, `storage/test.sqlite3`).
+- After porting, run the namespaced spec **and** the old Mongoid spec to confirm no regression.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..161bfa9a0e
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,9 @@
+See [AGENTS.md](AGENTS.md) for project conventions, the Mongo→SQL port plan, and commands.
+
+## Spec conventions
+
+- In RSpec, every `context` block description **must** start with `when`, `with`, or `without`. Examples: `context "when user is an admin"`, `context "with valid params"`, `context "without a tracker configured"`. Do not start a context with `as`, `for`, a participle, or any other word.
+
+## Ruby block style
+
+- Use `{ ... }` only for **single-line** blocks. For any block that spans more than one line, use `do ... end`. This applies everywhere — including `expect { ... }.to …`, `lambda { ... }`, `Proc.new { ... }`, `Hash#each { ... }`, `before { ... }`, etc. A multi-line `expect` becomes `expect do … end.to …`.
diff --git a/Gemfile b/Gemfile
index d8faaac66f..78b98a9488 100644
--- a/Gemfile
+++ b/Gemfile
@@ -39,6 +39,7 @@ gem "uri"
 gem "rack-timeout"
 gem "puma"
 gem "ostruct"
+gem "sqlite3", ">= 2.1"
 
 # Please don't update hoptoad_notifier to airbrake.
 # It's for internal use only, and we monkeypatch certain methods
@@ -98,6 +99,8 @@ group :test do
   gem "rspec-rebound", require: false
   gem "rspec-activemodel-mocks"
   gem "mongoid-rspec"
+  gem "shoulda-matchers"
+  gem "database_rewinder"
   gem "pundit-matchers"
   gem "capybara"
   gem "selenium-webdriver"
diff --git a/Gemfile.lock b/Gemfile.lock
index 1ee7f55feb..778a3bdc9d 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -138,6 +138,7 @@ GEM
       addressable
       ssrf_filter (~> 1.5)
     csv (3.3.5)
+    database_rewinder (1.1.0)
     date (3.5.1)
     decent_exposure (3.0.4)
       activesupport (>= 4.0)
@@ -580,6 +581,8 @@ GEM
       rexml (~> 3.2, >= 3.2.5)
       rubyzip (>= 1.2.2, < 4.0)
       websocket (~> 1.0)
+    shoulda-matchers (8.0.1)
+      activesupport (>= 7.2)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -597,6 +600,18 @@ GEM
       actionpack (>= 6.1)
       activesupport (>= 6.1)
       sprockets (>= 3.0.0)
+    sqlite3 (2.9.5)
+      mini_portile2 (~> 2.8.0)
+    sqlite3 (2.9.5-aarch64-linux-gnu)
+    sqlite3 (2.9.5-aarch64-linux-musl)
+    sqlite3 (2.9.5-arm-linux-gnu)
+    sqlite3 (2.9.5-arm-linux-musl)
+    sqlite3 (2.9.5-arm64-darwin)
+    sqlite3 (2.9.5-x86-linux-gnu)
+    sqlite3 (2.9.5-x86-linux-musl)
+    sqlite3 (2.9.5-x86_64-darwin)
+    sqlite3 (2.9.5-x86_64-linux-gnu)
+    sqlite3 (2.9.5-x86_64-linux-musl)
     ssrf_filter (1.5.0)
     standard (1.55.0)
       language_server-protocol (~> 3.17.0.2)
@@ -676,6 +691,7 @@ DEPENDENCIES
   bundler-audit
   campy
   capybara
+  database_rewinder
   decent_exposure
   devise
   dotenv
@@ -736,8 +752,10 @@ DEPENDENCIES
   rubocop-rspec_rails
   rubocop-thread_safety
   selenium-webdriver
+  shoulda-matchers
   simplecov
   sprockets-rails
+  sqlite3 (>= 2.1)
   standard (= 1.55.0)
   stimulus-rails
   super_diff
@@ -789,6 +807,7 @@ CHECKSUMS
   crass (1.0.7) sha256=94868719948664c89ddcaf0a37c65048413dfcb1c869470a5f7a7ceb5390b295
   css_parser (3.0.0) sha256=eaf0e9283fd581d06e815235ceef4f0910c0b394c606355dbc69f93e84443885
   csv (3.3.5) sha256=6e5134ac3383ef728b7f02725d9872934f523cb40b961479f69cf3afa6c8e73f
+  database_rewinder (1.1.0) sha256=950398ba97bb20fb4653b6ee502a7d6658a6333a61d88ba756217f32bfa04510
   date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0
   decent_exposure (3.0.4) sha256=5ce9e3df24f8d77f094b2e612d1c43a78a2de879847ccbb57c0e596e6c303cf1
   devise (5.0.4) sha256=d605f2b85854e74e56ee789e2d398702bc2d06e6bcd894717a670a3199c74cc1
@@ -963,12 +982,24 @@ CHECKSUMS
   sawyer (0.9.3) sha256=0d0f19298408047037638639fe62f4794483fb04320269169bd41af2bdcf5e41
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
   selenium-webdriver (4.45.0) sha256=ecac65a4df86ac6f7d707e6dcbacaa9c08b6cf2b966babecfb9653c5aa13e2d1
+  shoulda-matchers (8.0.1) sha256=5dbb46e5765b9da225111b085e0819e8c8a121ff94bba430a153eb1ea2c60288
   simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5
   simplecov-html (0.13.2) sha256=bd0b8e54e7c2d7685927e8d6286466359b6f16b18cb0df47b508e8d73c777246
   simplecov_json_formatter (0.1.4) sha256=529418fbe8de1713ac2b2d612aa3daa56d316975d307244399fa4838c601b428
   snaky_hash (2.0.6) sha256=3663cae48cdef582b517025cf8a39d8789996eaf0b4ed89e2f0624836505654a
   sprockets (4.2.2) sha256=761e5a49f1c288704763f73139763564c845a8f856d52fba013458f8af1b59b1
   sprockets-rails (3.5.2) sha256=a9e88e6ce9f8c912d349aa5401509165ec42326baf9e942a85de4b76dbc4119e
+  sqlite3 (2.9.5) sha256=04572973a3f943ad50a8adfffc8dd752a5f06e4c3db2026f71838fed8a982606
+  sqlite3 (2.9.5-aarch64-linux-gnu) sha256=78075b6337d3d182c6d2b4691049ed45cd220826160c9ea18946bf6a1de200dc
+  sqlite3 (2.9.5-aarch64-linux-musl) sha256=18c801185deb4adc01ddb281e8f672a39e3d1729979ca91e39439cd3eac0402d
+  sqlite3 (2.9.5-arm-linux-gnu) sha256=1bdfca0c7d63998c60b0f4a8e3c8df2d33800ccc4abd2d612eddbbbc92a4c48b
+  sqlite3 (2.9.5-arm-linux-musl) sha256=bae1109d12b2e9f588455967729b008e1ff4feb7761749df695019c9079913c6
+  sqlite3 (2.9.5-arm64-darwin) sha256=d0cf444a70fc9395d513cfbcc1e6719e224aa645314e3824cb0474c721425aa2
+  sqlite3 (2.9.5-x86-linux-gnu) sha256=c94b96b16f17796be6fa099d15218b52e396f55690c4760faaaefa21ebab9dd5
+  sqlite3 (2.9.5-x86-linux-musl) sha256=063a8c13cbadfe7f29453b1706cbdf91fca4a78d244f816ff20bac4fb259f1e4
+  sqlite3 (2.9.5-x86_64-darwin) sha256=8e9caae38bd7ebb29cbeee3e7ab1d12dc2327d9a1b92c7fcf0dda05589627a81
+  sqlite3 (2.9.5-x86_64-linux-gnu) sha256=233dbcb6714148dd23bc5aeb33e8efd6eac974969564ddd5794c23d5f52b231e
+  sqlite3 (2.9.5-x86_64-linux-musl) sha256=e7d3a7474e8af0f96150c21abc203fbab5437206bfcdf11deab7741c0ca516f2
   ssrf_filter (1.5.0) sha256=e03dcdb9d1730d7f6710532a606b3543df2a448a0293ce04a2d995523c5a97f6
   standard (1.55.0) sha256=8a8f2c3e681a4db3aafde1b301561b0f3d7c5f06c160167cb744a4d7baf0426e
   standard-custom (1.0.2) sha256=424adc84179a074f1a2a309bb9cf7cd6bfdb2b6541f20c6bf9436c0ba22a652b
diff --git a/app/assets/stylesheets/notification_service_icons.css.erb b/app/assets/stylesheets/notification_service_icons.css.erb
index bf9dd332dd..701c5b507c 100644
--- a/app/assets/stylesheets/notification_service_icons.css.erb
+++ b/app/assets/stylesheets/notification_service_icons.css.erb
@@ -1,5 +1,5 @@
   /* Notification Service inactive, select, create and goto icons */
-<% notification_services = NotificationService.subclasses.map{|t| t.label } << 'none' %>
+<% notification_services = Errbit::NotificationService.subclasses.map { |t| t.label } << "none" %>
 
 <% notification_services.each do |notification_service| %>
 div.notification_service.nested label.<%= notification_service %> {
diff --git a/app/controllers/api/v1/comments_controller.rb b/app/controllers/api/v1/comments_controller.rb
index 11bacf2498..c7d8aaa85d 100644
--- a/app/controllers/api/v1/comments_controller.rb
+++ b/app/controllers/api/v1/comments_controller.rb
@@ -7,11 +7,12 @@ class CommentsController < ApplicationController
       skip_before_action :authenticate_user!
 
       respond_to :json, :xml
-      FIELDS = ["_id", "err_id", "user_id", "body"].freeze
 
       def index
         results = benchmark("[api/v1/comments_controller/index] query time") do
-          Comment.where(err_id: params[:problem_id]).only(FIELDS).to_a
+          Errbit::Comment.where(errbit_problem_id: params[:problem_id])
+            .to_a
+            .map { |comment| serialize_comment(comment) }
         end
 
         respond_to do |format|
@@ -21,10 +22,10 @@ def index
       end
 
       def create
-        comment = Comment.new(comment_params)
+        comment = Errbit::Comment.new(comment_params)
 
         if comment.save
-          render status: :created, json: comment
+          render status: :created, json: serialize_comment(comment)
         else
           render(
             body: {errors: comment.errors.full_messages}.to_json,
@@ -36,8 +37,20 @@ def create
       private
 
       def comment_params
-        # merge makes a copy, merge! edits in place
-        params.require(:comment).permit(:body).merge!(user_id: current_user.id, err_id: params[:problem_id])
+        params.require(:comment).permit(:body).merge(
+          errbit_user_id: current_user.id,
+          errbit_problem_id: params[:problem_id]
+        )
+      end
+
+      # Preserve the Mongoid-era API contract: keys `_id`, `err_id`, `user_id`.
+      def serialize_comment(comment)
+        {
+          "_id" => comment.id.to_s,
+          "err_id" => comment.errbit_problem_id.to_s,
+          "user_id" => comment.errbit_user_id.to_s,
+          "body" => comment.body
+        }
       end
     end
   end
diff --git a/app/controllers/api/v1/notices_controller.rb b/app/controllers/api/v1/notices_controller.rb
index e4169a34cf..9e616a38e9 100644
--- a/app/controllers/api/v1/notices_controller.rb
+++ b/app/controllers/api/v1/notices_controller.rb
@@ -6,17 +6,16 @@ class NoticesController < ApplicationController
       respond_to :json, :xml
 
       def index
-        query = {}
-        fields = ["created_at", "message", "error_class"]
+        scope = Errbit::Notice.all
 
         if params.key?(:start_date) && params.key?(:end_date)
           start_date = Time.zone.parse(params[:start_date]).utc
           end_date = Time.zone.parse(params[:end_date]).utc
-          query = {created_at: {"$lte" => end_date, "$gte" => start_date}}
+          scope = scope.where(created_at: start_date..end_date)
         end
 
         results = benchmark("[api/v1/notices_controller] query time") do
-          Notice.where(query).only(fields).to_a
+          scope.to_a.map { |notice| serialize_notice(notice) }
         end
 
         respond_to do |format|
@@ -24,6 +23,18 @@ def index
           format.xml { render xml: results }
         end
       end
+
+      private
+
+      # Preserve the Mongoid-era API contract: key `_id` (string).
+      def serialize_notice(notice)
+        {
+          "_id" => notice.id.to_s,
+          "created_at" => notice.created_at,
+          "message" => notice.message,
+          "error_class" => notice.error_class
+        }
+      end
     end
   end
 end
diff --git a/app/controllers/api/v1/problems_controller.rb b/app/controllers/api/v1/problems_controller.rb
index 66b745f703..c035e192a0 100644
--- a/app/controllers/api/v1/problems_controller.rb
+++ b/app/controllers/api/v1/problems_controller.rb
@@ -5,23 +5,18 @@ module V1
     class ProblemsController < ApplicationController
       respond_to :json, :xml
 
-      FIELDS = [
-        "_id", "app_id", "app_name", "environment", "message", "where",
-        "first_notice_at", "last_notice_at", "resolved", "resolved_at",
-        "notices_count"
-      ].freeze
-
       def index
-        query = {}
+        scope = Errbit::Problem.all
 
         if params.key?(:start_date) && params.key?(:end_date)
           start_date = Time.parse(params[:start_date]).utc
           end_date = Time.parse(params[:end_date]).utc
-          query = {:first_notice_at => {"$lte" => end_date}, "$or" => [{resolved_at: nil}, {resolved_at: {"$gte" => start_date}}]}
+          scope = scope.where("first_notice_at <= ?", end_date)
+            .where("resolved_at IS NULL OR resolved_at >= ?", start_date)
         end
 
         results = benchmark("[api/v1/problems_controller/index] query time") do
-          Problem.where(query).only(FIELDS).to_a
+          scope.to_a.map { |problem| serialize_problem(problem) }
         end
 
         respond_to do |format|
@@ -32,8 +27,8 @@ def index
 
       def show
         result = benchmark("[api/v1/problems_controller/show] query time") do
-          Problem.only(FIELDS).find(params.expect(:id))
-        rescue Mongoid::Errors::DocumentNotFound
+          serialize_problem(Errbit::Problem.find(params.expect(:id)))
+        rescue ActiveRecord::RecordNotFound
           head :not_found
           return false
         end
@@ -43,6 +38,27 @@ def show
           format.xml { render xml: result }
         end
       end
+
+      private
+
+      # Preserve the Mongoid-era API contract (keys `_id` and `app_id` are
+      # string-typed). Clients depending on this v1 shape keep working after
+      # the SQL port.
+      def serialize_problem(problem)
+        {
+          "_id" => problem.id.to_s,
+          "app_id" => problem.errbit_app_id.to_s,
+          "app_name" => problem.app_name,
+          "environment" => problem.environment,
+          "message" => problem.message,
+          "where" => problem.where,
+          "first_notice_at" => problem.first_notice_at,
+          "last_notice_at" => problem.last_notice_at,
+          "resolved" => problem.resolved,
+          "resolved_at" => problem.resolved_at,
+          "notices_count" => problem.notices_count
+        }
+      end
     end
   end
 end
diff --git a/app/controllers/api/v1/stats_controller.rb b/app/controllers/api/v1/stats_controller.rb
index cb7d7635c9..8fb9404209 100644
--- a/app/controllers/api/v1/stats_controller.rb
+++ b/app/controllers/api/v1/stats_controller.rb
@@ -10,7 +10,7 @@ class StatsController < ApplicationController
       before_action :require_api_key_or_authenticate_user!
 
       def app
-        if (problem = @app.problems.order_by(:last_notice_at.desc).first)
+        if (problem = @app.problems.order(last_notice_at: :desc).first)
           @last_error_time = problem.last_notice_at
         end
 
@@ -31,7 +31,7 @@ def app
 
       def require_api_key_or_authenticate_user!
         if params[:api_key].present?
-          return true if (@app = App.where(api_key: params[:api_key]).first)
+          return true if (@app = Errbit::App.where(api_key: params[:api_key]).first)
         end
 
         authenticate_user!
diff --git a/app/controllers/api/v3/notices_controller.rb b/app/controllers/api/v3/notices_controller.rb
index 6cab50fd71..d65781bf7e 100644
--- a/app/controllers/api/v3/notices_controller.rb
+++ b/app/controllers/api/v3/notices_controller.rb
@@ -32,7 +32,7 @@ def create
 
         report.generate_notice!
         render status: :created, json: {
-          id: report.notice.id,
+          id: report.notice.id.to_s,
           url: report.problem.url
         }
       rescue AirbrakeApi::ParamsError
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index 63546f31c1..694ae3c855 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -26,8 +26,8 @@ def set_time_zone
   end
 
   def authenticate_user_from_token!
-    user_token = params[User.token_authentication_key].presence
-    user = user_token && User.find_by(authentication_token: user_token)
+    user_token = params[Errbit::User.token_authentication_key].presence
+    user = user_token && Errbit::User.find_by(authentication_token: user_token)
 
     sign_in user, store: false if user
   end
diff --git a/app/controllers/apps_controller.rb b/app/controllers/apps_controller.rb
index c92a55d246..7ff8ff8ee7 100644
--- a/app/controllers/apps_controller.rb
+++ b/app/controllers/apps_controller.rb
@@ -1,45 +1,11 @@
 # frozen_string_literal: true
 
 class AppsController < ApplicationController
-  include ProblemsSearcher
-
   before_action :require_admin!, except: [:index, :show, :search]
   before_action :parse_email_at_notices_or_set_default, only: [:create, :update]
   before_action :parse_notice_at_notices_or_set_default, only: [:create, :update]
 
-  expose(:app_scope) do
-    params[:search].present? ? App.search(params[:search]) : App.all
-  end
-
-  expose(:apps) do
-    app_scope.to_a.sort.map { |app| AppDecorator.new(app) }
-  end
-
-  expose(:app)
-
-  expose(:app_decorate) do
-    AppDecorator.new(app)
-  end
-
-  expose(:all_errs) do
-    params[:all_errs].present?
-  end
-
-  expose(:problems) do
-    if request.format == :atom
-      app.problems.unresolved.ordered
-    else
-      pr = app.problems
-      pr = pr.unresolved unless all_errs
-      pr.in_env(
-        params[:environment]
-      ).ordered_by(params_sort, params_order).page(params[:page]).per(current_user.per_page)
-    end
-  end
-
-  expose(:users) do
-    User.all.sort_by { |u| u.name.downcase }
-  end
+  helper_method :app_decorate, :apps, :app, :problems, :users, :all_errs, :params_sort, :params_order
 
   def index
   end
@@ -49,7 +15,8 @@ def show
   end
 
   def new
-    plug_params(app)
+    @app = Errbit::App.new
+    plug_params(@app)
   end
 
   def edit
@@ -57,13 +24,17 @@ def edit
   end
 
   def create
+    @app = Errbit::App.new
+
     process_fingerprinter_choice
     initialize_subclassed_notification_service
 
-    if app.save
+    @app.assign_attributes(app_params)
+
+    if @app.save
       flash[:success] = I18n.t("controllers.apps.flash.create.success")
 
-      redirect_to app_url(app)
+      redirect_to app_url(@app)
     else
       flash.now[:error] = I18n.t("controllers.apps.flash.create.error")
 
@@ -74,9 +45,8 @@ def create
   def update
     process_fingerprinter_choice
     initialize_subclassed_notification_service
-    app.update(app_params)
 
-    if app.save
+    if app.update(app_params)
       flash[:success] = I18n.t("controllers.apps.flash.update.success")
 
       redirect_to app_url(app)
@@ -113,25 +83,68 @@ def search
 
   private
 
+  def app
+    @app ||= Errbit::App.find(params[:id])
+  end
+
+  def app_decorate
+    @app_decorate ||= Errbit::AppDecorator.new(app)
+  end
+
+  def apps
+    @apps ||= begin
+      scope = params[:search].present? ? Errbit::App.search(params[:search]) : Errbit::App.all
+      scope.to_a.sort.map { |a| Errbit::AppDecorator.new(a) }
+    end
+  end
+
+  def all_errs
+    params[:all_errs].present?
+  end
+
+  def problems
+    @problems ||= if request.format == :atom
+      app.problems.unresolved.ordered
+    else
+      pr = app.problems
+      pr = pr.unresolved unless all_errs
+      pr.in_env(params[:environment])
+        .ordered_by(params_sort, params_order)
+        .page(params[:page]).per(current_user.per_page)
+    end
+  end
+
+  def users
+    @users ||= Errbit::User.all.sort_by { |u| u.name.downcase }
+  end
+
+  def params_sort
+    @params_sort ||= ["environment", "app", "message", "last_notice_at", "count"].include?(params[:sort]) ? params[:sort] : "last_notice_at"
+  end
+
+  def params_order
+    @params_order ||= ["asc", "desc"].include?(params[:order]) ? params[:order] : "desc"
+  end
+
   def initialize_subclassed_notification_service
-    notification_type = app_params
-      .fetch(:notification_service_attributes, {})
-      .fetch(:type, nil)
+    notification_type = params.dig(:app, :notification_service_attributes, :type)
     return if notification_type.blank?
 
-    # set the app's notification service
-    available_notification_classes = [NotificationService] + NotificationService.subclasses
+    available_notification_classes = [Errbit::NotificationService] + Errbit::NotificationService.subclasses
     notification_class = available_notification_classes.detect { |c| c.name == notification_type }
-    unless notification_class.nil?
-      app.notification_service = notification_class.new(params[:app][:notification_service_attributes])
-    end
+    return if notification_class.nil?
+
+    ns_params = params[:app][:notification_service_attributes].to_unsafe_h.except(:type)
+    @app.notification_service = notification_class.new(ns_params)
   end
 
   def plug_params(app)
     app.watchers.build if app.watchers.none?
-    app.issue_tracker ||= IssueTracker.new
-    app.notification_service = NotificationService.new unless app.notification_service_configured?
-    app.notice_fingerprinter = SiteConfig.document.notice_fingerprinter.dup if app.notice_fingerprinter.nil?
+    app.issue_tracker ||= Errbit::IssueTracker.new
+    app.notification_service = Errbit::NotificationService.new unless app.notification_service_configured?
+    if app.notice_fingerprinter.nil?
+      app.build_notice_fingerprinter(Errbit::SiteConfig.document.notice_fingerprinter_attributes)
+    end
     app.copy_attributes_from(params[:copy_attributes_from]) if params[:copy_attributes_from]
   end
 
@@ -165,9 +178,6 @@ def parse_notice_at_notices_or_set_default
     val = params[:app][:notification_service_attributes][:notify_at_notices]
     return if val.blank?
 
-    # Sanitize negative values, split on comma,
-    # strip, parse as integer, remove all '0's.
-    # If empty, set as default and show an error message.
     notify_at_notices = val.gsub(/-\d+/, "").split(",").map { |v| v.strip.to_i }
     if notify_at_notices.any?
       params[:app][:notification_service_attributes][:notify_at_notices] = notify_at_notices
@@ -178,10 +188,13 @@ def parse_notice_at_notices_or_set_default
   end
 
   def process_fingerprinter_choice
+    return if params[:app].blank?
+
     if params[:app].delete(:use_site_fingerprinter) == "0"
-      params[:app][:notice_fingerprinter_attributes][:source] = SiteConfig::CONFIG_SOURCE_APP
+      params[:app][:notice_fingerprinter_attributes] ||= {}
+      params[:app][:notice_fingerprinter_attributes][:source] = Errbit::SiteConfig::CONFIG_SOURCE_APP
     else
-      params[:app][:notice_fingerprinter_attributes] = SiteConfig.document.notice_fingerprinter_attributes
+      params[:app][:notice_fingerprinter_attributes] = Errbit::SiteConfig.document.notice_fingerprinter_attributes
     end
   end
 
diff --git a/app/controllers/comments_controller.rb b/app/controllers/comments_controller.rb
index bbf271b701..f2fbea72c1 100644
--- a/app/controllers/comments_controller.rb
+++ b/app/controllers/comments_controller.rb
@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 class CommentsController < ApplicationController
-  expose :app
-  expose :problem
-  expose :comment
-
   def create
-    problem.comments << comment
+    problem = Errbit::Problem.find(params.expect(:problem_id))
+    comment = problem.comments.build(comment_params)
 
-    if problem.save
+    if comment.save
       flash[:success] = I18n.t("comments.create.success")
     else
       flash[:error] = I18n.t("comments.create.error")
     end
-    redirect_to app_problem_path(app, problem)
+
+    redirect_to app_problem_path(problem.app, problem)
   end
 
   def destroy
+    comment = Errbit::Comment.find(params.expect(:id))
+    problem = comment.err
+
     if comment.destroy
       flash[:success] = I18n.t("comments.destroy.success")
     else
       flash[:error] = I18n.t("comments.destroy.error")
     end
 
-    redirect_to app_problem_path(app, problem)
+    redirect_to app_problem_path(problem.app, problem)
   end
 
   private
 
   def comment_params
-    # merge makes a copy, merge! edits in place
-    params.require(:comment).permit!.merge!(user_id: current_user.id)
+    params.require(:comment).permit(:body).merge(errbit_user_id: current_user.id)
   end
 end
diff --git a/app/controllers/concerns/problems_searcher.rb b/app/controllers/concerns/problems_searcher.rb
deleted file mode 100644
index 3286d1fda7..0000000000
--- a/app/controllers/concerns/problems_searcher.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module ProblemsSearcher
-  extend ActiveSupport::Concern
-
-  included do
-    expose(:params_sort) do
-      if ["environment", "app", "message", "last_notice_at", "count"].member?(params[:sort])
-        params[:sort]
-      else
-        "last_notice_at"
-      end
-    end
-
-    expose(:params_order) do
-      if ["asc", "desc"].member?(params[:order])
-        params[:order]
-      else
-        "desc"
-      end
-    end
-
-    expose(:selected_problems) do
-      Array(Problem.find(err_ids))
-    end
-
-    expose(:selected_problems_ids) do
-      selected_problems.map(&:id).map(&:to_s)
-    end
-
-    expose(:err_ids) do
-      (params[:problems] || []).compact
-    end
-  end
-end
diff --git a/app/controllers/health_controller.rb b/app/controllers/health_controller.rb
index da86118dd9..f22fa2e7e1 100644
--- a/app/controllers/health_controller.rb
+++ b/app/controllers/health_controller.rb
@@ -2,7 +2,7 @@
 
 class HealthController < ActionController::Base # rubocop:disable Rails/ApplicationController
   def api_key_tester
-    app = App.where(api_key: params[:api_key]).first
+    app = Errbit::App.where(api_key: params[:api_key]).first
     is_good_result = app ? true : false
     response_status = is_good_result ? :ok : :forbidden
     render json: {ok: is_good_result}, status: response_status
diff --git a/app/controllers/notices_controller.rb b/app/controllers/notices_controller.rb
index 335421c815..e75b6f3915 100644
--- a/app/controllers/notices_controller.rb
+++ b/app/controllers/notices_controller.rb
@@ -11,7 +11,7 @@ class ParamsError < StandardError
 
   def create
     # params[:data] if the notice came from a GET request, raw_post if it came via POST
-    report = ErrorReport.new(notice_params)
+    report = Errbit::ErrorReport.new(notice_params)
 
     if report.valid?
       if report.should_keep?
@@ -32,12 +32,12 @@ def create
 
   # Redirects a notice to the problem page. Useful when using User Information at Airbrake gem.
   def locate
-    problem = Notice.find(params.expect(:id)).problem
+    problem = Errbit::Notice.find(params.expect(:id)).problem
     redirect_to app_problem_path(problem.app, problem)
   end
 
   def show_by_id
-    notice = Notice.find(params.expect(:id))
+    notice = Errbit::Notice.find(params.expect(:id))
     problem = notice.problem
     redirect_to app_problem_path(problem.app, problem, notice_id: notice.id)
   end
diff --git a/app/controllers/problems_controller.rb b/app/controllers/problems_controller.rb
index 2931ae224d..4e5ba66736 100644
--- a/app/controllers/problems_controller.rb
+++ b/app/controllers/problems_controller.rb
@@ -1,70 +1,35 @@
 # frozen_string_literal: true
 
 class ProblemsController < ApplicationController
-  include ProblemsSearcher
-
   before_action :need_selected_problem, only: [
     :resolve_several, :unresolve_several, :unmerge_several
   ]
 
-  expose(:app_scope) do
-    params[:app_id] ? App.where(_id: params.expect(:app_id)) : App.all
-  end
-
-  expose(:app) do
-    AppDecorator.new(app_scope.find(params.expect(:app_id)))
-  end
-
-  expose(:problem) do
-    ProblemDecorator.new(app.problems.find(params.expect(:id)))
-  end
-
-  expose(:all_errs) do
-    params[:all_errs]
-  end
-
-  expose(:filter) do
-    params[:filter]
-  end
-
-  expose(:params_environment) do
-    params[:environment]
-  end
-
-  # to use with_app_exclusions, hit a path like /problems?filter=-app:noisy_app%20-app:another_noisy_app
-  # it would be possible to add a really fancy UI for it at some point, but for now, it's really
-  # useful if there are noisy apps that you want to ignore.
-  expose(:problems) do
-    finder = Problem
-      .for_apps(app_scope)
-      .in_env(params_environment)
-      .filtered(filter)
-      .all_else_unresolved(all_errs)
-      .ordered_by(params_sort, params_order)
-
-    finder = finder.search(params[:search]) if params[:search].present?
-    finder.page(params[:page]).per(current_user.per_page)
-  end
+  helper_method :app, :problem, :problems, :all_errs, :filter,
+    :params_environment, :params_sort, :params_order,
+    :selected_problems, :selected_problems_ids, :err_ids
 
   def index
   end
 
   def show
-    notice =
-      if params[:notice_id]
-        Notice.find(params.expect(:notice_id))
-      else
-        @notices = problem.object.notices.reverse_ordered
-          .page(params[:notice]).per(1)
-        @notices.first
-      end
-    @notice = notice ? NoticeDecorator.new(notice) : nil
-    @comment = Comment.new
+    notice = if params[:notice_id]
+      Errbit::Notice.find(params.expect(:notice_id))
+    else
+      # `notices` is pre-ordered ASC for callers like recache; use `.reorder`
+      # to override (AR appends order clauses instead of replacing).
+      @notices = problem.object.notices.reorder(created_at: :desc)
+        .page(params[:notice]).per(1)
+      @notices.first
+    end
+
+    @notice = notice ? Errbit::NoticeDecorator.new(notice) : nil
+    @comment = Errbit::Comment.new
   end
 
   def show_by_id
-    problem = Problem.find(params.expect(:id))
-    redirect_to app_problem_path(problem.app, problem)
+    record = Errbit::Problem.find(params.expect(:id))
+    redirect_to app_problem_path(record.app, record)
   end
 
   def xhr_sparkline
@@ -72,7 +37,7 @@ def xhr_sparkline
   end
 
   def close_issue
-    issue = Issue.new(problem: problem, user: current_user)
+    issue = Errbit::Issue.new(problem: problem, user: current_user)
 
     flash[:error] = issue.errors.full_messages.join(", ") unless issue.close
 
@@ -80,7 +45,7 @@ def close_issue
   end
 
   def create_issue
-    issue = Issue.new(problem: problem, user: current_user)
+    issue = Errbit::Issue.new(problem: problem, user: current_user)
 
     issue.body = render_to_string(*issue.render_body_args)
 
@@ -90,7 +55,7 @@ def create_issue
   end
 
   def unlink_issue
-    problem.update_attribute(:issue_link, nil)
+    problem.update(issue_link: nil)
 
     redirect_to app_problem_path(app, problem)
   end
@@ -123,7 +88,7 @@ def merge_several
     if selected_problems.length < 2
       flash[:notice] = I18n.t("controllers.problems.flash.need_two_errors_merge")
     else
-      ProblemMerge.new(selected_problems).merge
+      Errbit::ProblemMerge.new(selected_problems).merge
 
       flash[:notice] = I18n.t("controllers.problems.flash.merge_several.success", nb: selected_problems.count)
     end
@@ -140,7 +105,7 @@ def unmerge_several
   end
 
   def destroy_several
-    DestroyProblemsByIdJob.perform_later(selected_problems_ids)
+    Errbit::DestroyProblemsByIdJob.perform_later(selected_problems_ids)
 
     flash[:notice] = "#{I18n.t(:n_errs, count: selected_problems.size)} #{I18n.t("n_errs.will_be_deleted")}."
 
@@ -148,7 +113,7 @@ def destroy_several
   end
 
   def destroy_all
-    DestroyProblemsByAppJob.perform_later(app.id)
+    Errbit::DestroyProblemsByAppJob.perform_later(app.id)
 
     flash[:success] = "#{I18n.t(:n_errs, count: app.problems.count)} #{I18n.t("n_errs.will_be_deleted")}."
 
@@ -162,6 +127,70 @@ def search
     end
   end
 
+  # Helper-method-exposed accessors. Kept public so controller specs that read
+  # `controller.app`, `controller.problems`, etc. continue to work (mirroring
+  # the previous decent_exposure behavior).
+
+  def app_scope
+    @app_scope ||= params[:app_id] ? Errbit::App.where(id: params.expect(:app_id)) : Errbit::App.all
+  end
+
+  def app
+    @app ||= Errbit::AppDecorator.new(app_scope.find(params.expect(:app_id)))
+  end
+
+  def problem
+    @problem ||= Errbit::ProblemDecorator.new(app.problems.find(params.expect(:id)))
+  end
+
+  def all_errs
+    params[:all_errs]
+  end
+
+  def filter
+    params[:filter]
+  end
+
+  def params_environment
+    params[:environment]
+  end
+
+  def params_sort
+    @params_sort ||= ["environment", "app", "message", "last_notice_at", "count"].include?(params[:sort]) ? params[:sort] : "last_notice_at"
+  end
+
+  def params_order
+    @params_order ||= ["asc", "desc"].include?(params[:order]) ? params[:order] : "desc"
+  end
+
+  def err_ids
+    @err_ids ||= (params[:problems] || []).compact
+  end
+
+  def selected_problems
+    @selected_problems ||= Array(Errbit::Problem.where(id: err_ids))
+  end
+
+  def selected_problems_ids
+    selected_problems.map { |p| p.id.to_s }
+  end
+
+  # To use with_app_exclusions, hit a path like
+  # /problems?filter=-app:noisy_app%20-app:another_noisy_app — useful when
+  # there are noisy apps that should be ignored.
+  def problems
+    @problems ||= begin
+      finder = Errbit::Problem
+        .for_apps(app_scope)
+        .in_env(params_environment)
+        .filtered(filter)
+        .all_else_unresolved(all_errs)
+        .ordered_by(params_sort, params_order)
+      finder = finder.search(params[:search]) if params[:search].present?
+      finder.page(params[:page]).per(current_user.per_page)
+    end
+  end
+
   private
 
   def need_selected_problem
diff --git a/app/controllers/site_config_controller.rb b/app/controllers/site_config_controller.rb
index 9389256cdb..e3ccc975d2 100644
--- a/app/controllers/site_config_controller.rb
+++ b/app/controllers/site_config_controller.rb
@@ -4,12 +4,11 @@ class SiteConfigController < ApplicationController
   before_action :require_admin!
 
   def index
-    @config = SiteConfig.document
+    @config = Errbit::SiteConfig.document
   end
 
   def update
-    SiteConfig.document
-      .update(notice_fingerprinter: filtered_update_params.to_h)
+    Errbit::SiteConfig.document.update(filtered_update_params)
 
     flash[:success] = I18n.t("site_config.update.success")
 
diff --git a/app/controllers/unlink_githubs_controller.rb b/app/controllers/unlink_githubs_controller.rb
index 9c9ee98ab9..83ca408a07 100644
--- a/app/controllers/unlink_githubs_controller.rb
+++ b/app/controllers/unlink_githubs_controller.rb
@@ -2,7 +2,7 @@
 
 class UnlinkGithubsController < ApplicationController
   def update
-    @user = User.find(params.expect(:user_id))
+    @user = Errbit::User.find(params.expect(:user_id))
 
     authorize @user
 
diff --git a/app/controllers/unlink_googles_controller.rb b/app/controllers/unlink_googles_controller.rb
index af2f66e136..4a5c87da72 100644
--- a/app/controllers/unlink_googles_controller.rb
+++ b/app/controllers/unlink_googles_controller.rb
@@ -2,7 +2,7 @@
 
 class UnlinkGooglesController < ApplicationController
   def update
-    @user = User.find(params.expect(:user_id))
+    @user = Errbit::User.find(params.expect(:user_id))
 
     authorize @user
 
diff --git a/app/controllers/users/omniauth_callbacks_controller.rb b/app/controllers/users/omniauth_callbacks_controller.rb
index eadebdc0d8..d82748fd38 100644
--- a/app/controllers/users/omniauth_callbacks_controller.rb
+++ b/app/controllers/users/omniauth_callbacks_controller.rb
@@ -18,7 +18,7 @@ def github_auto_sign_up(github_token)
 
         nil
       else
-        User.create(name: request.env["omniauth.auth"].extra.raw_info.name, email: user_email)
+        Errbit::User.create(name: request.env["omniauth.auth"].extra.raw_info.name, email: user_email)
       end
     end
 
@@ -26,7 +26,7 @@ def github
       github_login = request.env["omniauth.auth"].dig(:extra, :raw_info, :login)
       github_token = request.env["omniauth.auth"].dig(:credentials, :token)
       github_site_title = Errbit::Config.github_site_title
-      github_user = User.where(github_login: github_login).first || github_auto_sign_up(github_token)
+      github_user = Errbit::User.where(github_login: github_login).first || github_auto_sign_up(github_token)
 
       # If user is already signed in, link GitHub details to their account
       if current_user
@@ -58,7 +58,7 @@ def github
     def google_oauth2
       google_uid = request.env["omniauth.auth"][:uid]
       google_email = request.env["omniauth.auth"].dig(:info, :email)
-      google_user = User.where(google_uid: google_uid).first
+      google_user = Errbit::User.where(google_uid: google_uid).first
       google_site_title = Errbit::Config.google_site_title
 
       # If user is already signed in, link google details to their account
@@ -80,8 +80,8 @@ def google_oauth2
 
         sign_in_and_redirect google_user, event: :authentication
       elsif Errbit::Config.google_auto_provision
-        if User.valid_google_domain?(google_email)
-          user = User.create_from_google_oauth2(request.env["omniauth.auth"])
+        if Errbit::User.valid_google_domain?(google_email)
+          user = Errbit::User.create_from_google_oauth2(request.env["omniauth.auth"])
 
           if user.persisted?
             flash[:notice] = I18n.t "devise.omniauth_callbacks.success", kind: google_site_title
diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index 2d9401a6b1..1c1c868f42 100644
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -2,32 +2,32 @@
 
 class UsersController < ApplicationController
   def index
-    @users = policy_scope(User)
-      .order_by(name: :asc)
+    @users = policy_scope(Errbit::User)
+      .order(name: :asc)
       .page(params[:page])
       .per(current_user.per_page)
   end
 
   def show
-    @user = User.find(params.expect(:id))
+    @user = Errbit::User.find(params.expect(:id))
 
     authorize @user
   end
 
   def new
-    @user = User.new
+    @user = Errbit::User.new
 
     authorize @user
   end
 
   def edit
-    @user = User.find(params.expect(:id))
+    @user = Errbit::User.find(params.expect(:id))
 
     authorize @user
   end
 
   def create
-    @user = User.new(permitted_attributes(User.new))
+    @user = Errbit::User.new(permitted_attributes(Errbit::User.new))
 
     authorize @user
 
@@ -41,7 +41,7 @@ def create
   end
 
   def update
-    @user = User.find(params.expect(:id))
+    @user = Errbit::User.find(params.expect(:id))
 
     authorize @user
 
@@ -55,14 +55,14 @@ def update
   end
 
   def destroy
-    @user = User.find(params.expect(:id))
+    @user = Errbit::User.find(params.expect(:id))
 
     if @user == current_user
       flash[:error] = t(".error")
     else
       authorize @user
 
-      UserDestroy.new(@user).destroy
+      Errbit::UserDestroy.new(@user).destroy
 
       flash[:success] = t(".success", name: @user.name)
     end
diff --git a/app/controllers/watchers_controller.rb b/app/controllers/watchers_controller.rb
index c18acd2cf5..bd7f70c6db 100644
--- a/app/controllers/watchers_controller.rb
+++ b/app/controllers/watchers_controller.rb
@@ -2,7 +2,7 @@
 
 class WatchersController < ApplicationController
   def create
-    app = App.find(params.expect(:app_id))
+    app = Errbit::App.find(params.expect(:app_id))
 
     app.watchers.create!(user: current_user)
 
@@ -12,11 +12,9 @@ def create
   end
 
   def destroy
-    app = App.find(params.expect(:app_id))
+    app = Errbit::App.find(params.expect(:app_id))
 
-    watcher = app.watchers.where(user: current_user).first
-
-    app.watchers.delete(watcher)
+    app.watchers.where(errbit_user_id: current_user.id).destroy_all
 
     flash[:success] = t(".success", app: app.name)
 
diff --git a/app/decorators/errbit/app_decorator.rb b/app/decorators/errbit/app_decorator.rb
new file mode 100644
index 0000000000..0bc5d9747a
--- /dev/null
+++ b/app/decorators/errbit/app_decorator.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Errbit
+  class AppDecorator < Draper::Decorator
+    decorates_association :issue_tracker
+    delegate_all
+
+    def email_at_notices
+      object.email_at_notices.join(", ")
+    end
+
+    def use_site_fingerprinter
+      return true if object.notice_fingerprinter.nil?
+
+      return true if object.notice_fingerprinter.attributes["source"].nil?
+
+      object.notice_fingerprinter.attributes["source"] == Errbit::SiteConfig::CONFIG_SOURCE_SITE
+    end
+
+    def custom_notice_fingerprinter_style
+      use_site_fingerprinter ? "display: none" : "display: inline"
+    end
+
+    def notify_user_display
+      object.notify_all_users ? "display: none;" : ""
+    end
+
+    def notify_err_display
+      object.notify_on_errs ? "" : "display: none;"
+    end
+
+    def custom_backtrace_url(file, line)
+      format(custom_backtrace_url_template, branch: object.repo_branch, file: file, line: line,
+        ebranch: CGI.escape(object.repo_branch), efile: CGI.escape(file))
+    end
+  end
+end
diff --git a/app/decorators/errbit/backtrace_decorator.rb b/app/decorators/errbit/backtrace_decorator.rb
new file mode 100644
index 0000000000..c88ca79cf2
--- /dev/null
+++ b/app/decorators/errbit/backtrace_decorator.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Errbit
+  class BacktraceDecorator < Draper::Decorator
+    def lines
+      @lines ||= (object.lines || []).map { |line| Errbit::BacktraceLineDecorator.new(line) }
+    end
+
+    # Group lines into sections of in-app files and external files
+    def grouped_lines
+      lines.chunk do |line|
+        line.in_app? || false
+      end
+    end
+  end
+end
diff --git a/app/decorators/errbit/backtrace_line_decorator.rb b/app/decorators/errbit/backtrace_line_decorator.rb
new file mode 100644
index 0000000000..81f6065b57
--- /dev/null
+++ b/app/decorators/errbit/backtrace_line_decorator.rb
@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Errbit
+  class BacktraceLineDecorator < Draper::Decorator
+    EMPTY_STRING = ""
+
+    def in_app?
+      return false if file.blank?
+
+      file.match Errbit::Backtrace::IN_APP_PATH
+    end
+
+    def number
+      object[:number] || object["number"]
+    end
+
+    def column
+      object[:column] || object["column"]
+    end
+
+    def file
+      (object.try(:[], :file) || object.try(:[], "file")).to_s
+    end
+
+    def method
+      object[:method] || object["method"]
+    end
+
+    def file_relative
+      file.to_s.sub(Errbit::Backtrace::IN_APP_PATH, EMPTY_STRING)
+    end
+
+    def file_name
+      File.basename(file)
+    end
+
+    def to_s
+      column = object.try(:[], :column) || object.try(:[], "column")
+
+      "#{file_relative}:#{number}#{column.present? ? ":#{column}" : ""}"
+    end
+
+    def link_to_source_file(app, &block)
+      text = h.capture(&block)
+
+      link_to_in_app_source_file(app, text) || text
+    end
+
+    def path
+      return "" if file.blank?
+
+      File.dirname(file).gsub(/^\.$/, "") + "/"
+    end
+
+    def decorated_path
+      path
+        .sub(Errbit::Backtrace::IN_APP_PATH, "")
+        .sub(Errbit::Backtrace::GEMS_PATH, "<strong>\\1</strong>")
+    end
+
+    private
+
+    def link_to_in_app_source_file(app, text)
+      return unless in_app?
+
+      if file_name =~ /\.js$/
+        link_to_hosted_javascript(app, text)
+      else
+        link_to_repo_source_file(app, text) ||
+          link_to_issue_tracker_file(app, text)
+      end
+    end
+
+    def link_to_repo_source_file(app, text)
+      link_to_custom_backtrace_url(app, text) ||
+        link_to_github(app, text) ||
+        link_to_bitbucket(app, text)
+    end
+
+    def link_to_hosted_javascript(app, text)
+      return unless app.asset_host?
+
+      h.link_to(text, "#{app.asset_host}/#{file_relative}", target: "_blank", rel: "noopener noreferrer")
+    end
+
+    def link_to_github(app, text = nil)
+      return unless app.github_repo?
+
+      href = format("%s#L%s", app.github_url_to_file(decorated_path + file_name), number)
+
+      h.link_to(text || file_name, href, target: "_blank", rel: "noopener noreferrer")
+    end
+
+    def link_to_bitbucket(app, text = nil)
+      return unless app.bitbucket_repo?
+
+      href = format("%s#%s-%s", app.bitbucket_url_to_file(decorated_path + file_name), file_name, number)
+
+      h.link_to(text || file_name, href, target: "_blank", rel: "noopener noreferrer")
+    end
+
+    def link_to_custom_backtrace_url(app, text = nil)
+      return unless app.custom_backtrace_url_template?
+
+      href = app.custom_backtrace_url(decorated_path + file_name, number)
+
+      h.link_to(text || file_name, href, target: "_blank", rel: "noopener noreferrer")
+    end
+
+    def link_to_issue_tracker_file(app, text = nil)
+      return unless app.issue_tracker && app.issue_tracker.respond_to?(:url_to_file)
+
+      href = app.issue_tracker.url_to_file(file_relative, number)
+
+      h.link_to(text || file_name, href, target: "_blank", rel: "noopener noreferrer")
+    end
+  end
+end
diff --git a/app/decorators/errbit/issue_tracker_decorator.rb b/app/decorators/errbit/issue_tracker_decorator.rb
new file mode 100644
index 0000000000..2411c22f2c
--- /dev/null
+++ b/app/decorators/errbit/issue_tracker_decorator.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Errbit
+  # Decorates an instance of Errbit::IssueTracker
+  class IssueTrackerDecorator < Draper::Decorator
+    delegate_all
+
+    def type
+      @type ||= Errbit::IssueTrackerTypeDecorator.new(object.tracker.class)
+    end
+  end
+end
diff --git a/app/decorators/errbit/issue_tracker_field_decorator.rb b/app/decorators/errbit/issue_tracker_field_decorator.rb
new file mode 100644
index 0000000000..e19671c169
--- /dev/null
+++ b/app/decorators/errbit/issue_tracker_field_decorator.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Errbit
+  class IssueTrackerFieldDecorator < Draper::Decorator
+    attr_reader :object, :field_info
+
+    def initialize(field, field_info)
+      @object = field
+      @field_info = field_info
+    end
+
+    alias_method :key, :object
+
+    def label
+      field_info[:label] || object.to_s.titleize
+    end
+
+    def input(form, issue_tracker)
+      form.send(input_field, key.to_s,
+        placeholder: field_info[:placeholder],
+        value: issue_tracker.options[key.to_s])
+    end
+
+    private
+
+    def input_field
+      (object == :password) ? :password_field : :text_field
+    end
+  end
+end
diff --git a/app/decorators/errbit/issue_tracker_type_decorator.rb b/app/decorators/errbit/issue_tracker_type_decorator.rb
new file mode 100644
index 0000000000..2d55ce1b53
--- /dev/null
+++ b/app/decorators/errbit/issue_tracker_type_decorator.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Errbit
+  # Decorates an IssueTracker class
+  class IssueTrackerTypeDecorator < Draper::Decorator
+    delegate_all
+
+    # return hash of icons as data URIs
+    def icons
+      return unless object.icons
+
+      object.icons.reduce({}) do |c, (k, v)|
+        c[k] = "data:#{v[0]};base64,#{Base64.encode64(v[1])}"
+        c
+      end
+    end
+
+    # class name for tracker type form fields
+    #
+    # 'chosen github' or 'bitbucket' for example
+    def params_class(tracker)
+      [(object.label == tracker.type_tracker) ? "chosen" : "", label].join(" ").strip
+    end
+
+    def note
+      object.note.html_safe
+    end
+
+    def fields
+      object.fields.each do |field, field_info|
+        yield Errbit::IssueTrackerFieldDecorator.new(field, field_info)
+      end
+    end
+  end
+end
diff --git a/app/decorators/errbit/notice_decorator.rb b/app/decorators/errbit/notice_decorator.rb
new file mode 100644
index 0000000000..214beb4986
--- /dev/null
+++ b/app/decorators/errbit/notice_decorator.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Errbit
+  class NoticeDecorator < Draper::Decorator
+    decorates_association :backtrace
+    delegate_all
+  end
+end
diff --git a/app/decorators/errbit/problem_decorator.rb b/app/decorators/errbit/problem_decorator.rb
new file mode 100644
index 0000000000..333bce4155
--- /dev/null
+++ b/app/decorators/errbit/problem_decorator.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ProblemDecorator < Draper::Decorator
+    # `Errbit::Notice.model_name` is overridden to "Notice" (for routes/views).
+    # Draper would otherwise resolve `decorates_association :notices` to the
+    # un-namespaced Mongoid `NoticeDecorator`. Pin it explicitly.
+    decorates_association :notices, with: Errbit::NoticeDecorator
+    delegate_all
+  end
+end
diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb
index 3d1f5fa926..677b7f409f 100644
--- a/app/helpers/application_helper.rb
+++ b/app/helpers/application_helper.rb
@@ -60,7 +60,7 @@ def tail(collection)
 
   def issue_tracker_types
     ErrbitPlugin::Registry.issue_trackers.map do |_, object|
-      IssueTrackerTypeDecorator.new(object)
+      Errbit::IssueTrackerTypeDecorator.new(object)
     end
   end
 
diff --git a/app/helpers/apps_helper.rb b/app/helpers/apps_helper.rb
index 6687632964..3cce8737a3 100644
--- a/app/helpers/apps_helper.rb
+++ b/app/helpers/apps_helper.rb
@@ -2,12 +2,12 @@
 
 module AppsHelper
   def link_to_copy_attributes_from_other_app
-    return if App.count <= 1
+    return if Errbit::App.count <= 1
 
     html = link_to("copy settings from another app", "#",
       class: "button copy_config")
     html << select("duplicate", "app",
-      App.all.asc(:name).reject { |a| a == @app }
+      Errbit::App.order(:name).reject { |a| a == @app }
       .collect { |p| [p.name, p.id] }, {include_blank: "[choose app]"},
       class: "choose_other_app", style: "display: none;")
     html
diff --git a/app/interactors/errbit/notice_refingerprinter.rb b/app/interactors/errbit/notice_refingerprinter.rb
new file mode 100644
index 0000000000..1d0be0ef7a
--- /dev/null
+++ b/app/interactors/errbit/notice_refingerprinter.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Errbit
+  class NoticeRefingerprinter
+    LOG_EVERY = 100
+    LOG_ITR = "%.1f%% complete, %i notice(s) remaining"
+    LOG_START = "Regenerating notice fingerprints for %i notices"
+
+    def self.run
+      count = Errbit::Notice.count
+      puts format(LOG_START, count)
+
+      Errbit::Notice.find_each.with_index do |notice, index|
+        refingerprint(notice)
+
+        next unless (index + 1) % LOG_EVERY == 0
+
+        puts format(LOG_ITR, index * 100 / count, count - index)
+      end
+
+      puts "Finished generating notice fingerprints"
+      puts "Destroying orphaned err records"
+
+      Errbit::Err.find_each { |err| err.destroy if err.notices.empty? }
+
+      puts "Finished destroying orphaned err records"
+    end
+
+    def self.refingerprint(notice)
+      app = notice.app
+      notice.err = app.find_or_create_err!(
+        error_class: notice.error_class,
+        environment: notice.environment_name,
+        fingerprint: app.notice_fingerprinter.generate(app.api_key, notice, notice.backtrace)
+      )
+      notice.save!
+    end
+
+    def self.puts(*args)
+      Rails.logger.info(*args)
+    end
+  end
+end
diff --git a/app/interactors/errbit/outdated_problem_clearer.rb b/app/interactors/errbit/outdated_problem_clearer.rb
new file mode 100644
index 0000000000..31b432aa8c
--- /dev/null
+++ b/app/interactors/errbit/outdated_problem_clearer.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Errbit
+  class OutdatedProblemClearer
+    ##
+    # Clear all problems whose last_notice_at is older than the configured
+    # deprecation window.
+    #
+    def execute
+      nb_problem_outdated.tap do |nb|
+        if nb > 0
+          criteria.each do |problem|
+            Errbit::ProblemDestroy.new(problem).execute
+          end
+        end
+      end
+    end
+
+    private
+
+    def nb_problem_outdated
+      @count ||= criteria.count
+    end
+
+    def criteria
+      @criteria ||= Errbit::Problem.where("last_notice_at < ?", Errbit::Config.notice_deprecation_days.to_f.days.ago)
+    end
+  end
+end
diff --git a/app/interactors/errbit/problem_destroy.rb b/app/interactors/errbit/problem_destroy.rb
new file mode 100644
index 0000000000..d6fe546764
--- /dev/null
+++ b/app/interactors/errbit/problem_destroy.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ProblemDestroy
+    attr_reader :problem
+
+    def initialize(problem)
+      @problem = problem
+    end
+
+    def execute
+      delete_errs
+      delete_comments
+      problem.delete
+    end
+
+    ##
+    # Destroy all problems passed in.
+    #
+    # @params [Array<Errbit::Problem>] problems the list of problems to destroy
+    #   (can be a single Problem).
+    # @return [Integer] the number of problems destroyed.
+    #
+    def self.execute(problems)
+      Array(problems).each do |problem|
+        new(problem).execute
+      end.count
+    end
+
+    private
+
+    def errs_id
+      problem.errs.pluck(:id)
+    end
+
+    def comments_id
+      problem.comments.pluck(:id)
+    end
+
+    def delete_errs
+      Errbit::Notice.where(errbit_err_id: errs_id).delete_all
+      Errbit::Err.where(id: errs_id).delete_all
+    end
+
+    def delete_comments
+      Errbit::Comment.where(id: comments_id).delete_all
+    end
+  end
+end
diff --git a/app/interactors/errbit/problem_merge.rb b/app/interactors/errbit/problem_merge.rb
new file mode 100644
index 0000000000..9844296699
--- /dev/null
+++ b/app/interactors/errbit/problem_merge.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ProblemMerge
+    attr_reader :merged_problem, :child_problems
+
+    def initialize(*problems)
+      problems = problems.flatten.uniq
+      @merged_problem = problems[0]
+      @child_problems = problems[1..]
+      fail ArgumentError, "need almost 2 uniq different problems" if @child_problems.empty?
+    end
+
+    def merge
+      child_problems.each do |problem|
+        problem.errs.update_all(errbit_problem_id: merged_problem.id)
+        problem.comments.update_all(errbit_problem_id: merged_problem.id)
+        problem.reload
+        Errbit::ProblemDestroy.execute(problem)
+      end
+
+      # update_all bypasses the comments counter_cache, and `merged_problem.comments.count`
+      # would itself return the (stale) cached value — query the table directly and
+      # bypass AR's read-only protection on counter-cache columns by using update_column.
+      actual_comments = Errbit::Comment.where(errbit_problem_id: merged_problem.id).count
+      merged_problem.update_column(:comments_count, actual_comments)
+
+      # update_all also leaves the in-memory errs/comments collections stale.
+      # Reset them so callers see the moved rows on the next access.
+      merged_problem.errs.reset
+      merged_problem.comments.reset
+      merged_problem.recache
+      merged_problem
+    end
+  end
+end
diff --git a/app/interactors/errbit/problem_recacher.rb b/app/interactors/errbit/problem_recacher.rb
new file mode 100644
index 0000000000..8367a18bf7
--- /dev/null
+++ b/app/interactors/errbit/problem_recacher.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ProblemRecacher
+    LOG_EVERY = 100
+    LOG_ITR = "%.1f%% complete, %i problem(s) remaining"
+    LOG_START = "Re-caching problem attributes for %i problems"
+
+    def self.run
+      count = Errbit::Problem.count
+      puts format(LOG_START, count)
+
+      Errbit::Problem.find_each.with_index do |problem, index|
+        problem.recache
+        problem.destroy if problem.notices_count == 0
+
+        next unless (index + 1) % LOG_EVERY == 0
+
+        puts format(LOG_ITR, index * 100 / count, count - index)
+      end
+
+      puts "Finished re-caching problem attributes"
+    end
+
+    def self.puts(*args)
+      Rails.logger.info(*args)
+    end
+  end
+end
diff --git a/app/interactors/errbit/resolved_problem_clearer.rb b/app/interactors/errbit/resolved_problem_clearer.rb
new file mode 100644
index 0000000000..c21a57680b
--- /dev/null
+++ b/app/interactors/errbit/resolved_problem_clearer.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ResolvedProblemClearer
+    ##
+    # Clear all problems that have been resolved.
+    #
+    def execute
+      nb_problem_resolved.tap do |nb|
+        if nb > 0
+          criteria.each do |problem|
+            Errbit::ProblemDestroy.new(problem).execute
+          end
+        end
+      end
+    end
+
+    private
+
+    def nb_problem_resolved
+      @count ||= criteria.count
+    end
+
+    def criteria
+      @criteria ||= Errbit::Problem.resolved
+    end
+  end
+end
diff --git a/app/interactors/errbit/user_destroy.rb b/app/interactors/errbit/user_destroy.rb
new file mode 100644
index 0000000000..6608d91bf5
--- /dev/null
+++ b/app/interactors/errbit/user_destroy.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Errbit
+  class UserDestroy
+    attr_reader :user
+
+    # @param user [Errbit::User] User to destroy
+    def initialize(user)
+      @user = user
+    end
+
+    # Cleanup is handled by Errbit::User's `has_many :watchers, dependent: :destroy`
+    # and `has_many :comments, dependent: :destroy` associations.
+    def destroy
+      user.destroy
+    end
+  end
+end
diff --git a/app/jobs/errbit/application_job.rb b/app/jobs/errbit/application_job.rb
new file mode 100644
index 0000000000..94c36ac6b4
--- /dev/null
+++ b/app/jobs/errbit/application_job.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ApplicationJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+  end
+end
diff --git a/app/jobs/errbit/destroy_problems_by_app_job.rb b/app/jobs/errbit/destroy_problems_by_app_job.rb
new file mode 100644
index 0000000000..632f1d1812
--- /dev/null
+++ b/app/jobs/errbit/destroy_problems_by_app_job.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Errbit
+  class DestroyProblemsByAppJob < ApplicationJob
+    queue_as :default
+
+    # @param app_id [Integer]
+    def perform(app_id)
+      app = Errbit::App.find_by(id: app_id)
+      return unless app
+
+      Errbit::ProblemDestroy.execute(app.problems)
+    end
+  end
+end
diff --git a/app/jobs/errbit/destroy_problems_by_id_job.rb b/app/jobs/errbit/destroy_problems_by_id_job.rb
new file mode 100644
index 0000000000..64f7e035bc
--- /dev/null
+++ b/app/jobs/errbit/destroy_problems_by_id_job.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Errbit
+  class DestroyProblemsByIdJob < ApplicationJob
+    queue_as :default
+
+    # @param problem_ids [Array<Integer>]
+    def perform(problem_ids)
+      problems = Errbit::Problem.where(id: problem_ids).to_a
+
+      Errbit::ProblemDestroy.execute(problems)
+    end
+  end
+end
diff --git a/app/lib/airbrake_api/v3/notice_parser.rb b/app/lib/airbrake_api/v3/notice_parser.rb
index 475bd286ca..33debe2309 100644
--- a/app/lib/airbrake_api/v3/notice_parser.rb
+++ b/app/lib/airbrake_api/v3/notice_parser.rb
@@ -26,7 +26,7 @@ def attributes
       end
 
       def report
-        ErrorReport.new(attributes)
+        Errbit::ErrorReport.new(attributes)
       end
 
       private
diff --git a/app/mailers/errbit/application_mailer.rb b/app/mailers/errbit/application_mailer.rb
new file mode 100644
index 0000000000..df162c1425
--- /dev/null
+++ b/app/mailers/errbit/application_mailer.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ApplicationMailer < ActionMailer::Base
+    layout "mailer"
+  end
+end
diff --git a/app/mailers/errbit/mailer.rb b/app/mailers/errbit/mailer.rb
new file mode 100644
index 0000000000..f4f5fcadda
--- /dev/null
+++ b/app/mailers/errbit/mailer.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Haml doesn't load routes automatically when called via a rake task.
+# This is only necessary when sending test emails (i.e. from rake hoptoad:test)
+require Rails.root.join("config/routes.rb")
+
+module Errbit
+  class Mailer < ApplicationMailer
+    helper ApplicationHelper
+
+    default :from => Errbit::Config.email_from,
+      "X-Errbit-Host" => Errbit::Config.host,
+      "X-Mailer" => "Errbit",
+      "X-Auto-Response-Suppress" => "OOF, AutoReply",
+      "Precedence" => "bulk",
+      "Auto-Submitted" => "auto-generated"
+
+    def err_notification
+      error_report = params[:error_report]
+
+      @notice = Errbit::NoticeDecorator.new(error_report.notice)
+      @app = Errbit::AppDecorator.new(error_report.app)
+
+      count = error_report.problem.notices_count
+      count = (count > 1) ? "(#{count}) " : ""
+
+      errbit_headers "App" => @app.name,
+        "Environment" => @notice.environment_name,
+        "Error-Id" => error_report.notice.err.id
+
+      mail to: @app.notification_recipients,
+        subject: "#{count}[#{@app.name}][#{@notice.environment_name}] #{@notice.message.truncate(50)}"
+    end
+
+    def comment_notification
+      comment = params[:comment]
+
+      @comment = comment
+      @user = comment.user
+      @problem = Errbit::ProblemDecorator.new(comment.err)
+      @notice = Errbit::NoticeDecorator.new(comment.err.notices.first)
+      @app = @problem.app
+
+      recipients = @comment.notification_recipients
+
+      errbit_headers "App" => @app.name,
+        "Environment" => @notice.environment_name,
+        "Problem-Id" => @problem.id,
+        "Comment-Author" => @user.name
+
+      mail to: recipients,
+        subject: "#{@user.name} commented on [#{@app.name}][#{@notice.environment_name}] #{@notice.message.truncate(50)}"
+    end
+
+    private
+
+    def errbit_headers(header)
+      header.each { |key, value| headers["X-Errbit-#{key}"] = value.to_s }
+    end
+  end
+end
diff --git a/app/models/errbit.rb b/app/models/errbit.rb
new file mode 100644
index 0000000000..051ff07bdf
--- /dev/null
+++ b/app/models/errbit.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Errbit
+  def self.table_name_prefix
+    "errbit_"
+  end
+end
diff --git a/app/models/errbit/app.rb b/app/models/errbit/app.rb
new file mode 100644
index 0000000000..37c0182146
--- /dev/null
+++ b/app/models/errbit/app.rb
@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Errbit
+  class App < ApplicationRecord
+    include Comparable
+
+    # Routes (`resources :apps`), form helpers (`form_with model: app`), Pundit
+    # `param_key`, partial paths, and i18n scopes all live under the un-namespaced
+    # "app" key. Override `model_name` so they match even though the class is
+    # under `Errbit::`.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "App")
+    end
+
+    # Pundit infers the policy class via model_name → "AppPolicy" (Mongoid).
+    # Force it back to the namespaced policy.
+    def self.policy_class
+      Errbit::AppPolicy
+    end
+
+    serialize :email_at_notices, type: Array, coder: YAML
+
+    has_many :watchers,
+      class_name: "Errbit::Watcher",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    has_many :problems,
+      class_name: "Errbit::Problem",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    has_many :notices,
+      class_name: "Errbit::Notice",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    has_one :notice_fingerprinter,
+      class_name: "Errbit::NoticeFingerprinter",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    has_one :issue_tracker,
+      class_name: "Errbit::IssueTracker",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    has_one :notification_service,
+      class_name: "Errbit::NotificationService",
+      foreign_key: :errbit_app_id,
+      inverse_of: :app,
+      dependent: :destroy
+
+    accepts_nested_attributes_for :issue_tracker,
+      allow_destroy: true,
+      reject_if: proc { |attrs| !ErrbitPlugin::Registry.issue_trackers.keys.map(&:to_s).include?(attrs[:type_tracker].to_s) }
+    accepts_nested_attributes_for :notification_service,
+      allow_destroy: true,
+      reject_if: proc { |attrs| !Errbit::NotificationService.subclasses.map(&:to_s).include?(attrs[:type].to_s) }
+    accepts_nested_attributes_for :notice_fingerprinter
+    accepts_nested_attributes_for :watchers,
+      allow_destroy: true,
+      reject_if: proc { |attrs| attrs[:errbit_user_id].blank? && attrs[:email].blank? }
+
+    before_validation :generate_api_key, on: :create
+    before_save :normalize_github_repo
+    before_create :ensure_notice_fingerprinter
+    after_find :ensure_notice_fingerprinter
+    after_update :store_cached_attributes_on_problems
+
+    validates :name, presence: true, uniqueness: {allow_blank: true}
+    validates :api_key, presence: true, uniqueness: {allow_blank: true}
+    validates_associated :issue_tracker
+    validates_associated :notice_fingerprinter
+    validates_associated :watchers
+
+    scope :search, ->(value) { where(arel_table[:name].matches("%#{value}%")) }
+
+    def notify_on_errs
+      self[:notify_on_errs] != false
+    end
+    alias_method :notify_on_errs?, :notify_on_errs
+
+    def emailable?
+      notify_on_errs? && notification_recipients.any?
+    end
+
+    def notification_recipients
+      if notify_all_users
+        (Errbit::User.all.map(&:email).reject(&:blank?) + watchers.map(&:address)).uniq
+      else
+        watchers.map(&:address)
+      end
+    end
+
+    def watched_by?(user)
+      watchers.where(errbit_user_id: user.id).exists?
+    end
+
+    def repo_branch
+      repository_branch.present? ? repository_branch : "main"
+    end
+
+    def github_repo?
+      github_repo.present?
+    end
+
+    def github_url
+      "#{Errbit::Config.github_url}/#{github_repo}" if github_repo?
+    end
+
+    def github_url_to_file(file)
+      "#{github_url}/blob/#{repo_branch}/#{file}"
+    end
+
+    def bitbucket_repo?
+      bitbucket_repo.present?
+    end
+
+    def bitbucket_url
+      "https://bitbucket.org/#{bitbucket_repo}" if bitbucket_repo?
+    end
+
+    def bitbucket_url_to_file(file)
+      "#{bitbucket_url}/src/#{repo_branch}/#{file}"
+    end
+
+    def email_at_notices
+      Errbit::Config.per_app_email_at_notices ? (super || Errbit::Config.email_at_notices) : Errbit::Config.email_at_notices
+    end
+
+    def regenerate_api_key!
+      update!(api_key: SecureRandom.hex)
+    end
+
+    def self.find_by_api_key!(key)
+      find_by!(api_key: key)
+    end
+
+    # Accepts a hash with the following attributes:
+    #
+    # * <tt>:error_class</tt>  - required to create a new Problem
+    # * <tt>:environment</tt>  - required to create a new Problem
+    # * <tt>:fingerprint</tt>  - a unique value identifying the err/notice group
+    #
+    def find_or_create_err!(attrs)
+      err = Errbit::Err.where(fingerprint: attrs[:fingerprint]).first
+      return err if err
+
+      problem = problems.create!(
+        error_class: attrs[:error_class],
+        environment: attrs[:environment],
+        app_name: name
+      )
+      problem.errs.create!(attrs.slice(:fingerprint))
+    end
+
+    def issue_tracker_configured?
+      issue_tracker.present? && issue_tracker.configured?
+    end
+
+    def notification_service_configured?
+      notification_service.present? &&
+        notification_service.class < Errbit::NotificationService &&
+        notification_service.configured?
+    end
+
+    def unresolved_count
+      @unresolved_count ||= problems.unresolved.count
+    end
+
+    def problem_count
+      @problem_count ||= problems.count
+    end
+
+    # Compare by unresolved errs, then by total problem count, then by name.
+    def <=>(other)
+      (other.unresolved_count <=> unresolved_count).nonzero? ||
+        (other.problem_count <=> problem_count).nonzero? ||
+        name <=> other.name
+    end
+
+    # Copy field values (and the singular relations) from another app. Used by
+    # the "New App" form's "copy attributes from existing app" feature.
+    def copy_attributes_from(app_id)
+      copy_app = Errbit::App.find_by(id: app_id)
+      return if copy_app.blank?
+
+      excluded = %w[id bson_id name created_at updated_at]
+      (copy_app.attributes.keys - excluded).each do |k|
+        send(:"#{k}=", copy_app.send(k))
+      end
+
+      if (it = copy_app.issue_tracker)
+        build_issue_tracker(it.attributes.except(*excluded, "errbit_app_id"))
+      end
+
+      if (ns = copy_app.notification_service)
+        attrs = ns.attributes.except(*excluded, "errbit_app_id")
+        build_notification_service(attrs).becomes!(ns.class)
+      end
+
+      copy_app.watchers.each do |w|
+        watchers.build(w.attributes.except(*excluded, "errbit_app_id"))
+      end
+    end
+
+    def attributes_for_super_diff
+      {
+        id: id,
+        name: name
+      }
+    end
+
+    private
+
+    def generate_api_key
+      self.api_key ||= SecureRandom.hex
+    end
+
+    def normalize_github_repo
+      return if github_repo.blank?
+
+      github_host = URI.parse(Errbit::Config.github_url).host
+      github_host = Regexp.escape(github_host)
+
+      self.github_repo = github_repo.strip
+      self.github_repo = github_repo.sub(%r{(git@|https?://)#{github_host}(/|:)}, "")
+      self.github_repo = github_repo.sub(/\.git$/, "")
+    end
+
+    # Seed the app's notice fingerprinter from SiteConfig if it doesn't have
+    # one yet. Fires both before_create (so a freshly-built app gets a
+    # fingerprinter at the moment of creation) and after_find (so legacy rows
+    # written before this callback existed pick one up on first access).
+    def ensure_notice_fingerprinter
+      return if association(:notice_fingerprinter).loaded? && notice_fingerprinter.present?
+      return if notice_fingerprinter.present?
+
+      build_notice_fingerprinter(Errbit::SiteConfig.document.notice_fingerprinter_attributes)
+    end
+
+    # Keep the `app_name` cache on every problem of this app in sync when the
+    # app is renamed. Mirrors the Mongoid `after_update` callback.
+    def store_cached_attributes_on_problems
+      return unless saved_change_to_name?
+
+      problems.update_all(app_name: name)
+    end
+  end
+end
diff --git a/app/models/errbit/application_record.rb b/app/models/errbit/application_record.rb
new file mode 100644
index 0000000000..d62e95ca9f
--- /dev/null
+++ b/app/models/errbit/application_record.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ApplicationRecord < ActiveRecord::Base
+    primary_abstract_class
+  end
+end
diff --git a/app/models/errbit/backtrace.rb b/app/models/errbit/backtrace.rb
new file mode 100644
index 0000000000..9578452b65
--- /dev/null
+++ b/app/models/errbit/backtrace.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Backtrace < ApplicationRecord
+    IN_APP_PATH = %r{^(?:\[|/)PROJECT_ROOT\]?(?!(/vendor))/?}
+    GEMS_PATH = %r{(?:\[|/)GEM_ROOT\]?/gems/([^/]+)}
+
+    def self.find_or_create(lines)
+      fingerprint = generate_fingerprint(lines)
+
+      find_or_create_by!(fingerprint: fingerprint) do |backtrace|
+        backtrace.lines = lines
+      end
+    rescue ActiveRecord::RecordNotUnique
+      find_by!(fingerprint: fingerprint)
+    end
+
+    def self.generate_fingerprint(lines)
+      Digest::SHA1.hexdigest(lines.map(&:to_s).join)
+    end
+  end
+end
diff --git a/app/models/errbit/comment.rb b/app/models/errbit/comment.rb
new file mode 100644
index 0000000000..8307e9f037
--- /dev/null
+++ b/app/models/errbit/comment.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Comment < ApplicationRecord
+    # Routes (`resources :comments`), form helpers, partial paths, and i18n
+    # scopes still use the un-namespaced "comment" key.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "Comment")
+    end
+
+    belongs_to :err,
+      class_name: "Errbit::Problem",
+      foreign_key: :errbit_problem_id,
+      inverse_of: :comments,
+      counter_cache: :comments_count
+
+    belongs_to :user,
+      class_name: "Errbit::User",
+      foreign_key: :errbit_user_id,
+      inverse_of: :comments
+
+    validates :body, presence: true
+
+    delegate :app, to: :err
+
+    scope :ordered, -> { order(created_at: :asc) }
+
+    after_create :deliver_email, if: :emailable?
+
+    def deliver_email
+      Errbit::Mailer.with(comment: self).comment_notification.deliver_now
+    end
+
+    def notification_recipients
+      app.notification_recipients - [user.email]
+    end
+
+    def emailable?
+      app.emailable? && notification_recipients.any?
+    end
+  end
+end
diff --git a/app/models/errbit/err.rb b/app/models/errbit/err.rb
new file mode 100644
index 0000000000..75c6ac7231
--- /dev/null
+++ b/app/models/errbit/err.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Err < ApplicationRecord
+    belongs_to :problem,
+      class_name: "Errbit::Problem",
+      foreign_key: :errbit_problem_id,
+      inverse_of: :errs
+
+    has_many :notices,
+      class_name: "Errbit::Notice",
+      foreign_key: :errbit_err_id,
+      inverse_of: :err,
+      dependent: :destroy
+
+    validates :fingerprint, presence: true
+
+    delegate :app, :resolved?, to: :problem
+  end
+end
diff --git a/app/models/errbit/error_report.rb b/app/models/errbit/error_report.rb
new file mode 100644
index 0000000000..27c0743681
--- /dev/null
+++ b/app/models/errbit/error_report.rb
@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Errbit
+  ##
+  # Processes a new error report.
+  #
+  # Accepts a hash with the following attributes:
+  #
+  # * <tt>:error_class</tt> - the class of error
+  # * <tt>:message</tt> - the error message
+  # * <tt>:backtrace</tt> - an array of stack trace lines
+  #
+  # * <tt>:request</tt> - a hash of values describing the request
+  # * <tt>:server_environment</tt> - a hash of values describing the server environment
+  #
+  # * <tt>:notifier</tt> - information to identify the source of the error report
+  #
+  class ErrorReport
+    attr_reader :api_key, :error_class, :framework, :message, :notice,
+      :notifier, :problem, :problem_was_resolved, :request, :server_environment,
+      :user_attributes
+
+    def initialize(xml_or_attributes)
+      @attributes = xml_or_attributes
+      @attributes = Hoptoad.parse_xml!(@attributes) if @attributes.is_a? String
+      @attributes = @attributes.with_indifferent_access
+      @attributes.each { |k, v| instance_variable_set(:"@#{k}", v) }
+    end
+
+    def rails_env
+      env = server_environment["environment-name"]
+      env.presence || "development"
+    end
+
+    def app
+      @app ||= Errbit::App.where(api_key: api_key).first
+    end
+
+    def backtrace
+      @backtrace_record ||= Errbit::Backtrace.find_or_create(@backtrace)
+    end
+
+    def generate_notice!
+      return unless valid?
+      return @notice if @notice
+
+      make_notice
+      notice.err = error
+      notice.save!
+
+      retrieve_problem_was_resolved
+      cache_attributes_on_problem
+      email_notification
+      services_notification
+      @notice
+    end
+
+    def make_notice
+      @notice = Errbit::Notice.new(
+        app: app,
+        message: message,
+        error_class: error_class,
+        backtrace: backtrace,
+        request: request,
+        server_environment: server_environment,
+        notifier: notifier,
+        user_attributes: user_attributes,
+        framework: framework
+      )
+    end
+
+    def retrieve_problem_was_resolved
+      @problem_was_resolved = Errbit::Problem.exists?(id: @error.errbit_problem_id, resolved: true)
+    end
+
+    # Update problem cache with information about this notice.
+    def cache_attributes_on_problem
+      @problem = Errbit::Problem.cache_notice(@error.errbit_problem_id, @notice)
+    end
+
+    def should_email?
+      problem_was_resolved ||
+        app.email_at_notices.include?(0) ||
+        app.email_at_notices.include?(@problem.notices_count)
+    end
+
+    def email_notification
+      return unless app.emailable? && should_email?
+
+      Errbit::Mailer.with(error_report: self).err_notification.deliver_now
+    rescue => e
+      HoptoadNotifier.notify(e)
+    end
+
+    def should_notify?
+      problem_was_resolved ||
+        app.notification_service.notify_at_notices.include?(0) ||
+        app.notification_service.notify_at_notices.include?(@problem.notices_count)
+    end
+
+    # Launch all notifications defined on the app associated with this notice.
+    def services_notification
+      return unless app.notification_service_configured? && should_notify?
+
+      app.notification_service.create_notification(problem)
+    rescue => e
+      HoptoadNotifier.notify(e)
+    end
+
+    ##
+    # Err associated with this error_report. Created if it doesn't exist.
+    #
+    # @return [ Errbit::Err ]
+    def error
+      @error ||= app.find_or_create_err!(
+        error_class: error_class,
+        environment: rails_env,
+        fingerprint: fingerprint
+      )
+    end
+
+    def valid?
+      app.present?
+    end
+
+    def should_keep?
+      app_version = server_environment["app-version"] || ""
+      current_version = app.current_app_version
+      return true if current_version.blank?
+      return false if app_version.length <= 0
+
+      Gem::Version.new(app_version) >= Gem::Version.new(current_version)
+    end
+
+    def fingerprint
+      app.notice_fingerprinter.generate(api_key, notice, backtrace)
+    end
+  end
+end
diff --git a/app/models/errbit/issue.rb b/app/models/errbit/issue.rb
new file mode 100644
index 0000000000..53f2fa6079
--- /dev/null
+++ b/app/models/errbit/issue.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Issue
+    include ActiveModel::Model
+
+    attr_accessor :problem, :user, :body
+
+    def issue_tracker
+      @issue_tracker ||= problem.app.issue_tracker
+    end
+
+    def tracker
+      @tracker ||= issue_tracker&.tracker
+    end
+
+    def render_body_args
+      if tracker.respond_to?(:render_body_args)
+        tracker.render_body_args
+      else
+        [{template: "issue_trackers/markdown"}]
+      end
+    end
+
+    def title
+      if tracker.respond_to?(:title)
+        tracker.title
+      else
+        "[#{problem.environment}][#{problem.where}] #{problem.message.to_s.truncate(100)}"
+      end
+    end
+
+    def close
+      errors.add :base, "This app has no issue tracker" unless issue_tracker
+
+      return false if errors.present?
+
+      tracker.errors.each { |k, err| errors.add k, err }
+
+      return false if errors.present?
+
+      if issue_tracker.respond_to? :close_issue
+        issue_tracker.close_issue(problem.issue_link, user: user.attributes)
+      end
+
+      errors.empty?
+    rescue => e
+      errors.add :base, "There was an error during issue closing: #{e.message}"
+
+      false
+    end
+
+    def save
+      errors.add :base, "The issue has no body" unless body
+      errors.add :base, "This app has no issue tracker" unless issue_tracker
+
+      return false if errors.present?
+
+      tracker.errors.each { |k, err| errors.add k, err }
+
+      return false if errors.present?
+
+      url = issue_tracker.create_issue(title, body, user: user.attributes)
+      problem.update(issue_link: url, issue_type: tracker.class.label)
+
+      errors.empty?
+    rescue => e
+      errors.add :base, "There was an error during issue creation: #{e.message}"
+
+      false
+    end
+  end
+end
diff --git a/app/models/errbit/issue_tracker.rb b/app/models/errbit/issue_tracker.rb
new file mode 100644
index 0000000000..c242a0d154
--- /dev/null
+++ b/app/models/errbit/issue_tracker.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Errbit
+  class IssueTracker < ApplicationRecord
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :issue_tracker,
+      optional: true
+
+    attribute :options, default: -> { {} }
+
+    validate :validate_tracker
+
+    def options
+      super&.with_indifferent_access || ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    delegate :configured?, to: :tracker
+    delegate :create_issue, to: :tracker
+    delegate :close_issue, to: :tracker
+    delegate :url, to: :tracker
+
+    def type_tracker
+      self[:type_tracker] || "none"
+    end
+
+    def tracker
+      @tracker ||= begin
+        klass = ErrbitPlugin::Registry.issue_trackers[type_tracker] || ErrbitPlugin::NoneIssueTracker
+        klass.new(
+          options.merge(
+            github_repo: app.try(:github_repo),
+            bitbucket_repo: app.try(:bitbucket_repo)
+          )
+        )
+      end
+    end
+
+    def validate_tracker
+      (tracker.errors || {}).each do |k, v|
+        errors.add(k, v)
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notice.rb b/app/models/errbit/notice.rb
new file mode 100644
index 0000000000..c011b8b40e
--- /dev/null
+++ b/app/models/errbit/notice.rb
@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Notice < ApplicationRecord
+    UNAVAILABLE = "N/A"
+
+    # Routes (`resources :notices`), form helpers, partial paths, and i18n
+    # scopes still use the un-namespaced "notice" key.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "Notice")
+    end
+
+    # Mongo will not accept index keys larger than 1,024 bytes and that includes
+    # some amount of BSON encoding overhead, so keep it under 1,000 bytes to be
+    # safe.
+    MESSAGE_LENGTH_LIMIT = 1_000
+
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :notices
+
+    belongs_to :err,
+      class_name: "Errbit::Err",
+      foreign_key: :errbit_err_id,
+      inverse_of: :notices
+
+    belongs_to :backtrace,
+      class_name: "Errbit::Backtrace",
+      foreign_key: :errbit_backtrace_id
+
+    delegate :lines, to: :backtrace, prefix: true
+    delegate :problem, to: :err
+
+    validates :server_environment, presence: true
+    validates :notifier, presence: true
+
+    before_save :sanitize
+    before_destroy :problem_recache
+
+    scope :ordered, -> { order(created_at: :asc) }
+    scope :reverse_ordered, -> { order(created_at: :desc) }
+    scope :for_errs, ->(errs) { where(errbit_err_id: errs.map(&:id)) }
+
+    def message=(m)
+      if m.is_a?(String)
+        super(m.truncate_bytes(MESSAGE_LENGTH_LIMIT, omission: nil))
+      else
+        super
+      end
+    end
+
+    def user_agent
+      agent_string = env_vars["HTTP_USER_AGENT"]
+      agent_string.blank? ? nil : UserAgent.parse(agent_string)
+    end
+
+    def user_agent_string
+      if user_agent.nil? || user_agent.none?
+        UNAVAILABLE
+      else
+        "#{user_agent.browser} #{user_agent.version} (#{user_agent.os})"
+      end
+    end
+
+    def environment_name
+      n = server_environment["server-environment"] || server_environment["environment-name"]
+      n.blank? ? "development" : n
+    end
+
+    def component
+      request["component"]
+    end
+
+    def action
+      request["action"]
+    end
+
+    def where
+      where = component.to_s.dup
+      where << "##{action}" if action.present?
+      where
+    end
+
+    def request
+      super || {}
+    end
+
+    def url
+      request["url"]
+    end
+
+    def host
+      uri = url && URI.parse(url)
+      return uri.host if uri && uri.host.present?
+
+      UNAVAILABLE
+    rescue URI::InvalidURIError
+      UNAVAILABLE
+    end
+
+    def env_vars
+      vars = request["cgi-data"]
+      vars.is_a?(Hash) ? vars : {}
+    end
+
+    def params
+      request["params"] || {}
+    end
+
+    def session
+      request["session"] || {}
+    end
+
+    def project_root
+      server_environment["project-root"] || "" if server_environment
+    end
+
+    def app_version
+      server_environment["app-version"] || "" if server_environment
+    end
+
+    # filter memory addresses out of object strings
+    # example: "#<Object:0x007fa2b33d9458>" becomes "#<Object>"
+    def filtered_message
+      message.gsub(/(#<.+?):[0-9a-f]x[0-9a-f]+(>)/, '\1\2')
+    end
+
+    private
+
+    def problem_recache
+      problem&.uncache_notice(self)
+    end
+
+    def sanitize
+      [:server_environment, :request, :notifier].each do |h|
+        send(:"#{h}=", sanitize_hash(send(h)))
+      end
+    end
+
+    def sanitize_hash(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(k, v), result|
+        new_key = k.is_a?(String) ? k.gsub(/\./, "&#46;").gsub(/^\$/, "&#36;") : k
+        result[new_key] = v.is_a?(Hash) ? sanitize_hash(v) : v
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notice_fingerprinter.rb b/app/models/errbit/notice_fingerprinter.rb
new file mode 100644
index 0000000000..8e0fa80c68
--- /dev/null
+++ b/app/models/errbit/notice_fingerprinter.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Errbit
+  class NoticeFingerprinter < ApplicationRecord
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :notice_fingerprinter,
+      optional: true
+
+    def generate(api_key, notice, backtrace)
+      material = [api_key]
+      material << notice.error_class if error_class
+      material << notice.filtered_message if message
+      material << notice.component if component
+      material << notice.action if action
+      material << notice.environment_name if environment_name
+
+      if backtrace
+        if backtrace_lines < 0
+          material << backtrace.lines
+        else
+          material << backtrace.lines.slice(0, backtrace_lines)
+        end
+      end
+
+      Digest::MD5.hexdigest(material.map(&:to_s).join)
+    end
+  end
+end
diff --git a/app/models/errbit/notification_service.rb b/app/models/errbit/notification_service.rb
new file mode 100644
index 0000000000..ac51977312
--- /dev/null
+++ b/app/models/errbit/notification_service.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Errbit
+  class NotificationService < ApplicationRecord
+    LABEL = ""
+
+    include Rails.application.routes.url_helpers
+
+    default_url_options[:host] = ActionMailer::Base.default_url_options[:host]
+    default_url_options[:port] = ActionMailer::Base.default_url_options[:port]
+
+    serialize :notify_at_notices, type: Array, coder: YAML
+
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :notification_service,
+      optional: true
+
+    validate :check_params
+
+    FIELDS = if Errbit::Config.per_app_notify_at_notices
+      [
+        [:notify_at_notices,
+          {
+            placeholder: "comma separated numbers or simply 0 for every notice",
+            label: "notify on errors (0 for all errors)"
+          }]
+      ]
+    else
+      []
+    end
+
+    def notify_at_notices
+      Errbit::Config.per_app_notify_at_notices ? (super.presence || Errbit::Config.notify_at_notices) : Errbit::Config.notify_at_notices
+    end
+
+    # Subclasses are responsible for overwriting this method.
+    def check_params
+      true
+    end
+
+    def notification_description(problem)
+      "[#{problem.environment}][#{problem.where}] #{problem.message.to_s.truncate(100)}"
+    end
+
+    def url
+    end
+
+    def self.label
+      self::LABEL
+    end
+
+    def label
+      self.class.label
+    end
+
+    def configured?
+      api_token.present?
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/campfire_service.rb b/app/models/errbit/notification_services/campfire_service.rb
new file mode 100644
index 0000000000..d9e74b9523
--- /dev/null
+++ b/app/models/errbit/notification_services/campfire_service.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class CampfireService < NotificationService
+      LABEL = "campfire"
+      FIELDS = NotificationService::FIELDS + [
+        [:subdomain, {
+          label: "Subdomain",
+          placeholder: "subdomain from http://{{subdomain}}.campfirenow.com"
+        }],
+        [:api_token, {
+          label: "API Token",
+          placeholder: "123456789abcdef123456789abcdef"
+        }],
+        [:room_id, {
+          label: "Room ID",
+          placeholder: "123456"
+        }]
+      ]
+
+      def check_params
+        if FIELDS.detect { |f| self[f[0]].blank? }
+          errors.add :base, "You must specify your Campfire Subdomain, API token and Room ID"
+        end
+      end
+
+      def url
+        "http://#{subdomain}.campfirenow.com/"
+      end
+
+      def create_notification(problem)
+        campy = Campy::Room.new(account: subdomain, token: api_token, room_id: room_id)
+        campy.speak "[errbit] #{problem.app.name} #{notification_description(problem)} - https://#{Errbit::Config.host}/apps/#{problem.app.id}/problems/#{problem.id}"
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/hoiio_service.rb b/app/models/errbit/notification_services/hoiio_service.rb
new file mode 100644
index 0000000000..9e4caca1e5
--- /dev/null
+++ b/app/models/errbit/notification_services/hoiio_service.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class HoiioService < NotificationService
+      LABEL = "hoiio"
+      FIELDS = NotificationService::FIELDS + [
+        [:api_token, {
+          placeholder: "App ID",
+          label: "App ID"
+        }],
+        [:subdomain, {
+          placeholder: "Access Token",
+          label: "Access Token"
+        }],
+        [:room_id, {
+          placeholder: "+6511111111, +6511111111",
+          label: "Recipient's phone numbers seperated by comma. Phone numbers should start with a \"+\" and country code."
+        }]
+      ]
+
+      def check_params
+        if FIELDS.detect { |f| self[f[0]].blank? }
+          errors.add :base, "You must specify your App ID, Access Token and Recipient's phone numbers"
+        end
+      end
+
+      def url
+        "https://secure.hoiio.com/user/"
+      end
+
+      def notification_description(problem)
+        "[#{problem.environment}]#{problem.message.to_s.truncate(50)}"
+      end
+
+      def create_notification(problem)
+        sms = Hoi::SMS.new(api_token, subdomain)
+
+        room_id.split(",").each do |number|
+          sms.send dest: number, msg: "https://#{Errbit::Config.host}/apps/#{problem.app.id} #{notification_description(problem)}"
+        end
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/hubot_service.rb b/app/models/errbit/notification_services/hubot_service.rb
new file mode 100644
index 0000000000..c720b75713
--- /dev/null
+++ b/app/models/errbit/notification_services/hubot_service.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class HubotService < NotificationService
+      LABEL = "hubot"
+      FIELDS = NotificationService::FIELDS + [
+        [:api_token, {
+          placeholder: "http://hubot.example.org:8080/hubot/say",
+          label: "Hubot URL"
+        }],
+        [:room_id, {
+          placeholder: "#dev",
+          label: "Room where Hubot should notify"
+        }]
+      ]
+
+      def check_params
+        if FIELDS.detect { |f| self[f[0]].blank? }
+          errors.add :base, "You must specify the URL of your hubot"
+        end
+      end
+
+      def url
+        api_token
+      end
+
+      def message_for_hubot(problem)
+        "[#{problem.app.name}][#{problem.environment}][#{problem.where}]: #{problem.error_class} #{problem.url}"
+      end
+
+      def create_notification(problem)
+        HTTParty.post(url, body: {message: message_for_hubot(problem), room: room_id})
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/pushover_service.rb b/app/models/errbit/notification_services/pushover_service.rb
new file mode 100644
index 0000000000..ebe880cbd2
--- /dev/null
+++ b/app/models/errbit/notification_services/pushover_service.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class PushoverService < NotificationService
+      LABEL = "pushover"
+      FIELDS = NotificationService::FIELDS + [
+        [:api_token, {
+          placeholder: "User Key",
+          label: "User Key"
+        }],
+        [:subdomain, {
+          placeholder: "Application API Token",
+          label: "Application API Token"
+        }]
+      ]
+
+      def check_params
+        if FIELDS.detect { |f| self[f[0]].blank? }
+          errors.add :base, "You must specify your User Key and Application API Token."
+        end
+      end
+
+      def url
+        "https://pushover.net/login"
+      end
+
+      def create_notification(problem)
+        Pushover2::Message.new(
+          token: subdomain,
+          user: api_token,
+          message: notification_description(problem),
+          priority: 1,
+          title: "Errbit Notification",
+          url: "https://#{Errbit::Config.host}/apps/#{problem.app.id}",
+          url_title: "Link to error"
+        ).push
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/slack_service.rb b/app/models/errbit/notification_services/slack_service.rb
new file mode 100644
index 0000000000..2dd3314869
--- /dev/null
+++ b/app/models/errbit/notification_services/slack_service.rb
@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class SlackService < NotificationService
+      CHANNEL_NAME_REGEXP = /^#[a-z\d_-]+$/
+      LABEL = "slack"
+      FIELDS = NotificationService::FIELDS + [
+        [:service_url, {
+          placeholder: "Slack Hook URL (https://hooks.slack.com/services/XXXXXXXXX/XXXXXXXXX/XXXXXXXXX)",
+          label: "Hook URL"
+        }],
+        [:room_id, {
+          placeholder: "#general",
+          label: "Notification channel",
+          hint: "If empty Errbit will use the default channel for the webhook"
+        }]
+      ]
+
+      def check_params
+        if service_url.blank?
+          errors.add :service_url, "You must specify your Slack Hook url"
+        end
+
+        if room_id.present? && !CHANNEL_NAME_REGEXP.match(room_id)
+          errors.add :room_id, "Slack channel name must be lowercase, with no space, special character, or periods."
+        end
+      end
+
+      def message_for_slack(problem)
+        "[#{problem.app.name}][#{problem.environment}][#{problem.where}]: #{problem.error_class} #{problem.url}"
+      end
+
+      def post_payload(problem)
+        {
+          username: "Errbit",
+          icon_url: "https://raw.githubusercontent.com/errbit/errbit/main/docs/notifications/slack/errbit.png",
+          channel: room_id,
+          attachments: [
+            {
+              fallback: message_for_slack(problem),
+              title: problem.message.to_s.truncate(100),
+              title_link: problem.url,
+              text: problem.where,
+              color: "#D00000",
+              mrkdwn_in: ["fields"],
+              fields: post_payload_fields(problem)
+            }
+          ]
+        }.compact.to_json
+      end
+
+      def create_notification(problem)
+        HTTParty.post(
+          service_url,
+          body: post_payload(problem),
+          headers: {
+            "Content-Type" => "application/json"
+          }
+        )
+      end
+
+      def configured?
+        service_url.present?
+      end
+
+      private
+
+      def post_payload_fields(problem)
+        [
+          {title: "Application", value: problem.app.name, short: true},
+          {title: "Environment", value: problem.environment, short: true},
+          {title: "Times Occurred", value: problem.notices_count.try(:to_s), short: true},
+          {title: "First Noticed", value: problem.first_notice_at.try(:localtime).try(:to_fs, :db), short: true},
+          {title: "Backtrace", value: backtrace_lines(problem), short: false}
+        ]
+      end
+
+      def backtrace_line(line)
+        path = line.decorated_path.gsub(%r{</?strong>}, "")
+        "#{path}#{line.file_name}:#{line.number} → #{line.method}\n"
+      end
+
+      def backtrace_lines(problem)
+        notice = Errbit::NoticeDecorator.new(problem.notices.last)
+        return unless notice
+
+        backtrace = notice.backtrace
+        return unless backtrace
+
+        output = +""
+        backtrace.lines[0..4].each { |line| output << backtrace_line(line) }
+        "```#{output}```"
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/notification_services/webhook_service.rb b/app/models/errbit/notification_services/webhook_service.rb
new file mode 100644
index 0000000000..c7dc62c491
--- /dev/null
+++ b/app/models/errbit/notification_services/webhook_service.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Errbit
+  module NotificationServices
+    class WebhookService < NotificationService
+      LABEL = "webhook"
+      FIELDS = [
+        [:api_token, {
+          placeholder: "URL to receive a POST request when an error occurs",
+          label: "URL"
+        }]
+      ]
+
+      def check_params
+        if FIELDS.detect { |f| self[f[0]].blank? }
+          errors.add :base, "You must specify the URL"
+        end
+      end
+
+      def message_for_webhook(problem)
+        {
+          problem: {url: problem.url}.merge!(problem.as_json)
+        }
+      end
+
+      def create_notification(problem)
+        HTTParty.post(api_token, headers: {"Content-Type" => "application/json", "User-Agent" => "Errbit"}, body: message_for_webhook(problem).to_json)
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/problem.rb b/app/models/errbit/problem.rb
new file mode 100644
index 0000000000..e1306f3776
--- /dev/null
+++ b/app/models/errbit/problem.rb
@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Problem < ApplicationRecord
+    # Routes (`resources :problems`, nested under apps), form helpers, partial
+    # paths, and i18n scopes still use the un-namespaced "problem" key.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "Problem")
+    end
+
+    CACHED_NOTICE_ATTRIBUTES = {
+      messages: :message,
+      hosts: :host,
+      user_agents: :user_agent_string
+    }.freeze
+
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :problems
+
+    has_many :errs,
+      class_name: "Errbit::Err",
+      foreign_key: :errbit_problem_id,
+      inverse_of: :problem,
+      dependent: :destroy
+
+    has_many :comments,
+      class_name: "Errbit::Comment",
+      foreign_key: :errbit_problem_id,
+      inverse_of: :err,
+      dependent: :destroy
+
+    attribute :first_notice_at, default: -> { Time.zone.now }
+    attribute :last_notice_at, default: -> { Time.zone.now }
+    attribute :user_agents, default: -> { {} }
+    attribute :messages, default: -> { {} }
+    attribute :hosts, default: -> { {} }
+
+    validates :environment, presence: true
+    validates :first_notice_at, presence: true
+    validates :last_notice_at, presence: true
+
+    before_create :cache_app_attributes
+
+    scope :resolved, -> { where(resolved: true) }
+    scope :unresolved, -> { where(resolved: false) }
+    scope :ordered, -> { order(last_notice_at: :desc) }
+    scope :for_apps, ->(apps) { where(errbit_app_id: apps.map(&:id)) }
+
+    # If `value` matches an existing notice id, return that notice's problem.
+    # Otherwise LIKE-search the cached text columns. Mirrors the Mongoid
+    # `$text` scope while staying within plain SQL.
+    scope :search, lambda { |value|
+      notice = Errbit::Notice.where(id: value).first
+      next where(id: notice.err.errbit_problem_id) if notice
+
+      pattern = "%#{value}%"
+      where(
+        arel_table[:error_class].matches(pattern)
+          .or(arel_table[:message].matches(pattern))
+          .or(arel_table[:app_name].matches(pattern))
+          .or(arel_table[:environment].matches(pattern))
+          .or(arel_table[:where].matches(pattern))
+      )
+    }
+
+    def self.all_else_unresolved(fetch_all)
+      fetch_all ? all : where(resolved: false)
+    end
+
+    def self.in_env(env)
+      env.present? ? where(environment: env) : all
+    end
+
+    def self.filtered(filter)
+      app_names_to_exclude = []
+
+      if filter
+        filter.scan(/(-app):(['"][^'"]+['"]|[^ ]+)/).each do |filter_type, filter_value|
+          filter_value = filter_value.gsub(/^['"]/, "").gsub(/['"]$/, "")
+          app_names_to_exclude << filter_value if filter_type == "-app"
+        end
+      end
+
+      app_names_to_exclude.present? ? where.not(app_name: app_names_to_exclude) : all
+    end
+
+    def self.ordered_by(sort, order)
+      column = case sort
+      when "app" then :app_name
+      when "environment" then :environment
+      when "message" then :message
+      when "last_notice_at" then :last_notice_at
+      when "count" then :notices_count
+      else
+        fail("\"#{sort}\" is not a recognized sort")
+      end
+
+      order(column => order)
+    end
+
+    def url
+      Rails.application.routes.url_helpers.app_problem_url(
+        app, self, host: Errbit::Config.host
+      )
+    end
+
+    def notices
+      Errbit::Notice.for_errs(errs).ordered
+    end
+
+    def recache
+      notice_records = notices.to_a
+
+      CACHED_NOTICE_ATTRIBUTES.each do |attr, source|
+        counts = Hash.new(0)
+        values = {}
+
+        notice_records.each do |notice|
+          value = notice.send(source) || "N/A"
+          key = Digest::MD5.hexdigest(value)
+          counts[key] += 1
+          values[key] = value
+        end
+
+        hash = counts.each_with_object({}) do |(key, count), h|
+          h[key] = {"value" => values[key], "count" => count}
+        end
+
+        send(:"#{attr}=", hash)
+      end
+
+      first_notice = notice_records.min_by(&:created_at)
+      last_notice = notice_records.max_by(&:created_at)
+
+      self.notices_count = notice_records.size
+      if first_notice
+        self.first_notice_at = first_notice.created_at
+        self.message = first_notice.message
+        self.where = first_notice.where
+      end
+      self.last_notice_at = last_notice.created_at if last_notice
+
+      save
+    end
+
+    def resolve!
+      update!(resolved: true, resolved_at: Time.zone.now)
+    end
+
+    def unresolve!
+      update!(resolved: false, resolved_at: nil)
+    end
+
+    def unresolved?
+      !resolved?
+    end
+
+    def link_text
+      message.presence || error_class
+    end
+
+    # Override the column reader: when the stored value is nil, fall back to
+    # the app's configured issue tracker type. Cached into the in-memory
+    # attribute (Mongoid behavior) without persisting.
+    def issue_type
+      self[:issue_type] ||= (app.issue_tracker_configured? && app.issue_tracker.type_tracker) || nil
+    end
+
+    def self.merge!(*problems)
+      result = Errbit::ProblemMerge.new(problems).merge
+      result.reload
+    end
+
+    # Apply a freshly-received notice to the problem's cached fields:
+    # latest environment/error_class/message/where/last_notice_at, the
+    # resolved-flag reset, the messages/hosts/user_agents digest counters,
+    # and notices_count++. Mirrors the Mongoid `cache_notice` atomic upsert
+    # in a single `UPDATE` via `save!`.
+    def self.cache_notice(id, notice)
+      problem = find(id)
+
+      problem.update!(
+        environment: notice.environment_name,
+        error_class: notice.error_class,
+        last_notice_at: notice.created_at.utc,
+        message: notice.message,
+        resolved: false,
+        resolved_at: nil,
+        where: notice.where,
+        notices_count: (problem.notices_count || 0) + 1,
+        messages: increment_hash_counter(problem.messages, Digest::MD5.hexdigest(notice.message.to_s), notice.message),
+        hosts: increment_hash_counter(problem.hosts, Digest::MD5.hexdigest(notice.host.to_s), notice.host),
+        user_agents: increment_hash_counter(problem.user_agents, Digest::MD5.hexdigest(notice.user_agent_string.to_s), notice.user_agent_string)
+      )
+
+      problem
+    end
+
+    def self.increment_hash_counter(hash, key, value)
+      result = (hash || {}).deep_dup
+      result[key] ||= {"value" => value, "count" => 0}
+      result[key]["value"] = value
+      result[key]["count"] += 1
+      result
+    end
+    private_class_method :increment_hash_counter
+
+    # Counterpart to `cache_notice`: when a notice is destroyed, refresh the
+    # problem's cached fields from the most recent remaining notice and
+    # decrement the matching hash counter (or drop the digest entry entirely).
+    def uncache_notice(notice)
+      last_notice = notices.reorder(created_at: :desc).first
+      return unless last_notice
+
+      attrs = {
+        environment: last_notice.environment_name,
+        error_class: last_notice.error_class,
+        last_notice_at: last_notice.created_at,
+        message: last_notice.message,
+        where: last_notice.where,
+        notices_count: (notices_count.to_i > 1) ? notices_count - 1 : 0
+      }
+
+      CACHED_NOTICE_ATTRIBUTES.each do |attr, source|
+        attrs[attr] = decrement_hash_counter(send(attr), Digest::MD5.hexdigest(notice.send(source).to_s))
+      end
+
+      update!(attrs)
+    end
+
+    private
+
+    def decrement_hash_counter(hash, key)
+      result = (hash || {}).deep_dup
+
+      if result[key] && result[key]["count"].to_i > 1
+        result[key]["count"] -= 1
+      else
+        result.delete(key)
+      end
+
+      result
+    end
+
+    public
+
+    def merged?
+      errs.length > 1
+    end
+
+    def unmerge!
+      attrs = {error_class: error_class, environment: environment}
+      problem_errs = errs.to_a
+
+      new_problems = [self]
+      (problem_errs[1..] || []).each do |err|
+        new_problems << app.problems.create(attrs)
+        err.update!(problem: new_problems.last)
+      end
+
+      errs.reset
+      new_problems.each(&:recache)
+      new_problems
+    end
+
+    def cache_app_attributes
+      self.app_name = app.name if app
+    end
+
+    # Bucketed notice counts since the given moment, grouped by `:yday` or
+    # `:hour`. Returns the Mongoid-shaped output [{"_id" => {group_by => bucket},
+    # "count" => n}, ...]. Used by `xhr_sparkline`.
+    def grouped_notice_counts(since, group_by = "day")
+      time_method = (group_by == "day") ? :yday : :hour
+
+      Errbit::Notice
+        .for_errs(errs)
+        .where("created_at > ?", since)
+        .pluck(:created_at)
+        .group_by { |t| t.send(time_method) }
+        .map { |bucket, ts| {"_id" => {group_by => bucket}, "count" => ts.size} }
+        .sort_by { |row| row["_id"][group_by] }
+    end
+
+    def zero_filled_grouped_noticed_counts(since, group_by = "day")
+      non_zero_filled = grouped_notice_counts(since, group_by)
+      buckets = (group_by == "day") ? 14 : 24
+      time_method = (group_by == "day") ? :yday : :hour
+
+      bucket_times = Array.new(buckets) { |i| (since + i.send(group_by)).send(time_method) }
+      bucket_times.map do |bucket_time|
+        match = non_zero_filled.detect { |row| row.dig("_id", group_by) == bucket_time }
+        {bucket_time => match ? match["count"] : 0}
+      end
+    end
+
+    def grouped_notice_count_relative_percentages(since, group_by = "day")
+      counts = zero_filled_grouped_noticed_counts(since, group_by).map { |h| h.values.first }
+      max = counts.max
+      counts.map { |n| max.zero? ? 0 : (n.to_f / max.to_f) * 100.0 }
+    end
+  end
+end
diff --git a/app/models/errbit/site_config.rb b/app/models/errbit/site_config.rb
new file mode 100644
index 0000000000..ff69672f86
--- /dev/null
+++ b/app/models/errbit/site_config.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Errbit
+  class SiteConfig < ApplicationRecord
+    CONFIG_SOURCE_SITE = "site"
+    CONFIG_SOURCE_APP = "app"
+
+    NOTICE_FINGERPRINTER_FIELDS = %i[
+      error_class
+      message
+      backtrace_lines
+      component
+      action
+      environment_name
+    ].freeze
+
+    # Routes (`resources :site_config`), form helpers (`form_for @config`),
+    # partial paths, and i18n scopes use the un-namespaced "site_config" key.
+    # Override model_name so they keep matching even though this class is under
+    # `Errbit::`.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "SiteConfig")
+    end
+
+    after_save :denormalize
+
+    def self.document
+      first || create!
+    end
+
+    def notice_fingerprinter_attributes
+      attrs = NOTICE_FINGERPRINTER_FIELDS.each_with_object({}) { |f, h| h[f] = self[f] }
+      attrs[:source] = CONFIG_SOURCE_SITE
+      attrs
+    end
+
+    # Form-side shim: in the Mongoid model the fingerprinter is an embedded
+    # document. Here the fields live on SiteConfig itself, so `f.fields_for
+    # :notice_fingerprinter` reads/writes the SiteConfig directly. Defining a
+    # matching `notice_fingerprinter_attributes=` setter makes Rails' form
+    # builder generate the `notice_fingerprinter_attributes` nested key the
+    # controller's strong-params expect.
+    def notice_fingerprinter
+      self
+    end
+
+    def notice_fingerprinter_attributes=(attrs)
+      attrs.each do |key, value|
+        send(:"#{key}=", value) if NOTICE_FINGERPRINTER_FIELDS.include?(key.to_sym)
+      end
+    end
+
+    # Propagate fingerprinter changes to every Errbit::App that is still
+    # following site-wide settings. Mirrors the Mongoid SiteConfig#denormalize
+    # callback. Apps that have opted into their own per-app fingerprinter
+    # (source = CONFIG_SOURCE_APP) are left alone.
+    def denormalize
+      attrs = notice_fingerprinter_attributes
+
+      Errbit::App.find_each do |app|
+        fingerprinter = app.notice_fingerprinter
+        next if fingerprinter&.source && fingerprinter.source != CONFIG_SOURCE_SITE
+
+        if fingerprinter
+          fingerprinter.update(attrs)
+        else
+          app.create_notice_fingerprinter(attrs)
+        end
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/user.rb b/app/models/errbit/user.rb
new file mode 100644
index 0000000000..3231c4044e
--- /dev/null
+++ b/app/models/errbit/user.rb
@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Errbit
+  class User < ApplicationRecord
+    PER_PAGE = 30
+
+    # During the Mongo→SQL port, routes and views still use the un-namespaced
+    # "user" key (resources :users, params[:user], user_path, …). Override
+    # model_name so Rails' form helpers, Pundit's param_key, partial paths and
+    # i18n scopes all match.
+    def self.model_name
+      @_model_name ||= ActiveModel::Name.new(self, nil, "User")
+    end
+
+    # Pundit infers the policy class via model_name → "UserPolicy" (Mongoid).
+    # Force it back to the namespaced policy explicitly.
+    def self.policy_class
+      Errbit::UserPolicy
+    end
+
+    devise(*Errbit::Config.devise_modules)
+
+    has_many :comments,
+      class_name: "Errbit::Comment",
+      foreign_key: :errbit_user_id,
+      inverse_of: :user,
+      dependent: :destroy
+
+    has_many :watchers,
+      class_name: "Errbit::Watcher",
+      foreign_key: :errbit_user_id,
+      inverse_of: :user,
+      dependent: :destroy
+
+    before_save :ensure_authentication_token
+
+    validates :name, presence: true
+    validates :github_login, uniqueness: {allow_nil: true}
+
+    if Errbit::Config.user_has_username
+      validates :username, presence: true
+    end
+
+    class << self
+      # @param email [String]
+      def valid_google_domain?(email)
+        return true if Errbit::Config.google_authorized_domains.blank?
+
+        match_data = /.+@(?<domain>.+)$/.match(email)
+        return false if match_data.nil?
+
+        Errbit::Config.google_authorized_domains.split(",").include?(match_data[:domain])
+      end
+
+      # @param access_token [String]
+      def create_from_google_oauth2(access_token) # rubocop:disable Naming/VariableNumber
+        email = access_token.dig(:info, :email)
+        name = access_token.dig(:info, :name)
+        uid = access_token[:uid]
+
+        user = Errbit::User.where(email: email).first
+
+        user || Errbit::User.create(name: name,
+          email: email,
+          google_uid: uid,
+          password: Devise.friendly_token[0, 20])
+      end
+
+      def token_authentication_key
+        :auth_token
+      end
+    end
+
+    def per_page
+      super || PER_PAGE
+    end
+
+    def watching?(app)
+      apps.all.include?(app)
+    end
+
+    def password_required?
+      github_login.present? ? false : super
+    end
+
+    def github_account?
+      github_login.present? && github_oauth_token.present?
+    end
+
+    def can_create_github_issues?
+      github_account? && Errbit::Config.github_access_scope.include?("repo")
+    end
+
+    def github_login=(login)
+      login = nil if login.is_a?(String) && login.strip.empty?
+      self[:github_login] = login
+    end
+
+    def google_account?
+      google_uid.present?
+    end
+
+    def ensure_authentication_token
+      if authentication_token.blank?
+        self.authentication_token = generate_authentication_token
+      end
+    end
+
+    def reset_password(new_password, new_password_confirmation)
+      self.password = new_password
+      self.password_confirmation = new_password_confirmation
+
+      self.class.validators_on(:password).map { |v| v.validate_each(self, :password, password) }
+      return false if errors.any?
+
+      save(validate: false)
+    end
+
+    def attributes_for_super_diff
+      {
+        id: id,
+        name: name
+      }
+    end
+
+    private
+
+    def generate_authentication_token
+      loop do
+        token = Devise.friendly_token
+        break token unless Errbit::User.where(authentication_token: token).first
+      end
+    end
+  end
+end
diff --git a/app/models/errbit/watcher.rb b/app/models/errbit/watcher.rb
new file mode 100644
index 0000000000..89f90758a6
--- /dev/null
+++ b/app/models/errbit/watcher.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Errbit
+  class Watcher < ApplicationRecord
+    belongs_to :app,
+      class_name: "Errbit::App",
+      foreign_key: :errbit_app_id,
+      inverse_of: :watchers
+
+    belongs_to :user,
+      class_name: "Errbit::User",
+      foreign_key: :errbit_user_id,
+      optional: true
+
+    validate :ensure_user_or_email
+
+    before_validation :clear_unused_watcher_type
+
+    attr_accessor :_watcher_type
+
+    def watcher_type
+      @_watcher_type ||= email.present? ? "email" : "user"
+    end
+
+    def watcher_type=(value)
+      @_watcher_type = value
+    end
+
+    def label
+      user ? user.name : email
+    end
+
+    def address
+      user&.email || email
+    end
+
+    def email_choosen
+      email.blank? ? "chosen" : ""
+    end
+
+    private
+
+    def ensure_user_or_email
+      return if user.present? || email.present?
+
+      errors.add(:base, "You must specify either a user or an email address")
+    end
+
+    def clear_unused_watcher_type
+      case watcher_type
+      when "user"
+        self.email = nil
+      when "email"
+        self.user = nil
+        self.errbit_user_id = nil
+      end
+    end
+  end
+end
diff --git a/app/models/user.rb b/app/models/user.rb
index 34f9ea02e4..b810c64b2a 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -6,8 +6,6 @@ class User
   include Mongoid::Document
   include Mongoid::Timestamps
 
-  devise(*Errbit::Config.devise_modules)
-
   field :email
   field :github_login
   field :github_oauth_token
@@ -17,31 +15,21 @@ class User
   field :per_page, type: Integer, default: PER_PAGE
   field :time_zone, default: "UTC"
 
-  ## Devise field
-  ### Database Authenticatable
+  # Legacy fields preserved so the Mongo → SQL migration rake task can copy
+  # them into Errbit::User. The Mongoid User itself no longer uses Devise.
   field :encrypted_password, type: String
-
-  ### Recoverable
   field :reset_password_token, type: String
   field :reset_password_sent_at, type: Time
-
-  ### Rememberable
   field :remember_created_at, type: Time
-
-  ### Trackable
   field :sign_in_count, type: Integer
   field :current_sign_in_at, type: Time
   field :last_sign_in_at, type: Time
   field :current_sign_in_ip, type: String
   field :last_sign_in_ip, type: String
-
-  ### Token_authenticatable
   field :authentication_token, type: String
 
   index authentication_token: 1
 
-  before_save :ensure_authentication_token
-
   validates :name, presence: true
   validates :github_login, uniqueness: {allow_nil: true}
 
@@ -71,8 +59,7 @@ def create_from_google_oauth2(access_token) # rubocop:disable Naming/VariableNum
 
       user || User.create(name: name,
         email: email,
-        google_uid: uid,
-        password: Devise.friendly_token[0, 20])
+        google_uid: uid)
     end
   end
 
@@ -84,10 +71,6 @@ def watching?(app)
     apps.all.include?(app)
   end
 
-  def password_required?
-    github_login.present? ? false : super
-  end
-
   def github_account?
     github_login.present? && github_oauth_token.present?
   end
@@ -105,39 +88,10 @@ def google_account?
     google_uid.present?
   end
 
-  def ensure_authentication_token
-    if authentication_token.blank?
-      self.authentication_token = generate_authentication_token
-    end
-  end
-
-  def self.token_authentication_key
-    :auth_token
-  end
-
-  def reset_password(new_password, new_password_confirmation)
-    self.password = new_password
-    self.password_confirmation = new_password_confirmation
-
-    self.class.validators_on(:password).map { |v| v.validate_each(self, :password, password) }
-    return false if errors.any?
-
-    save(validate: false)
-  end
-
   def attributes_for_super_diff
     {
       id: id.to_s,
       name: name
     }
   end
-
-  private
-
-  def generate_authentication_token
-    loop do
-      token = Devise.friendly_token
-      break token unless User.where(authentication_token: token).first
-    end
-  end
 end
diff --git a/app/policies/errbit/app_policy.rb b/app/policies/errbit/app_policy.rb
new file mode 100644
index 0000000000..466d67f223
--- /dev/null
+++ b/app/policies/errbit/app_policy.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Errbit
+  class AppPolicy < ApplicationPolicy
+    # @param user [Errbit::User] The user making the request
+    # @param record [Errbit::App] The record being accessed
+    def initialize(user, record) # rubocop:disable Style/RedundantInitialize, Lint/UselessMethodDefinition
+      super
+    end
+
+    def index?
+      false
+    end
+
+    def show?
+      true
+    end
+
+    def create?
+      user.admin?
+    end
+
+    def new?
+      user.admin?
+    end
+
+    def update?
+      user.admin?
+    end
+
+    def edit?
+      user.admin?
+    end
+
+    def destroy?
+      user.admin?
+    end
+
+    class Scope < ApplicationPolicy::Scope
+      attr_reader :user, :scope
+
+      # @param user [Errbit::User]
+      # @param scope [Errbit::App, Object] The scope of records being accessed
+      def initialize(user, scope) # rubocop:disable Style/RedundantInitialize, Lint/UselessMethodDefinition
+        super
+      end
+
+      def resolve
+        scope.all
+      end
+    end
+  end
+end
diff --git a/app/policies/errbit/application_policy.rb b/app/policies/errbit/application_policy.rb
new file mode 100644
index 0000000000..2c6a3d7c0f
--- /dev/null
+++ b/app/policies/errbit/application_policy.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Errbit
+  class ApplicationPolicy
+    attr_reader :user, :record
+
+    # @param user [Errbit::User] The user making the request
+    # @param record [ActiveRecord::Base] The record being accessed
+    def initialize(user, record)
+      raise Pundit::NotAuthorizedError, "must be logged in" if user.blank?
+
+      @user = user
+      @record = record
+    end
+
+    def index?
+      false
+    end
+
+    def show?
+      false
+    end
+
+    def create?
+      false
+    end
+
+    def new?
+      false
+    end
+
+    def update?
+      false
+    end
+
+    def edit?
+      false
+    end
+
+    def destroy?
+      false
+    end
+
+    def scope
+      Pundit.policy_scope!(user, record.class)
+    end
+
+    def permitted_attributes
+      raise NotImplementedError, "You must define #permitted_attributes in #{self.class}"
+    end
+
+    class Scope
+      attr_reader :user, :scope
+
+      # @param user [Errbit::User]
+      # @param scope [Object] The scope of records being accessed
+      def initialize(user, scope)
+        raise Pundit::NotAuthorizedError, "must be logged in" if user.blank?
+
+        @user = user
+        @scope = scope
+      end
+
+      def resolve
+        raise NotImplementedError, "You must define #resolve in #{self.class}"
+      end
+    end
+  end
+end
diff --git a/app/policies/errbit/user_policy.rb b/app/policies/errbit/user_policy.rb
new file mode 100644
index 0000000000..f1f5dc1e5c
--- /dev/null
+++ b/app/policies/errbit/user_policy.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Errbit
+  class UserPolicy < ApplicationPolicy
+    FIELDS = [
+      :name, :username, :email, :password, :github_login, :per_page, :time_zone,
+      :password, :password_confirmation
+    ].freeze
+
+    # @param user [Errbit::User] The user making the request
+    # @param record [Errbit::User] The record being accessed
+    def initialize(user, record) # rubocop:disable Style/RedundantInitialize, Lint/UselessMethodDefinition
+      super
+    end
+
+    def index?
+      false
+    end
+
+    def show?
+      scope.exists?(id: record.id)
+    end
+
+    def create?
+      user.admin?
+    end
+
+    def new?
+      create?
+    end
+
+    def update?
+      scope.exists?(id: record.id)
+    end
+
+    def edit?
+      scope.exists?(id: record.id)
+    end
+
+    def destroy?
+      scope.exists?(id: record.id) && user.id != record.id
+    end
+
+    def permitted_attributes
+      if user.admin? && user.id != record.id
+        FIELDS + [:admin]
+      else
+        FIELDS
+      end
+    end
+
+    class Scope < ApplicationPolicy::Scope
+      attr_reader :user, :scope
+
+      # @param user [Errbit::User]
+      # @param scope [Errbit::User, Object] The scope of records being accessed
+      def initialize(user, scope) # rubocop:disable Style/RedundantInitialize, Lint/UselessMethodDefinition
+        super
+      end
+
+      def resolve
+        if user.admin?
+          scope.all
+        else
+          scope.where(id: user.id)
+        end
+      end
+    end
+  end
+end
diff --git a/app/views/apps/_service_notification_fields.html.erb b/app/views/apps/_service_notification_fields.html.erb
index 760f6e72c2..d3321030cc 100644
--- a/app/views/apps/_service_notification_fields.html.erb
+++ b/app/views/apps/_service_notification_fields.html.erb
@@ -4,24 +4,24 @@
   <%= f.fields_for :notification_service do |w| %>
     <div class="notification_service nested">
       <div class="choose">
-        <%= label_tag :type_none, for: label_for_attr(w, "type_notificationservice"), class: "label_radio none" do %>
-          <%= w.radio_button :type, "NotificationService", "data-section" => "none" %>
+        <%= label_tag :type_none, for: label_for_attr(w, "type_errbitnotificationservice"), class: "label_radio none" do %>
+          <%= w.radio_button :type, "Errbit::NotificationService", "data-section" => "none" %>
 
           (None)
         <% end %>
 
-        <% NotificationService.subclasses.each do |notification_service| %>
+        <% Errbit::NotificationService.subclasses.each do |notification_service| %>
           <%= label_tag "type_#{notification_service.label}:", for: label_for_attr(w, "type_#{notification_service.name.downcase.gsub(":", "")}"), class: "label_radio #{notification_service.label}" do %>
             <%= w.radio_button :type, notification_service.name, "data-section" => notification_service.label %>
 
-            <%= notification_service.name[/::(.*)Service/,1].titleize %>
+            <%= notification_service.name.demodulize.sub(/Service\z/, "").titleize %>
           <% end %>
         <% end %>
       </div>
 
-      <div class="notification_params none <%= (w.object && !(w.object.class < NotificationService)) ? "chosen" : "" %>"></div>
+      <div class="notification_params none <%= (w.object && !(w.object.class < Errbit::NotificationService)) ? "chosen" : "" %>"></div>
 
-      <% NotificationService.subclasses.each do |notification_service| %>
+      <% Errbit::NotificationService.subclasses.each do |notification_service| %>
         <div class="notification_params <%= "#{w.object.is_a?(notification_service) ? "chosen" : ""} #{notification_service.label}" %>">
           <% notification_service::FIELDS.each do |field, field_info| %>
             <%= w.label field, field_info[:label] || field.to_s.titleize %>
@@ -40,7 +40,7 @@
       <% end %>
 
       <div class="image_preloader">
-        <% (NotificationService.subclasses.map{|t| t.label } << "none").each do |notification_service| %>
+        <% (Errbit::NotificationService.subclasses.map { |t| t.label } << "none").each do |notification_service| %>
           <%= image_tag "#{notification_service}_inactive.png" %>
 
           <%= image_tag "#{notification_service}_create.png" %>
diff --git a/app/views/apps/show.html.erb b/app/views/apps/show.html.erb
index 9a4d06812c..f225dd1f3f 100644
--- a/app/views/apps/show.html.erb
+++ b/app/views/apps/show.html.erb
@@ -2,7 +2,7 @@
 
 <% content_for :head do %>
   <%= auto_discovery_link_tag :atom,
-        app_path(app, User.token_authentication_key => current_user.authentication_token, format: :atom),
+        app_path(app, Errbit::User.token_authentication_key => current_user.authentication_token, format: :atom),
         title: t(".atom_title", name: app.name, host: request.host) %>
 <% end %>
 
diff --git a/app/views/errbit/mailer/comment_notification.html.erb b/app/views/errbit/mailer/comment_notification.html.erb
new file mode 100644
index 0000000000..799a6bc09c
--- /dev/null
+++ b/app/views/errbit/mailer/comment_notification.html.erb
@@ -0,0 +1,88 @@
+<tr>
+  <td class="section">
+    <table cellpadding="0" cellspacing="0" border="0" align="left">
+      <tbody>
+        <tr>
+          <td class="content" valign="top">
+            <div>
+              <p>
+                <%= @user.name %>
+                has just commented on an error that occurred in
+                <%= link_to(@app.name, app_url(@app), class: "bold") << "," %>
+                on the
+                <span class="bold"><%= @problem.environment %></span>
+                environment.
+                <br>
+                This error has occurred <%= pluralize(@problem.notices_count, "time") %>.
+              </p>
+
+              <p>
+                <%= link_to("Click here to view the error and add a comment on Errbit", app_problem_url(@app, @problem), class: "bold") << "." %>
+              </p>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </td>
+</tr>
+
+<tr>
+  <td class="section">
+    <table cellpadding="0" cellspacing="0" border="0" align="left">
+      <tbody>
+        <tr>
+          <td class="content" valign="top">
+            <div>
+              <p class="heading">COMMENT:</p>
+
+              <br>
+
+              <p><%= @comment.body.to_s.gsub("\n", "<br>").html_safe %></p>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </td>
+</tr>
+
+<tr>
+  <td class="section">
+    <table cellpadding="0" cellspacing="0" border="0" align="left">
+      <tbody>
+        <tr>
+          <td class="content" valign="top">
+            <div>
+              <p class="heading">ERROR MESSAGE:</p>
+
+              <p><%= @problem.message %></p>
+
+              <p class="heading">WHERE:</p>
+
+              <p class="monospace">
+                <%= @problem.where %>
+              </p>
+
+              <p class="heading">URL:</p>
+
+              <p class="monospace">
+                <% if @notice.request["url"].present? %>
+                  <%= link_to @notice.request["url"], @notice.request["url"] %>
+                <% end %>
+              </p>
+
+              <p class="heading">BROWSER:</p>
+
+              <p class="monospace">
+                <%= user_agent_graph(@problem) %>
+              </p>
+
+              <br>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </td>
+</tr>
diff --git a/app/views/errbit/mailer/comment_notification.text.erb b/app/views/errbit/mailer/comment_notification.text.erb
new file mode 100644
index 0000000000..c5c01d7c5c
--- /dev/null
+++ b/app/views/errbit/mailer/comment_notification.text.erb
@@ -0,0 +1,36 @@
+<%= @user.name %> has just commented on an error that occurred in <%= @notice.environment_name %>: <%= raw(@notice.message) %>
+
+This error has occurred <%= pluralize @notice.problem.notices_count, "time" %>. You should really look into it here:
+
+  <%= app_problem_url(@app, @notice.problem) %>
+
+
+COMMENT:
+
+<%= @comment.body %>
+
+
+-----------------------------------------------
+
+ERROR MESSAGE:
+
+<%= raw(@notice.message) %>
+
+
+WHERE:
+
+<%= @notice.where %>
+
+<% @notice.backtrace.lines.each do |line| %>
+  <% next unless line.in_app? %><%= line %>
+<% end %>
+
+
+URL:
+
+<%= @notice.request["url"] %>
+
+
+BROWSER:
+
+<%= @notice.user_agent_string %>
diff --git a/app/views/errbit/mailer/err_notification.html.erb b/app/views/errbit/mailer/err_notification.html.erb
new file mode 100644
index 0000000000..48f971c10a
--- /dev/null
+++ b/app/views/errbit/mailer/err_notification.html.erb
@@ -0,0 +1,133 @@
+<tr>
+  <td class="section">
+    <table cellpadding="0" cellspacing="0" border="0" align="left">
+      <tbody>
+        <tr>
+          <td class="content" valign="top">
+            <div>
+              <p>
+                An error has just occurred in
+                <%= link_to(@app.name, app_url(@app), class: "bold") << "," %>
+                on the
+                <span class="bold"><%= @notice.environment_name %></span>
+                environment.
+                <br>
+                This error has occurred <%= pluralize(@notice.problem.notices_count, "time") %>.
+              </p>
+
+              <p>
+                <%= link_to("Click here to view the error on Errbit", app_problem_url(@app, @notice.problem), class: "bold") << "." %>
+              </p>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </td>
+</tr>
+
+<tr>
+  <td class="section">
+    <table cellpadding="0" cellspacing="0" border="0" align="left">
+      <tbody>
+        <tr>
+          <td class="content" valign="top">
+            <div>
+              <p class="heading">ERROR MESSAGE:</p>
+
+              <p><%= @notice.message %></p>
+
+              <p class="heading">WHERE:</p>
+
+              <p class="monospace">
+                <%= @notice.where %>
+              </p>
+
+              <% @notice.backtrace.lines.each do |line| %>
+                <% next unless line.in_app? %>
+
+                <p class="backtrace">
+                  <%= line.link_to_source_file(@app) do %>
+                    <%= line %>
+                  <% end %>
+                </p>
+              <% end %>
+
+              <br>
+
+              <% if @notice.app_version.present? %>
+                <p class="heading">APP VERSION:</p>
+
+                <p class="monospace">
+                  <%= @notice.app_version %>
+                </p>
+
+                <br>
+              <% end %>
+
+              <br>
+
+              <% if @notice.server_environment.present? && @notice.server_environment["hostname"].present? %>
+                <p class="heading">APP SERVER:</p>
+
+                <p class="monospace">
+                  <%= @notice.server_environment["hostname"] %>
+                </p>
+
+                <br>
+              <% end %>
+
+              <p class="heading">URL:</p>
+
+              <p class="monospace">
+                <% if @notice.request["url"].present? %>
+                  <%= link_to @notice.request["url"], @notice.request["url"] %>
+                <% end %>
+              </p>
+
+              <p class="heading">BROWSER:</p>
+
+              <p class="monospace">
+                <%= user_agent_graph(@notice.problem) %>
+              </p>
+
+              <br>
+
+              <% if @notice.user_attributes.present? %>
+                <p class="heading">USER:</p>
+
+                <table>
+                  <% @notice.user_attributes.each do |key, value| %>
+                    <tr>
+                      <td style="text-align: right; padding-right: 10px; color: #6a6a6a;"><%= key.to_s.titleize + ":" %></td>
+
+                      <td><%= auto_link(value.to_s) %></td>
+                    </tr>
+                  <% end %>
+                </table>
+
+                <br>
+              <% end %>
+
+              <% if @notice.backtrace.lines.any? %>
+                <br>
+
+                <p class="heading">FULL BACKTRACE:</p>
+
+                <% @notice.backtrace.lines.each do |line| %>
+                  <p class="backtrace">
+                    <%= line.link_to_source_file(@app) do %>
+                      <%= line %>
+                    <% end %>
+                  </p>
+                <% end %>
+
+                <br>
+              <% end %>
+            </div>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </td>
+</tr>
diff --git a/app/views/errbit/mailer/err_notification.text.erb b/app/views/errbit/mailer/err_notification.text.erb
new file mode 100644
index 0000000000..6dae3094b9
--- /dev/null
+++ b/app/views/errbit/mailer/err_notification.text.erb
@@ -0,0 +1,57 @@
+An error has just occurred in <%= @notice.environment_name %>: <%= raw(@notice.message) %>
+
+This error has occurred <%= pluralize @notice.problem.notices_count, 'time' %>. You should really look into it here:
+
+  <%= app_problem_url(@app, @notice.problem) %>
+
+
+ERROR MESSAGE:
+
+<%= raw(@notice.message) %>
+
+
+WHERE:
+
+<%= @notice.where %>
+
+<% @notice.backtrace.lines.each do |line| %>
+  <% next unless line.in_app? %>
+  <%= line %>
+<% end %>
+
+<%- if @notice.app_version.present? %>
+APP VERSION:
+
+<%= @notice.app_version %>
+<%- end %>
+
+<%- if @notice.server_environment.present? && @notice.server_environment["hostname"].present? %>
+APP SERVER:
+
+<%= @notice.server_environment["hostname"] %>
+<%- end %>
+
+URL:
+
+<%= @notice.request["url"] %>
+
+
+BROWSER:
+
+<%= @notice.user_agent_string %>
+
+
+<%- if @notice.user_attributes.present? %>
+USER:
+
+<%- @notice.user_attributes.each do |key, value| %>
+<%= key.to_s.titleize %>: <%= value.to_s %>
+<%- end %>
+
+<%- end %>
+
+BACKTRACE:
+
+<% @notice.backtrace.lines.each do |line| %>
+  <%= line %>
+<% end %>
diff --git a/app/views/problems/_table.html.erb b/app/views/problems/_table.html.erb
index 7950a99509..cca53722da 100644
--- a/app/views/problems/_table.html.erb
+++ b/app/views/problems/_table.html.erb
@@ -25,7 +25,7 @@
     </thead>
 
     <tbody>
-      <% ProblemDecorator.decorate_collection(problems).each do |problem| %>
+      <% Errbit::ProblemDecorator.decorate_collection(problems).each do |problem| %>
         <tr class="<%= problem.resolved? ? "resolved" : "unresolved" %>">
           <td class="select narrow-as-possible">
             <div class="td-container">
diff --git a/app/views/problems/index.html.erb b/app/views/problems/index.html.erb
index 2e9782b9ca..2c4a0cc1c1 100644
--- a/app/views/problems/index.html.erb
+++ b/app/views/problems/index.html.erb
@@ -1,7 +1,7 @@
 <% content_for :title, (all_errs ? t(".all_errors") : t(".unresolved_errors")) %>
 
 <% content_for :head do %>
-  <%= auto_discovery_link_tag :atom, problems_path(User.token_authentication_key => current_user.authentication_token, format: :atom), title: "Errbit notices at #{request.host}" %>
+  <%= auto_discovery_link_tag :atom, problems_path(Errbit::User.token_authentication_key => current_user.authentication_token, format: :atom), title: "Errbit notices at #{request.host}" %>
 <% end %>
 
 <% content_for :action_bar do %>
diff --git a/app/views/problems/show.ics.erb b/app/views/problems/show.ics.erb
index b2098056bf..cc41ee3ad1 100644
--- a/app/views/problems/show.ics.erb
+++ b/app/views/problems/show.ics.erb
@@ -1 +1 @@
-<%= generate_problem_ical(problem.notices.object.order_by(:created_at.asc)) %>
+<%= generate_problem_ical(problem.notices.object.reorder(created_at: :asc)) %>
diff --git a/config/application.rb b/config/application.rb
index 88998b3636..3d4c72a9b4 100644
--- a/config/application.rb
+++ b/config/application.rb
@@ -6,7 +6,7 @@
 # Pick the frameworks you want:
 require "active_model/railtie"
 require "active_job/railtie"
-# require "active_record/railtie"
+require "active_record/railtie"
 # require "active_storage/engine"
 require "action_controller/railtie"
 require "action_mailer/railtie"
diff --git a/config/database.yml b/config/database.yml
new file mode 100644
index 0000000000..5ef7c10f44
--- /dev/null
+++ b/config/database.yml
@@ -0,0 +1,16 @@
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: storage/development.sqlite3
+
+test:
+  <<: *default
+  database: storage/test.sqlite3
+
+production:
+  <<: *default
+  database: storage/production.sqlite3
diff --git a/config/initializers/devise.rb b/config/initializers/devise.rb
index 1ed024ca2d..16db436d86 100644
--- a/config/initializers/devise.rb
+++ b/config/initializers/devise.rb
@@ -36,7 +36,7 @@
   # Load and configure the ORM. Supports :active_record (default) and
   # :mongoid (bson_ext recommended) by default. Other ORMs may be
   # available as additional gems.
-  require "devise/orm/mongoid"
+  require "devise/orm/active_record"
 
   # ==> Configuration for any authentication mechanism
   # Configure which keys are used when authenticating a user. The default is
diff --git a/config/routes.rb b/config/routes.rb
index 3a93f604c2..1c683f053d 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -5,7 +5,7 @@
   # Can be used by load balancers and uptime monitors to verify that the app is live.
   get "up" => "rails/health#show", :as => :rails_health_check
 
-  devise_for :users, controllers: {omniauth_callbacks: "users/omniauth_callbacks"}
+  devise_for :users, class_name: "Errbit::User", controllers: {omniauth_callbacks: "users/omniauth_callbacks"}
 
   # Hoptoad Notifier Routes
   match "/notifier_api/v2/notices" => "notices#create", :via => [:get, :post]
diff --git a/db/migrate/20260513192604_create_errbit_users.rb b/db/migrate/20260513192604_create_errbit_users.rb
new file mode 100644
index 0000000000..4d53de3add
--- /dev/null
+++ b/db/migrate/20260513192604_create_errbit_users.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class CreateErrbitUsers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_users do |t|
+      t.string :bson_id
+
+      ## Database authenticatable
+      t.string :email, null: false, default: ""
+      t.string :encrypted_password, null: false, default: ""
+
+      ## Recoverable
+      t.string :reset_password_token
+      t.datetime :reset_password_sent_at
+
+      ## Rememberable
+      t.datetime :remember_created_at
+
+      ## Trackable
+      t.integer :sign_in_count, default: 0, null: false
+      t.datetime :current_sign_in_at
+      t.datetime :last_sign_in_at
+      t.string :current_sign_in_ip
+      t.string :last_sign_in_ip
+
+      ## Token authenticatable
+      t.string :authentication_token
+
+      t.string :name
+      t.string :username
+      t.boolean :admin, null: false, default: false
+      t.integer :per_page, default: 30
+      t.string :time_zone, default: "UTC"
+
+      t.string :github_login
+      t.string :github_oauth_token
+      t.string :google_uid
+
+      t.timestamps
+    end
+
+    add_index :errbit_users, :bson_id, unique: true
+    add_index :errbit_users, :email, unique: true
+    add_index :errbit_users, :reset_password_token, unique: true
+    add_index :errbit_users, :github_login, unique: true
+    add_index :errbit_users, :authentication_token, unique: true
+  end
+end
diff --git a/db/migrate/20260513204143_create_errbit_apps.rb b/db/migrate/20260513204143_create_errbit_apps.rb
new file mode 100644
index 0000000000..67cbfd56dd
--- /dev/null
+++ b/db/migrate/20260513204143_create_errbit_apps.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CreateErrbitApps < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_apps do |t|
+      t.string :bson_id
+
+      t.string :name
+      t.string :api_key
+      t.string :github_repo
+      t.string :bitbucket_repo
+      t.string :custom_backtrace_url_template
+      t.string :asset_host
+      t.string :repository_branch
+      t.string :current_app_version
+      t.boolean :notify_all_users, null: false, default: false
+      t.boolean :notify_on_errs, null: false, default: true
+      t.text :email_at_notices
+
+      t.timestamps
+    end
+
+    add_index :errbit_apps, :bson_id, unique: true
+    add_index :errbit_apps, :name, unique: true
+    add_index :errbit_apps, :api_key, unique: true
+  end
+end
diff --git a/db/migrate/20260513204638_create_errbit_watchers.rb b/db/migrate/20260513204638_create_errbit_watchers.rb
new file mode 100644
index 0000000000..5a9f314bcf
--- /dev/null
+++ b/db/migrate/20260513204638_create_errbit_watchers.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateErrbitWatchers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_watchers do |t|
+      t.string :bson_id
+      t.references :errbit_app, null: false, foreign_key: true
+      t.references :errbit_user, foreign_key: true
+      t.string :email
+
+      t.timestamps
+    end
+
+    add_index :errbit_watchers, :bson_id, unique: true
+  end
+end
diff --git a/db/migrate/20260513210330_create_errbit_site_configs.rb b/db/migrate/20260513210330_create_errbit_site_configs.rb
new file mode 100644
index 0000000000..de6b6da8a7
--- /dev/null
+++ b/db/migrate/20260513210330_create_errbit_site_configs.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateErrbitSiteConfigs < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_site_configs do |t|
+      t.string :bson_id
+
+      t.boolean :error_class, null: false, default: true
+      t.boolean :message, null: false, default: true
+      t.integer :backtrace_lines, default: -1
+      t.boolean :component, null: false, default: true
+      t.boolean :action, null: false, default: true
+      t.boolean :environment_name, null: false, default: true
+
+      t.timestamps
+    end
+
+    add_index :errbit_site_configs, :bson_id, unique: true
+  end
+end
diff --git a/db/migrate/20260513213042_create_errbit_backtraces.rb b/db/migrate/20260513213042_create_errbit_backtraces.rb
new file mode 100644
index 0000000000..3b796d60cc
--- /dev/null
+++ b/db/migrate/20260513213042_create_errbit_backtraces.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateErrbitBacktraces < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_backtraces do |t|
+      t.string :bson_id
+      t.string :fingerprint
+      t.json :lines
+
+      t.timestamps
+    end
+
+    add_index :errbit_backtraces, :bson_id, unique: true
+    add_index :errbit_backtraces, :fingerprint, unique: true
+  end
+end
diff --git a/db/migrate/20260513213546_create_errbit_problems.rb b/db/migrate/20260513213546_create_errbit_problems.rb
new file mode 100644
index 0000000000..a0c9a2cc63
--- /dev/null
+++ b/db/migrate/20260513213546_create_errbit_problems.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class CreateErrbitProblems < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_problems do |t|
+      t.string :bson_id
+      t.references :errbit_app, null: false, foreign_key: true
+
+      t.datetime :first_notice_at
+      t.datetime :last_notice_at
+      t.boolean :resolved, null: false, default: false
+      t.datetime :resolved_at
+      t.string :issue_link
+      t.string :issue_type
+
+      t.string :app_name
+      t.integer :notices_count, null: false, default: 0
+      t.integer :comments_count, null: false, default: 0
+      t.string :message
+      t.string :environment
+      t.string :error_class
+      t.string :where
+
+      t.json :user_agents
+      t.json :messages
+      t.json :hosts
+
+      t.timestamps
+    end
+
+    add_index :errbit_problems, :bson_id, unique: true
+    add_index :errbit_problems, :app_name
+    add_index :errbit_problems, :message
+    add_index :errbit_problems, :first_notice_at
+    add_index :errbit_problems, :last_notice_at
+    add_index :errbit_problems, :resolved_at
+    add_index :errbit_problems, :notices_count
+  end
+end
diff --git a/db/migrate/20260513214424_create_errbit_errs.rb b/db/migrate/20260513214424_create_errbit_errs.rb
new file mode 100644
index 0000000000..b196f9440e
--- /dev/null
+++ b/db/migrate/20260513214424_create_errbit_errs.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateErrbitErrs < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_errs do |t|
+      t.string :bson_id
+      t.references :errbit_problem, null: false, foreign_key: true
+      t.string :fingerprint
+
+      t.timestamps
+    end
+
+    add_index :errbit_errs, :bson_id, unique: true
+    add_index :errbit_errs, :fingerprint
+  end
+end
diff --git a/db/migrate/20260513225736_create_errbit_notices.rb b/db/migrate/20260513225736_create_errbit_notices.rb
new file mode 100644
index 0000000000..698c017d34
--- /dev/null
+++ b/db/migrate/20260513225736_create_errbit_notices.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CreateErrbitNotices < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_notices do |t|
+      t.string :bson_id
+      t.references :errbit_app, null: false, foreign_key: true
+      t.references :errbit_err, null: false, foreign_key: true
+      t.references :errbit_backtrace, null: false, foreign_key: true
+
+      t.text :message
+      t.string :framework
+      t.string :error_class
+
+      t.json :server_environment
+      t.json :request
+      t.json :notifier
+      t.json :user_attributes
+
+      t.timestamps
+    end
+
+    add_index :errbit_notices, :bson_id, unique: true
+    add_index :errbit_notices, :created_at
+    add_index :errbit_notices, [:errbit_err_id, :created_at, :id], name: "index_errbit_notices_on_err_created_id"
+  end
+end
diff --git a/db/migrate/20260513232131_create_errbit_comments.rb b/db/migrate/20260513232131_create_errbit_comments.rb
new file mode 100644
index 0000000000..5257dfa2f6
--- /dev/null
+++ b/db/migrate/20260513232131_create_errbit_comments.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateErrbitComments < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_comments do |t|
+      t.string :bson_id
+      t.references :errbit_problem, null: false, foreign_key: true
+      t.references :errbit_user, null: false, foreign_key: true
+      t.text :body
+
+      t.timestamps
+    end
+
+    add_index :errbit_comments, :bson_id, unique: true
+  end
+end
diff --git a/db/migrate/20260515081228_create_errbit_notice_fingerprinters.rb b/db/migrate/20260515081228_create_errbit_notice_fingerprinters.rb
new file mode 100644
index 0000000000..d5947807ba
--- /dev/null
+++ b/db/migrate/20260515081228_create_errbit_notice_fingerprinters.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateErrbitNoticeFingerprinters < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_notice_fingerprinters do |t|
+      t.string :bson_id
+      t.references :errbit_app, foreign_key: true, index: {unique: true}
+
+      t.boolean :error_class, null: false, default: true
+      t.boolean :message, null: false, default: true
+      t.integer :backtrace_lines, null: false, default: -1
+      t.boolean :component, null: false, default: true
+      t.boolean :action, null: false, default: true
+      t.boolean :environment_name, null: false, default: true
+      t.string :source
+
+      t.timestamps
+    end
+
+    add_index :errbit_notice_fingerprinters, :bson_id, unique: true
+  end
+end
diff --git a/db/migrate/20260515082430_create_errbit_issue_trackers.rb b/db/migrate/20260515082430_create_errbit_issue_trackers.rb
new file mode 100644
index 0000000000..fd2a5ddffb
--- /dev/null
+++ b/db/migrate/20260515082430_create_errbit_issue_trackers.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateErrbitIssueTrackers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_issue_trackers do |t|
+      t.string :bson_id
+      t.references :errbit_app, foreign_key: true, index: {unique: true}
+
+      t.string :type_tracker
+      t.json :options
+
+      t.timestamps
+    end
+
+    add_index :errbit_issue_trackers, :bson_id, unique: true
+  end
+end
diff --git a/db/migrate/20260515082431_create_errbit_notification_services.rb b/db/migrate/20260515082431_create_errbit_notification_services.rb
new file mode 100644
index 0000000000..30a2937db7
--- /dev/null
+++ b/db/migrate/20260515082431_create_errbit_notification_services.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class CreateErrbitNotificationServices < ActiveRecord::Migration[8.1]
+  def change
+    create_table :errbit_notification_services do |t|
+      t.string :bson_id
+      t.references :errbit_app, foreign_key: true, index: {unique: true}
+
+      t.string :type
+      t.string :room_id
+      t.string :mentions
+      t.string :user_id
+      t.string :service_url
+      t.string :service
+      t.string :api_token
+      t.string :subdomain
+      t.string :sender_name
+      t.text :notify_at_notices
+
+      t.timestamps
+    end
+
+    add_index :errbit_notification_services, :bson_id, unique: true
+    add_index :errbit_notification_services, :type
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
new file mode 100644
index 0000000000..05504dfd57
--- /dev/null
+++ b/db/schema.rb
@@ -0,0 +1,234 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.1].define(version: 2026_05_15_082431) do
+  create_table "errbit_apps", force: :cascade do |t|
+    t.string "api_key"
+    t.string "asset_host"
+    t.string "bitbucket_repo"
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.string "current_app_version"
+    t.string "custom_backtrace_url_template"
+    t.text "email_at_notices"
+    t.string "github_repo"
+    t.string "name"
+    t.boolean "notify_all_users", default: false, null: false
+    t.boolean "notify_on_errs", default: true, null: false
+    t.string "repository_branch"
+    t.datetime "updated_at", null: false
+    t.index ["api_key"], name: "index_errbit_apps_on_api_key", unique: true
+    t.index ["bson_id"], name: "index_errbit_apps_on_bson_id", unique: true
+    t.index ["name"], name: "index_errbit_apps_on_name", unique: true
+  end
+
+  create_table "errbit_backtraces", force: :cascade do |t|
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.string "fingerprint"
+    t.json "lines"
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_backtraces_on_bson_id", unique: true
+    t.index ["fingerprint"], name: "index_errbit_backtraces_on_fingerprint", unique: true
+  end
+
+  create_table "errbit_comments", force: :cascade do |t|
+    t.text "body"
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.integer "errbit_problem_id", null: false
+    t.integer "errbit_user_id", null: false
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_comments_on_bson_id", unique: true
+    t.index ["errbit_problem_id"], name: "index_errbit_comments_on_errbit_problem_id"
+    t.index ["errbit_user_id"], name: "index_errbit_comments_on_errbit_user_id"
+  end
+
+  create_table "errbit_errs", force: :cascade do |t|
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.integer "errbit_problem_id", null: false
+    t.string "fingerprint"
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_errs_on_bson_id", unique: true
+    t.index ["errbit_problem_id"], name: "index_errbit_errs_on_errbit_problem_id"
+    t.index ["fingerprint"], name: "index_errbit_errs_on_fingerprint"
+  end
+
+  create_table "errbit_issue_trackers", force: :cascade do |t|
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.integer "errbit_app_id"
+    t.json "options"
+    t.string "type_tracker"
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_issue_trackers_on_bson_id", unique: true
+    t.index ["errbit_app_id"], name: "index_errbit_issue_trackers_on_errbit_app_id", unique: true
+  end
+
+  create_table "errbit_notice_fingerprinters", force: :cascade do |t|
+    t.boolean "action", default: true, null: false
+    t.integer "backtrace_lines", default: -1, null: false
+    t.string "bson_id"
+    t.boolean "component", default: true, null: false
+    t.datetime "created_at", null: false
+    t.boolean "environment_name", default: true, null: false
+    t.integer "errbit_app_id"
+    t.boolean "error_class", default: true, null: false
+    t.boolean "message", default: true, null: false
+    t.string "source"
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_notice_fingerprinters_on_bson_id", unique: true
+    t.index ["errbit_app_id"], name: "index_errbit_notice_fingerprinters_on_errbit_app_id", unique: true
+  end
+
+  create_table "errbit_notices", force: :cascade do |t|
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.integer "errbit_app_id", null: false
+    t.integer "errbit_backtrace_id", null: false
+    t.integer "errbit_err_id", null: false
+    t.string "error_class"
+    t.string "framework"
+    t.text "message"
+    t.json "notifier"
+    t.json "request"
+    t.json "server_environment"
+    t.datetime "updated_at", null: false
+    t.json "user_attributes"
+    t.index ["bson_id"], name: "index_errbit_notices_on_bson_id", unique: true
+    t.index ["created_at"], name: "index_errbit_notices_on_created_at"
+    t.index ["errbit_app_id"], name: "index_errbit_notices_on_errbit_app_id"
+    t.index ["errbit_backtrace_id"], name: "index_errbit_notices_on_errbit_backtrace_id"
+    t.index ["errbit_err_id", "created_at", "id"], name: "index_errbit_notices_on_err_created_id"
+    t.index ["errbit_err_id"], name: "index_errbit_notices_on_errbit_err_id"
+  end
+
+  create_table "errbit_notification_services", force: :cascade do |t|
+    t.string "api_token"
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.integer "errbit_app_id"
+    t.string "mentions"
+    t.text "notify_at_notices"
+    t.string "room_id"
+    t.string "sender_name"
+    t.string "service"
+    t.string "service_url"
+    t.string "subdomain"
+    t.string "type"
+    t.datetime "updated_at", null: false
+    t.string "user_id"
+    t.index ["bson_id"], name: "index_errbit_notification_services_on_bson_id", unique: true
+    t.index ["errbit_app_id"], name: "index_errbit_notification_services_on_errbit_app_id", unique: true
+    t.index ["type"], name: "index_errbit_notification_services_on_type"
+  end
+
+  create_table "errbit_problems", force: :cascade do |t|
+    t.string "app_name"
+    t.string "bson_id"
+    t.integer "comments_count", default: 0, null: false
+    t.datetime "created_at", null: false
+    t.string "environment"
+    t.integer "errbit_app_id", null: false
+    t.string "error_class"
+    t.datetime "first_notice_at"
+    t.json "hosts"
+    t.string "issue_link"
+    t.string "issue_type"
+    t.datetime "last_notice_at"
+    t.string "message"
+    t.json "messages"
+    t.integer "notices_count", default: 0, null: false
+    t.boolean "resolved", default: false, null: false
+    t.datetime "resolved_at"
+    t.datetime "updated_at", null: false
+    t.json "user_agents"
+    t.string "where"
+    t.index ["app_name"], name: "index_errbit_problems_on_app_name"
+    t.index ["bson_id"], name: "index_errbit_problems_on_bson_id", unique: true
+    t.index ["errbit_app_id"], name: "index_errbit_problems_on_errbit_app_id"
+    t.index ["first_notice_at"], name: "index_errbit_problems_on_first_notice_at"
+    t.index ["last_notice_at"], name: "index_errbit_problems_on_last_notice_at"
+    t.index ["message"], name: "index_errbit_problems_on_message"
+    t.index ["notices_count"], name: "index_errbit_problems_on_notices_count"
+    t.index ["resolved_at"], name: "index_errbit_problems_on_resolved_at"
+  end
+
+  create_table "errbit_site_configs", force: :cascade do |t|
+    t.boolean "action", default: true, null: false
+    t.integer "backtrace_lines", default: -1
+    t.string "bson_id"
+    t.boolean "component", default: true, null: false
+    t.datetime "created_at", null: false
+    t.boolean "environment_name", default: true, null: false
+    t.boolean "error_class", default: true, null: false
+    t.boolean "message", default: true, null: false
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_site_configs_on_bson_id", unique: true
+  end
+
+  create_table "errbit_users", force: :cascade do |t|
+    t.boolean "admin", default: false, null: false
+    t.string "authentication_token"
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.datetime "current_sign_in_at"
+    t.string "current_sign_in_ip"
+    t.string "email", default: "", null: false
+    t.string "encrypted_password", default: "", null: false
+    t.string "github_login"
+    t.string "github_oauth_token"
+    t.string "google_uid"
+    t.datetime "last_sign_in_at"
+    t.string "last_sign_in_ip"
+    t.string "name"
+    t.integer "per_page", default: 30
+    t.datetime "remember_created_at"
+    t.datetime "reset_password_sent_at"
+    t.string "reset_password_token"
+    t.integer "sign_in_count", default: 0, null: false
+    t.string "time_zone", default: "UTC"
+    t.datetime "updated_at", null: false
+    t.string "username"
+    t.index ["authentication_token"], name: "index_errbit_users_on_authentication_token", unique: true
+    t.index ["bson_id"], name: "index_errbit_users_on_bson_id", unique: true
+    t.index ["email"], name: "index_errbit_users_on_email", unique: true
+    t.index ["github_login"], name: "index_errbit_users_on_github_login", unique: true
+    t.index ["reset_password_token"], name: "index_errbit_users_on_reset_password_token", unique: true
+  end
+
+  create_table "errbit_watchers", force: :cascade do |t|
+    t.string "bson_id"
+    t.datetime "created_at", null: false
+    t.string "email"
+    t.integer "errbit_app_id", null: false
+    t.integer "errbit_user_id"
+    t.datetime "updated_at", null: false
+    t.index ["bson_id"], name: "index_errbit_watchers_on_bson_id", unique: true
+    t.index ["errbit_app_id"], name: "index_errbit_watchers_on_errbit_app_id"
+    t.index ["errbit_user_id"], name: "index_errbit_watchers_on_errbit_user_id"
+  end
+
+  add_foreign_key "errbit_comments", "errbit_problems"
+  add_foreign_key "errbit_comments", "errbit_users"
+  add_foreign_key "errbit_errs", "errbit_problems"
+  add_foreign_key "errbit_issue_trackers", "errbit_apps"
+  add_foreign_key "errbit_notice_fingerprinters", "errbit_apps"
+  add_foreign_key "errbit_notices", "errbit_apps"
+  add_foreign_key "errbit_notices", "errbit_backtraces"
+  add_foreign_key "errbit_notices", "errbit_errs"
+  add_foreign_key "errbit_notification_services", "errbit_apps"
+  add_foreign_key "errbit_problems", "errbit_apps"
+  add_foreign_key "errbit_watchers", "errbit_apps"
+  add_foreign_key "errbit_watchers", "errbit_users"
+end
diff --git a/db/seeds.rb b/db/seeds.rb
index fbf62bf130..5cc35dae75 100644
--- a/db/seeds.rb
+++ b/db/seeds.rb
@@ -33,7 +33,7 @@ def heroku_pr_review_app?
 puts "Be sure to note down these credentials now!"
 puts "\nNOTE: DEMO instance, not for production use!" if heroku_pr_review_app?
 
-user = User.find_or_initialize_by(email: admin_email)
+user = Errbit::User.find_or_initialize_by(email: admin_email)
 
 user.name = "Errbit Admin"
 user.password = admin_pass
diff --git a/lib/tasks/errbit/bootstrap.rake b/lib/tasks/errbit/bootstrap.rake
index b7ed3b2c21..de07a20152 100644
--- a/lib/tasks/errbit/bootstrap.rake
+++ b/lib/tasks/errbit/bootstrap.rake
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 namespace :errbit do
-  desc "Seed and index the DB"
-  task bootstrap: ["db:seed", "db:mongoid:create_indexes"]
+  desc "Migrate the SQL schema and seed the DB"
+  task bootstrap: ["db:migrate", "db:seed"]
 end
diff --git a/lib/tasks/errbit/database.rake b/lib/tasks/errbit/database.rake
index 04bcd6c425..5e03ce1630 100644
--- a/lib/tasks/errbit/database.rake
+++ b/lib/tasks/errbit/database.rake
@@ -3,18 +3,18 @@
 namespace :errbit do
   desc "Updates cached attributes on Problem"
   task problem_recache: :environment do
-    ProblemRecacher.run
+    Errbit::ProblemRecacher.run
   end
 
   desc "Delete resolved errors from the database. (Useful for limited heroku databases)"
   task clear_resolved: :environment do
-    puts "=== Cleared #{ResolvedProblemClearer.new.execute} resolved errors from the database."
+    puts "=== Cleared #{Errbit::ResolvedProblemClearer.new.execute} resolved errors from the database."
   end
 
   desc "Delete old errors from the database. (Useful for limited heroku databases)"
   task clear_outdated: :environment do
     if Errbit::Config.notice_deprecation_days.present?
-      puts "=== Cleared #{OutdatedProblemClearer.new.execute} outdated errors from the database."
+      puts "=== Cleared #{Errbit::OutdatedProblemClearer.new.execute} outdated errors from the database."
     else
       puts "=== ERRBIT_PROBLEM_DESTROY_AFTER_DAYS not set. Old problems will not be destroyed."
     end
@@ -22,20 +22,20 @@ namespace :errbit do
 
   desc "Regenerate fingerprints"
   task notice_refingerprint: :environment do
-    NoticeRefingerprinter.run
-    ProblemRecacher.run
+    Errbit::NoticeRefingerprinter.run
+    Errbit::ProblemRecacher.run
   end
 
   desc "Remove notices in batch"
-  task :notices_delete, [:problem_id] => [:environment] do
+  task :notices_delete, [:problem_id] => [:environment] do |_task, args|
     BATCH_SIZE = 1000
     if args[:problem_id]
-      item_count = Problem.find(args[:problem_id]).notices.count
+      item_count = Errbit::Problem.find(args[:problem_id]).notices.count
       removed_count = 0
       puts "Notices to remove: #{item_count}"
       while item_count > 0
-        Problem.find(args[:problem_id]).notices.limit(BATCH_SIZE).each do |notice|
-          notice.remove
+        Errbit::Problem.find(args[:problem_id]).notices.limit(BATCH_SIZE).each do |notice|
+          notice.destroy
           removed_count += 1
         end
         item_count -= BATCH_SIZE
diff --git a/lib/tasks/errbit/demo.rake b/lib/tasks/errbit/demo.rake
index d7f033a50e..47132ff1b6 100644
--- a/lib/tasks/errbit/demo.rake
+++ b/lib/tasks/errbit/demo.rake
@@ -5,7 +5,7 @@ namespace :errbit do
   task demo: :environment do
     require "factory_bot_rails"
 
-    app = FactoryBot.create(:app, name: "Demo App #{Time.zone.now.strftime("%N")}")
+    app = FactoryBot.create(:errbit_app, name: "Demo App #{Time.zone.now.strftime("%N")}")
 
     # Report a number of errors for the application
     app.problems.delete_all
@@ -46,7 +46,7 @@ namespace :errbit do
 
     errors.each do |error_template|
       rand(34).times do
-        ErrorReport.new(
+        Errbit::ErrorReport.new(
           error_template.reverse_merge(
             api_key: app.api_key,
             error_class: "StandardError",
@@ -70,9 +70,9 @@ namespace :errbit do
       end
     end
 
-    problem = FactoryBot.create(:problem, app: app)
-    err = FactoryBot.create(:err, problem: problem)
-    FactoryBot.create(:notice, err: err)
+    problem = FactoryBot.create(:errbit_problem, app: app)
+    err = FactoryBot.create(:errbit_err, problem: problem)
+    FactoryBot.create(:errbit_notice, err: err)
 
     puts "=== Created demo app: '#{app.name}', with example errors."
   end
diff --git a/lib/tasks/errbit/migrate.rake b/lib/tasks/errbit/migrate.rake
new file mode 100644
index 0000000000..25efd32d75
--- /dev/null
+++ b/lib/tasks/errbit/migrate.rake
@@ -0,0 +1,519 @@
+# frozen_string_literal: true
+
+# Rake tasks for porting MongoDB-backed Errbit data into the new SQL-backed
+# Errbit::* models. Each task is idempotent — records are linked back to their
+# Mongo origin via the `bson_id` string column, so re-running updates instead
+# of duplicating.
+
+namespace :errbit do
+  namespace :migrate do
+    # ------------------------------------------------------------------
+    # Helpers shared by all tasks below
+    # ------------------------------------------------------------------
+    module Helpers
+      module_function
+
+      def ar_id_for(klass, mongo_id)
+        return nil if mongo_id.blank?
+
+        klass.where(bson_id: mongo_id.to_s).pick(:id)
+      end
+
+      def with_preserved_timestamps(klass)
+        klass.record_timestamps = false
+        yield
+      ensure
+        klass.record_timestamps = true
+      end
+
+      def assign_and_save!(record, attrs, stats)
+        existed = record.persisted?
+        # Coerce nil timestamps to now — some Mongoid embedded docs (e.g.
+        # auto-built fingerprinters) never get created_at/updated_at set, and
+        # the SQL columns are NOT NULL.
+        attrs[:created_at] ||= Time.current if attrs.key?(:created_at)
+        attrs[:updated_at] ||= attrs[:created_at] || Time.current if attrs.key?(:updated_at)
+        record.assign_attributes(attrs)
+
+        if record.save(validate: false)
+          existed ? stats[:updated] += 1 : stats[:created] += 1
+        else
+          stats[:failed] += 1
+          warn "  failed bson_id=#{record.bson_id}: #{record.errors.full_messages.join(", ")}"
+        end
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::NotNullViolation => e
+        stats[:failed] += 1
+        warn "  failed bson_id=#{record.bson_id}: #{e.message}"
+      end
+
+      def print_summary(label, stats)
+        puts "=== Migrated #{label}: #{stats[:created]} created, #{stats[:updated]} updated, #{stats[:failed]} failed."
+      end
+    end
+
+    # ------------------------------------------------------------------
+    # Users
+    # ------------------------------------------------------------------
+    desc "Migrate users from MongoDB to Errbit::User (SQL). Idempotent — re-runs update by bson_id."
+    task users: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::User.transaction do
+        Helpers.with_preserved_timestamps(Errbit::User) do
+          ::User.all.each do |mongo|
+            ar = Errbit::User.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              email: mongo.email.to_s,
+              encrypted_password: mongo.encrypted_password.to_s,
+              reset_password_token: mongo.reset_password_token,
+              reset_password_sent_at: mongo.reset_password_sent_at,
+              remember_created_at: mongo.remember_created_at,
+              sign_in_count: mongo.sign_in_count || 0,
+              current_sign_in_at: mongo.current_sign_in_at,
+              last_sign_in_at: mongo.last_sign_in_at,
+              current_sign_in_ip: mongo.current_sign_in_ip,
+              last_sign_in_ip: mongo.last_sign_in_ip,
+              authentication_token: mongo.authentication_token,
+              name: mongo.name,
+              username: mongo.try(:username),
+              admin: mongo.admin || false,
+              per_page: mongo.per_page || Errbit::User::PER_PAGE,
+              time_zone: mongo.time_zone || "UTC",
+              github_login: mongo.github_login,
+              github_oauth_token: mongo.github_oauth_token,
+              google_uid: mongo.google_uid,
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("users", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # SiteConfig (singleton)
+    # ------------------------------------------------------------------
+    desc "Migrate SiteConfig from MongoDB to Errbit::SiteConfig (SQL)."
+    task site_configs: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::SiteConfig.transaction do
+        Helpers.with_preserved_timestamps(Errbit::SiteConfig) do
+          ::SiteConfig.all.each do |mongo|
+            ar = Errbit::SiteConfig.find_or_initialize_by(bson_id: mongo._id.to_s)
+            fp = mongo.notice_fingerprinter
+
+            Helpers.assign_and_save!(ar, {
+              error_class: fp&.error_class.nil? ? true : fp.error_class,
+              message: fp&.message.nil? ? true : fp.message,
+              backtrace_lines: fp&.backtrace_lines || -1,
+              component: fp&.component.nil? ? true : fp.component,
+              action: fp&.action.nil? ? true : fp.action,
+              environment_name: fp&.environment_name.nil? ? true : fp.environment_name,
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("site_configs", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Apps
+    # ------------------------------------------------------------------
+    desc "Migrate Apps from MongoDB to Errbit::App (SQL)."
+    task apps: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::App.transaction do
+        Helpers.with_preserved_timestamps(Errbit::App) do
+          ::App.all.each do |mongo|
+            ar = Errbit::App.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              name: mongo.name,
+              api_key: mongo.api_key,
+              github_repo: mongo.github_repo,
+              bitbucket_repo: mongo.bitbucket_repo,
+              custom_backtrace_url_template: mongo.try(:custom_backtrace_url_template),
+              asset_host: mongo.asset_host,
+              repository_branch: mongo.repository_branch,
+              current_app_version: mongo.current_app_version,
+              notify_all_users: mongo.notify_all_users || false,
+              notify_on_errs: mongo.notify_on_errs.nil? ? true : mongo.notify_on_errs,
+              # Read via attributes hash to bypass the App#email_at_notices
+              # getter override which masks the stored value behind the global
+              # Errbit::Config.email_at_notices when per_app_email_at_notices
+              # is off.
+              email_at_notices: mongo.attributes["email_at_notices"] || [],
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("apps", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Watchers (embedded in App)
+    # ------------------------------------------------------------------
+    desc "Migrate embedded App watchers to Errbit::Watcher (SQL). Run after :users and :apps."
+    task watchers: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Watcher.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Watcher) do
+          ::App.all.each do |mongo_app|
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo_app._id)
+            next unless errbit_app_id
+
+            mongo_app.watchers.each do |mongo_watcher|
+              ar = Errbit::Watcher.find_or_initialize_by(bson_id: mongo_watcher._id.to_s)
+
+              Helpers.assign_and_save!(ar, {
+                errbit_app_id: errbit_app_id,
+                errbit_user_id: Helpers.ar_id_for(Errbit::User, mongo_watcher.user_id),
+                email: mongo_watcher.email,
+                created_at: mongo_watcher.try(:created_at),
+                updated_at: mongo_watcher.try(:updated_at)
+              }, stats)
+            end
+          end
+        end
+      end
+
+      Helpers.print_summary("watchers", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # IssueTrackers (embedded in App)
+    # ------------------------------------------------------------------
+    desc "Migrate embedded App issue trackers to Errbit::IssueTracker (SQL). Run after :apps."
+    task issue_trackers: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::IssueTracker.transaction do
+        Helpers.with_preserved_timestamps(Errbit::IssueTracker) do
+          ::App.all.each do |mongo_app|
+            mongo_tracker = mongo_app.issue_tracker
+            next if mongo_tracker.blank?
+
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo_app._id)
+            next unless errbit_app_id
+
+            ar = Errbit::IssueTracker.find_or_initialize_by(bson_id: mongo_tracker._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_app_id: errbit_app_id,
+              type_tracker: mongo_tracker.attributes["type_tracker"],
+              options: mongo_tracker.options || {},
+              created_at: mongo_tracker.try(:created_at),
+              updated_at: mongo_tracker.try(:updated_at)
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("issue_trackers", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # NotificationServices (embedded in App, polymorphic via Mongoid _type)
+    # ------------------------------------------------------------------
+    desc "Migrate embedded App notification services to Errbit::NotificationService (SQL STI). Run after :apps."
+    task notification_services: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::NotificationService.transaction do
+        Helpers.with_preserved_timestamps(Errbit::NotificationService) do
+          ::App.all.each do |mongo_app|
+            mongo_ns = mongo_app.notification_service
+            next if mongo_ns.blank?
+
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo_app._id)
+            next unless errbit_app_id
+
+            ar_type = "Errbit::#{mongo_ns.class.name}"
+
+            ar = Errbit::NotificationService.find_or_initialize_by(bson_id: mongo_ns._id.to_s)
+            ar = ar.becomes!(ar_type.constantize)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_app_id: errbit_app_id,
+              room_id: mongo_ns.try(:room_id),
+              mentions: mongo_ns.try(:mentions),
+              user_id: mongo_ns.try(:user_id),
+              service_url: mongo_ns.try(:service_url),
+              service: mongo_ns.try(:service),
+              api_token: mongo_ns.try(:api_token),
+              subdomain: mongo_ns.try(:subdomain),
+              sender_name: mongo_ns.try(:sender_name),
+              notify_at_notices: mongo_ns.try(:notify_at_notices) || [],
+              created_at: mongo_ns.try(:created_at),
+              updated_at: mongo_ns.try(:updated_at)
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("notification_services", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # NoticeFingerprinters (embedded in App)
+    # ------------------------------------------------------------------
+    desc "Migrate embedded App notice fingerprinters to Errbit::NoticeFingerprinter (SQL). Run after :apps."
+    task notice_fingerprinters: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::NoticeFingerprinter.transaction do
+        Helpers.with_preserved_timestamps(Errbit::NoticeFingerprinter) do
+          ::App.all.each do |mongo_app|
+            mongo_fp = mongo_app.notice_fingerprinter
+            next if mongo_fp.blank?
+
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo_app._id)
+            next unless errbit_app_id
+
+            # Errbit::App#ensure_notice_fingerprinter (before_create) already
+            # made a fingerprinter row for every migrated app. There is at
+            # most one per app (unique index on errbit_app_id); look it up by
+            # app and overwrite with the values from the Mongo embedded
+            # fingerprinter, stamping its bson_id for traceability.
+            ar = Errbit::NoticeFingerprinter.find_or_initialize_by(errbit_app_id: errbit_app_id)
+
+            Helpers.assign_and_save!(ar, {
+              bson_id: mongo_fp._id.to_s,
+              errbit_app_id: errbit_app_id,
+              error_class: mongo_fp.error_class.nil? ? true : mongo_fp.error_class,
+              message: mongo_fp.message.nil? ? true : mongo_fp.message,
+              backtrace_lines: mongo_fp.backtrace_lines || -1,
+              component: mongo_fp.component.nil? ? true : mongo_fp.component,
+              action: mongo_fp.action.nil? ? true : mongo_fp.action,
+              environment_name: mongo_fp.environment_name.nil? ? true : mongo_fp.environment_name,
+              source: mongo_fp.source,
+              created_at: mongo_fp.try(:created_at),
+              updated_at: mongo_fp.try(:updated_at)
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("notice_fingerprinters", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Backtraces (standalone)
+    # ------------------------------------------------------------------
+    desc "Migrate Backtraces from MongoDB to Errbit::Backtrace (SQL)."
+    task backtraces: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Backtrace.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Backtrace) do
+          ::Backtrace.all.each do |mongo|
+            ar = Errbit::Backtrace.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              fingerprint: mongo.fingerprint,
+              lines: mongo.lines || [],
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("backtraces", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Problems (depends on App)
+    # ------------------------------------------------------------------
+    desc "Migrate Problems from MongoDB to Errbit::Problem (SQL). Run after :apps."
+    task problems: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Problem.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Problem) do
+          ::Problem.all.each do |mongo|
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo.app_id)
+            unless errbit_app_id
+              stats[:failed] += 1
+              warn "  failed problem bson_id=#{mongo._id}: app not migrated"
+              next
+            end
+
+            ar = Errbit::Problem.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_app_id: errbit_app_id,
+              first_notice_at: mongo.first_notice_at,
+              last_notice_at: mongo.last_notice_at,
+              resolved: mongo.resolved || false,
+              resolved_at: mongo.resolved_at,
+              issue_link: mongo.issue_link,
+              issue_type: mongo[:issue_type],
+              app_name: mongo.app_name,
+              notices_count: mongo.notices_count || 0,
+              comments_count: mongo.comments_count || 0,
+              message: mongo.message,
+              environment: mongo.environment,
+              error_class: mongo.error_class,
+              where: mongo.where,
+              user_agents: mongo.user_agents || {},
+              messages: mongo.messages || {},
+              hosts: mongo.hosts || {},
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("problems", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Errs (depends on Problem)
+    # ------------------------------------------------------------------
+    desc "Migrate Errs from MongoDB to Errbit::Err (SQL). Run after :problems."
+    task errs: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Err.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Err) do
+          ::Err.all.each do |mongo|
+            errbit_problem_id = Helpers.ar_id_for(Errbit::Problem, mongo.problem_id)
+            unless errbit_problem_id
+              stats[:failed] += 1
+              warn "  failed err bson_id=#{mongo._id}: problem not migrated"
+              next
+            end
+
+            ar = Errbit::Err.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_problem_id: errbit_problem_id,
+              fingerprint: mongo.fingerprint,
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("errs", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Notices (depends on App + Err + Backtrace)
+    # ------------------------------------------------------------------
+    desc "Migrate Notices from MongoDB to Errbit::Notice (SQL). Run after :apps, :errs, :backtraces."
+    task notices: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Notice.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Notice) do
+          ::Notice.all.each do |mongo|
+            errbit_app_id = Helpers.ar_id_for(Errbit::App, mongo.app_id)
+            errbit_err_id = Helpers.ar_id_for(Errbit::Err, mongo.err_id)
+            errbit_backtrace_id = Helpers.ar_id_for(Errbit::Backtrace, mongo.backtrace_id)
+
+            unless errbit_app_id && errbit_err_id && errbit_backtrace_id
+              stats[:failed] += 1
+              warn "  failed notice bson_id=#{mongo._id}: missing app/err/backtrace mapping"
+              next
+            end
+
+            ar = Errbit::Notice.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_app_id: errbit_app_id,
+              errbit_err_id: errbit_err_id,
+              errbit_backtrace_id: errbit_backtrace_id,
+              message: mongo.message,
+              framework: mongo.framework,
+              error_class: mongo.error_class,
+              server_environment: mongo.server_environment,
+              request: mongo.request,
+              notifier: mongo.notifier,
+              user_attributes: mongo.try(:user_attributes),
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("notices", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # Comments (depends on Problem + User)
+    # ------------------------------------------------------------------
+    desc "Migrate Comments from MongoDB to Errbit::Comment (SQL). Run after :problems and :users."
+    task comments: :environment do
+      stats = {created: 0, updated: 0, failed: 0}
+
+      Errbit::Comment.transaction do
+        Helpers.with_preserved_timestamps(Errbit::Comment) do
+          ::Comment.all.each do |mongo|
+            errbit_problem_id = Helpers.ar_id_for(Errbit::Problem, mongo.err_id)
+            errbit_user_id = Helpers.ar_id_for(Errbit::User, mongo.user_id)
+
+            unless errbit_problem_id && errbit_user_id
+              stats[:failed] += 1
+              warn "  failed comment bson_id=#{mongo._id}: missing problem/user mapping"
+              next
+            end
+
+            ar = Errbit::Comment.find_or_initialize_by(bson_id: mongo._id.to_s)
+
+            Helpers.assign_and_save!(ar, {
+              errbit_problem_id: errbit_problem_id,
+              errbit_user_id: errbit_user_id,
+              body: mongo.body,
+              created_at: mongo.created_at,
+              updated_at: mongo.updated_at
+            }, stats)
+          end
+        end
+      end
+
+      Helpers.print_summary("comments", stats)
+    end
+
+    # ------------------------------------------------------------------
+    # All — runs every model migration in dependency order
+    # ------------------------------------------------------------------
+    desc "Run all Mongo→SQL migrations in dependency order."
+    task all: :environment do
+      %i[
+        users
+        site_configs
+        apps
+        watchers
+        issue_trackers
+        notification_services
+        notice_fingerprinters
+        backtraces
+        problems
+        errs
+        notices
+        comments
+      ].each do |t|
+        task = Rake::Task["errbit:migrate:#{t}"]
+        task.reenable
+        task.invoke
+      end
+    end
+  end
+end
diff --git a/spec/controllers/api/v1/comments_controller_spec.rb b/spec/controllers/api/v1/comments_controller_spec.rb
index a7b3663b22..02ab1c1677 100644
--- a/spec/controllers/api/v1/comments_controller_spec.rb
+++ b/spec/controllers/api/v1/comments_controller_spec.rb
@@ -4,73 +4,65 @@
 
 RSpec.describe Api::V1::CommentsController, type: :controller do
   context "when logged in" do
-    before do
-      @user = create(:user)
-    end
+    let(:user) { create(:errbit_user) }
 
     describe "GET /api/v1/problems/:problem_id/comments" do
+      let!(:problem) { create(:errbit_problem) }
+
       before do
-        @problem = create(:problem)
-        create(:comment, err: @problem)
-        create(:comment, err: @problem)
-        create(:comment)
+        create(:errbit_comment, err: problem)
+        create(:errbit_comment, err: problem)
+        create(:errbit_comment)
       end
 
-      it "should return JSON if JSON is requested" do
-        get :index, params: {problem_id: @problem.id, auth_token: @user.authentication_token, format: "json"}
+      it "returns JSON when JSON is requested" do
+        get :index, params: {problem_id: problem.id, auth_token: user.authentication_token, format: "json"}
 
         expect { response.parsed_body }.not_to raise_error
       end
 
-      it "should return XML if XML is requested" do
-        get :index, params: {problem_id: @problem.id, auth_token: @user.authentication_token, format: "xml"}
+      it "returns XML when XML is requested" do
+        get :index, params: {problem_id: problem.id, auth_token: user.authentication_token, format: "xml"}
 
         expect(Nokogiri::XML(response.body).errors).to be_empty
       end
 
-      it "should return JSON by default" do
-        get :index, params: {problem_id: @problem.id, auth_token: @user.authentication_token}
+      it "returns JSON by default" do
+        get :index, params: {problem_id: problem.id, auth_token: user.authentication_token}
 
         expect { response.parsed_body }.not_to raise_error
       end
 
-      it "should return all comments of a problem" do
-        get :index, params: {problem_id: @problem.id, auth_token: @user.authentication_token}
+      it "returns only the comments for the requested problem" do
+        get :index, params: {problem_id: problem.id, auth_token: user.authentication_token}
 
         expect(response).to be_successful
-
-        comments = JSON.parse(response.body)
-
-        expect(comments.length).to eq(2)
+        expect(JSON.parse(response.body).length).to eq(2)
       end
     end
 
     describe "POST /api/v1/problems/:problem_id/comments" do
-      before do
-        @problem = create(:problem)
-      end
+      let!(:problem) { create(:errbit_problem) }
 
       context "with valid params" do
-        it "should create comment" do
-          expect do
-            post :create, params: {problem_id: @problem.id, auth_token: @user.authentication_token, comment: {body: "I'll take a look at it."}}
-          end.to change(Comment, :count)
+        it "creates a comment" do
+          expect {
+            post :create, params: {problem_id: problem.id, auth_token: user.authentication_token, comment: {body: "I'll take a look at it."}}
+          }.to change(Errbit::Comment, :count).by(1)
 
           expect(response).to be_successful
         end
       end
 
       context "with invalid params" do
-        it "shouldn't create comment" do
-          expect do
-            post :create, params: {problem_id: @problem.id, auth_token: @user.authentication_token, comment: {body: nil}}
-          end.not_to change(Comment, :count)
+        it "does not create a comment and returns 422 with errors" do
+          expect {
+            post :create, params: {problem_id: problem.id, auth_token: user.authentication_token, comment: {body: nil}}
+          }.not_to change(Errbit::Comment, :count)
 
           expect(response).not_to be_successful
 
-          errors = JSON.parse(response.body)
-
-          expect(errors).to eq("errors" => ["Body can't be blank"])
+          expect(JSON.parse(response.body)).to eq("errors" => ["Body can't be blank"])
         end
       end
     end
diff --git a/spec/controllers/api/v1/notices_controller_spec.rb b/spec/controllers/api/v1/notices_controller_spec.rb
index 7860edaa19..b6aa939a10 100644
--- a/spec/controllers/api/v1/notices_controller_spec.rb
+++ b/spec/controllers/api/v1/notices_controller_spec.rb
@@ -4,63 +4,56 @@
 
 RSpec.describe Api::V1::NoticesController, type: :controller do
   context "when logged in" do
-    before do
-      @user = create(:user)
-    end
+    let(:user) { create(:errbit_user) }
 
     describe "GET /api/v1/notices" do
       before do
-        create(:notice, created_at: Time.zone.parse("2012-08-01"))
-        create(:notice, created_at: Time.zone.parse("2012-08-01"))
-        create(:notice, created_at: Time.zone.parse("2012-08-21"))
-        create(:notice, created_at: Time.zone.parse("2012-08-30"))
+        create(:errbit_notice, created_at: Time.zone.parse("2012-08-01"))
+        create(:errbit_notice, created_at: Time.zone.parse("2012-08-01"))
+        create(:errbit_notice, created_at: Time.zone.parse("2012-08-21"))
+        create(:errbit_notice, created_at: Time.zone.parse("2012-08-30"))
       end
 
-      it "should return JSON if JSON is requested" do
-        get :index, params: {auth_token: @user.authentication_token, format: "json"}
+      it "returns JSON when JSON is requested" do
+        get :index, params: {auth_token: user.authentication_token, format: "json"}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      it "should return XML if XML is requested" do
-        get :index, params: {auth_token: @user.authentication_token, format: "xml"}
+      it "returns XML when XML is requested" do
+        get :index, params: {auth_token: user.authentication_token, format: "xml"}
 
         expect(Nokogiri::XML(response.body).errors).to be_empty
       end
 
-      it "should return JSON by default" do
-        get :index, params: {auth_token: @user.authentication_token}
+      it "returns JSON by default" do
+        get :index, params: {auth_token: user.authentication_token}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      describe "given a date range" do
-        it "should return only the notices created during the date range" do
-          get :index, params: {auth_token: @user.authentication_token, start_date: "2012-08-01", end_date: "2012-08-27"}
+      context "with a date range" do
+        it "returns only the notices created during the date range" do
+          get :index, params: {auth_token: user.authentication_token, start_date: "2012-08-01", end_date: "2012-08-27"}
 
           expect(response).to be_successful
 
-          notices = JSON.parse(response.body)
-
-          expect(notices.length).to eq(3)
+          expect(JSON.parse(response.body).length).to eq(3)
         end
       end
 
-      it "should return all notices" do
-        get :index, params: {auth_token: @user.authentication_token}
+      it "returns every notice when no date range is given" do
+        get :index, params: {auth_token: user.authentication_token}
 
         expect(response).to be_successful
 
-        notices = JSON.parse(response.body)
-
-        expect(notices.length).to eq(4)
+        expect(JSON.parse(response.body).length).to eq(4)
       end
 
-      it "should return notice objects with correct fields" do
-        get :index, params: {auth_token: @user.authentication_token, format: "json"}
+      it "returns notice objects with the legacy v1 keys" do
+        get :index, params: {auth_token: user.authentication_token, format: "json"}
 
-        notices = JSON.parse(response.body)
-        notice = notices.first
+        notice = JSON.parse(response.body).first
 
         expect(notice).to be_a(Hash)
         expect(notice.keys).to match_array(["_id", "created_at", "message", "error_class"])
diff --git a/spec/controllers/api/v1/problems_controller_spec.rb b/spec/controllers/api/v1/problems_controller_spec.rb
index b1ebe6fdb5..af9354f419 100644
--- a/spec/controllers/api/v1/problems_controller_spec.rb
+++ b/spec/controllers/api/v1/problems_controller_spec.rb
@@ -4,65 +4,46 @@
 
 RSpec.describe Api::V1::ProblemsController, type: :controller do
   context "when logged in" do
-    before do
-      @user = create(:user)
-    end
+    let(:user) { create(:errbit_user) }
 
     describe "GET /api/v1/problems/:id" do
-      before do
-        notice = create(:notice)
-        err = create(:err, notices: [notice])
-        @problem = create(:problem, errs: [err])
-      end
+      let!(:problem) { create(:errbit_problem) }
 
-      it "should return JSON if JSON is requested" do
-        get :show, params: {auth_token: @user.authentication_token, format: "json", id: Problem.first.id}
+      it "returns JSON when JSON is requested" do
+        get :show, params: {auth_token: user.authentication_token, format: "json", id: problem.id}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      it "should return XML if XML is requested" do
-        get :index, params: {auth_token: @user.authentication_token, format: "xml", id: @problem.id}
+      it "returns XML when XML is requested" do
+        get :show, params: {auth_token: user.authentication_token, format: "xml", id: problem.id}
 
         expect(Nokogiri::XML(response.body).errors).to be_empty
       end
 
-      it "should return JSON by default" do
-        get :show, params: {auth_token: @user.authentication_token, id: @problem.id}
+      it "returns JSON by default" do
+        get :show, params: {auth_token: user.authentication_token, id: problem.id}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      it "should return the correct problem" do
-        get :show, params: {auth_token: @user.authentication_token, format: "json", id: @problem.id}
-
-        returned_problem = JSON.parse(response.body)
+      it "returns the correct problem" do
+        get :show, params: {auth_token: user.authentication_token, format: "json", id: problem.id}
 
-        expect(returned_problem["_id"]).to eq(@problem.id.to_s)
+        expect(JSON.parse(response.body)["_id"]).to eq(problem.id.to_s)
       end
 
-      it "should return only the correct fields" do
-        get :show, params: {auth_token: @user.authentication_token, format: "json", id: @problem.id}
-
-        returned_problem = JSON.parse(response.body)
-
-        expect(returned_problem.keys).to match_array([
-          "app_name",
-          "first_notice_at",
-          "message",
-          "app_id",
-          "last_notice_at",
-          "_id",
-          "resolved",
-          "resolved_at",
-          "where",
-          "notices_count",
-          "environment"
+      it "returns only the legacy v1 keys" do
+        get :show, params: {auth_token: user.authentication_token, format: "json", id: problem.id}
+
+        expect(JSON.parse(response.body).keys).to match_array([
+          "app_name", "first_notice_at", "message", "app_id", "last_notice_at",
+          "_id", "resolved", "resolved_at", "where", "notices_count", "environment"
         ])
       end
 
-      it "returns a 404 if the problem cannot be found" do
-        get :show, params: {auth_token: @user.authentication_token, format: "json", id: "IdontExist"}
+      it "returns 404 when the problem cannot be found" do
+        get :show, params: {auth_token: user.authentication_token, format: "json", id: "999999999"}
 
         expect(response).to have_http_status(:not_found)
       end
@@ -70,57 +51,52 @@
 
     describe "GET /api/v1/problems" do
       before do
-        create(:problem, first_notice_at: Date.new(2012, 8, 1), resolved_at: Date.new(2012, 8, 2))
-        create(:problem, first_notice_at: Date.new(2012, 8, 1), resolved_at: Date.new(2012, 8, 21))
-        create(:problem, first_notice_at: Date.new(2012, 8, 21))
-        create(:problem, first_notice_at: Date.new(2012, 8, 30))
+        create(:errbit_problem, first_notice_at: Date.new(2012, 8, 1), resolved_at: Date.new(2012, 8, 2))
+        create(:errbit_problem, first_notice_at: Date.new(2012, 8, 1), resolved_at: Date.new(2012, 8, 21))
+        create(:errbit_problem, first_notice_at: Date.new(2012, 8, 21))
+        create(:errbit_problem, first_notice_at: Date.new(2012, 8, 30))
       end
 
-      it "should return JSON if JSON is requested" do
-        get :index, params: {auth_token: @user.authentication_token, format: "json"}
+      it "returns JSON when JSON is requested" do
+        get :index, params: {auth_token: user.authentication_token, format: "json"}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      it "should return XML if XML is requested" do
-        get :index, params: {auth_token: @user.authentication_token, format: "xml"}
+      it "returns XML when XML is requested" do
+        get :index, params: {auth_token: user.authentication_token, format: "xml"}
 
         expect(Nokogiri::XML(response.body).errors).to be_empty
       end
 
-      it "should return JSON by default" do
-        get :index, params: {auth_token: @user.authentication_token}
+      it "returns JSON by default" do
+        get :index, params: {auth_token: user.authentication_token}
 
         expect { JSON.parse(response.body) }.not_to raise_error
       end
 
-      describe "given a date range" do
-        it "should return only the problems open during the date range" do
-          get :index, params: {auth_token: @user.authentication_token, start_date: "2012-08-20", end_date: "2012-08-27"}
+      context "with a date range" do
+        it "returns only the problems open during the date range" do
+          get :index, params: {auth_token: user.authentication_token, start_date: "2012-08-20", end_date: "2012-08-27"}
 
           expect(response).to be_successful
 
-          problems = JSON.parse(response.body)
-
-          expect(problems.length).to eq(2)
+          expect(JSON.parse(response.body).length).to eq(2)
         end
       end
 
-      it "should return all problems" do
-        get :index, params: {auth_token: @user.authentication_token}
+      it "returns every problem when no date range is given" do
+        get :index, params: {auth_token: user.authentication_token}
 
         expect(response).to be_successful
 
-        problems = JSON.parse(response.body)
-
-        expect(problems.length).to eq(4)
+        expect(JSON.parse(response.body).length).to eq(4)
       end
 
-      it "should return problem objects with correct fields" do
-        get :index, params: {auth_token: @user.authentication_token, format: "json"}
+      it "returns problem objects with the legacy v1 keys" do
+        get :index, params: {auth_token: user.authentication_token, format: "json"}
 
-        problems = JSON.parse(response.body)
-        problem = problems.first
+        problem = JSON.parse(response.body).first
 
         expect(problem).to be_a(Hash)
         expect(problem.keys).to match_array([
diff --git a/spec/controllers/api/v3/notices_controller_spec.rb b/spec/controllers/api/v3/notices_controller_spec.rb
index 54ef2849b4..d423e565ea 100644
--- a/spec/controllers/api/v3/notices_controller_spec.rb
+++ b/spec/controllers/api/v3/notices_controller_spec.rb
@@ -3,21 +3,15 @@
 require "rails_helper"
 
 RSpec.describe Api::V3::NoticesController, type: :controller do
-  let(:app) { create(:app) }
-
+  let(:app) { create(:errbit_app) }
   let(:project_id) { app.api_key }
-
   let(:legit_params) { {project_id: project_id, key: project_id} }
-
-  let(:legit_body) do
-    Rails.root.join("spec/fixtures/api_v3_request.json").read
-  end
+  let(:legit_body) { Rails.root.join("spec/fixtures/api_v3_request.json").read }
 
   it "sets CORS headers on POST request" do
     post :create, params: {project_id: "invalid id"}
 
     expect(response.headers["Access-Control-Allow-Origin"]).to eq("*")
-
     expect(response.headers["Access-Control-Allow-Headers"]).to eq("origin, content-type, accept")
   end
 
@@ -25,14 +19,13 @@
     process :create, method: "OPTIONS", params: {project_id: "nothingspecial"}
 
     expect(response.headers["Access-Control-Allow-Origin"]).to eq("*")
-
     expect(response.headers["Access-Control-Allow-Headers"]).to eq("origin, content-type, accept")
   end
 
-  it "returns created notice id in json format" do
+  it "returns the created notice id and url in the JSON body" do
     post :create, body: legit_body, params: {**legit_params}
 
-    notice = Notice.last
+    notice = Errbit::Notice.last
 
     expect(response.parsed_body).to eq(
       "id" => notice.id.to_s,
@@ -40,13 +33,13 @@
     )
   end
 
-  it "responds with 201 created on success" do
+  it "responds with 201 on success" do
     post :create, body: legit_body, params: {**legit_params}
 
     expect(response).to have_http_status(:created)
   end
 
-  it "responds with 201 created on success with token in Airbrake Token header" do
+  it "responds with 201 when the token is in the X-Airbrake-Token header" do
     request.headers["X-Airbrake-Token"] = project_id
 
     post :create, body: legit_body, params: {project_id: 123}
@@ -54,7 +47,7 @@
     expect(response).to have_http_status(:created)
   end
 
-  it "responds with 201 created on success with token in Authorization header" do
+  it "responds with 201 when the token is in the Authorization header" do
     request.headers["Authorization"] = "Bearer #{project_id}"
 
     post :create, body: legit_body, params: {project_id: 123}
@@ -62,7 +55,7 @@
     expect(response).to have_http_status(:created)
   end
 
-  it "responds with 422 when Authorization header is not valid" do
+  it "responds with 422 when the Authorization header is malformed" do
     request.headers["Authorization"] = "incorrect"
 
     post :create, body: legit_body, params: {project_id: 123}
@@ -70,21 +63,21 @@
     expect(response).to have_http_status(:unprocessable_content)
   end
 
-  it "responds with 400 when request attributes are not valid" do
+  it "responds with 400 when the request attributes are invalid" do
     allow_any_instance_of(AirbrakeApi::V3::NoticeParser)
       .to receive(:report).and_raise(AirbrakeApi::ParamsError)
 
     post :create, params: {project_id: "ID"}
 
     expect(response).to have_http_status(:bad_request)
-
     expect(response.body).to eq("Invalid request")
   end
 
-  it "responds with 422 when notice comes from an old app" do
-    app.current_app_version = "1.1.0"
-    app.save!
+  it "responds with 422 when the notice comes from an older app version" do
+    app.update!(current_app_version: "1.1.0")
+
     post :create, body: legit_body, params: {**legit_params}
+
     expect(response).to have_http_status(:unprocessable_content)
   end
 
@@ -95,10 +88,12 @@
     expect(response.body).to eq("Your API key is unknown")
   end
 
-  it "ignores notices for older api" do
-    app = create(:app, current_app_version: "2.0")
-    post :create, body: legit_body, params: {project_id: app.api_key, key: app.api_key}
+  it "ignores notices for older app versions" do
+    older_app = create(:errbit_app, current_app_version: "2.0")
+
+    post :create, body: legit_body, params: {project_id: older_app.api_key, key: older_app.api_key}
+
     expect(response.body).to eq("Notice for old app version ignored")
-    expect(Notice.count).to eq(0)
+    expect(Errbit::Notice.count).to eq(0)
   end
 end
diff --git a/spec/controllers/apps_controller_spec.rb b/spec/controllers/apps_controller_spec.rb
index 3899813c3e..2ccc8f3920 100644
--- a/spec/controllers/apps_controller_spec.rb
+++ b/spec/controllers/apps_controller_spec.rb
@@ -7,124 +7,107 @@
   it_requires_admin_privileges for: {new: :get, edit: :get, create: :post, update: :patch, destroy: :delete}
 
   let(:app_params) { {name: "BestApp"} }
-  let(:admin) { create(:user, admin: true) }
-  let(:user) { create(:user) }
-  let(:watcher) { create(:user_watcher, app: app, user: user) }
-  let(:unwatched_app) { create(:app) }
+  let(:admin) { create(:errbit_user, admin: true) }
+  let(:user) { create(:errbit_user) }
+  let(:unwatched_app) { create(:errbit_app) }
   let(:app) { unwatched_app }
-  let(:watched_app_1) do
-    a = create(:app)
-    create(:user_watcher, user: user, app: a)
-    a
-  end
-  let(:watched_app_2) do
-    a = create(:app)
-    create(:user_watcher, user: user, app: a)
-    a
-  end
-  let(:err) do
-    create(:err, problem: problem)
-  end
-  let(:notice) do
-    create(:notice, err: err)
-  end
-  let(:problem) do
-    create(:problem, app: app)
-  end
-  let(:problem_resolved) { create(:problem_resolved, app: app) }
-  let(:notice_fingerprinter) do
-    nf = SiteConfig.document.notice_fingerprinter
-    nf.backtrace_lines = 10
-    nf
-  end
+  let(:watcher) { create(:errbit_user_watcher, app: app, user: user) }
 
   describe "GET /apps" do
     context "when logged in as an admin" do
       it "finds all apps" do
         sign_in admin
-        unwatched_app && watched_app_1 && watched_app_2
+        unwatched_app
+
         get :index
-        expect(controller.apps.entries).to eq(App.all.to_a.sort.entries)
+
+        expect(controller.send(:apps).map(&:object)).to eq(Errbit::App.all.to_a.sort)
       end
     end
 
     context "when logged in as a regular user" do
       it "finds all apps" do
         sign_in user
-        unwatched_app && watched_app_1 && watched_app_2
+        unwatched_app
+
         get :index
-        expect(controller.apps.entries).to eq(App.all.to_a.sort.entries)
+
+        expect(controller.send(:apps).map(&:object)).to eq(Errbit::App.all.to_a.sort)
       end
     end
   end
 
   describe "GET /apps/:id" do
-    context "logged in as an admin" do
-      before do
-        sign_in admin
-      end
+    context "when logged in as an admin" do
+      before { sign_in admin }
 
       it "finds the app" do
         get :show, params: {id: app.id}
-        expect(controller.app).to eq(app)
+
+        expect(controller.send(:app)).to eq(app)
       end
 
-      it "should not raise errors for app with err without notices" do
-        err
+      it "does not raise errors for an app with an err but no notices" do
+        create(:errbit_err, problem: create(:errbit_problem, app: app))
+
         expect { get :show, params: {id: app.id} }.not_to raise_error
       end
 
-      it "should list atom feed successfully" do
+      it "responds successfully for the atom feed" do
         get :show, params: {id: app.id, format: "atom"}
+
         expect(response).to be_successful
       end
 
-      it "should list available watchers by name" do
-        create(:user, name: "Carol")
-        create(:user, name: "Alice")
-        create(:user, name: "Betty")
+      it "lists available watchers by name" do
+        create(:errbit_user, name: "Carol")
+        create(:errbit_user, name: "Alice")
+        create(:errbit_user, name: "Betty")
 
         get :show, params: {id: app.id}
 
-        expect(controller.users.to_a).to eq(User.all.to_a.sort_by(&:name))
+        expect(controller.send(:users).to_a).to eq(Errbit::User.all.to_a.sort_by { |u| u.name.downcase })
       end
 
-      context "pagination" do
-        before do
-          35.times { create(:err, problem: create(:problem, app: app)) }
-        end
+      context "with default pagination" do
+        before { 35.times { create(:errbit_err, problem: create(:errbit_problem, app: app)) } }
 
-        it "should have default per_page value for user" do
+        it "uses the default per_page value" do
           get :show, params: {id: app.id}
 
-          expect(controller.problems.to_a.size).to eq(User::PER_PAGE)
+          expect(controller.send(:problems).to_a.size).to eq(Errbit::User::PER_PAGE)
         end
 
-        it "should be able to override default per_page value" do
-          admin.update_attribute :per_page, 10
+        it "honors the user's per_page override" do
+          admin.update!(per_page: 10)
 
           get :show, params: {id: app.id}
 
-          expect(controller.problems.to_a.size).to eq(10)
+          expect(controller.send(:problems).to_a.size).to eq(10)
         end
       end
 
       context "with resolved errors" do
-        before do
-          problem_resolved && problem
+        let!(:resolved_problem) do
+          p = create(:errbit_problem, app: app)
+          p.resolve!
+          p
         end
+        let!(:open_problem) { create(:errbit_problem, app: app) }
 
-        context "and no params" do
+        context "without all_errs param" do
           it "shows only unresolved problems" do
             get :show, params: {id: app.id}
-            expect(controller.problems.size).to eq(1)
+
+            expect(controller.send(:problems).size).to eq(1)
           end
         end
 
-        context "and all_problems=true params" do
-          it "shows all errors" do
+        context "with all_errs=true" do
+          it "shows all problems" do
             get :show, params: {id: app.id, all_errs: true}
-            expect(controller.problems.size).to eq(2)
+
+            expect(controller.send(:problems).size).to eq(2)
           end
         end
       end
@@ -133,284 +116,202 @@
         before do
           environments = ["production", "test", "development", "staging"]
           20.times do |i|
-            create(:problem, app: app, environment: environments[i % environments.length])
+            create(:errbit_problem, app: app, environment: environments[i % environments.length])
           end
         end
 
-        context "no params" do
-          it "shows errs for all environments" do
+        context "without any environment param" do
+          it "shows problems for every environment" do
             get :show, params: {id: app.id}
 
-            expect(controller.problems.size).to eq(20)
+            expect(controller.send(:problems).size).to eq(20)
           end
         end
 
-        context "environment production" do
-          it "shows errs for just production" do
+        context "with environment=production" do
+          it "filters to just production" do
             get :show, params: {id: app.id, environment: "production"}
 
-            expect(controller.problems.size).to eq(5)
+            expect(controller.send(:problems).size).to eq(5)
           end
         end
 
-        context "environment staging" do
-          it "shows errs for just staging" do
+        context "with environment=staging" do
+          it "filters to just staging" do
             get :show, params: {id: app.id, environment: "staging"}
 
-            expect(controller.problems.size).to eq(5)
-          end
-        end
-
-        context "environment development" do
-          it "shows errs for just development" do
-            get :show, params: {id: app.id, environment: "development"}
-
-            expect(controller.problems.size).to eq(5)
-          end
-        end
-
-        context "environment test" do
-          it "shows errs for just test" do
-            get :show, params: {id: app.id, environment: "test"}
-
-            expect(controller.problems.size).to eq(5)
+            expect(controller.send(:problems).size).to eq(5)
           end
         end
       end
     end
 
-    context "logged in as a user" do
+    context "when logged in as a regular user" do
       it "finds the app even when not watching it" do
-        sign_in create(:user)
-
-        app = create(:app)
+        sign_in create(:errbit_user)
+        the_app = create(:errbit_app)
 
-        get :show, params: {id: app.id}
+        get :show, params: {id: the_app.id}
 
-        expect(controller.app).to eq(app)
+        expect(controller.send(:app)).to eq(the_app)
       end
     end
   end
 
-  context "logged in as an admin" do
-    before do
-      sign_in admin
-    end
+  context "when signed in as an admin" do
+    before { sign_in admin }
 
     describe "GET /apps/new" do
       it "instantiates a new app with a prebuilt watcher" do
         get :new
-        expect(controller.app).to be_a(App)
-        expect(controller.app).to be_new_record
-        expect(controller.app.watchers).not_to be_empty
+
+        expect(controller.send(:app)).to be_a(Errbit::App)
+        expect(controller.send(:app)).to be_new_record
+        expect(controller.send(:app).watchers).not_to be_empty
       end
 
-      it "should copy attributes from an existing app" do
-        @app = create(:app, name: "do not copy", github_repo: "test/example")
-        get :new, params: {copy_attributes_from: @app.id}
-        expect(controller.app).to be_a(App)
-        expect(controller.app).to be_new_record
-        expect(controller.app.name).to be_blank
-        expect(controller.app.github_repo).to eq("test/example")
+      it "copies attributes from an existing app when copy_attributes_from is set" do
+        @existing = create(:errbit_app, name: "do not copy", github_repo: "test/example")
+
+        get :new, params: {copy_attributes_from: @existing.id}
+
+        expect(controller.send(:app)).to be_a(Errbit::App)
+        expect(controller.send(:app)).to be_new_record
+        expect(controller.send(:app).name).to be_blank
+        expect(controller.send(:app).github_repo).to eq("test/example")
       end
     end
 
     describe "GET /apps/:id/edit" do
       it "finds the correct app" do
-        app = create(:app)
+        the_app = create(:errbit_app)
 
-        get :edit, params: {id: app.id}
+        get :edit, params: {id: the_app.id}
 
-        expect(controller.app).to eq(app)
+        expect(controller.send(:app)).to eq(the_app)
       end
     end
 
     describe "POST /apps" do
-      before do
-        @app = create(:app)
-
-        allow(App).to receive(:new).and_return(@app)
-      end
+      context "with a successful create" do
+        it "redirects to the app page" do
+          post :create, params: {app: app_params}
 
-      context "when the create is successful" do
-        before do
-          expect(@app).to receive(:save).and_return(true)
+          expect(response).to redirect_to(app_path(assigns(:app)))
         end
 
-        it "should redirect to the app page" do
+        it "flashes a success message" do
           post :create, params: {app: app_params}
-          expect(response).to redirect_to(app_path(@app))
-        end
 
-        it "should display a message" do
-          post :create, params: {app: app_params}
           expect(request.flash[:success]).to match(/success/)
         end
       end
     end
 
     describe "PATCH /apps/:id" do
-      before do
-        @app = create(:app)
-      end
+      let!(:the_app) { create(:errbit_app) }
 
-      context "when the update is successful" do
-        it "should redirect to the app page" do
-          patch :update, params: {id: @app.id, app: app_params}
-          expect(response).to redirect_to(app_path(@app))
+      context "with a successful update" do
+        it "redirects to the app page" do
+          patch :update, params: {id: the_app.id, app: app_params}
+
+          expect(response).to redirect_to(app_path(the_app))
         end
 
-        it "should display a message" do
-          patch :update, params: {id: @app.id, app: app_params}
+        it "flashes a success message" do
+          patch :update, params: {id: the_app.id, app: app_params}
+
           expect(request.flash[:success]).to match(/success/)
         end
       end
 
-      context "changing name" do
-        it "should redirect to app page" do
-          id = @app.id
-          patch :update, params: {id: id, app: {name: "new name"}}
-          expect(response).to redirect_to(app_path(id))
+      context "when changing the name" do
+        it "redirects to the app page" do
+          patch :update, params: {id: the_app.id, app: {name: "new name"}}
+
+          expect(response).to redirect_to(app_path(the_app))
         end
       end
 
-      context "when the update is unsuccessful" do
-        it "should render the edit page" do
-          patch :update, params: {id: @app.id, app: {name: ""}}
+      context "with an unsuccessful update" do
+        it "renders the edit page" do
+          patch :update, params: {id: the_app.id, app: {name: ""}}
+
           expect(response).to render_template(:edit)
         end
       end
 
-      context "changing email_at_notices" do
-        before do
-          allow(Errbit::Config)
-            .to receive(:per_app_email_at_notices).and_return(true)
-        end
+      context "when changing email_at_notices" do
+        before { allow(Errbit::Config).to receive(:per_app_email_at_notices).and_return(true) }
 
-        it "should parse legal csv values" do
-          patch :update, params: {id: @app.id, app: {email_at_notices: "1,   4,      7,8,  10"}}
+        it "parses legal CSV values" do
+          patch :update, params: {id: the_app.id, app: {email_at_notices: "1,   4,      7,8,  10"}}
 
-          @app.reload
+          the_app.reload
 
-          expect(@app.email_at_notices).to eq([1, 4, 7, 8, 10])
+          expect(the_app.email_at_notices).to eq([1, 4, 7, 8, 10])
         end
 
-        context "failed parsing of CSV" do
-          it "should set the default value" do
-            @app = create(:app, email_at_notices: [1, 2, 3, 4])
-
-            patch :update, params: {id: @app.id, app: {email_at_notices: "asdf, -1,0,foobar,gd00,0,abc"}}
+        context "when CSV parsing fails" do
+          it "resets to the default value" do
+            patch :update, params: {id: the_app.id, app: {email_at_notices: "asdf, -1,0,foobar,gd00,0,abc"}}
 
-            @app.reload
+            the_app.reload
 
-            expect(@app.email_at_notices).to eq(Errbit::Config.email_at_notices)
+            expect(the_app.email_at_notices).to eq(Errbit::Config.email_at_notices)
           end
 
-          it "should display a message" do
-            patch :update, params: {id: @app.id, app: {email_at_notices: "qwertyuiop"}}
+          it "flashes an error message" do
+            patch :update, params: {id: the_app.id, app: {email_at_notices: "qwertyuiop"}}
 
             expect(request.flash[:error]).to match(/Couldn't parse/)
           end
         end
       end
 
-      context "setting up issue tracker" do
-        context "unknown tracker type" do
-          before do
-            patch :update, params: {
-              id: @app.id,
-              app: {
-                issue_tracker_attributes: {
-                  type_tracker: "unknown",
-                  options: {
-                    project_id: "1234",
-                    api_token: "123123",
-                    account: "myapp"
-                  }
-                }
-              }
-            }
-
-            @app.reload
-          end
-
-          it "should not create issue tracker" do
-            expect(@app.issue_tracker_configured?).to eq(false)
-          end
-        end
-      end
-
-      context "selecting 'use site fingerprinter'" do
-        before do
-          SiteConfig.document.update!(notice_fingerprinter: notice_fingerprinter)
-
-          patch :update, params: {
-            id: @app.id,
-            app: {
-              notice_fingerprinter_attributes: {
-                backtrace_lines: 42
-              },
-              use_site_fingerprinter: "1"
-            }
-          }
-        end
-
-        it "should copy site fingerprinter into app fingerprinter" do
-          fingerprinter_attrs = @app.reload.notice_fingerprinter.attributes.except("_id", "source")
-          expected_attrs = SiteConfig.document.notice_fingerprinter.attributes.except("_id", "source")
-          expect(fingerprinter_attrs).to eq(expected_attrs)
-        end
-      end
-
-      context "not selecting 'use site fingerprinter'" do
+      context "when setting up an issue tracker with an unknown type" do
         before do
-          SiteConfig.document.update_attributes(notice_fingerprinter: notice_fingerprinter)
-
           patch :update, params: {
-            id: @app.id,
+            id: the_app.id,
             app: {
-              notice_fingerprinter_attributes: {
-                backtrace_lines: 42
-              },
-              use_site_fingerprinter: "0"
+              issue_tracker_attributes: {
+                type_tracker: "unknown",
+                options: {project_id: "1234", api_token: "123123", account: "myapp"}
+              }
             }
           }
+          the_app.reload
         end
 
-        it "shouldn't copy site fingerprinter into app fingerprinter" do
-          fingerprinter_attrs = @app.reload.notice_fingerprinter.attributes.except("_id", "source")
-          expected_attrs = SiteConfig.document.notice_fingerprinter.attributes.except("_id", "source")
-          expect(fingerprinter_attrs).not_to eq(expected_attrs)
-          expect(@app.notice_fingerprinter.backtrace_lines).to eq(42)
+        it "does not create an issue tracker" do
+          expect(the_app.issue_tracker_configured?).to eq(false)
         end
       end
     end
 
     describe "DELETE /apps/:id" do
-      before do
-        @app = create(:app)
-      end
+      let!(:the_app) { create(:errbit_app) }
+
+      it "finds the app" do
+        delete :destroy, params: {id: the_app.id}
 
-      it "should find the app" do
-        delete :destroy, params: {id: @app.id}
-        expect(controller.app).to eq(@app)
+        expect(controller.send(:app)).to eq(the_app)
       end
 
-      it "should destroy the app" do
-        delete :destroy, params: {id: @app.id}
-        expect do
-          @app.reload
-        end.to raise_error(Mongoid::Errors::DocumentNotFound)
+      it "destroys the app" do
+        delete :destroy, params: {id: the_app.id}
+
+        expect { the_app.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
-      it "should display a message" do
-        delete :destroy, params: {id: @app.id}
+      it "flashes a success message" do
+        delete :destroy, params: {id: the_app.id}
 
         expect(request.flash[:success]).to match(/success/)
       end
 
-      it "should redirect to the apps page" do
-        delete :destroy, params: {id: @app.id}
+      it "redirects to the apps page" do
+        delete :destroy, params: {id: the_app.id}
 
         expect(response).to redirect_to(apps_path)
       end
@@ -418,28 +319,25 @@
   end
 
   describe "POST /apps/:id/regenerate_api_key" do
-    context "like watcher" do
-      before do
-        sign_in watcher.user
-      end
+    context "when called by a watcher (non-admin)" do
+      before { sign_in watcher.user }
 
-      it "redirect to root with flash error" do
-        post :regenerate_api_key, params: {id: "foo"}
+      it "redirects to root path" do
+        post :regenerate_api_key, params: {id: app.id}
 
         expect(request).to redirect_to(root_path)
       end
     end
 
-    context "like admin" do
-      before do
-        sign_in admin
-      end
+    context "when called by an admin" do
+      before { sign_in admin }
 
-      it "redirect_to app view" do
-        expect do
+      it "regenerates the api_key and redirects to the edit page" do
+        expect {
           post :regenerate_api_key, params: {id: app.id}
-          expect(request).to redirect_to edit_app_path(app)
-        end.to change { app.reload.api_key }
+        }.to change { app.reload.api_key }
+
+        expect(request).to redirect_to(edit_app_path(app))
       end
     end
   end
@@ -447,8 +345,8 @@
   describe "GET /apps/search" do
     before do
       sign_in user
-      @app_1 = create(:app, name: "Foo")
-      @app_2 = create(:app, name: "Bar")
+      @app_foo = create(:errbit_app, name: "Foo")
+      @app_bar = create(:errbit_app, name: "Bar")
     end
 
     it "renders successfully" do
@@ -457,24 +355,23 @@
       expect(response).to be_successful
     end
 
-    it "renders index template" do
+    it "renders the index template" do
       get :search
 
       expect(response).to render_template("apps/index")
     end
 
-    it "searches problems for given string" do
-      get :search, params: {search: "\"Foo\""}
+    it "filters apps by the search string" do
+      get :search, params: {search: "Foo"}
 
-      expect(controller.apps).to include(@app_1)
-      expect(controller.apps).not_to include(@app_2)
+      expect(controller.send(:apps).map(&:object)).to include(@app_foo)
+      expect(controller.send(:apps).map(&:object)).not_to include(@app_bar)
     end
 
-    it "works when given string is empty" do
+    it "returns every app when the search string is empty" do
       get :search, params: {search: ""}
 
-      expect(controller.apps).to include(@app_1)
-      expect(controller.apps).to include(@app_2)
+      expect(controller.send(:apps).map(&:object)).to include(@app_foo, @app_bar)
     end
   end
 end
diff --git a/spec/controllers/comments_controller_spec.rb b/spec/controllers/comments_controller_spec.rb
index 6d1cec774b..fc3372cb26 100644
--- a/spec/controllers/comments_controller_spec.rb
+++ b/spec/controllers/comments_controller_spec.rb
@@ -3,50 +3,58 @@
 require "rails_helper"
 
 RSpec.describe CommentsController, type: :controller do
-  let(:app) { create(:app) }
+  before { sign_in create(:errbit_user, admin: true) }
 
-  describe "POST /apps/:app_id/errs/:id/comments/create" do
-    render_views
+  describe "POST /apps/:app_id/problems/:problem_id/comments" do
+    context "when create succeeds" do
+      let(:problem) { create(:errbit_problem) }
 
-    before do
-      sign_in create(:user, admin: true)
+      before do
+        post :create, params: {
+          app_id: problem.app.id,
+          problem_id: problem.id,
+          comment: {body: "One test comment"}
+        }
+      end
+
+      it "creates the comment under the problem" do
+        expect(problem.comments.reload.size).to eq(1)
+        expect(problem.comments.first.body).to eq("One test comment")
+      end
+
+      it "redirects to the problem page" do
+        expect(response).to redirect_to(app_problem_path(problem.app, problem))
+      end
     end
 
-    context "successful comment creation" do
-      let(:problem) { create(:problem) }
-      let(:user) { create(:user) }
+    context "when create fails (blank body)" do
+      let(:problem) { create(:errbit_problem) }
 
       before do
         post :create, params: {
           app_id: problem.app.id,
           problem_id: problem.id,
-          comment: {
-            body: "One test comment",
-            user_id: user.id
-          }
+          comment: {body: ""}
         }
-        problem.reload
       end
 
-      it "should create the comment" do
-        expect(problem.comments.size).to eq(1)
+      it "does not create a comment" do
+        expect(problem.comments.reload).to be_empty
+      end
+
+      it "flashes the error message" do
+        expect(request.flash[:error]).to eq(I18n.t("comments.create.error"))
       end
 
-      it "should redirect to problem page" do
+      it "redirects to the problem page" do
         expect(response).to redirect_to(app_problem_path(problem.app, problem))
       end
     end
   end
 
-  describe "DELETE /apps/:app_id/errs/:id/comments/:id/destroy" do
-    render_views
-
-    before do
-      sign_in create(:user, admin: true)
-    end
-
-    context "successful comment deletion" do
-      let(:problem) { create(:problem_with_comments) }
+  describe "DELETE /apps/:app_id/problems/:problem_id/comments/:id" do
+    context "when destroy succeeds" do
+      let(:problem) { create(:errbit_problem_with_comments) }
       let(:comment) { problem.reload.comments.first }
 
       before do
@@ -55,14 +63,13 @@
           problem_id: problem.id,
           id: comment.id.to_s
         }
-        problem.reload
       end
 
-      it "should delete the comment" do
-        expect(problem.comments.detect { |c| c.id.to_s == comment.id }).to eq(nil)
+      it "deletes the comment" do
+        expect(Errbit::Comment.where(id: comment.id)).to be_empty
       end
 
-      it "should redirect to problem page" do
+      it "redirects to the problem page" do
         expect(response).to redirect_to(app_problem_path(problem.app, problem))
       end
     end
diff --git a/spec/controllers/devise/sessions_controller_spec.rb b/spec/controllers/devise/sessions_controller_spec.rb
index add0ff23c2..878b48d1cd 100644
--- a/spec/controllers/devise/sessions_controller_spec.rb
+++ b/spec/controllers/devise/sessions_controller_spec.rb
@@ -10,11 +10,9 @@
       @request.env["devise.mapping"] = Devise.mappings[:user]
     end
 
-    let(:app) { create(:app) }
+    let(:user) { create(:errbit_user) }
 
-    let(:user) { create(:user) }
-
-    it "redirects to app index page if there are no apps for the user" do
+    it "redirects to app index page on successful sign-in" do
       post :create, params: {user: {"email" => user.email, "password" => user.password}}
 
       expect(response).to redirect_to(root_path)
diff --git a/spec/controllers/notices_controller_spec.rb b/spec/controllers/notices_controller_spec.rb
index be1f76de83..5ec1930b86 100644
--- a/spec/controllers/notices_controller_spec.rb
+++ b/spec/controllers/notices_controller_spec.rb
@@ -5,70 +5,71 @@
 RSpec.describe NoticesController, type: :controller do
   it_requires_authentication for: {locate: :get}
 
-  let(:notice) { create(:notice) }
-
+  let(:notice) { create(:errbit_notice) }
   let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice.xml").read }
-
-  let(:app) { create(:app) }
-
+  let(:app) { create(:errbit_app) }
   let(:error_report) { double(valid?: true, generate_notice!: true, notice: notice, should_keep?: true) }
 
-  context "notices API" do
+  context "with the notices API" do
     context "with bogus xml" do
       it "returns an error" do
         post :create, body: "<r><b>notxml</r>", format: :xml
+
         expect(response).to have_http_status(:unprocessable_content)
         expect(response.body).to eq("The provided XML was not well-formed")
       end
     end
 
-    context "with all params" do
+    context "with valid params" do
       before do
-        expect(ErrorReport).to receive(:new).with(xml).and_return(error_report)
+        expect(Errbit::ErrorReport).to receive(:new).with(xml).and_return(error_report)
       end
 
-      context "with xml pass in raw_port" do
-        before do
-          post :create, body: xml, format: :xml
-        end
+      context "with xml in the raw POST body" do
+        before { post :create, body: xml, format: :xml }
 
-        it "generates a notice from raw xml [POST]" do
+        it "generates a notice and renders an XML payload" do
           expect(response).to be_successful
-          # Same RegExp from Airbrake::Sender#send_to_airbrake (https://github.com/airbrake/airbrake/blob/master/lib/airbrake/sender.rb#L53)
-          # Inspired by https://github.com/airbrake/airbrake/blob/master/test/sender_test.rb
           expect(response.body).to match(%r{<id[^>]*>#{notice.id}</id>})
           expect(response.body).to match(%r{<url[^>]*>(.+)#{locate_path(notice.id)}</url>})
         end
       end
 
-      it "generates a notice from xml in a data param [POST]" do
-        post :create, params: {data: xml, format: :xml}
-        expect(response).to be_successful
-        # Same RegExp from Airbrake::Sender#send_to_airbrake (https://github.com/airbrake/airbrake/blob/master/lib/airbrake/sender.rb#L53)
-        # Inspired by https://github.com/airbrake/airbrake/blob/master/test/sender_test.rb
-        expect(response.body).to match(%r{<id[^>]*>#{notice.id}</id>})
-        expect(response.body).to match(%r{<url[^>]*>(.+)#{locate_path(notice.id)}</url>})
+      context "with xml in a data POST param" do
+        before { post :create, params: {data: xml, format: :xml} }
+
+        it "generates a notice and renders an XML payload" do
+          expect(response).to be_successful
+          expect(response.body).to match(%r{<id[^>]*>#{notice.id}</id>})
+          expect(response.body).to match(%r{<url[^>]*>(.+)#{locate_path(notice.id)}</url>})
+        end
       end
 
-      it "generates a notice from xml [GET]" do
-        get :create, params: {data: xml, format: :xml}
-        expect(response).to be_successful
-        expect(response.body).to match(%r{<id[^>]*>#{notice.id}</id>})
-        expect(response.body).to match(%r{<url[^>]*>(.+)#{locate_path(notice.id)}</url>})
+      context "with xml in a data GET param" do
+        before { get :create, params: {data: xml, format: :xml} }
+
+        it "generates a notice and renders an XML payload" do
+          expect(response).to be_successful
+          expect(response.body).to match(%r{<id[^>]*>#{notice.id}</id>})
+          expect(response.body).to match(%r{<url[^>]*>(.+)#{locate_path(notice.id)}</url>})
+        end
       end
-      context "with an invalid API_KEY" do
+
+      context "with an invalid API key" do
         let(:error_report) { double(valid?: false) }
 
-        it "return 422" do
+        it "returns 422" do
           post :create, params: {format: :xml, data: xml}
+
           expect(response).to have_http_status(:unprocessable_content)
         end
       end
     end
 
-    context "without params needed" do
-      it "return 400" do
+    context "without the params needed" do
+      it "returns 400" do
         post :create, format: :xml
+
         expect(response).to have_http_status(:bad_request)
         expect(response.body).to eq("Need a data params in GET or raw post data")
       end
@@ -77,16 +78,15 @@
 
   describe "GET /locate/:id" do
     context "when logged in as an admin" do
-      before do
-        @user = create(:user, admin: true)
-        sign_in @user
-      end
+      before { sign_in create(:errbit_user, admin: true) }
+
+      it "locates the notice and redirects to its problem page" do
+        problem = create(:errbit_problem, app: app, environment: "production")
+        err = create(:errbit_err, problem: problem)
+        located = create(:errbit_notice, err: err, app: app)
+
+        get :locate, params: {id: located.id}
 
-      it "should locate notice and redirect to problem" do
-        problem = create(:problem, app: app, environment: "production")
-        err = create(:err, problem: problem)
-        notice = create(:notice, err: err)
-        get :locate, params: {id: notice.id}
         expect(response).to redirect_to(app_problem_path(problem.app, problem))
       end
     end
@@ -94,17 +94,16 @@
 
   describe "GET /notices/:id" do
     context "when logged in as an admin" do
-      before do
-        @user = create(:user, admin: true)
-        sign_in @user
-      end
+      before { sign_in create(:errbit_user, admin: true) }
+
+      it "redirects to the problem page with the notice id" do
+        problem = create(:errbit_problem, app: app, environment: "production")
+        err = create(:errbit_err, problem: problem)
+        located = create(:errbit_notice, err: err, app: app)
+
+        get :show_by_id, params: {id: located.id}
 
-      it "should locate notice and redirect to problem with notice_id" do
-        problem = create(:problem, app: app, environment: "production")
-        err = create(:err, problem: problem)
-        notice = create(:notice, err: err)
-        get :show_by_id, params: {id: notice.id}
-        expect(response).to redirect_to(app_problem_path(problem.app, problem, notice_id: notice.id))
+        expect(response).to redirect_to(app_problem_path(problem.app, problem, notice_id: located.id))
       end
     end
   end
diff --git a/spec/controllers/problems_controller_spec.rb b/spec/controllers/problems_controller_spec.rb
index a7bf117065..1eec790f5f 100644
--- a/spec/controllers/problems_controller_spec.rb
+++ b/spec/controllers/problems_controller_spec.rb
@@ -4,38 +4,29 @@
 
 RSpec.describe ProblemsController, type: :controller do
   it_requires_authentication(
-    for: {
-      index: :get, show: :get, resolve: :patch, search: :get
-    },
+    for: {index: :get, show: :get, resolve: :patch, search: :get},
     params: {app_id: "dummyid", id: "dummyid"}
   )
 
-  let(:app) { create(:app) }
-
-  let(:err) { create(:err, problem: problem) }
-
-  let(:user) { create(:user) }
-
-  let(:problem) { create(:problem, app: app, environment: "production") }
+  let(:user) { create(:errbit_user) }
+  let(:app) { create(:errbit_app) }
+  let(:problem) { create(:errbit_problem, app: app, environment: "production") }
+  let(:err) { create(:errbit_err, problem: problem) }
 
   describe "GET /problems" do
-    before do
-      sign_in user
-
-      @problem = create(:notice, err: create(:err, problem: create(:problem, app: app, environment: "production"))).problem
-    end
+    before { sign_in user }
 
-    context "pagination" do
-      before { create_list(:err, 35) }
+    context "with pagination" do
+      before { 35.times { create(:errbit_err) } }
 
-      it "should have default per_page value for user" do
+      it "uses the default per_page value" do
         get :index
 
-        expect(controller.problems.to_a.size).to eq(User::PER_PAGE)
+        expect(controller.problems.to_a.size).to eq(Errbit::User::PER_PAGE)
       end
 
-      it "should be able to override default per_page value" do
-        user.update_attribute(:per_page, 10)
+      it "honors the user's per_page override" do
+        user.update!(per_page: 10)
 
         get :index
 
@@ -45,48 +36,29 @@
 
     context "with environment filters" do
       before do
-        environments = ["production", "test", "development", "staging"]
-
-        20.times do |i|
-          create(:problem, environment: environments[i % environments.length])
-        end
+        environments = %w[production test development staging]
+        20.times { |i| create(:errbit_problem, environment: environments[i % environments.length]) }
       end
 
-      context "no params" do
-        it "shows problems for all environments" do
+      context "without env params" do
+        it "shows problems for every environment" do
           get :index
 
-          expect(controller.problems.size).to eq(21)
+          expect(controller.problems.size).to eq(20)
         end
       end
 
-      context "environment production" do
-        it "shows problems for just production" do
+      context "with environment=production" do
+        it "filters to just production" do
           get :index, params: {environment: "production"}
 
-          expect(controller.problems.size).to eq(6)
-        end
-      end
-
-      context "environment staging" do
-        it "shows problems for just staging" do
-          get :index, params: {environment: "staging"}
-
-          expect(controller.problems.size).to eq(5)
-        end
-      end
-
-      context "environment development" do
-        it "shows problems for just development" do
-          get :index, params: {environment: "development"}
-
           expect(controller.problems.size).to eq(5)
         end
       end
 
-      context "environment test" do
-        it "shows problems for just test" do
-          get :index, params: {environment: "test"}
+      context "with environment=staging" do
+        it "filters to just staging" do
+          get :index, params: {environment: "staging"}
 
           expect(controller.problems.size).to eq(5)
         end
@@ -94,32 +66,12 @@
     end
   end
 
-  describe "GET /problems - previously all" do
-    it "gets a paginated list of all problems" do
-      sign_in create(:user)
-
-      problems = Kaminari.paginate_array((1..30).to_a)
-
-      3.times { problems << create(:err).problem }
-
-      3.times { problems << create(:err, problem: create(:problem, resolved: true)).problem }
-
-      expect(Problem).to receive(:ordered_by).and_return(
-        double("proxy", page: double("other_proxy", per: problems))
-      )
-
-      get :index, params: {all_errs: true}
-
-      expect(controller.problems).to eq(problems)
-    end
-  end
-
   describe "GET /problems/search" do
     before do
       sign_in user
-      @app = create(:app)
-      @problem_1 = create(:problem, app: @app, message: "Most important")
-      @problem_2 = create(:problem, app: @app, message: "Very very important")
+      @search_app = create(:errbit_app)
+      @problem_1 = create(:errbit_problem, app: @search_app, message: "Most important")
+      @problem_2 = create(:errbit_problem, app: @search_app, message: "Trivial issue")
     end
 
     it "renders successfully" do
@@ -128,109 +80,80 @@
       expect(response).to be_successful
     end
 
-    it "renders index template" do
+    it "renders the index template" do
       get :search
 
       expect(response).to render_template("problems/index")
     end
 
-    it "searches problems for given string" do
-      get :search, params: {search: "\"Most important\""}
+    it "filters problems by the search string" do
+      get :search, params: {search: "Most important"}
 
       expect(controller.problems).to include(@problem_1)
-
       expect(controller.problems).not_to include(@problem_2)
     end
 
-    it "works when given string is empty" do
+    it "returns every problem when the search string is empty" do
       get :search, params: {search: ""}
 
-      expect(controller.problems).to include(@problem_1)
-
-      expect(controller.problems).to include(@problem_2)
+      expect(controller.problems).to include(@problem_1, @problem_2)
     end
   end
 
-  # you do not need an app id, strictly speaking, to find
-  # a problem, and if your metrics system does not happen
-  # to know the app id, but does know the problem id,
-  # it can be handy to have a way to link in to errbit.
-  describe "GET /problems/:id" do
-    before do
-      sign_in user
-    end
+  describe "GET /problems/:id (show_by_id)" do
+    before { sign_in user }
 
-    it "should redirect to the standard problems page" do
+    it "redirects to the standard problem page" do
       get :show_by_id, params: {id: err.problem.id}
 
-      expect(response).to redirect_to(app_problem_path(app, err.problem.id))
+      expect(response).to redirect_to(app_problem_path(app, err.problem))
     end
   end
 
-  describe "GET /apps/:app_id/problems/:id" do
-    before do
-      sign_in user
-    end
+  describe "GET /apps/:app_id/problems/:id (show)" do
+    before { sign_in user }
 
     it "finds the app" do
       get :show, params: {app_id: app.id, id: err.problem.id}
 
-      expect(controller.app).to eq(app)
+      expect(controller.app.object).to eq(app)
     end
 
     it "finds the problem" do
       get :show, params: {app_id: app.id, id: err.problem.id}
 
-      expect(controller.problem).to eq(err.problem)
+      expect(controller.problem.object).to eq(err.problem)
     end
 
-    it "successfully render page" do
+    it "responds successfully" do
       get :show, params: {app_id: app.id, id: err.problem.id}
 
       expect(response).to be_successful
     end
 
-    context "when rendering views" do
-      render_views
-
-      it "successfully renders the view even when there are no notices attached to the problem" do
-        expect(err.problem.notices).to be_empty
-
-        get :show, params: {app_id: app.id, id: err.problem.id}
-
-        expect(response).to be_successful
-      end
-    end
-
-    context "pagination" do
+    context "with notices" do
       let!(:notices) do
-        3.times.reduce([]) do |coll, i|
-          coll << create(:notice, err: err, created_at: i.seconds.from_now)
-        end
+        3.times.map { |i| create(:errbit_notice, err: err, created_at: i.seconds.from_now) }
       end
 
-      it "paginates the notices 1 at a time, starting with the most recent" do
+      it "paginates notices 1 at a time, newest first" do
         get :show, params: {app_id: app.id, id: err.problem.id}
 
         expect(assigns(:notices).entries.count).to eq(1)
-
         expect(assigns(:notices)).to include(notices.last)
       end
 
-      it "paginates the notices 1 at a time, based on then notice param" do
+      it "honors the notice page param" do
         get :show, params: {app_id: app.id, id: err.problem.id, notice: 3}
 
         expect(assigns(:notices).entries.count).to eq(1)
-
         expect(assigns(:notices)).to include(notices.first)
       end
     end
   end
 
   describe "GET /apps/:app_id/problems/:id/xhr_sparkline" do
-    before do
-      sign_in user
-    end
+    before { sign_in user }
 
     it "renders without error" do
       get :xhr_sparkline, params: {app_id: app.id, id: err.problem.id}
@@ -240,155 +163,88 @@
   end
 
   describe "PATCH /apps/:app_id/problems/:id/resolve" do
-    before do
-      sign_in user
-
-      @err = create(:err)
-    end
+    let!(:resolvable_err) { create(:errbit_err) }
 
-    it "finds the app and the problem" do
-      patch :resolve, params: {app_id: @err.app.id, id: @err.problem.id}
-
-      expect(controller.app).to eq @err.app
-      expect(controller.problem).to eq(@err.problem)
-    end
+    before { sign_in user }
 
-    it "should resolve the issue" do
-      patch :resolve, params: {app_id: @err.app.id, id: @err.problem.id}
+    it "finds the app and problem" do
+      patch :resolve, params: {app_id: resolvable_err.app.id, id: resolvable_err.problem.id}
 
-      expect(@err.problem.reload.resolved).to eq(true)
+      expect(controller.app.object).to eq(resolvable_err.app)
+      expect(controller.problem.object).to eq(resolvable_err.problem)
     end
 
-    it "should display a message" do
-      patch :resolve, params: {app_id: @err.app.id, id: @err.problem.id}
+    it "marks the problem as resolved" do
+      patch :resolve, params: {app_id: resolvable_err.app.id, id: resolvable_err.problem.id}
 
-      expect(request.flash[:success]).to match(/Great news/)
+      expect(resolvable_err.problem.reload.resolved).to eq(true)
     end
 
-    it "should redirect to the app page" do
-      request.env["HTTP_REFERER"] = app_path(@err.app)
-
-      patch :resolve, params: {app_id: @err.app.id, id: @err.problem.id}
+    it "flashes a success message" do
+      patch :resolve, params: {app_id: resolvable_err.app.id, id: resolvable_err.problem.id}
 
-      expect(response).to redirect_to(app_path(@err.app))
+      expect(request.flash[:success]).to match(/resolved/)
     end
 
-    it "should redirect back to problems page" do
-      request.env["HTTP_REFERER"] = problems_path
+    it "redirects back to the referer" do
+      request.env["HTTP_REFERER"] = app_path(resolvable_err.app)
 
-      patch :resolve, params: {app_id: @err.app.id, id: @err.problem.id}
+      patch :resolve, params: {app_id: resolvable_err.app.id, id: resolvable_err.problem.id}
 
-      expect(response).to redirect_to(problems_path)
+      expect(response).to redirect_to(app_path(resolvable_err.app))
     end
   end
 
   describe "POST /apps/:app_id/problems/:id/create_issue" do
     before { sign_in user }
 
-    context "when app has a issue tracker" do
-      let(:notice) { NoticeDecorator.new(create(:notice)) }
-      let(:problem) { ProblemDecorator.new(notice.problem) }
-      let(:issue_tracker) do
-        create(:issue_tracker).tap do |t|
-          t.instance_variable_set(:@tracker, ErrbitPlugin::MockIssueTracker.new(t.options))
-        end
-      end
-
-      before do
-        problem.app.issue_tracker = issue_tracker
-        allow(controller).to receive(:problem).and_return(problem)
-        allow(controller).to receive(:current_user).and_return(user)
-      end
-
-      it "should redirect to problem page" do
+    context "when the app has no issue tracker" do
+      it "flashes an error and redirects to the problem page" do
         post :create_issue, params: {app_id: problem.app.id, id: problem.id}
 
         expect(response).to redirect_to(app_problem_path(problem.app, problem))
+        expect(flash[:error]).to eq("This app has no issue tracker")
+      end
+    end
 
-        expect(flash[:error]).to be_blank
+    context "when the app has an issue tracker" do
+      let(:decorated_problem) { Errbit::ProblemDecorator.new(problem) }
+      let!(:issue_tracker) do
+        t = create(:errbit_issue_tracker, app: app)
+        # The controller's `app` is a fresh AR load that wouldn't see this
+        # instance_variable_set. Stub `controller.problem` below so the issue
+        # tracker chain reuses the test's records.
+        t.instance_variable_set(:@tracker, ErrbitPlugin::MockIssueTracker.new(t.options))
+        t
       end
 
-      it "should save the right title" do
-        post :create_issue, params: {app_id: problem.app.id, id: problem.id}
-        title = "[#{problem.environment}][#{problem.where}] #{problem.message.to_s.truncate(100)}"
-        line = issue_tracker.tracker.output.shift
-        expect(line[0]).to eq(title)
+      before do
+        allow(controller).to receive(:problem).and_return(decorated_problem)
+        allow(controller).to receive(:current_user).and_return(user)
       end
 
-      it "should renders the issue body" do
-        post :create_issue, params: {app_id: problem.app.id, id: problem.id, format: "html"}
+      it "redirects to the problem page without an error" do
+        post :create_issue, params: {app_id: app.id, id: problem.id}
 
-        expect(response).to render_template("issue_trackers/markdown")
+        expect(response).to redirect_to(app_problem_path(app, problem))
+        expect(flash[:error]).to be_blank
       end
 
-      it "should update the problem" do
-        post :create_issue, params: {app_id: problem.app.id, id: problem.id}
+      it "stores the issue link and type on the problem" do
+        post :create_issue, params: {app_id: app.id, id: problem.id}
 
+        problem.reload
         expect(problem.issue_link).to eq("http://example.com/mock-errbit")
         expect(problem.issue_type).to eq("mock")
       end
-
-      context "when rendering views" do
-        render_views
-
-        it "should save the right body" do
-          post :create_issue, params: {app_id: problem.app.id, id: problem.id, format: "html"}
-
-          line = issue_tracker.tracker.output.shift
-
-          expect(line[1]).to include(app_problem_url(problem.app, problem))
-        end
-
-        it "should render whatever the issue tracker says" do
-          allow_any_instance_of(Issue).to receive(:render_body_args).and_return(
-            [{inline: "one <%= problem.id %> two"}]
-          )
-          post :create_issue, params: {app_id: problem.app.id, id: problem.id, format: "html"}
-          line = issue_tracker.tracker.output.shift
-          expect(line[1]).to include("one #{problem.id} two")
-        end
-      end
-    end
-
-    context "when app has no issue tracker" do
-      it "should redirect to problem page" do
-        post :create_issue, params: {app_id: problem.app.id, id: problem.id}
-
-        expect(response).to redirect_to(app_problem_path(problem.app, problem))
-
-        expect(flash[:error]).to eq("This app has no issue tracker")
-      end
     end
   end
 
   describe "POST /apps/:app_id/problems/:id/close_issue" do
     before { sign_in user }
 
-    context "when app has a issue tracker" do
-      let(:notice) { NoticeDecorator.new(create(:notice)) }
-      let(:problem) { ProblemDecorator.new(notice.problem) }
-      let(:issue_tracker) do
-        create(:issue_tracker).tap do |t|
-          t.instance_variable_set(:@tracker, ErrbitPlugin::MockIssueTracker.new(t.options))
-        end
-      end
-
-      before do
-        problem.app.issue_tracker = issue_tracker
-        allow(controller).to receive(:problem).and_return(problem)
-        allow(controller).to receive(:current_user).and_return(user)
-      end
-
-      it "should redirect to problem page" do
-        post :close_issue, params: {app_id: problem.app.id, id: problem.id}
-
-        expect(response).to redirect_to(app_problem_path(problem.app, problem))
-        expect(flash[:error]).to be_blank
-      end
-    end
-
-    context "when app has no issue tracker" do
-      it "should redirect to problem page" do
+    context "when the app has no issue tracker" do
+      it "flashes an error and redirects to the problem page" do
         post :close_issue, params: {app_id: problem.app.id, id: problem.id}
 
         expect(response).to redirect_to(app_problem_path(problem.app, problem))
@@ -398,155 +254,159 @@
   end
 
   describe "DELETE /apps/:app_id/problems/:id/unlink_issue" do
-    before do
-      sign_in user
-    end
-
-    context "problem with issue" do
-      let(:err) { create(:err, problem: create(:problem, issue_link: "http://some.host")) }
+    before { sign_in user }
 
-      before do
-        delete :unlink_issue, params: {app_id: err.app.id, id: err.problem.id}
-        err.problem.reload
+    context "when the problem has an issue link" do
+      let!(:linked_err) do
+        create(:errbit_err, problem: create(:errbit_problem, app: app, issue_link: "http://some.host"))
       end
 
-      it "should redirect to problem page" do
-        expect(response).to redirect_to(app_problem_path(err.app, err.problem))
-      end
+      it "clears the issue_link and redirects" do
+        delete :unlink_issue, params: {app_id: linked_err.app.id, id: linked_err.problem.id}
 
-      it "should clear issue link" do
-        expect(err.problem.issue_link).to eq(nil)
+        expect(response).to redirect_to(app_problem_path(linked_err.app, linked_err.problem))
+        expect(linked_err.problem.reload.issue_link).to be_nil
       end
     end
 
-    context "err without issue" do
-      let(:err) { create(:err) }
-
-      before do
+    context "when the problem has no issue link" do
+      it "redirects to the problem page" do
         delete :unlink_issue, params: {app_id: err.app.id, id: err.problem.id}
-        err.problem.reload
-      end
 
-      it "should redirect to problem page" do
         expect(response).to redirect_to(app_problem_path(err.app, err.problem))
       end
     end
   end
 
   describe "Bulk Actions" do
-    before do
-      sign_in user
-      @problem_1 = create(:err, problem: create(:problem, resolved: true)).problem
-      @problem_2 = create(:err, problem: create(:problem, resolved: false)).problem
-    end
+    let!(:problem_1) { create(:errbit_err, problem: create(:errbit_problem, resolved: true)).problem }
+    let!(:problem_2) { create(:errbit_err, problem: create(:errbit_problem, resolved: false)).problem }
+
+    before { sign_in user }
 
-    context "POST /problems/merge_several" do
-      it "should require at least two problems" do
-        post :merge_several, params: {problems: [@problem_1.id.to_s]}
+    describe "POST /problems/merge_several" do
+      context "when only one problem is selected" do
+        it "flashes that two are required" do
+          post :merge_several, params: {problems: [problem_1.id.to_s]}
 
-        expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.need_two_errors_merge"))
+          expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.need_two_errors_merge"))
+        end
       end
 
-      it "should merge the problems" do
-        expect(ProblemMerge).to receive(:new).and_return(double(merge: true))
+      context "with at least two problems" do
+        it "merges them via Errbit::ProblemMerge" do
+          expect(Errbit::ProblemMerge).to receive(:new).and_return(double(merge: true))
 
-        post :merge_several, params: {problems: [@problem_1.id.to_s, @problem_2.id.to_s]}
+          post :merge_several, params: {problems: [problem_1.id.to_s, problem_2.id.to_s]}
+        end
       end
     end
 
-    context "POST /problems/unmerge_several" do
-      it "should require at least one problem" do
-        post :unmerge_several, params: {problems: []}
-        expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+    describe "POST /problems/unmerge_several" do
+      context "without any selected problems" do
+        it "flashes the no-select message" do
+          post :unmerge_several, params: {problems: []}
+
+          expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+        end
       end
 
-      it "should unmerge a merged problem" do
-        merged_problem = Problem.merge!(@problem_1, @problem_2)
-        expect(merged_problem.errs.length).to eq(2)
-        expect do
-          post :unmerge_several, params: {problems: [merged_problem.id.to_s]}
-          expect(merged_problem.reload.errs.length).to eq(1)
-        end.to change(Problem, :count).by(1)
+      context "with a merged problem selected" do
+        it "splits its errs back into separate problems" do
+          merged = Errbit::Problem.merge!(problem_1, problem_2)
+
+          expect(merged.errs.length).to eq(2)
+
+          expect {
+            post :unmerge_several, params: {problems: [merged.id.to_s]}
+          }.to change(Errbit::Problem, :count).by(1)
+
+          expect(merged.reload.errs.length).to eq(1)
+        end
       end
     end
 
-    context "POST /problems/resolve_several" do
-      it "should require at least one problem" do
-        post :resolve_several, params: {problems: []}
+    describe "POST /problems/resolve_several" do
+      context "without any selected problems" do
+        it "flashes the no-select message" do
+          post :resolve_several, params: {problems: []}
 
-        expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+          expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+        end
       end
 
-      it "should resolve the issue" do
-        post :resolve_several, params: {problems: [@problem_2.id.to_s]}
+      context "with one selected problem" do
+        it "resolves it" do
+          post :resolve_several, params: {problems: [problem_2.id.to_s]}
 
-        expect(@problem_2.reload.resolved?).to eq(true)
-      end
+          expect(problem_2.reload.resolved?).to eq(true)
+        end
 
-      it "should display a message about 1 err" do
-        post :resolve_several, params: {problems: [@problem_2.id.to_s]}
+        it "flashes a singular message" do
+          post :resolve_several, params: {problems: [problem_2.id.to_s]}
 
-        expect(flash[:success]).to match(/1 error has been resolved/)
+          expect(flash[:success]).to match(/1 error has been resolved/)
+        end
       end
 
-      it "should display a message about 2 errs" do
-        post :resolve_several, params: {problems: [@problem_1.id.to_s, @problem_2.id.to_s]}
+      context "with two selected problems" do
+        it "flashes a plural message" do
+          post :resolve_several, params: {problems: [problem_1.id.to_s, problem_2.id.to_s]}
 
-        expect(flash[:success]).to match(/2 errors have been resolved/)
-        expect(controller.selected_problems).to eq([@problem_1, @problem_2])
+          expect(flash[:success]).to match(/2 errors have been resolved/)
+        end
       end
     end
 
-    context "POST /problems/unresolve_several" do
-      it "should require at least one problem" do
-        post :unresolve_several, params: {problems: []}
+    describe "POST /problems/unresolve_several" do
+      context "without any selected problems" do
+        it "flashes the no-select message" do
+          post :unresolve_several, params: {problems: []}
 
-        expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+          expect(request.flash[:notice]).to eq(I18n.t("controllers.problems.flash.no_select_problem"))
+        end
       end
 
-      it "should unresolve the issue" do
-        post :unresolve_several, params: {problems: [@problem_1.id.to_s]}
+      context "with one selected problem" do
+        it "unresolves it" do
+          post :unresolve_several, params: {problems: [problem_1.id.to_s]}
 
-        expect(@problem_1.reload.resolved?).to eq(false)
+          expect(problem_1.reload.resolved?).to eq(false)
+        end
       end
     end
 
-    context "POST /problems/destroy_several" do
-      it "should delete the problems" do
-        expect do
-          post :destroy_several, params: {problems: [@problem_1.id.to_s]}
-        end.to change(Problem, :count).by(-1)
+    describe "POST /problems/destroy_several" do
+      it "enqueues a destroy job" do
+        expect(Errbit::DestroyProblemsByIdJob).to receive(:perform_later).with([problem_1.id.to_s])
+
+        post :destroy_several, params: {problems: [problem_1.id.to_s]}
       end
     end
 
     describe "POST /apps/:app_id/problems/destroy_all" do
-      before do
-        sign_in user
-        @app = create(:app)
-        @problem_1 = create(:problem, app: @app)
-        @problem_2 = create(:problem, app: @app)
-      end
+      let!(:bulk_app) { create(:errbit_app) }
+      let!(:bulk_problem_1) { create(:errbit_problem, app: bulk_app) }
+      let!(:bulk_problem_2) { create(:errbit_problem, app: bulk_app) }
 
-      it "destroys all problems" do
-        expect do
-          post :destroy_all, params: {app_id: @app.id}
-        end.to change(Problem, :count).by(-2)
+      it "enqueues a destroy-all-by-app job" do
+        expect(Errbit::DestroyProblemsByAppJob).to receive(:perform_later).with(bulk_app.id)
 
-        expect(controller.app).to eq(@app)
+        post :destroy_all, params: {app_id: bulk_app.id}
       end
 
-      it "should display a message" do
-        patch :destroy_all, params: {app_id: @app.id}
+      it "flashes a confirmation" do
+        patch :destroy_all, params: {app_id: bulk_app.id}
 
         expect(request.flash[:success]).to match(/be deleted/)
       end
 
-      it "should redirect back to the app page" do
-        request.env["HTTP_REFERER"] = edit_app_path(@app)
+      it "redirects back to the referer" do
+        request.env["HTTP_REFERER"] = edit_app_path(bulk_app)
 
-        patch :destroy_all, params: {app_id: @app.id}
+        patch :destroy_all, params: {app_id: bulk_app.id}
 
-        expect(response).to redirect_to(edit_app_path(@app))
+        expect(response).to redirect_to(edit_app_path(bulk_app))
       end
     end
   end
diff --git a/spec/controllers/site_config_controller_spec.rb b/spec/controllers/site_config_controller_spec.rb
index d03d67ea63..576c700e57 100644
--- a/spec/controllers/site_config_controller_spec.rb
+++ b/spec/controllers/site_config_controller_spec.rb
@@ -8,18 +8,20 @@
     update: :patch
   }
 
-  let(:admin) { create(:user, admin: true) }
+  let(:admin) { create(:errbit_user, admin: true) }
 
   before { sign_in admin }
 
   describe "#index" do
-    it "has an index action" do
+    it "responds successfully" do
       get :index
+
+      expect(response).to be_successful
     end
   end
 
   describe "#update" do
-    it "updates" do
+    it "writes the submitted fingerprinter fields to SiteConfig" do
       patch :update, params: {
         site_config: {
           notice_fingerprinter_attributes: {
@@ -29,19 +31,15 @@
         }
       }
 
-      fingerprinter = SiteConfig.document.notice_fingerprinter
+      document = Errbit::SiteConfig.document
 
-      expect(fingerprinter.environment_name).to eq(false)
-      expect(fingerprinter.backtrace_lines).to eq(3)
+      expect(document.environment_name).to eq(false)
+      expect(document.backtrace_lines).to eq(3)
     end
 
     it "redirects to the index" do
       patch :update, params: {
-        site_config: {
-          notice_fingerprinter_attributes: {
-            error_class: true
-          }
-        }
+        site_config: {notice_fingerprinter_attributes: {error_class: true}}
       }
 
       expect(response).to redirect_to(site_config_index_path)
@@ -49,45 +47,68 @@
 
     it "flashes a confirmation" do
       patch :update, params: {
-        site_config: {
-          notice_fingerprinter_attributes: {
-            error_class: true
-          }
-        }
+        site_config: {notice_fingerprinter_attributes: {error_class: true}}
       }
 
-      expect(request.flash[:success]).to eq "Updated site config"
+      expect(request.flash[:success]).to eq("Updated site config")
     end
 
-    it "updates apps that are using site wide notice fingerprinter" do
-      patch :update, params: {
-        site_config: {
-          notice_fingerprinter_attributes: {
-            backtrace_lines: 10,
-            environment_name: false
+    context "with an Errbit::App that follows the site-wide fingerprinter" do
+      let!(:app) do
+        a = create(:errbit_app)
+        # The before_create callback auto-builds a "site"-sourced fingerprinter;
+        # update its values to the test's baseline.
+        a.notice_fingerprinter.update!(
+          error_class: true,
+          message: true,
+          backtrace_lines: -1,
+          component: true,
+          action: true,
+          environment_name: true,
+          source: Errbit::SiteConfig::CONFIG_SOURCE_SITE
+        )
+        a
+      end
+
+      it "propagates the change to the app's fingerprinter" do
+        patch :update, params: {
+          site_config: {
+            notice_fingerprinter_attributes: {backtrace_lines: 11, environment_name: false}
           }
         }
-      }
 
-      app = App.new(name: "my_app")
-      app.save
-
-      expect(app.notice_fingerprinter.backtrace_lines).to eq(10)
-      expect(app.notice_fingerprinter.environment_name).to eq(false)
+        app.reload
+        expect(app.notice_fingerprinter.backtrace_lines).to eq(11)
+        expect(app.notice_fingerprinter.environment_name).to eq(false)
+      end
+    end
 
-      patch :update, params: {
-        site_config: {
-          notice_fingerprinter_attributes: {
-            backtrace_lines: 11,
-            environment_name: true
+    context "with an Errbit::App that has opted into a per-app fingerprinter" do
+      let!(:app) do
+        a = create(:errbit_app)
+        a.notice_fingerprinter.update!(
+          error_class: true,
+          message: true,
+          backtrace_lines: 5,
+          component: true,
+          action: true,
+          environment_name: true,
+          source: Errbit::SiteConfig::CONFIG_SOURCE_APP
+        )
+        a
+      end
+
+      it "leaves the app's fingerprinter untouched" do
+        patch :update, params: {
+          site_config: {
+            notice_fingerprinter_attributes: {backtrace_lines: 99, environment_name: false}
           }
         }
-      }
-
-      app.reload
 
-      expect(app.notice_fingerprinter.backtrace_lines).to eq(11)
-      expect(app.notice_fingerprinter.environment_name).to eq(true)
+        app.reload
+        expect(app.notice_fingerprinter.backtrace_lines).to eq(5)
+        expect(app.notice_fingerprinter.environment_name).to eq(true)
+      end
     end
   end
 end
diff --git a/spec/controllers/users/omniauth_callbacks_controller_spec.rb b/spec/controllers/users/omniauth_callbacks_controller_spec.rb
index f2a3475a25..a9a1a16ed9 100644
--- a/spec/controllers/users/omniauth_callbacks_controller_spec.rb
+++ b/spec/controllers/users/omniauth_callbacks_controller_spec.rb
@@ -23,11 +23,11 @@ def stub_client_for_github_omniauth(emails = [])
 
   context "Linking a GitHub account to a signed in user" do
     before do
-      sign_in @user = create(:user)
+      sign_in @user = create(:errbit_user)
     end
 
     it "should show an error if another user already has that GitHub login" do
-      create(:user, github_login: "existing_user")
+      create(:errbit_user, github_login: "existing_user")
       stub_env_for_github_omniauth("existing_user")
       get :github
 
@@ -92,11 +92,11 @@ def stub_env_for_google_omniauth(login, _ = nil)
 
   context "Linking a Google account to a signed in user" do
     before do
-      sign_in @user = create(:user)
+      sign_in @user = create(:errbit_user)
     end
 
     it "should show an error if another user already has that google login" do
-      create(:user, google_uid: "111111111111111111111")
+      create(:errbit_user, google_uid: "111111111111111111111")
       stub_env_for_google_omniauth("111111111111111111111")
       get :google_oauth2
 
diff --git a/spec/controllers/watchers_controller_spec.rb b/spec/controllers/watchers_controller_spec.rb
index cdec783833..b261e364df 100644
--- a/spec/controllers/watchers_controller_spec.rb
+++ b/spec/controllers/watchers_controller_spec.rb
@@ -3,28 +3,21 @@
 require "rails_helper"
 
 RSpec.describe WatchersController, type: :controller do
-  let(:user) { create(:user) }
-  let(:problem) { create(:problem) }
+  let(:user) { create(:errbit_user) }
 
   before { sign_in user }
 
   describe "#create" do
-    let(:app) { create(:app) }
+    let(:app) { create(:errbit_app) }
 
-    context "successful watcher create" do
-      before do
-        post :create, params: {app_id: app.id}
+    context "when create succeeds" do
+      before { post :create, params: {app_id: app.id} }
 
-        problem.reload
+      it "adds the current user as an Errbit::Watcher on the app" do
+        expect(app.watchers.reload.first.user).to eq(user)
       end
 
-      it "should be watching" do
-        app.reload
-
-        expect(app.watchers.first.user_id).to eq(user.id)
-      end
-
-      it "should redirect to app page" do
+      it "redirects to the app page" do
         expect(response).to redirect_to(app_path(app))
       end
     end
@@ -32,25 +25,22 @@
 
   describe "#destroy" do
     let(:app) do
-      a = create(:app)
-      create(:user_watcher, app: a, user: user)
+      a = create(:errbit_app)
+      create(:errbit_user_watcher, app: a, user: user)
       a
     end
 
-    context "successful watcher deletion" do
-      let(:watcher) { app.watchers.first }
+    context "when destroy succeeds" do
+      let!(:watcher) { app.watchers.find_by(errbit_user_id: user.id) }
 
-      before do
-        delete :destroy, params: {app_id: app.id}
-
-        problem.reload
-      end
+      before { delete :destroy, params: {app_id: app.id} }
 
-      it "should delete the watcher" do
-        expect(app.watchers.detect { |w| w.id.to_s == watcher.id }).to eq(nil)
+      it "removes the watcher" do
+        expect(Errbit::Watcher.where(id: watcher.id)).to be_empty
+        expect(app.watchers.reload).to be_empty
       end
 
-      it "should redirect to app page" do
+      it "redirects to the app page" do
         expect(response).to redirect_to(app_path(app))
       end
     end
diff --git a/spec/decorators/errbit/app_decorator_spec.rb b/spec/decorators/errbit/app_decorator_spec.rb
new file mode 100644
index 0000000000..bfe646bd1f
--- /dev/null
+++ b/spec/decorators/errbit/app_decorator_spec.rb
@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::AppDecorator, type: :decorator do
+  describe "#email_at_notices" do
+    it "returns the list joined by commas" do
+      expect(described_class.new(double(email_at_notices: [2, 3])).email_at_notices).to eq("2, 3")
+    end
+  end
+
+  describe "#notify_user_display" do
+    it "returns display:none when notify_all_users is true" do
+      expect(described_class.new(double(notify_all_users: true)).notify_user_display).to eq("display: none;")
+    end
+
+    it "returns blank when notify_all_users is false" do
+      expect(described_class.new(double(notify_all_users: false)).notify_user_display).to eq("")
+    end
+  end
+
+  describe "#notify_err_display" do
+    it "returns display:none when notify_on_errs is false" do
+      expect(described_class.new(double(notify_on_errs: false)).notify_err_display).to eq("display: none;")
+    end
+
+    it "returns blank when notify_on_errs is true" do
+      expect(described_class.new(double(notify_on_errs: true)).notify_err_display).to eq("")
+    end
+  end
+
+  describe "#custom_backtrace_url" do
+    it "replaces unescaped fields in the template" do
+      dbl = double(repo_branch: "feature/branch",
+        custom_backtrace_url_template: "https://example.com/repo/name/src/branch/%{branch}/%{file}#L%{line}")
+
+      expect(described_class.new(dbl).custom_backtrace_url("test/file.rb", 42))
+        .to eq("https://example.com/repo/name/src/branch/feature/branch/test/file.rb#L42")
+    end
+
+    it "replaces escaped fields in the template" do
+      dbl = double(repo_branch: "feature/branch",
+        custom_backtrace_url_template: "https://example.com/repo/name/src/branch/%{ebranch}/%{efile}#L%{line}")
+
+      expect(described_class.new(dbl).custom_backtrace_url("test/file.rb", 42))
+        .to eq("https://example.com/repo/name/src/branch/feature%2Fbranch/test%2Ffile.rb#L42")
+    end
+  end
+
+  describe "#use_site_fingerprinter" do
+    it "is true when notice_fingerprinter is nil" do
+      app = create(:errbit_app)
+      # Errbit::App auto-builds a fingerprinter on create; explicitly drop it
+      # to exercise the nil branch of the decorator.
+      app.notice_fingerprinter.destroy
+      app.reload
+
+      expect(described_class.new(app).use_site_fingerprinter).to eq(true)
+    end
+
+    it "is true when the fingerprinter source is nil" do
+      app = create(:errbit_app)
+      app.notice_fingerprinter.update!(source: nil)
+
+      expect(described_class.new(app.reload).use_site_fingerprinter).to eq(true)
+    end
+
+    it "is true when the fingerprinter source is 'site'" do
+      app = create(:errbit_app)
+      app.notice_fingerprinter.update!(source: Errbit::SiteConfig::CONFIG_SOURCE_SITE)
+
+      expect(described_class.new(app.reload).use_site_fingerprinter).to eq(true)
+    end
+
+    it "is false when the fingerprinter source is not 'site'" do
+      app = create(:errbit_app)
+      app.notice_fingerprinter.update!(source: Errbit::SiteConfig::CONFIG_SOURCE_APP)
+
+      expect(described_class.new(app.reload).use_site_fingerprinter).to eq(false)
+    end
+  end
+end
diff --git a/spec/decorators/errbit/backtrace_decorator_spec.rb b/spec/decorators/errbit/backtrace_decorator_spec.rb
new file mode 100644
index 0000000000..87fadf884f
--- /dev/null
+++ b/spec/decorators/errbit/backtrace_decorator_spec.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::BacktraceDecorator, type: :decorator do
+  let(:backtrace) do
+    described_class.new(
+      Errbit::Backtrace.new(
+        lines: [
+          {number: 131,
+           file: "[PROJECT_ROOT]app/controllers/accounts_controller.rb",
+           method: :update_preferences},
+          {number: 61,
+           file: "[PROJECT_ROOT]app/controllers/application_controller.rb",
+           method: :call},
+          {number: 182,
+           file: "[GEM_ROOT]activesupport-2.3.18/lib/active_support/callbacks.rb",
+           method: :call},
+          {number: 384,
+           file: "[PROJECT_ROOT]app/models/account.rb",
+           method: :update_server_tag_scope},
+          {number: 182,
+           file: "[GEM_ROOT]activesupport-2.3.18/lib/active_support/callbacks.rb",
+           method: :evaluate_method},
+          {number: 23,
+           file: "/home/rails/library/current/vendor/bundle/ruby/2.1.0/bin/rainbows",
+           method: "<main>"}
+        ]
+      )
+    )
+  end
+
+  describe "#grouped_lines" do
+    let(:grouped) { backtrace.grouped_lines.to_a }
+
+    it "puts the first two in-app lines in separate groups" do
+      expect(grouped[0][0]).to be_present
+      expect(grouped[0][1]).to eq([backtrace.lines[0]])
+      expect(grouped[1][0]).to be_present
+      expect(grouped[1][1]).to eq([backtrace.lines[1]])
+    end
+
+    it "puts the first out-of-app line in its own group" do
+      expect(grouped[2][0]).to eq(false)
+      expect(grouped[2][1]).to eq([backtrace.lines[2]])
+    end
+
+    it "puts the last two out-of-app lines together in one group" do
+      expect(grouped[4][0]).to eq(false)
+      expect(grouped[4][1]).to eq([backtrace.lines[4], backtrace.lines[5]])
+    end
+  end
+
+  describe "#lines" do
+    context "when empty" do
+      let(:backtrace) { described_class.new(Errbit::Backtrace.new) }
+
+      it "does not raise NoMethodError" do
+        expect { backtrace.lines }.not_to raise_error
+      end
+    end
+  end
+end
diff --git a/spec/decorators/errbit/backtrace_line_decorator_spec.rb b/spec/decorators/errbit/backtrace_line_decorator_spec.rb
new file mode 100644
index 0000000000..aea1ba16eb
--- /dev/null
+++ b/spec/decorators/errbit/backtrace_line_decorator_spec.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::BacktraceLineDecorator, type: :decorator do
+  let(:backtrace_line) do
+    described_class.new(
+      number: 884,
+      file: "/path/to/file/ea315ea4.rb",
+      method: :instance_eval
+    )
+  end
+
+  let(:backtrace_line_in_app) do
+    described_class.new(
+      number: 884,
+      file: "[PROJECT_ROOT]/path/to/file/ea315ea4.rb",
+      method: :instance_eval
+    )
+  end
+
+  let(:backtrace_line_in_app_slashes) do
+    described_class.new(
+      number: 884,
+      file: "/PROJECT_ROOT/path/to/file/ea315ea4.rb",
+      method: :instance_eval
+    )
+  end
+
+  let(:backtrace_line_no_file) do
+    described_class.new(number: 884, method: :instance_eval)
+  end
+
+  let(:backtrace_line_no_object) do
+    described_class.new(nil)
+  end
+
+  let(:app) { create(:errbit_app, github_repo: "foo/bar", repository_branch: "main") }
+
+  describe "#to_s" do
+    it "returns a nice string representation of the first line" do
+      expect(backtrace_line.to_s).to eq("/path/to/file/ea315ea4.rb:884")
+    end
+  end
+
+  describe "#file" do
+    it 'returns "" when there is no file' do
+      expect(backtrace_line_no_file.file).to eq("")
+    end
+
+    it 'returns "" when there is no object' do
+      expect(backtrace_line_no_object.file).to eq("")
+    end
+  end
+
+  describe "#in_app?" do
+    it "returns false when there is no file" do
+      expect(backtrace_line_no_file.in_app?).to eq(false)
+    end
+  end
+
+  describe "#path" do
+    it 'returns "" when there is no file' do
+      expect(backtrace_line_no_file.path).to eq("")
+    end
+  end
+
+  describe "#decorated_path" do
+    it "parses old backtrace format with square brackets" do
+      expect(backtrace_line_in_app.decorated_path).to eq("path/to/file/")
+    end
+
+    it "parses new backtrace format with slashes" do
+      expect(backtrace_line_in_app_slashes.decorated_path).to eq("path/to/file/")
+    end
+  end
+
+  describe "#link_to_source_file" do
+    it "adds a link to the source file" do
+      link = backtrace_line_in_app.link_to_source_file(app) { "mytext" }
+
+      expect(link).to eq(
+        '<a target="_blank" ' \
+        'rel="noopener noreferrer" ' \
+        'href="https://github.com/foo/bar/blob/main/path/to/file/ea315ea4.rb#L884">mytext</a>'
+      )
+    end
+  end
+
+  context "with string-keyed hash (post-JSON deserialization)" do
+    let(:line) do
+      described_class.new(
+        "number" => 884,
+        "file" => "[PROJECT_ROOT]/path/to/file/ea315ea4.rb",
+        "method" => "instance_eval"
+      )
+    end
+
+    it "still reads number, file, and method" do
+      expect(line.number).to eq(884)
+      expect(line.file).to eq("[PROJECT_ROOT]/path/to/file/ea315ea4.rb")
+      expect(line.method).to eq("instance_eval")
+    end
+  end
+end
diff --git a/spec/decorators/errbit/issue_tracker_decorator_spec.rb b/spec/decorators/errbit/issue_tracker_decorator_spec.rb
new file mode 100644
index 0000000000..34849ddc93
--- /dev/null
+++ b/spec/decorators/errbit/issue_tracker_decorator_spec.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::IssueTrackerDecorator, type: :decorator do
+  let(:fake_tracker) do
+    klass = Class.new(ErrbitPlugin::IssueTracker) do
+      def self.label
+        "fake"
+      end
+
+      def self.note
+        "a note"
+      end
+
+      def self.fields
+        {
+          foo: {label: "foo"},
+          bar: {label: "bar"}
+        }
+      end
+
+      def configured?
+        true
+      end
+    end
+    klass.new "nothing special"
+  end
+
+  let(:issue_tracker) do
+    it = Errbit::IssueTracker.new
+    allow(it).to receive(:tracker).and_return(fake_tracker)
+    it
+  end
+
+  let(:decorator) { described_class.new(issue_tracker) }
+
+  describe "#type" do
+    it "returns Errbit::IssueTrackerTypeDecorator for the tracker class" do
+      expect(decorator.type.class).to eq(Errbit::IssueTrackerTypeDecorator)
+    end
+  end
+end
diff --git a/spec/decorators/errbit/issue_tracker_field_decorator_spec.rb b/spec/decorators/errbit/issue_tracker_field_decorator_spec.rb
new file mode 100644
index 0000000000..1449fc81d8
--- /dev/null
+++ b/spec/decorators/errbit/issue_tracker_field_decorator_spec.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::IssueTrackerFieldDecorator, type: :decorator do
+  describe "#label" do
+    it "returns the label from field_info when present" do
+      expect(described_class.new(:foo, label: "hello").label).to eq("hello")
+    end
+
+    it "falls back to the titleized key when no label is provided" do
+      expect(described_class.new(:foo, {}).label).to eq("Foo")
+    end
+  end
+end
diff --git a/spec/decorators/errbit/issue_tracker_type_decorator_spec.rb b/spec/decorators/errbit/issue_tracker_type_decorator_spec.rb
new file mode 100644
index 0000000000..50bad35a10
--- /dev/null
+++ b/spec/decorators/errbit/issue_tracker_type_decorator_spec.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::IssueTrackerTypeDecorator, type: :decorator do
+  let(:fake_tracker_class) do
+    klass = Class.new(ErrbitPlugin::IssueTracker) do
+      def self.label
+        "fake"
+      end
+
+      def self.note
+        "a note"
+      end
+
+      def self.fields
+        {
+          foo: {label: "foo"},
+          bar: {label: "bar"}
+        }
+      end
+
+      def self.icons
+        {
+          one: ["text/plain", "all your base are belong to us"],
+          two: ["application/xml", "<root></root>"]
+        }
+      end
+    end
+
+    allow(ErrbitPlugin::Registry).to receive(:issue_trackers).and_return(fake: klass)
+
+    klass
+  end
+
+  let(:decorator) { described_class.new(fake_tracker_class) }
+
+  describe ".note" do
+    it "returns html_safe note" do
+      expect(decorator.note).to eq(fake_tracker_class.note)
+    end
+  end
+
+  describe "#fields" do
+    it "yields a decorated field for each entry" do
+      decorator.fields do |itf|
+        expect(itf).to be_a(Errbit::IssueTrackerFieldDecorator)
+        expect([:foo, :bar]).to be_include(itf.object)
+        expect([{label: "foo"}, {label: "bar"}]).to be_include(itf.field_info)
+      end
+    end
+  end
+
+  describe "#params_class" do
+    it "includes the label" do
+      tracker = Errbit::IssueTrackerDecorator.new(
+        Errbit::IssueTracker.new(type_tracker: "none")
+      )
+
+      expect(decorator.params_class(tracker)).to eq("fake")
+    end
+
+    it "prepends 'chosen' when the tracker type matches" do
+      tracker = Errbit::IssueTrackerDecorator.new(
+        Errbit::IssueTracker.new(type_tracker: "fake")
+      )
+
+      expect(decorator.params_class(tracker)).to eq("chosen fake")
+    end
+  end
+
+  describe "#icons" do
+    it "returns data URIs for each icon" do
+      result = decorator.icons
+
+      expect(result.keys).to match_array([:one, :two])
+      expect(result[:one]).to start_with("data:text/plain;base64,")
+      expect(result[:two]).to start_with("data:application/xml;base64,")
+    end
+  end
+end
diff --git a/spec/decorators/errbit/notice_decorator_spec.rb b/spec/decorators/errbit/notice_decorator_spec.rb
new file mode 100644
index 0000000000..756ff4fb3f
--- /dev/null
+++ b/spec/decorators/errbit/notice_decorator_spec.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NoticeDecorator, type: :decorator do
+  it "decorates an Errbit::Notice" do
+    notice = create(:errbit_notice)
+
+    expect(described_class.new(notice).object).to eq(notice)
+  end
+
+  it "decorates the backtrace association" do
+    notice = create(:errbit_notice)
+
+    decorated = described_class.new(notice)
+
+    expect(decorated.backtrace).to be_a(Errbit::BacktraceDecorator)
+  end
+end
diff --git a/spec/decorators/errbit/problem_decorator_spec.rb b/spec/decorators/errbit/problem_decorator_spec.rb
new file mode 100644
index 0000000000..644901dda8
--- /dev/null
+++ b/spec/decorators/errbit/problem_decorator_spec.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ProblemDecorator, type: :decorator do
+  it "decorates an Errbit::Problem" do
+    problem = create(:errbit_problem)
+
+    expect(described_class.new(problem).object).to eq(problem)
+  end
+
+  it "decorates the notices association" do
+    problem = create(:errbit_problem)
+    err = create(:errbit_err, problem: problem)
+    create(:errbit_notice, err: err, app: problem.app)
+
+    decorated = described_class.new(problem)
+
+    expect(decorated.notices.first).to be_a(Errbit::NoticeDecorator)
+  end
+end
diff --git a/spec/factories/errbit/app_factory.rb b/spec/factories/errbit/app_factory.rb
new file mode 100644
index 0000000000..2c7feedfd0
--- /dev/null
+++ b/spec/factories/errbit/app_factory.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_app, class: "Errbit::App" do
+    name { Faker::App.unique.name }
+  end
+end
diff --git a/spec/factories/errbit/backtrace_factory.rb b/spec/factories/errbit/backtrace_factory.rb
new file mode 100644
index 0000000000..2d433cb698
--- /dev/null
+++ b/spec/factories/errbit/backtrace_factory.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_backtrace, class: "Errbit::Backtrace" do
+    sequence(:lines) do |n|
+      [
+        {"number" => "123", "file" => "/some/path/to.rb", "method" => "abc_#{n}"},
+        {"number" => "345", "file" => "/path/to.rb", "method" => "dowhat"}
+      ]
+    end
+
+    fingerprint { Errbit::Backtrace.generate_fingerprint(lines) }
+  end
+end
diff --git a/spec/factories/errbit/comment_factory.rb b/spec/factories/errbit/comment_factory.rb
new file mode 100644
index 0000000000..f1ab2659cf
--- /dev/null
+++ b/spec/factories/errbit/comment_factory.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_comment, class: "Errbit::Comment" do
+    association :user, factory: :errbit_user
+    association :err, factory: :errbit_problem
+
+    body { "Test comment" }
+  end
+end
diff --git a/spec/factories/errbit/err_factory.rb b/spec/factories/errbit/err_factory.rb
new file mode 100644
index 0000000000..7efa5676d5
--- /dev/null
+++ b/spec/factories/errbit/err_factory.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_err, class: "Errbit::Err" do
+    association :problem, factory: :errbit_problem
+
+    sequence(:fingerprint) { |n| "fingerprint-#{n}" }
+  end
+end
diff --git a/spec/factories/errbit/issue_tracker_factory.rb b/spec/factories/errbit/issue_tracker_factory.rb
new file mode 100644
index 0000000000..1dc035bba5
--- /dev/null
+++ b/spec/factories/errbit/issue_tracker_factory.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_issue_tracker, class: "Errbit::IssueTracker" do
+    association :app, factory: :errbit_app
+
+    type_tracker { "mock" }
+    options { {foo: "one", bar: "two"} }
+  end
+end
diff --git a/spec/factories/errbit/notice_factory.rb b/spec/factories/errbit/notice_factory.rb
new file mode 100644
index 0000000000..37fd7c7a58
--- /dev/null
+++ b/spec/factories/errbit/notice_factory.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_notice, class: "Errbit::Notice" do
+    association :app, factory: :errbit_app
+    association :err, factory: :errbit_err
+    association :backtrace, factory: :errbit_backtrace
+
+    error_class { "FooError" }
+    message { "FooError: Too Much Bar" }
+
+    server_environment { {"environment-name" => "production"} }
+    request { {"component" => "foo", "action" => "bar"} }
+    notifier { {"name" => "Notifier", "version" => "1", "url" => "http://toad.com"} }
+
+    after(:create) do |notice|
+      Errbit::Problem.cache_notice(notice.err.errbit_problem_id, notice)
+
+      notice.problem.reload
+    end
+  end
+end
diff --git a/spec/factories/errbit/notice_fingerprinter_factory.rb b/spec/factories/errbit/notice_fingerprinter_factory.rb
new file mode 100644
index 0000000000..f6353c065a
--- /dev/null
+++ b/spec/factories/errbit/notice_fingerprinter_factory.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_notice_fingerprinter, class: "Errbit::NoticeFingerprinter" do
+    association :app, factory: :errbit_app
+  end
+end
diff --git a/spec/factories/errbit/notification_service_factory.rb b/spec/factories/errbit/notification_service_factory.rb
new file mode 100644
index 0000000000..2185484edc
--- /dev/null
+++ b/spec/factories/errbit/notification_service_factory.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_notification_service, class: "Errbit::NotificationService" do
+    association :app, factory: :errbit_app
+
+    sequence(:room_id) { |n| "word#{n}" }
+    sequence(:api_token) { |n| "word#{n}" }
+    sequence(:subdomain) { |n| "word#{n}" }
+  end
+
+  factory :errbit_slack_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::SlackService" do
+    sequence(:service_url) { |n| "https://hooks.slack.com/services/word#{n}" }
+    sequence(:room_id) { |n| "#room-#{n}" }
+  end
+
+  factory :errbit_campfire_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::CampfireService"
+
+  factory :errbit_hoiio_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::HoiioService"
+
+  factory :errbit_hubot_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::HubotService"
+
+  factory :errbit_pushover_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::PushoverService"
+
+  factory :errbit_webhook_notification_service, parent: :errbit_notification_service, class: "Errbit::NotificationServices::WebhookService"
+end
diff --git a/spec/factories/errbit/problem_factory.rb b/spec/factories/errbit/problem_factory.rb
new file mode 100644
index 0000000000..e574704d55
--- /dev/null
+++ b/spec/factories/errbit/problem_factory.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_problem, class: "Errbit::Problem" do
+    association :app, factory: :errbit_app
+
+    environment { "production" }
+    error_class { "RuntimeError" }
+  end
+
+  factory :errbit_problem_with_comments, parent: :errbit_problem do
+    after(:create) do |problem|
+      create_list(:errbit_comment, 3, err: problem)
+    end
+  end
+end
diff --git a/spec/factories/errbit/user_factory.rb b/spec/factories/errbit/user_factory.rb
new file mode 100644
index 0000000000..8240bfcdd2
--- /dev/null
+++ b/spec/factories/errbit/user_factory.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_user, class: "Errbit::User" do
+    email { Faker::Internet.unique.email }
+
+    name { Faker::Name.unique.name }
+
+    password { Faker::Internet.password }
+  end
+end
diff --git a/spec/factories/errbit/watcher_factory.rb b/spec/factories/errbit/watcher_factory.rb
new file mode 100644
index 0000000000..be65e32762
--- /dev/null
+++ b/spec/factories/errbit/watcher_factory.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :errbit_watcher, class: "Errbit::Watcher" do
+    association :app, factory: :errbit_app
+
+    watcher_type { "email" }
+
+    sequence(:email) { |n| "email#{n}@example.com" }
+  end
+
+  factory :errbit_user_watcher, parent: :errbit_watcher do
+    association :user, factory: :errbit_user
+
+    watcher_type { "user" }
+  end
+end
diff --git a/spec/factories/user_factory.rb b/spec/factories/user_factory.rb
index d36c2f5c36..6f81055b5b 100644
--- a/spec/factories/user_factory.rb
+++ b/spec/factories/user_factory.rb
@@ -5,7 +5,5 @@
     email { Faker::Internet.unique.email }
 
     name { Faker::Name.unique.name }
-
-    password { Faker::Internet.password }
   end
 end
diff --git a/spec/helpers/application_helper_spec.rb b/spec/helpers/application_helper_spec.rb
index 3b378162cd..1d5073dd43 100644
--- a/spec/helpers/application_helper_spec.rb
+++ b/spec/helpers/application_helper_spec.rb
@@ -3,11 +3,202 @@
 require "rails_helper"
 
 RSpec.describe ApplicationHelper, type: :helper do
-  let(:notice) { create(:notice) }
+  describe "#tally" do
+    it "converts a digest-keyed collection into a {value => count} hash" do
+      collection = {
+        "d1" => {"value" => "foo", "count" => 3},
+        "d2" => {"value" => "bar", "count" => 7}
+      }
+
+      expect(helper.tally(collection)).to eq("foo" => 3, "bar" => 7)
+    end
+
+    it "returns an empty hash when the collection is empty" do
+      expect(helper.tally({})).to eq({})
+    end
+
+    it "collapses duplicate values onto the last count seen" do
+      collection = {
+        "d1" => {"value" => "foo", "count" => 3},
+        "d2" => {"value" => "foo", "count" => 5}
+      }
+
+      expect(helper.tally(collection)).to eq("foo" => 5)
+    end
+  end
+
+  describe "#head" do
+    it "returns the first 4 elements" do
+      expect(helper.head((1..10).to_a)).to eq([1, 2, 3, 4])
+    end
+
+    it "returns the whole collection when it is smaller than the head size" do
+      expect(helper.head([1, 2])).to eq([1, 2])
+    end
+
+    it "returns an empty array when the collection is empty" do
+      expect(helper.head([])).to eq([])
+    end
+  end
+
+  describe "#tail" do
+    it "returns elements after the first 4" do
+      expect(helper.tail((1..10).to_a)).to eq([5, 6, 7, 8, 9, 10])
+    end
+
+    it "returns an empty array when the collection is smaller than the head size" do
+      expect(helper.tail([1, 2])).to eq([])
+    end
+
+    it "returns an empty array when the collection is empty" do
+      expect(helper.tail([])).to eq([])
+    end
+  end
+
+  describe "#create_percentage_table_from_tallies" do
+    it "renders the partial with rows sorted by descending percentage" do
+      result = helper.create_percentage_table_from_tallies("foo" => 1, "bar" => 3)
+
+      expect(result).to include("75.0%")
+      expect(result).to include("25.0%")
+      expect(result.index("bar")).to be < result.index("foo")
+    end
+
+    it "uses the supplied total when provided" do
+      result = helper.create_percentage_table_from_tallies({"foo" => 1}, total: 4)
+
+      expect(result).to include("25.0%")
+    end
+
+    it "renders the show-more footer when there are more rows than the head size" do
+      tallies = {"a" => 1, "b" => 1, "c" => 1, "d" => 1, "e" => 1}
+
+      expect(helper.create_percentage_table_from_tallies(tallies)).to include("Show more...")
+    end
+
+    it "omits the show-more footer when there are no rows beyond the head" do
+      tallies = {"a" => 1, "b" => 1}
+
+      expect(helper.create_percentage_table_from_tallies(tallies)).not_to include("Show more...")
+    end
+  end
+
+  describe "#create_percentage_table_for" do
+    it "tallies the collection and renders the partial" do
+      collection = {
+        "d1" => {"value" => "foo", "count" => 1},
+        "d2" => {"value" => "bar", "count" => 3}
+      }
+
+      result = helper.create_percentage_table_for(collection)
+
+      expect(result).to include("foo")
+      expect(result).to include("bar")
+      expect(result).to include("75.0%")
+      expect(result).to include("25.0%")
+    end
+  end
+
+  describe "#message_graph" do
+    it "delegates to #create_percentage_table_for with the problem's messages" do
+      problem = double(messages: {"d" => {"value" => "msg", "count" => 1}})
+
+      expect(helper).to receive(:create_percentage_table_for).with(problem.messages).and_return("rendered")
+      expect(helper.message_graph(problem)).to eq("rendered")
+    end
+  end
+
+  describe "#user_agent_graph" do
+    it "delegates to #create_percentage_table_for with the problem's user_agents" do
+      problem = double(user_agents: {"d" => {"value" => "ua", "count" => 1}})
+
+      expect(helper).to receive(:create_percentage_table_for).with(problem.user_agents).and_return("rendered")
+      expect(helper.user_agent_graph(problem)).to eq("rendered")
+    end
+  end
+
+  describe "#tenant_graph" do
+    it "delegates to #create_percentage_table_for with the problem's hosts" do
+      problem = double(hosts: {"d" => {"value" => "host", "count" => 1}})
+
+      expect(helper).to receive(:create_percentage_table_for).with(problem.hosts).and_return("rendered")
+      expect(helper.tenant_graph(problem)).to eq("rendered")
+    end
+  end
+
+  describe "#issue_tracker_types" do
+    let(:fake_tracker_class) do
+      Class.new(ErrbitPlugin::IssueTracker) do
+        def self.label
+          "fake"
+        end
+
+        def self.note
+          "a note"
+        end
+
+        def self.fields
+          {}
+        end
+
+        def self.icons
+          {}
+        end
+      end
+    end
+
+    it "wraps every registered tracker in an Errbit::IssueTrackerTypeDecorator" do
+      allow(ErrbitPlugin::Registry).to receive(:issue_trackers).and_return(fake: fake_tracker_class)
+
+      types = helper.issue_tracker_types
+
+      expect(types.size).to eq(1)
+      expect(types.first).to be_a(Errbit::IssueTrackerTypeDecorator)
+      expect(types.first.object).to eq(fake_tracker_class)
+    end
+
+    it "returns an empty array when no trackers are registered" do
+      allow(ErrbitPlugin::Registry).to receive(:issue_trackers).and_return({})
+
+      expect(helper.issue_tracker_types).to eq([])
+    end
+  end
 
   describe "#generate_problem_ical" do
-    it "return the ical format" do
-      helper.generate_problem_ical([notice])
+    let(:notice) { create(:errbit_notice) }
+
+    it "renders the ical format without raising" do
+      expect { helper.generate_problem_ical([notice]) }.not_to raise_error
+    end
+
+    it "returns a VCALENDAR document" do
+      ical = helper.generate_problem_ical([notice])
+
+      expect(ical).to include("BEGIN:VCALENDAR")
+      expect(ical).to include("END:VCALENDAR")
+    end
+
+    it "emits one VEVENT per notice with summary indexed from 1" do
+      other = create(:errbit_notice)
+      ical = helper.generate_problem_ical([notice, other])
+
+      expect(ical.scan("BEGIN:VEVENT").size).to eq(2)
+      expect(ical).to match(/SUMMARY:1 #{Regexp.escape(notice.message)}/)
+      expect(ical).to match(/SUMMARY:2 #{Regexp.escape(other.message)}/)
+    end
+
+    it "produces an empty calendar when there are no notices" do
+      ical = helper.generate_problem_ical([])
+
+      expect(ical).to include("BEGIN:VCALENDAR")
+      expect(ical).not_to include("BEGIN:VEVENT")
+    end
+
+    it "includes the notice URL when one is present" do
+      notice.request = notice.request.merge("url" => "https://example.com/boom")
+      notice.save!
+
+      expect(helper.generate_problem_ical([notice])).to include("https://example.com/boom")
     end
   end
 end
diff --git a/spec/helpers/apps_helper_spec.rb b/spec/helpers/apps_helper_spec.rb
new file mode 100644
index 0000000000..fb246af60b
--- /dev/null
+++ b/spec/helpers/apps_helper_spec.rb
@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe AppsHelper, type: :helper do
+  describe "#link_to_copy_attributes_from_other_app" do
+    context "when there is only one app" do
+      it "returns nil" do
+        create(:errbit_app)
+
+        expect(helper.link_to_copy_attributes_from_other_app).to be_nil
+      end
+    end
+
+    context "when there are no apps" do
+      it "returns nil" do
+        expect(helper.link_to_copy_attributes_from_other_app).to be_nil
+      end
+    end
+
+    context "when there are multiple apps" do
+      let!(:current_app) { create(:errbit_app, name: "Current") }
+      let!(:other_app) { create(:errbit_app, name: "Other") }
+
+      before { assign(:app, current_app) }
+
+      it "renders a copy-settings link" do
+        html = helper.link_to_copy_attributes_from_other_app
+
+        expect(html).to include('class="button copy_config"')
+        expect(html).to include("copy settings from another app")
+      end
+
+      it "renders a select tag with the other apps as options" do
+        html = helper.link_to_copy_attributes_from_other_app
+
+        expect(html).to include('class="choose_other_app"')
+        expect(html).to include("Other")
+        expect(html).to include(%(value="#{other_app.id}"))
+      end
+
+      it "does not include the current app among the options" do
+        html = helper.link_to_copy_attributes_from_other_app
+
+        expect(html).not_to include(%(value="#{current_app.id}"))
+      end
+
+      it "includes a blank prompt option" do
+        expect(helper.link_to_copy_attributes_from_other_app).to include("[choose app]")
+      end
+
+      it "hides the select element by default" do
+        expect(helper.link_to_copy_attributes_from_other_app).to include('style="display: none;"')
+      end
+    end
+  end
+
+  describe "attribute detection across apps" do
+    let(:plain_app) do
+      double(
+        github_repo?: false,
+        bitbucket_repo?: false,
+        issue_tracker_configured?: false,
+        notification_service_configured?: false
+      )
+    end
+
+    let(:fancy_app) do
+      double(
+        github_repo?: true,
+        bitbucket_repo?: true,
+        issue_tracker_configured?: true,
+        notification_service_configured?: true
+      )
+    end
+
+    describe "#any_github_repos?" do
+      it "is true when at least one app has a github repo" do
+        allow(helper).to receive(:apps).and_return([plain_app, fancy_app])
+
+        expect(helper.any_github_repos?).to be true
+      end
+
+      it "is false when no apps have a github repo" do
+        allow(helper).to receive(:apps).and_return([plain_app])
+
+        expect(helper.any_github_repos?).to be false
+      end
+
+      it "memoizes the result so apps is only iterated once" do
+        expect(helper).to receive(:apps).once.and_return([plain_app])
+
+        helper.any_github_repos?
+        helper.any_github_repos?
+      end
+    end
+
+    describe "#any_bitbucket_repos?" do
+      it "is true when at least one app has a bitbucket repo" do
+        allow(helper).to receive(:apps).and_return([plain_app, fancy_app])
+
+        expect(helper.any_bitbucket_repos?).to be true
+      end
+
+      it "is false when no apps have a bitbucket repo" do
+        allow(helper).to receive(:apps).and_return([plain_app])
+
+        expect(helper.any_bitbucket_repos?).to be false
+      end
+    end
+
+    describe "#any_issue_trackers?" do
+      it "is true when at least one app has an issue tracker configured" do
+        allow(helper).to receive(:apps).and_return([plain_app, fancy_app])
+
+        expect(helper.any_issue_trackers?).to be true
+      end
+
+      it "is false when no apps have an issue tracker configured" do
+        allow(helper).to receive(:apps).and_return([plain_app])
+
+        expect(helper.any_issue_trackers?).to be false
+      end
+    end
+
+    describe "#any_notification_services?" do
+      it "reflects the detection results once they have been populated" do
+        allow(helper).to receive(:apps).and_return([plain_app, fancy_app])
+        helper.any_github_repos?
+
+        expect(helper.any_notification_services?).to be true
+      end
+
+      it "is false when detection has populated the result as false" do
+        allow(helper).to receive(:apps).and_return([plain_app])
+        helper.any_github_repos?
+
+        expect(helper.any_notification_services?).to be false
+      end
+    end
+  end
+end
diff --git a/spec/helpers/form_helper_spec.rb b/spec/helpers/form_helper_spec.rb
new file mode 100644
index 0000000000..91c5dac689
--- /dev/null
+++ b/spec/helpers/form_helper_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe FormHelper, type: :helper do
+  describe "#errors_for" do
+    context "when the document has no errors" do
+      it "returns nil" do
+        document = double(errors: double(any?: false))
+
+        expect(helper.errors_for(document)).to be_nil
+      end
+    end
+
+    context "when the document has errors" do
+      let(:document) do
+        double(errors: double(any?: true, full_messages: ["Name can't be blank", "Email is invalid"]))
+      end
+
+      it "wraps the messages in a div with the error-messages class" do
+        expect(helper.errors_for(document)).to match(%r{<div class="error-messages">})
+      end
+
+      it "renders the standard heading" do
+        expect(helper.errors_for(document)).to include(
+          "<h2>Dang. The following errors are keeping this from being a success.</h2>"
+        )
+      end
+
+      it "renders each full message as a list item" do
+        html = helper.errors_for(document)
+
+        expect(html).to include("<li>Name can&#39;t be blank</li>")
+        expect(html).to include("<li>Email is invalid</li>")
+      end
+
+      it "returns an html-safe string" do
+        expect(helper.errors_for(document)).to be_html_safe
+      end
+    end
+
+    context "when a message contains HTML" do
+      it "escapes the message content" do
+        document = double(errors: double(any?: true, full_messages: ["<script>alert(1)</script>"]))
+
+        html = helper.errors_for(document)
+
+        expect(html).not_to include("<script>alert(1)</script>")
+        expect(html).to include("&lt;script&gt;alert(1)&lt;/script&gt;")
+      end
+    end
+  end
+
+  describe "#label_for_attr" do
+    let(:builder) { double(object_name: "errbit_app") }
+
+    it "concatenates the object_name with the field" do
+      expect(helper.label_for_attr(builder, "name")).to eq("errbit_appname")
+    end
+
+    it "replaces brackets with underscores and squeezes them" do
+      expect(helper.label_for_attr(builder, "[watchers_attributes][0][email]"))
+        .to eq("errbit_app_watchers_attributes_0_email_")
+    end
+
+    it "squeezes consecutive underscores spanning object_name and field" do
+      nested = double(object_name: "errbit_app[watchers_attributes][0]")
+
+      expect(helper.label_for_attr(nested, "[email]")).to eq("errbit_app_watchers_attributes_0_email_")
+    end
+  end
+end
diff --git a/spec/helpers/navigation_helper_spec.rb b/spec/helpers/navigation_helper_spec.rb
index cee02f3b6f..f0ebfc6110 100644
--- a/spec/helpers/navigation_helper_spec.rb
+++ b/spec/helpers/navigation_helper_spec.rb
@@ -3,6 +3,55 @@
 require "rails_helper"
 
 RSpec.describe NavigationHelper, type: :helper do
+  describe "#active_if_here" do
+    before do
+      allow(controller).to receive(:controller_name).and_return("users")
+      allow(controller).to receive(:action_name).and_return("index")
+    end
+
+    context "with a single controller symbol" do
+      it "returns ' active' when the current controller matches" do
+        expect(helper.active_if_here(:users)).to eq(" active")
+      end
+
+      it "returns nil when the current controller does not match" do
+        expect(helper.active_if_here(:blogs)).to be_nil
+      end
+    end
+
+    context "with an array of controllers" do
+      it "returns ' active' when the current controller is in the list" do
+        expect(helper.active_if_here([:users, :blogs, :comments])).to eq(" active")
+      end
+
+      it "returns nil when the current controller is not in the list" do
+        expect(helper.active_if_here([:blogs, :comments])).to be_nil
+      end
+    end
+
+    context "with a hash of controllers to actions" do
+      it "returns ' active' when the action is included for the matching controller" do
+        expect(helper.active_if_here(users: :index)).to eq(" active")
+      end
+
+      it "returns ' active' when the action is in the list of actions for the controller" do
+        expect(helper.active_if_here(users: [:index, :show])).to eq(" active")
+      end
+
+      it "returns ' active' when actions are specified as :all" do
+        expect(helper.active_if_here(users: :all)).to eq(" active")
+      end
+
+      it "returns nil when the action is not included for the matching controller" do
+        expect(helper.active_if_here(users: :create)).to be_nil
+      end
+
+      it "returns nil when the controller does not match any entry" do
+        expect(helper.active_if_here(blogs: :index)).to be_nil
+      end
+    end
+  end
+
   describe "#page_count_from_end" do
     it "returns the page number when counting from the last occurrence of a notice" do
       expect(page_count_from_end(1, 6)).to eq 6
diff --git a/spec/interactors/errbit/notice_refingerprinter_spec.rb b/spec/interactors/errbit/notice_refingerprinter_spec.rb
new file mode 100644
index 0000000000..93f580d50f
--- /dev/null
+++ b/spec/interactors/errbit/notice_refingerprinter_spec.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NoticeRefingerprinter do
+  let(:app) { create(:errbit_app) }
+  let(:fingerprinter) { app.notice_fingerprinter }
+
+  describe ".run" do
+    context "with identical backtraces" do
+      let(:backtrace) { create(:errbit_backtrace) }
+
+      before do
+        5.times { create(:errbit_notice, backtrace: backtrace, app: app) }
+      end
+
+      it "collapses all five notices into a single err" do
+        expect { described_class.run }.to change(Errbit::Err, :count).to(1)
+      end
+    end
+
+    context "with three distinct backtraces" do
+      before do
+        3.times do
+          create(:errbit_notice, app: app)
+        end
+        # Create one more notice sharing the first backtrace.
+        first_bt = Errbit::Backtrace.first
+        create(:errbit_notice, app: app, backtrace: first_bt)
+      end
+
+      it "produces one err per unique backtrace fingerprint" do
+        expect { described_class.run }.to change(Errbit::Err, :count).to(3)
+      end
+    end
+
+    it "destroys orphaned errs (with no notices) at the end" do
+      orphan = create(:errbit_err, problem: create(:errbit_problem, app: app))
+
+      expect { described_class.run }.to change { Errbit::Err.where(id: orphan.id).count }.from(1).to(0)
+    end
+  end
+
+  describe ".refingerprint" do
+    it "reassigns the notice to a freshly-computed err" do
+      notice = create(:errbit_notice, app: app)
+      original_err = notice.err
+
+      described_class.refingerprint(notice.reload)
+
+      expect(notice.reload.err).not_to eq(original_err)
+      expect(notice.err.fingerprint).to eq(
+        fingerprinter.generate(app.api_key, notice, notice.backtrace)
+      )
+    end
+  end
+end
diff --git a/spec/interactors/errbit/outdated_problem_clearer_spec.rb b/spec/interactors/errbit/outdated_problem_clearer_spec.rb
new file mode 100644
index 0000000000..bc16ecccad
--- /dev/null
+++ b/spec/interactors/errbit/outdated_problem_clearer_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::OutdatedProblemClearer do
+  before do
+    allow(Errbit::Config).to receive(:notice_deprecation_days).and_return(7)
+  end
+
+  describe "#execute" do
+    let!(:problems) { create_list(:errbit_problem, 3) }
+
+    context "without old problems" do
+      it "does nothing" do
+        expect { expect(subject.execute).to eq(0) }.not_to change(Errbit::Problem, :count)
+      end
+    end
+
+    context "with old problems" do
+      before do
+        problems.first.update!(last_notice_at: 1.year.ago)
+        problems.second.update!(last_notice_at: 1.year.ago)
+      end
+
+      it "deletes the outdated problems" do
+        expect { expect(subject.execute).to eq(2) }.to change(Errbit::Problem, :count).by(-2)
+
+        expect(Errbit::Problem.where(id: problems.first.id)).to be_empty
+        expect(Errbit::Problem.where(id: problems.second.id)).to be_empty
+      end
+    end
+  end
+end
diff --git a/spec/interactors/errbit/problem_destroy_spec.rb b/spec/interactors/errbit/problem_destroy_spec.rb
new file mode 100644
index 0000000000..c24bf254d2
--- /dev/null
+++ b/spec/interactors/errbit/problem_destroy_spec.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ProblemDestroy do
+  let(:problem_destroy) { described_class.new(problem) }
+
+  context "in unit form" do
+    let(:problem) do
+      problem = Errbit::Problem.new
+      allow(problem).to receive(:errs).and_return(double(:errs, pluck: [11, 22]))
+      allow(problem).to receive(:comments).and_return(double(:comments, pluck: [111, 222]))
+      allow(problem).to receive(:delete)
+      problem
+    end
+
+    describe "#initialize" do
+      it "takes a problem" do
+        expect(problem_destroy.problem).to eq(problem)
+      end
+    end
+
+    describe "#execute" do
+      it "destroys the problem itself" do
+        expect(problem).to receive(:delete)
+
+        problem_destroy.execute
+      end
+
+      it "deletes all errs by id" do
+        expect(Errbit::Err).to receive(:where).with(id: [11, 22]).and_call_original
+
+        problem_destroy.execute
+      end
+
+      it "deletes all comments by id" do
+        expect(Errbit::Comment).to receive(:where).with(id: [111, 222]).and_call_original
+
+        problem_destroy.execute
+      end
+
+      it "deletes notices for the problem's errs" do
+        expect(Errbit::Notice).to receive(:where).with(errbit_err_id: [11, 22]).and_call_original
+
+        problem_destroy.execute
+      end
+    end
+  end
+
+  context "in integration form" do
+    let!(:problem) { create(:errbit_problem) }
+    let!(:comment_1) { create(:errbit_comment, err: problem) }
+    let!(:comment_2) { create(:errbit_comment, err: problem) }
+    let!(:err_1) { create(:errbit_err, problem: problem) }
+    let!(:err_2) { create(:errbit_err, problem: problem) }
+    let!(:notice_1_1) { create(:errbit_notice, err: err_1) }
+    let!(:notice_1_2) { create(:errbit_notice, err: err_1) }
+    let!(:notice_2_1) { create(:errbit_notice, err: err_2) }
+    let!(:notice_2_2) { create(:errbit_notice, err: err_2) }
+
+    it "destroys the problem, errs, comments, and notices" do
+      problem_destroy.execute
+
+      expect(Errbit::Problem.where(id: problem.id)).to be_empty
+      expect(Errbit::Err.where(id: [err_1.id, err_2.id])).to be_empty
+      expect(Errbit::Comment.where(id: [comment_1.id, comment_2.id])).to be_empty
+      expect(Errbit::Notice.where(id: [notice_1_1.id, notice_1_2.id, notice_2_1.id, notice_2_2.id])).to be_empty
+    end
+  end
+
+  describe ".execute" do
+    let!(:problem_1) { create(:errbit_problem) }
+    let!(:problem_2) { create(:errbit_problem) }
+
+    it "destroys an array of problems and returns the count" do
+      count = described_class.execute([problem_1, problem_2])
+
+      expect(count).to eq(2)
+      expect(Errbit::Problem.where(id: [problem_1.id, problem_2.id])).to be_empty
+    end
+
+    it "accepts a single problem" do
+      count = described_class.execute(problem_1)
+
+      expect(count).to eq(1)
+      expect(Errbit::Problem.where(id: problem_1.id)).to be_empty
+    end
+  end
+end
diff --git a/spec/interactors/errbit/problem_merge_spec.rb b/spec/interactors/errbit/problem_merge_spec.rb
new file mode 100644
index 0000000000..2840996ca2
--- /dev/null
+++ b/spec/interactors/errbit/problem_merge_spec.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ProblemMerge do
+  let(:app) { create(:errbit_app) }
+  let(:problem) { create(:errbit_problem, app: app) }
+  let(:problem_1) { create(:errbit_problem, app: app) }
+
+  before do
+    create(:errbit_err, problem: problem)
+    create(:errbit_err, problem: problem_1)
+  end
+
+  describe "#initialize" do
+    it "raises when fewer than 2 unique problems are passed" do
+      expect { described_class.new(problem) }.to raise_error(ArgumentError)
+    end
+
+    it "uses the first problem as merged_problem" do
+      pm = described_class.new(problem, problem, problem_1)
+
+      expect(pm.merged_problem).to eq(problem)
+    end
+
+    it "uses the remaining unique problems as child_problems" do
+      pm = described_class.new(problem, problem, problem_1)
+
+      expect(pm.child_problems).to eq([problem_1])
+    end
+  end
+
+  describe "#merge" do
+    let!(:problem_merge) { described_class.new(problem, problem_1) }
+    let(:first_errs) { problem.errs.to_a }
+    let(:merged_errs) { problem_1.errs.to_a }
+
+    before do
+      create(:errbit_notice, err: first_errs.first, app: app)
+      create(:errbit_notice, err: merged_errs.first, app: app)
+    end
+
+    it "destroys one of the problems" do
+      expect { problem_merge.merge }.to change(Errbit::Problem, :count).by(-1)
+    end
+
+    it "reassigns all errs to the merged problem" do
+      expected_err_ids = (first_errs + merged_errs).map(&:id).sort
+
+      problem_merge.merge
+
+      expect(problem.reload.errs.pluck(:id).sort).to eq(expected_err_ids)
+    end
+
+    it "keeps the issue link on the merged problem" do
+      problem.update!(issue_link: "http://foo.com", issue_type: "mock")
+
+      problem_merge.merge
+
+      expect(problem.reload.issue_link).to eq("http://foo.com")
+      expect(problem.reload.issue_type).to eq("mock")
+    end
+
+    it "recaches the merged problem" do
+      expect(problem).to receive(:recache)
+
+      problem_merge.merge
+    end
+
+    context "with comments on both problems" do
+      let(:user) { create(:errbit_user) }
+      let!(:comment) { create(:errbit_comment, err: problem, user: user) }
+      let!(:comment_2) { create(:errbit_comment, err: problem_1, user: user) }
+
+      it "reassigns comments to the merged problem" do
+        expect { problem_merge.merge }
+          .to change { problem.reload.comments.size }.from(1).to(2)
+
+        expect(comment_2.reload.err).to eq(problem)
+      end
+    end
+  end
+end
diff --git a/spec/interactors/errbit/problem_recacher_spec.rb b/spec/interactors/errbit/problem_recacher_spec.rb
new file mode 100644
index 0000000000..89427e5c41
--- /dev/null
+++ b/spec/interactors/errbit/problem_recacher_spec.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ProblemRecacher do
+  describe ".run" do
+    let(:problem) { create(:errbit_problem) }
+    let(:err) { create(:errbit_err, problem: problem) }
+
+    it "recaches each problem and destroys problems with no notices" do
+      empty_problem = create(:errbit_problem)
+      create(:errbit_notice, err: err)
+
+      described_class.run
+
+      expect(Errbit::Problem.where(id: empty_problem.id)).to be_empty
+      expect(problem.reload.notices_count).to eq(1)
+    end
+  end
+end
diff --git a/spec/interactors/errbit/resolved_problem_clearer_spec.rb b/spec/interactors/errbit/resolved_problem_clearer_spec.rb
new file mode 100644
index 0000000000..766e9b7cfa
--- /dev/null
+++ b/spec/interactors/errbit/resolved_problem_clearer_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ResolvedProblemClearer do
+  describe "#execute" do
+    let!(:problems) { create_list(:errbit_problem, 3) }
+
+    context "without resolved problems" do
+      it "does nothing" do
+        expect { expect(subject.execute).to eq(0) }.not_to change(Errbit::Problem, :count)
+      end
+    end
+
+    context "with resolved problems" do
+      before do
+        problems.first.resolve!
+        problems.second.resolve!
+      end
+
+      it "deletes the resolved problems" do
+        expect { expect(subject.execute).to eq(2) }.to change(Errbit::Problem, :count).by(-2)
+
+        expect(Errbit::Problem.where(id: problems.first.id)).to be_empty
+        expect(Errbit::Problem.where(id: problems.second.id)).to be_empty
+      end
+    end
+  end
+end
diff --git a/spec/interactors/errbit/user_destroy_spec.rb b/spec/interactors/errbit/user_destroy_spec.rb
new file mode 100644
index 0000000000..b766ee9c20
--- /dev/null
+++ b/spec/interactors/errbit/user_destroy_spec.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::UserDestroy do
+  describe "#destroy" do
+    let!(:app) { create(:errbit_app) }
+    let!(:user) { create(:errbit_user) }
+    let!(:user_watcher) { create(:errbit_user_watcher, app: app, user: user) }
+
+    it "destroys the user" do
+      expect { described_class.new(user).destroy }.to change(Errbit::User, :count).by(-1)
+    end
+
+    it "destroys watchers belonging to the user via dependent: :destroy" do
+      expect { described_class.new(user).destroy }
+        .to change { Errbit::Watcher.where(errbit_user_id: user.id).count }
+        .from(1).to(0)
+    end
+  end
+end
diff --git a/spec/jobs/errbit/application_job_spec.rb b/spec/jobs/errbit/application_job_spec.rb
new file mode 100644
index 0000000000..6f33e7a513
--- /dev/null
+++ b/spec/jobs/errbit/application_job_spec.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ApplicationJob, type: :job do
+  it { expect(subject).to be_an(ActiveJob::Base) }
+end
diff --git a/spec/jobs/errbit/destroy_problems_by_app_job_spec.rb b/spec/jobs/errbit/destroy_problems_by_app_job_spec.rb
new file mode 100644
index 0000000000..aaf6e6d3db
--- /dev/null
+++ b/spec/jobs/errbit/destroy_problems_by_app_job_spec.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::DestroyProblemsByAppJob, type: :job do
+  it { expect(subject).to be_an(Errbit::ApplicationJob) }
+
+  it "destroys all problems for the given app" do
+    app = create(:errbit_app)
+    create(:errbit_problem, app: app)
+
+    expect {
+      described_class.perform_later(app.id)
+    }.to change(Errbit::Problem, :count).by(-1)
+
+    expect(app.problems.reload.count).to eq(0)
+  end
+
+  it "is a no-op when the app has no problems" do
+    app = create(:errbit_app)
+
+    expect {
+      described_class.perform_later(app.id)
+    }.not_to change(Errbit::Problem, :count)
+
+    expect(app.problems.reload.count).to eq(0)
+  end
+
+  it "is a no-op when the app does not exist" do
+    expect {
+      described_class.perform_later(999_999_999)
+    }.not_to change(Errbit::Problem, :count)
+  end
+end
diff --git a/spec/jobs/errbit/destroy_problems_by_id_job_spec.rb b/spec/jobs/errbit/destroy_problems_by_id_job_spec.rb
new file mode 100644
index 0000000000..7a1b62df61
--- /dev/null
+++ b/spec/jobs/errbit/destroy_problems_by_id_job_spec.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::DestroyProblemsByIdJob, type: :job do
+  it { expect(subject).to be_an(Errbit::ApplicationJob) }
+
+  it "destroys the problems with the given ids" do
+    app = create(:errbit_app)
+    problem = create(:errbit_problem, app: app)
+
+    expect {
+      described_class.perform_later([problem.id])
+    }.to change(Errbit::Problem, :count).by(-1)
+
+    expect(app.problems.reload.count).to eq(0)
+  end
+
+  it "leaves problems whose ids are not in the list" do
+    kept = create(:errbit_problem)
+    deleted = create(:errbit_problem)
+
+    expect {
+      described_class.perform_later([deleted.id])
+    }.to change(Errbit::Problem, :count).by(-1)
+
+    expect(Errbit::Problem.find_by(id: kept.id)).to eq(kept)
+    expect(Errbit::Problem.find_by(id: deleted.id)).to be_nil
+  end
+
+  it "is a no-op when passed an empty list" do
+    create(:errbit_problem)
+
+    expect {
+      described_class.perform_later([])
+    }.not_to change(Errbit::Problem, :count)
+  end
+end
diff --git a/spec/lib/airbrake_api/v3/notice_parser_spec.rb b/spec/lib/airbrake_api/v3/notice_parser_spec.rb
index 369a45834b..733e5e9736 100644
--- a/spec/lib/airbrake_api/v3/notice_parser_spec.rb
+++ b/spec/lib/airbrake_api/v3/notice_parser_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe AirbrakeApi::V3::NoticeParser do
-  let(:app) { create(:app) }
+  let(:app) { create(:errbit_app) }
 
   let(:notifier_params) do
     {
diff --git a/spec/lib/tasks/errbit/migrate_rake_spec.rb b/spec/lib/tasks/errbit/migrate_rake_spec.rb
new file mode 100644
index 0000000000..242c4cf8f3
--- /dev/null
+++ b/spec/lib/tasks/errbit/migrate_rake_spec.rb
@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "rake"
+
+RSpec.describe "errbit:migrate" do
+  before(:all) do
+    Rails.application.load_tasks if Rake::Task.tasks.empty?
+  end
+
+  def invoke(task_name)
+    Rake::Task["errbit:migrate:#{task_name}"].reenable
+    Rake::Task["errbit:migrate:#{task_name}"].invoke
+  end
+
+  describe ":users" do
+    it "creates an Errbit::User row for each Mongo User, linked by bson_id" do
+      mongo_user = User.create!(
+        email: "ported@example.com",
+        name: "Ported",
+        admin: true,
+        encrypted_password: "fake-encrypted-pw",
+        authentication_token: "fake-token"
+      )
+
+      expect { invoke(:users) }.to change(Errbit::User, :count).by(1)
+
+      ar_user = Errbit::User.find_by!(bson_id: mongo_user._id.to_s)
+      expect(ar_user.email).to eq("ported@example.com")
+      expect(ar_user.name).to eq("Ported")
+      expect(ar_user.admin).to eq(true)
+      expect(ar_user.encrypted_password).to eq(mongo_user.encrypted_password)
+      expect(ar_user.authentication_token).to eq(mongo_user.authentication_token)
+    end
+
+    it "preserves the original Mongo timestamps" do
+      created = 3.years.ago.change(usec: 0)
+      updated = 1.year.ago.change(usec: 0)
+
+      mongo_user = User.create!(email: "old@example.com", name: "Old")
+      mongo_user.update_attributes!(created_at: created, updated_at: updated)
+
+      invoke(:users)
+
+      ar_user = Errbit::User.find_by!(bson_id: mongo_user._id.to_s)
+      expect(ar_user.created_at.to_i).to eq(created.to_i)
+      expect(ar_user.updated_at.to_i).to eq(updated.to_i)
+    end
+
+    it "is idempotent — re-running updates the existing record" do
+      mongo_user = User.create!(email: "twice@example.com", name: "Twice")
+
+      invoke(:users)
+      mongo_user.update!(name: "Renamed")
+
+      expect { invoke(:users) }.not_to change(Errbit::User, :count)
+      expect(Errbit::User.find_by!(bson_id: mongo_user._id.to_s).name).to eq("Renamed")
+    end
+
+    it "migrates github-only users without password fields populated" do
+      mongo_user = User.create!(email: "gh@example.com", name: "GH", github_login: "gh-handle")
+
+      expect { invoke(:users) }.to change(Errbit::User, :count).by(1)
+      expect(Errbit::User.find_by!(bson_id: mongo_user._id.to_s).github_login).to eq("gh-handle")
+    end
+  end
+
+  describe ":apps" do
+    it "creates an Errbit::App row linked by bson_id" do
+      mongo_app = App.create!(name: "Mongo App", github_repo: "owner/repo", repository_branch: "main")
+
+      expect { invoke(:apps) }.to change(Errbit::App, :count).by(1)
+
+      ar = Errbit::App.find_by!(bson_id: mongo_app._id.to_s)
+      expect(ar.name).to eq("Mongo App")
+      expect(ar.github_repo).to eq("owner/repo")
+      expect(ar.repository_branch).to eq("main")
+      expect(ar.api_key).to eq(mongo_app.api_key)
+    end
+
+    it "preserves email_at_notices in the underlying column" do
+      mongo_app = App.create!(name: "Notif App", email_at_notices: [1, 5, 10])
+
+      invoke(:apps)
+
+      # The Errbit::App#email_at_notices getter masks the column value when
+      # per_app_email_at_notices is off, so read the deserialized column directly.
+      ar = Errbit::App.find_by!(bson_id: mongo_app._id.to_s)
+      expect(ar.attributes["email_at_notices"]).to eq([1, 5, 10])
+    end
+  end
+
+  describe ":site_configs" do
+    it "creates an Errbit::SiteConfig with fingerprinter fields flattened" do
+      Errbit::SiteConfig.delete_all
+      SiteConfig.delete_all
+
+      mongo = SiteConfig.new
+      mongo.build_notice_fingerprinter(error_class: false, backtrace_lines: 3)
+      mongo.save!
+
+      expect { invoke(:site_configs) }.to change(Errbit::SiteConfig, :count).by(1)
+
+      ar = Errbit::SiteConfig.find_by!(bson_id: mongo._id.to_s)
+      expect(ar.error_class).to eq(false)
+      expect(ar.backtrace_lines).to eq(3)
+    end
+  end
+
+  describe ":watchers" do
+    it "migrates embedded watchers and resolves user references via bson_id" do
+      mongo_user = User.create!(email: "watcher@example.com", name: "Watcher")
+      mongo_app = App.create!(name: "Watched")
+      mongo_app.watchers.create!(user_id: mongo_user._id)
+      mongo_app.watchers.create!(email: "external@example.com")
+
+      invoke(:users)
+      invoke(:apps)
+      expect { invoke(:watchers) }.to change(Errbit::Watcher, :count).by(2)
+
+      errbit_app = Errbit::App.find_by!(bson_id: mongo_app._id.to_s)
+      errbit_user = Errbit::User.find_by!(bson_id: mongo_user._id.to_s)
+
+      addresses = errbit_app.watchers.reload.map(&:address)
+      expect(addresses).to match_array(["watcher@example.com", "external@example.com"])
+      expect(errbit_app.watchers.find_by(email: nil).user).to eq(errbit_user)
+    end
+  end
+
+  describe ":issue_trackers" do
+    it "migrates the embedded IssueTracker linked to its app" do
+      mongo_app = App.new(name: "Tracker App")
+      mongo_app.build_issue_tracker(type_tracker: "mock", options: {"foo" => "1"})
+      mongo_app.save!
+
+      invoke(:apps)
+      expect { invoke(:issue_trackers) }.to change(Errbit::IssueTracker, :count).by(1)
+
+      errbit_app = Errbit::App.find_by!(bson_id: mongo_app._id.to_s)
+      tracker = errbit_app.reload.issue_tracker
+      expect(tracker.type_tracker).to eq("mock")
+      expect(tracker.options["foo"]).to eq("1")
+    end
+  end
+
+  describe ":notification_services" do
+    it "migrates an embedded slack service and preserves STI type" do
+      mongo_app = App.new(name: "Slack App")
+      mongo_app.build_notification_service(
+        _type: "NotificationServices::SlackService",
+        service_url: "https://hooks.slack.com/services/X",
+        room_id: "#errors"
+      )
+      mongo_app.save!
+
+      invoke(:apps)
+      expect { invoke(:notification_services) }.to change(Errbit::NotificationService, :count).by(1)
+
+      ar = Errbit::App.find_by!(bson_id: mongo_app._id.to_s).reload.notification_service
+      expect(ar).to be_a(Errbit::NotificationServices::SlackService)
+      expect(ar.service_url).to eq("https://hooks.slack.com/services/X")
+      expect(ar.room_id).to eq("#errors")
+    end
+  end
+
+  describe ":notice_fingerprinters" do
+    it "merges the Mongo embedded fingerprinter onto the app's auto-built row" do
+      mongo_app = App.create!(name: "FP App")
+      mongo_app.notice_fingerprinter.update!(message: false, backtrace_lines: 5, source: "site")
+
+      # Errbit::App#ensure_notice_fingerprinter auto-creates the fingerprinter
+      # during :apps. The :notice_fingerprinters task then overwrites that row
+      # with the Mongo values (and stamps the bson_id). Net count delta is 0.
+      invoke(:apps)
+      expect { invoke(:notice_fingerprinters) }.not_to change(Errbit::NoticeFingerprinter, :count)
+
+      ar = Errbit::App.find_by!(bson_id: mongo_app._id.to_s).reload.notice_fingerprinter
+      expect(ar.bson_id).to eq(mongo_app.notice_fingerprinter._id.to_s)
+      expect(ar.message).to eq(false)
+      expect(ar.backtrace_lines).to eq(5)
+      expect(ar.source).to eq("site")
+    end
+  end
+
+  describe ":backtraces" do
+    it "creates an Errbit::Backtrace row linked by bson_id" do
+      mongo = Backtrace.create!(
+        fingerprint: "abc123",
+        lines: [{"number" => "1", "file" => "x.rb", "method" => "foo"}]
+      )
+
+      expect { invoke(:backtraces) }.to change(Errbit::Backtrace, :count).by(1)
+
+      ar = Errbit::Backtrace.find_by!(bson_id: mongo._id.to_s)
+      expect(ar.fingerprint).to eq("abc123")
+      expect(ar.lines.first["file"]).to eq("x.rb")
+    end
+  end
+
+  describe ":problems" do
+    it "creates an Errbit::Problem linked to its app via bson_id" do
+      mongo_app = App.create!(name: "Problem App")
+      mongo = Problem.create!(
+        app: mongo_app,
+        environment: "production",
+        error_class: "RuntimeError",
+        message: "boom"
+      )
+
+      invoke(:apps)
+      expect { invoke(:problems) }.to change(Errbit::Problem, :count).by(1)
+
+      ar = Errbit::Problem.find_by!(bson_id: mongo._id.to_s)
+      expect(ar.app).to eq(Errbit::App.find_by!(bson_id: mongo_app._id.to_s))
+      expect(ar.environment).to eq("production")
+      expect(ar.error_class).to eq("RuntimeError")
+    end
+
+    it "skips problems whose app hasn't been migrated yet" do
+      App.create!(name: "Skipped App").tap do |a|
+        Problem.create!(app: a, environment: "production", error_class: "X")
+      end
+
+      expect { invoke(:problems) }.not_to change(Errbit::Problem, :count)
+    end
+  end
+
+  describe ":errs" do
+    it "creates an Errbit::Err linked to its problem via bson_id" do
+      mongo_app = App.create!(name: "Err App")
+      mongo_problem = Problem.create!(app: mongo_app, environment: "production", error_class: "X")
+      mongo_err = Err.create!(problem: mongo_problem, fingerprint: "fp-1")
+
+      invoke(:apps)
+      invoke(:problems)
+      expect { invoke(:errs) }.to change(Errbit::Err, :count).by(1)
+
+      ar = Errbit::Err.find_by!(bson_id: mongo_err._id.to_s)
+      expect(ar.fingerprint).to eq("fp-1")
+      expect(ar.problem).to eq(Errbit::Problem.find_by!(bson_id: mongo_problem._id.to_s))
+    end
+  end
+
+  describe ":notices" do
+    it "creates an Errbit::Notice linked to app, err, and backtrace via bson_id" do
+      mongo_app = App.create!(name: "Notice App")
+      mongo_problem = Problem.create!(app: mongo_app, environment: "production", error_class: "X")
+      mongo_err = Err.create!(problem: mongo_problem, fingerprint: "n-fp")
+      mongo_backtrace = Backtrace.create!(fingerprint: "bt-fp", lines: [{"f" => "a.rb"}])
+      mongo_notice = Notice.create!(
+        app: mongo_app,
+        err: mongo_err,
+        backtrace: mongo_backtrace,
+        message: "Notice msg",
+        server_environment: {"environment-name" => "production"},
+        notifier: {"name" => "Notifier"}
+      )
+
+      invoke(:apps)
+      invoke(:backtraces)
+      invoke(:problems)
+      invoke(:errs)
+      expect { invoke(:notices) }.to change(Errbit::Notice, :count).by(1)
+
+      ar = Errbit::Notice.find_by!(bson_id: mongo_notice._id.to_s)
+      expect(ar.message).to eq("Notice msg")
+      expect(ar.app).to eq(Errbit::App.find_by!(bson_id: mongo_app._id.to_s))
+      expect(ar.err).to eq(Errbit::Err.find_by!(bson_id: mongo_err._id.to_s))
+      expect(ar.backtrace).to eq(Errbit::Backtrace.find_by!(bson_id: mongo_backtrace._id.to_s))
+    end
+  end
+
+  describe ":comments" do
+    it "creates an Errbit::Comment linked to its problem and user via bson_id" do
+      mongo_user = User.create!(email: "c@example.com", name: "Commenter")
+      mongo_app = App.create!(name: "Comment App")
+      mongo_problem = Problem.create!(app: mongo_app, environment: "production", error_class: "X")
+      mongo_comment = Comment.create!(err: mongo_problem, user: mongo_user, body: "first comment")
+
+      invoke(:users)
+      invoke(:apps)
+      invoke(:problems)
+      expect { invoke(:comments) }.to change(Errbit::Comment, :count).by(1)
+
+      ar = Errbit::Comment.find_by!(bson_id: mongo_comment._id.to_s)
+      expect(ar.body).to eq("first comment")
+      expect(ar.err).to eq(Errbit::Problem.find_by!(bson_id: mongo_problem._id.to_s))
+      expect(ar.user).to eq(Errbit::User.find_by!(bson_id: mongo_user._id.to_s))
+    end
+  end
+
+  describe ":all" do
+    it "runs every migration in dependency order with one Rake invocation" do
+      mongo_user = User.create!(email: "all@example.com", name: "All")
+      mongo_app = App.create!(name: "All App")
+      mongo_problem = Problem.create!(app: mongo_app, environment: "production", error_class: "X")
+      mongo_err = Err.create!(problem: mongo_problem, fingerprint: "all-fp")
+      mongo_backtrace = Backtrace.create!(fingerprint: "all-bt", lines: [])
+      Notice.create!(app: mongo_app, err: mongo_err, backtrace: mongo_backtrace,
+        server_environment: {"environment-name" => "production"},
+        notifier: {"name" => "Notifier"})
+      Comment.create!(err: mongo_problem, user: mongo_user, body: "all-comment")
+
+      invoke(:all)
+
+      expect(Errbit::User.where(bson_id: mongo_user._id.to_s)).to exist
+      expect(Errbit::App.where(bson_id: mongo_app._id.to_s)).to exist
+      expect(Errbit::Problem.where(bson_id: mongo_problem._id.to_s)).to exist
+      expect(Errbit::Err.where(bson_id: mongo_err._id.to_s)).to exist
+      expect(Errbit::Backtrace.where(bson_id: mongo_backtrace._id.to_s)).to exist
+      expect(Errbit::Notice.count).to be >= 1
+      expect(Errbit::Comment.count).to be >= 1
+    end
+  end
+end
diff --git a/spec/mailers/errbit/mailer_spec.rb b/spec/mailers/errbit/mailer_spec.rb
new file mode 100644
index 0000000000..6f5c5b0e57
--- /dev/null
+++ b/spec/mailers/errbit/mailer_spec.rb
@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.shared_examples "an Errbit notification email" do
+  it "has the X-Mailer header" do
+    expect(email).to have_header("X-Mailer", "Errbit")
+  end
+
+  it "has the X-Errbit-Host header" do
+    expect(email).to have_header("X-Errbit-Host", Errbit::Config.host)
+  end
+
+  it "has the Precedence header" do
+    expect(email).to have_header("Precedence", "bulk")
+  end
+
+  it "has the Auto-Submitted header" do
+    expect(email).to have_header("Auto-Submitted", "auto-generated")
+  end
+
+  it "has the X-Auto-Response-Suppress header" do
+    expect(email).to have_header("X-Auto-Response-Suppress", "OOF, AutoReply")
+  end
+
+  it "delivers the email" do
+    email
+
+    expect(ActionMailer::Base.deliveries.size).to eq(1)
+  end
+end
+
+RSpec.describe Errbit::Mailer do
+  context "with an Err notification" do
+    include EmailSpec::Helpers
+    include EmailSpec::Matchers
+
+    let(:notice) do
+      n = create(:errbit_notice, message: "class < ActionController::Base")
+      # Use a JS file so the email's per-file link shows the asset-host URL
+      n.backtrace.lines[-1] = n.backtrace.lines.last.merge("file" => "[PROJECT_ROOT]/path/to/file.js")
+      n
+    end
+
+    let(:app) do
+      a = notice.app
+      a.update!(asset_host: "http://example.com", notify_all_users: true)
+      a
+    end
+
+    let(:problem) do
+      p = notice.err.problem
+      p.notices_count = 3
+      p
+    end
+
+    let!(:user) { create(:errbit_user, admin: true) }
+
+    let(:error_report) do
+      instance_double(
+        "Errbit::ErrorReport",
+        notice: notice,
+        app: app,
+        problem: problem
+      )
+    end
+
+    let(:email) do
+      Errbit::Mailer.with(error_report: error_report).err_notification.deliver_now
+    end
+
+    before { email }
+
+    it_behaves_like "an Errbit notification email"
+
+    it "html-escapes the notice's message in the html part" do
+      html_body = email.body.parts.detect { |p| p.content_type.match(/html/) }.body.raw_source
+
+      expect(html_body).to match("class &lt; ActionController::Base")
+    end
+
+    it "inlines styles in the backtrace markup" do
+      expect(email).to have_body_text('<p class="backtrace" style="')
+    end
+
+    it "links to the source file via the app's asset host" do
+      expect(email).to have_body_text('<a target="_blank" rel="noopener noreferrer" href="http://example.com/path/to/file.js"> path/to/file.js')
+    end
+
+    it "puts the error count in the subject" do
+      expect(email.subject).to match(/^\(3\) /)
+    end
+
+    context "with a very long message" do
+      let(:notice) { create(:errbit_notice, message: 6.times.collect { |_a| "0123456789" }.join("")) }
+
+      it "truncates the long message" do
+        expect(email.subject).to match(/ \d{47}\.{3}$/)
+      end
+    end
+  end
+
+  context "with a Comment notification" do
+    include EmailSpec::Helpers
+    include EmailSpec::Matchers
+
+    let!(:err) { create(:errbit_err) }
+    let!(:notice) { create(:errbit_notice, err: err, app: err.app) }
+    let!(:comment) { create(:errbit_comment, err: notice.err.problem) }
+    let!(:watcher) { create(:errbit_watcher, app: comment.app) }
+
+    let(:recipients) { ["recipient@example.com", "another@example.com"] }
+
+    before do
+      expect(comment).to receive(:notification_recipients).and_return(recipients)
+      create(:errbit_notice, err: notice.err, app: notice.err.app)
+      # The Errbit::Notice factory doesn't call Errbit::Problem.cache_notice
+      # (the Mongoid notice factory did). Bump the cached count to match the
+      # "2 notices were created" expectation in the body assertion below.
+      notice.err.problem.update!(notices_count: 2)
+      @email = Errbit::Mailer.with(comment: comment).comment_notification.deliver_now
+    end
+
+    it "is sent to the comment's notification recipients" do
+      expect(@email.to).to eq(recipients)
+    end
+
+    it "includes the notices count in the body" do
+      expect(@email).to have_body_text("This error has occurred 2 times")
+    end
+
+    it "includes the comment body" do
+      expect(@email).to have_body_text(comment.body)
+    end
+  end
+end
diff --git a/spec/mailers/previews/errbit/mailer_preview.rb b/spec/mailers/previews/errbit/mailer_preview.rb
new file mode 100644
index 0000000000..ea01e11450
--- /dev/null
+++ b/spec/mailers/previews/errbit/mailer_preview.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Errbit
+  class MailerPreview < ActionMailer::Preview
+    def err_notification
+      notice = FactoryBot.create(:errbit_notice)
+      report = Struct.new(:notice, :app, :problem).new(notice, notice.app, notice.problem)
+
+      Errbit::Mailer.with(error_report: report).err_notification
+    end
+
+    def comment_notification
+      user = FactoryBot.create(:errbit_user)
+      comment = FactoryBot.create(:errbit_comment, user: user)
+
+      Errbit::Mailer.with(comment: comment).comment_notification
+    end
+  end
+end
diff --git a/spec/models/errbit/app_spec.rb b/spec/models/errbit/app_spec.rb
new file mode 100644
index 0000000000..57f37b8c76
--- /dev/null
+++ b/spec/models/errbit/app_spec.rb
@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::App, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_apps table" do
+    expect(described_class.table_name).to eq("errbit_apps")
+  end
+
+  context "validations" do
+    it "requires a name" do
+      app = build(:errbit_app, name: nil)
+
+      expect(app.valid?).to eq(false)
+      expect(app.errors[:name]).to include("can't be blank")
+    end
+
+    it "requires unique names" do
+      create(:errbit_app, name: "Errbit")
+      app = build(:errbit_app, name: "Errbit")
+
+      expect(app.valid?).to eq(false)
+      expect(app.errors[:name]).to eq(["has already been taken"])
+    end
+
+    it "requires unique api_keys" do
+      create(:errbit_app, api_key: "APIKEY")
+      app = build(:errbit_app, api_key: "APIKEY")
+
+      expect(app.valid?).to eq(false)
+      expect(app.errors[:api_key]).to eq(["has already been taken"])
+    end
+  end
+
+  context "being created" do
+    it "generates a new api-key" do
+      app = build(:errbit_app)
+
+      expect(app.api_key).to eq(nil)
+
+      app.save
+
+      expect(app.api_key).not_to eq(nil)
+    end
+
+    it "generates a correct api-key" do
+      app = create(:errbit_app)
+
+      expect(app.api_key).to match(/^[a-f0-9]{32}$/)
+    end
+
+    it "is fine with blank github repos" do
+      app = build(:errbit_app, github_repo: "")
+      app.save
+
+      expect(app.github_repo).to eq("")
+    end
+
+    it "doesn't touch a plain github user/repo" do
+      app = build(:errbit_app, github_repo: "errbit/errbit")
+      app.save
+
+      expect(app.github_repo).to eq("errbit/errbit")
+    end
+
+    it "removes domain from https github repos" do
+      app = build(:errbit_app, github_repo: "https://github.com/errbit/errbit")
+      app.save
+
+      expect(app.github_repo).to eq("errbit/errbit")
+    end
+
+    it "normalizes public git repo as a github repo" do
+      app = build(:errbit_app, github_repo: "https://github.com/errbit/errbit.git")
+      app.save
+
+      expect(app.github_repo).to eq("errbit/errbit")
+    end
+
+    it "normalizes private git repo as a github repo" do
+      app = build(:errbit_app, github_repo: "git@github.com:errbit/errbit.git")
+      app.save
+
+      expect(app.github_repo).to eq("errbit/errbit")
+    end
+  end
+
+  describe "#repo_branch" do
+    it "falls back to main when blank" do
+      app = build(:errbit_app)
+
+      expect(app.repo_branch).to eq("main")
+    end
+
+    it "returns the stored branch when present" do
+      app = build(:errbit_app, repository_branch: "develop")
+
+      expect(app.repo_branch).to eq("develop")
+    end
+  end
+
+  describe "#github_repo?" do
+    it "is true when there is a github_repo" do
+      app = create(:errbit_app, github_repo: "errbit/errbit")
+
+      expect(app.github_repo?).to eq(true)
+    end
+
+    it "is false when no github_repo" do
+      app = create(:errbit_app)
+
+      expect(app.github_repo?).to eq(false)
+    end
+  end
+
+  describe "#github_url" do
+    it "returns nil when no repo" do
+      expect(build(:errbit_app).github_url).to be_nil
+    end
+
+    it "joins the configured base url with the repo" do
+      app = build(:errbit_app, github_repo: "errbit/errbit")
+
+      expect(app.github_url).to eq("https://github.com/errbit/errbit")
+    end
+  end
+
+  describe "#github_url_to_file" do
+    it "resolves to full path to file" do
+      app = create(:errbit_app, github_repo: "errbit/errbit", repository_branch: "main")
+
+      expect(app.github_url_to_file("path/to/file")).to eq("https://github.com/errbit/errbit/blob/main/path/to/file")
+    end
+  end
+
+  describe "#bitbucket_repo?" do
+    it "is true when bitbucket_repo is present" do
+      app = build(:errbit_app, bitbucket_repo: "errbit/errbit")
+
+      expect(app.bitbucket_repo?).to eq(true)
+    end
+
+    it "is false otherwise" do
+      expect(build(:errbit_app).bitbucket_repo?).to eq(false)
+    end
+  end
+
+  describe "#bitbucket_url_to_file" do
+    it "resolves to full path to file" do
+      app = create(:errbit_app, bitbucket_repo: "errbit/errbit", repository_branch: "main")
+
+      expect(app.bitbucket_url_to_file("path/to/file")).to eq("https://bitbucket.org/errbit/errbit/src/main/path/to/file")
+    end
+  end
+
+  describe "#notify_on_errs" do
+    it "defaults to true" do
+      app = build(:errbit_app)
+
+      expect(app.notify_on_errs?).to eq(true)
+    end
+
+    it "is false when explicitly false" do
+      app = build(:errbit_app, notify_on_errs: false)
+
+      expect(app.notify_on_errs?).to eq(false)
+    end
+  end
+
+  describe "#regenerate_api_key!" do
+    it "replaces the api_key" do
+      app = create(:errbit_app)
+      original = app.api_key
+
+      app.regenerate_api_key!
+
+      expect(app.api_key).not_to eq(original)
+      expect(app.api_key).to match(/^[a-f0-9]{32}$/)
+    end
+  end
+
+  describe ".find_by_api_key!" do
+    it "returns the app with the given api_key" do
+      app = create(:errbit_app)
+
+      expect(described_class.find_by_api_key!(app.api_key)).to eq(app)
+    end
+
+    it "raises when not found" do
+      expect {
+        described_class.find_by_api_key!("does-not-exist")
+      }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe ".search" do
+    it "finds the correct record" do
+      found = create(:errbit_app, name: "Foo")
+      create(:errbit_app, name: "Brr")
+
+      expect(described_class.search("Foo").to_a).to eq([found])
+    end
+  end
+
+  describe "#attributes_for_super_diff" do
+    subject { create(:errbit_app) }
+
+    it { expect(subject.attributes_for_super_diff).to eq(id: subject.id, name: subject.name) }
+  end
+
+  describe "before_create :ensure_notice_fingerprinter" do
+    it "auto-builds a fingerprinter on create using SiteConfig defaults" do
+      app = create(:errbit_app)
+
+      expect(app.notice_fingerprinter).to be_present
+      expect(app.notice_fingerprinter.source).to eq(Errbit::SiteConfig::CONFIG_SOURCE_SITE)
+    end
+
+    it "does not replace an existing fingerprinter" do
+      app = build(:errbit_app)
+      app.build_notice_fingerprinter(error_class: false, backtrace_lines: 5, source: "app")
+      app.save!
+
+      expect(app.notice_fingerprinter.backtrace_lines).to eq(5)
+      expect(app.notice_fingerprinter.source).to eq("app")
+    end
+  end
+
+  describe "after_update :store_cached_attributes_on_problems" do
+    it "syncs app_name onto its problems when the app is renamed" do
+      app = create(:errbit_app, name: "Original")
+      problem = create(:errbit_problem, app: app)
+
+      expect(problem.reload.app_name).to eq("Original")
+
+      app.update!(name: "Renamed")
+
+      expect(problem.reload.app_name).to eq("Renamed")
+    end
+
+    it "does not touch problems when other attributes change" do
+      app = create(:errbit_app, name: "Stable")
+      problem = create(:errbit_problem, app: app)
+      problem.update!(app_name: "Stale")
+
+      app.update!(github_repo: "foo/bar")
+
+      expect(problem.reload.app_name).to eq("Stale")
+    end
+  end
+end
diff --git a/spec/models/errbit/backtrace_spec.rb b/spec/models/errbit/backtrace_spec.rb
new file mode 100644
index 0000000000..81da21ac2d
--- /dev/null
+++ b/spec/models/errbit/backtrace_spec.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Backtrace, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_backtraces table" do
+    expect(described_class.table_name).to eq("errbit_backtraces")
+  end
+
+  describe "constants" do
+    it "exposes IN_APP_PATH" do
+      expect(described_class::IN_APP_PATH).to be_a(Regexp)
+    end
+
+    it "exposes GEMS_PATH" do
+      expect(described_class::GEMS_PATH).to be_a(Regexp)
+    end
+  end
+
+  describe ".generate_fingerprint" do
+    it "returns a SHA1 hex digest of the lines joined as strings" do
+      lines = [{"number" => "1", "file" => "a.rb", "method" => "foo"}]
+
+      expect(described_class.generate_fingerprint(lines))
+        .to eq(Digest::SHA1.hexdigest(lines.map(&:to_s).join))
+    end
+
+    it "produces the same fingerprint for identical lines" do
+      lines = [{"number" => "1"}, {"number" => "2"}]
+
+      expect(described_class.generate_fingerprint(lines))
+        .to eq(described_class.generate_fingerprint(lines))
+    end
+
+    it "produces different fingerprints for different lines" do
+      first = described_class.generate_fingerprint([{"number" => "1"}])
+      second = described_class.generate_fingerprint([{"number" => "2"}])
+
+      expect(first).not_to eq(second)
+    end
+  end
+
+  describe ".find_or_create" do
+    let(:lines) do
+      [
+        {"number" => "123", "file" => "/some/path/to.rb", "method" => "abc"},
+        {"number" => "345", "file" => "/path/to.rb", "method" => "dowhat"}
+      ]
+    end
+    let(:fingerprint) { described_class.generate_fingerprint(lines) }
+
+    it "creates a new backtrace" do
+      backtrace = described_class.find_or_create(lines)
+
+      expect(backtrace).to be_persisted
+      expect(backtrace.lines).to eq(lines)
+      expect(backtrace.fingerprint).to eq(fingerprint)
+    end
+
+    it "creates only one backtrace for two identical line sets" do
+      described_class.find_or_create(lines)
+      described_class.find_or_create(lines)
+
+      expect(described_class.where(fingerprint: fingerprint).count).to eq(1)
+    end
+
+    it "returns the existing backtrace when called with matching lines" do
+      first = described_class.find_or_create(lines)
+      second = described_class.find_or_create(lines)
+
+      expect(second).to eq(first)
+    end
+  end
+end
diff --git a/spec/models/errbit/comment_spec.rb b/spec/models/errbit/comment_spec.rb
new file mode 100644
index 0000000000..8c5e23c873
--- /dev/null
+++ b/spec/models/errbit/comment_spec.rb
@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Comment, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_comments table" do
+    expect(described_class.table_name).to eq("errbit_comments")
+  end
+
+  context "validations" do
+    it "requires a body" do
+      comment = build(:errbit_comment, body: nil)
+
+      expect(comment.valid?).to eq(false)
+      expect(comment.errors[:body]).to include("can't be blank")
+    end
+
+    it "requires an err (problem)" do
+      comment = build(:errbit_comment, err: nil)
+
+      expect(comment.valid?).to eq(false)
+      expect(comment.errors[:err]).to include("must exist")
+    end
+
+    it "requires a user" do
+      comment = build(:errbit_comment, user: nil)
+
+      expect(comment.valid?).to eq(false)
+      expect(comment.errors[:user]).to include("must exist")
+    end
+  end
+
+  describe "delegation" do
+    it "delegates app to err" do
+      app = create(:errbit_app)
+      problem = create(:errbit_problem, app: app)
+      comment = create(:errbit_comment, err: problem)
+
+      expect(comment.app).to eq(app)
+    end
+  end
+
+  describe "counter cache" do
+    it "increments comments_count on the problem when created" do
+      problem = create(:errbit_problem)
+
+      expect {
+        create(:errbit_comment, err: problem)
+      }.to change { problem.reload.comments_count }.from(0).to(1)
+    end
+
+    it "decrements comments_count on the problem when destroyed" do
+      problem = create(:errbit_problem)
+      comment = create(:errbit_comment, err: problem)
+
+      expect {
+        comment.destroy
+      }.to change { problem.reload.comments_count }.from(1).to(0)
+    end
+  end
+
+  describe ".ordered" do
+    it "orders by created_at asc" do
+      older = create(:errbit_comment, created_at: 2.days.ago)
+      newer = create(:errbit_comment, created_at: 1.minute.ago)
+
+      ordered = described_class.ordered.to_a
+
+      expect(ordered.index(older)).to be < ordered.index(newer)
+    end
+  end
+
+  context "notification_recipients" do
+    let(:app) { create(:errbit_app) }
+    let!(:watcher) { create(:errbit_watcher, app: app, email: "watcher@example.com") }
+    let(:problem) { create(:errbit_problem, app: app) }
+    let(:comment_user) { create(:errbit_user, email: "author@example.com") }
+    let(:comment) { build(:errbit_comment, err: problem, user: comment_user) }
+
+    before { create(:errbit_user_watcher, app: app, user: comment_user) }
+
+    it "includes app notification_recipients except the comment user's email" do
+      expect(comment.notification_recipients).to eq([watcher.address])
+    end
+  end
+
+  context "emailable?" do
+    let(:app) { create(:errbit_app, notify_on_errs: true) }
+    let!(:watcher) { create(:errbit_watcher, app: app, email: "watcher@example.com") }
+    let(:problem) { create(:errbit_problem, app: app) }
+    let(:comment_user) { create(:errbit_user, email: "author@example.com") }
+    let(:comment) { build(:errbit_comment, err: problem, user: comment_user) }
+
+    before { create(:errbit_user_watcher, app: app, user: comment_user) }
+
+    it "is true when the app is emailable and there are recipients other than the comment user" do
+      expect(comment.emailable?).to eq(true)
+    end
+
+    it "is false when the app is not emailable" do
+      app.update!(notify_on_errs: false)
+
+      expect(comment.notification_recipients).to be_any
+      expect(comment.emailable?).to eq(false)
+    end
+
+    it "is false when the only recipient is the comment user" do
+      watcher.destroy
+      app.reload
+
+      expect(app.emailable?).to eq(true)
+      expect(comment.emailable?).to eq(false)
+    end
+  end
+end
diff --git a/spec/models/errbit/err_spec.rb b/spec/models/errbit/err_spec.rb
new file mode 100644
index 0000000000..b75f75b6e8
--- /dev/null
+++ b/spec/models/errbit/err_spec.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Err, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_errs table" do
+    expect(described_class.table_name).to eq("errbit_errs")
+  end
+
+  context "validations" do
+    it "requires a fingerprint" do
+      err = build(:errbit_err, fingerprint: nil)
+
+      expect(err.valid?).to eq(false)
+      expect(err.errors[:fingerprint]).to include("can't be blank")
+    end
+
+    it "requires a problem" do
+      err = build(:errbit_err, problem: nil)
+
+      expect(err.valid?).to eq(false)
+      expect(err.errors[:problem]).to include("must exist")
+    end
+  end
+
+  describe "associations" do
+    it "belongs to a problem" do
+      problem = create(:errbit_problem)
+      err = create(:errbit_err, problem: problem)
+
+      expect(err.problem).to eq(problem)
+    end
+
+    it "is destroyed when its problem is destroyed" do
+      err = create(:errbit_err)
+
+      expect {
+        err.problem.destroy
+      }.to change(described_class, :count).by(-1)
+    end
+  end
+
+  describe "delegation" do
+    it "delegates app to problem" do
+      app = create(:errbit_app)
+      problem = create(:errbit_problem, app: app)
+      err = create(:errbit_err, problem: problem)
+
+      expect(err.app).to eq(app)
+    end
+
+    it "delegates resolved? to problem" do
+      problem = create(:errbit_problem, resolved: true)
+      err = create(:errbit_err, problem: problem)
+
+      expect(err.resolved?).to eq(true)
+    end
+  end
+end
diff --git a/spec/models/errbit/error_report_spec.rb b/spec/models/errbit/error_report_spec.rb
new file mode 100644
index 0000000000..0ebefa177d
--- /dev/null
+++ b/spec/models/errbit/error_report_spec.rb
@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+require "airbrake/version"
+require "airbrake/backtrace"
+require "airbrake/notice"
+require "airbrake/utils/params_cleaner"
+
+# Allow building an Airbrake::Notice without configuring Airbrake first.
+module Airbrake
+  API_VERSION = "2.4"
+
+  class Notice
+    def framework
+      "rails"
+    end
+  end
+end
+
+RSpec.describe Errbit::ErrorReport, type: :model do
+  let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice.xml").read }
+  let(:error_report) { described_class.new(xml) }
+  # Errbit::App#ensure_notice_fingerprinter (before_create) auto-builds the
+  # fingerprinter from SiteConfig, so this spec no longer seeds one.
+  let!(:app) { create(:errbit_app, api_key: "APIKEY") }
+
+  describe "#app" do
+    it "finds the app by api_key" do
+      expect(error_report.app).to eq(app)
+    end
+  end
+
+  describe "#backtrace" do
+    it "returns a persisted Errbit::Backtrace" do
+      bt = error_report.backtrace
+
+      expect(bt).to be_a(Errbit::Backtrace)
+      expect(bt).to be_persisted
+    end
+  end
+
+  describe "#generate_notice!" do
+    it "creates a problem for the app" do
+      expect { error_report.generate_notice! }
+        .to change { app.reload.problems.count }.by(1)
+    end
+
+    context "with a minimal notice XML" do
+      let(:xml) { Rails.root.join("spec/fixtures/minimal_test_notice.xml").read }
+
+      it "creates a problem for the app" do
+        expect { error_report.generate_notice! }
+          .to change { app.reload.problems.count }.by(1)
+      end
+    end
+
+    context "with a notice generated by the Airbrake gem" do
+      let(:xml) do
+        Airbrake::Notice.new(
+          exception: Exception.new,
+          api_key: "APIKEY",
+          project_root: Rails.root
+        ).to_xml
+      end
+
+      it "creates a problem for the app" do
+        expect { error_report.generate_notice! }
+          .to change { app.reload.problems.count }.by(1)
+      end
+    end
+
+    context "after generating the notice" do
+      subject(:notice) { error_report.notice }
+
+      before { error_report.generate_notice! }
+
+      it "stores the error message" do
+        expect(notice.message).to include('HoptoadTestingException: Testing hoptoad via "rake hoptoad:test". If you can see this, it works')
+      end
+
+      it "stores the framework" do
+        expect(notice.framework).to eq("Rails: 3.2.11")
+      end
+
+      it "stores the full backtrace" do
+        expect(notice.backtrace_lines.size).to eq(73)
+        expect(notice.backtrace_lines.last["file"]).to eq("[GEM_ROOT]/bin/rake")
+      end
+
+      it "stores server_environment" do
+        expect(notice.server_environment["environment-name"]).to eq("development")
+      end
+
+      it "stores the request hash" do
+        expect(notice.request["url"]).to eq("http://example.org/verify/cupcake=fistfight&lovebird=doomsayer")
+        expect(notice.request["params"]["controller"]).to eq("application")
+      end
+
+      it "stores the notifier name" do
+        expect(notice.notifier["name"]).to eq("Hoptoad Notifier")
+      end
+
+      it "stores user_attributes" do
+        expect(notice.user_attributes["id"]).to eq("123")
+        expect(notice.user_attributes["name"]).to eq("Mr. Bean")
+        expect(notice.user_attributes["email"]).to eq("mr.bean@example.com")
+        expect(notice.user_attributes["username"]).to eq("mrbean")
+      end
+
+      it "exposes parsed env_vars" do
+        expect(notice.env_vars).to have_key("SCRIPT_NAME")
+        expect(notice.env_vars["SCRIPT_NAME"]).to be_nil
+
+        expected = {
+          "secure" => "false",
+          "httponly" => "true",
+          "path" => "/",
+          "expire_after" => nil,
+          "domain" => nil,
+          "id" => nil
+        }
+        expect(notice.env_vars).to have_key("rack_session_options")
+        expect(notice.env_vars["rack_session_options"]).to eq(expected)
+      end
+    end
+  end
+
+  describe "#cache_attributes_on_problem" do
+    it "writes the latest notice attributes onto the problem" do
+      error_report.generate_notice!
+
+      problem = error_report.problem.reload
+      notice = error_report.notice.reload
+
+      expect(problem.environment).to eq("development")
+      expect(problem.error_class).to eq("HoptoadTestingException")
+      expect(problem.last_notice_at.to_i).to eq(notice.created_at.to_i)
+      expect(problem.message).to eq(notice.message)
+      expect(problem.where).to eq(notice.where)
+    end
+
+    it "unresolves an already-resolved problem when a new notice arrives" do
+      error_report.generate_notice!
+      problem = error_report.problem
+      problem.update!(resolved_at: Time.zone.now, resolved: true)
+
+      described_class.new(xml).generate_notice!
+      problem.reload
+
+      expect(problem.resolved_at).to be_nil
+      expect(problem.resolved).to eq(false)
+    end
+
+    it "initializes the messages/hosts/user_agents digest counters" do
+      error_report.generate_notice!
+      problem = error_report.problem.reload
+
+      expect(problem.notices_count).to eq(1)
+      expect(problem.user_agents.values.first["count"]).to eq(1)
+      expect(problem.messages.values.first["count"]).to eq(1)
+      expect(problem.hosts.values.first["count"]).to eq(1)
+    end
+
+    it "increments the digest counters on repeat notices" do
+      error_report.generate_notice!
+      described_class.new(xml).generate_notice!
+      problem = error_report.problem.reload
+
+      expect(problem.notices_count).to eq(2)
+      expect(problem.user_agents.values.first["count"]).to eq(2)
+      expect(problem.messages.values.first["count"]).to eq(2)
+      expect(problem.hosts.values.first["count"]).to eq(2)
+    end
+  end
+
+  it "assigns the notice to an Errbit::Err" do
+    error_report.generate_notice!
+
+    expect(error_report.notice.err).to be_a(Errbit::Err)
+  end
+
+  it "memoizes the notice across repeated generate_notice! calls on the same instance" do
+    expect {
+      error_report.generate_notice!
+      error_report.generate_notice!
+    }.to change(Errbit::Notice, :count).by(1)
+  end
+
+  it "reuses the existing err on subsequent notices" do
+    error_report.generate_notice!
+    error_report.problem.resolve!
+
+    expect {
+      described_class.new(xml).generate_notice!
+    }.to change {
+      error_report.problem.reload.resolved?
+    }.from(true).to(false)
+  end
+
+  context "with a notification recipient configured" do
+    before do
+      app.update!(notify_on_errs: true)
+      app.watchers.create!(email: "foo@example.com")
+    end
+
+    it "delivers an email" do
+      notice = error_report.generate_notice!
+      email = ActionMailer::Base.deliveries.last
+
+      expect(email.to).to include(app.watchers.first.email)
+      expect(email.subject).to include(notice.message.truncate(50))
+      expect(email.subject).to include("[#{app.name}]")
+      expect(email.subject).to include("[#{notice.environment_name}]")
+    end
+
+    context "with email_at_notices set to [0]", type: :mailer do
+      before { allow(Errbit::Config).to receive(:email_at_notices).and_return([0]) }
+
+      it "delivers on the 1st occurrence" do
+        described_class.new(xml).generate_notice!
+
+        expect(ActionMailer::Base.deliveries.length).to eq(1)
+      end
+
+      it "delivers on the 2nd occurrence" do
+        2.times { described_class.new(xml).generate_notice! }
+
+        expect(ActionMailer::Base.deliveries.length).to eq(2)
+      end
+
+      it "delivers on the 3rd occurrence" do
+        3.times { described_class.new(xml).generate_notice! }
+
+        expect(ActionMailer::Base.deliveries.length).to eq(3)
+      end
+    end
+
+    context "with email_at_notices set to [1, 3]", type: :mailer do
+      before { allow(Errbit::Config).to receive(:email_at_notices).and_return([1, 3]) }
+
+      it "delivers on the 1st occurrence" do
+        described_class.new(xml).generate_notice!
+
+        expect(ActionMailer::Base.deliveries.length).to eq(1)
+      end
+
+      it "does not deliver on the 2nd occurrence" do
+        2.times { described_class.new(xml).generate_notice! }
+
+        expect(ActionMailer::Base.deliveries.length).to eq(1)
+      end
+
+      it "delivers on the 3rd occurrence" do
+        3.times { described_class.new(xml).generate_notice! }
+
+        expect(ActionMailer::Base.deliveries.length).to eq(2)
+      end
+
+      it "delivers on every occurrence after the problem is resolved between notices" do
+        3.times do
+          notice = described_class.new(xml).generate_notice!
+          notice.problem.resolve!
+        end
+
+        expect(ActionMailer::Base.deliveries.length).to eq(3)
+      end
+    end
+
+    context "with XML that has no request section" do
+      let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice_without_request_section.xml").read }
+
+      it "still creates a problem for the app" do
+        expect { error_report.generate_notice! }
+          .to change { app.reload.problems.count }.by(1)
+      end
+    end
+
+    context "with XML that has a single backtrace line" do
+      let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice_with_one_line_of_backtrace.xml").read }
+
+      it "still creates a problem for the app" do
+        expect { error_report.generate_notice! }
+          .to change { app.reload.problems.count }.by(1)
+      end
+    end
+  end
+
+  describe "#valid?" do
+    context "with a known api_key" do
+      it "returns true" do
+        expect(error_report.valid?).to eq(true)
+      end
+    end
+
+    context "with an unknown api_key" do
+      # destroy_all cascades the dependent: :destroy on notice_fingerprinter
+      # etc.; delete_all would violate the FK from errbit_notice_fingerprinters.
+      before { Errbit::App.where(api_key: app.api_key).destroy_all }
+
+      it "returns false" do
+        expect(error_report.valid?).to eq(false)
+      end
+    end
+  end
+
+  describe "#notice" do
+    context "before generate_notice!" do
+      it "is nil" do
+        expect(error_report.notice).to be_nil
+      end
+    end
+
+    context "after generate_notice!" do
+      before { error_report.generate_notice! }
+
+      it "returns the persisted Errbit::Notice" do
+        expect(error_report.notice).to be_a(Errbit::Notice)
+      end
+    end
+  end
+
+  describe "#should_keep?" do
+    context "without a current_app_version on the app" do
+      before do
+        error_report.app.current_app_version = nil
+        error_report.server_environment["app-version"] = "1.0"
+      end
+
+      it "returns true" do
+        expect(error_report.should_keep?).to eq(true)
+      end
+    end
+
+    context "with a current_app_version on the app" do
+      before { error_report.app.current_app_version = "1.0" }
+
+      it "returns true when the notice version matches the current version" do
+        error_report.server_environment["app-version"] = "1.0"
+
+        expect(error_report.should_keep?).to eq(true)
+      end
+
+      it "returns false when the notice version is older" do
+        error_report.server_environment["app-version"] = "0.9"
+
+        expect(error_report.should_keep?).to eq(false)
+      end
+    end
+  end
+end
diff --git a/spec/models/errbit/issue_spec.rb b/spec/models/errbit/issue_spec.rb
new file mode 100644
index 0000000000..59ec139447
--- /dev/null
+++ b/spec/models/errbit/issue_spec.rb
@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Issue, type: :model do
+  subject { described_class.new(problem: problem, user: user, body: body) }
+
+  let(:problem) { create(:errbit_problem) }
+  let(:user) { create(:errbit_user, admin: true) }
+  let(:issue_tracker) do
+    create(:errbit_issue_tracker, app: problem.app).tap do |t|
+      t.instance_variable_set(:@tracker, ErrbitPlugin::MockIssueTracker.new(t.options))
+    end
+  end
+  let(:errors) { subject.errors[:base] }
+
+  context "when app has no issue tracker" do
+    let(:body) { "barrr" }
+
+    describe "#save" do
+      it "returns false" do
+        expect(subject.save).to eq(false)
+      end
+
+      it "returns an error" do
+        subject.save
+
+        expect(errors).to include("This app has no issue tracker")
+      end
+    end
+  end
+
+  context "when there is no body" do
+    let(:body) { nil }
+
+    describe "#save" do
+      it "returns false" do
+        expect(subject.save).to eq(false)
+      end
+
+      it "returns an error" do
+        subject.save
+
+        expect(errors).to include("The issue has no body")
+      end
+    end
+  end
+
+  context "when app has an issue tracker" do
+    let(:body) { "barrr" }
+
+    before { issue_tracker }
+
+    describe "#render_body_args" do
+      it "returns custom args if the tracker provides them" do
+        allow(subject.tracker).to receive(:render_body_args).and_return(
+          ["my", {custom: "args"}]
+        )
+
+        expect(subject.render_body_args).to eq(["my", {custom: "args"}])
+      end
+
+      it "returns the default markdown template args otherwise" do
+        expect(subject.render_body_args)
+          .to eq([template: "issue_trackers/markdown"])
+      end
+    end
+
+    describe "#title" do
+      it "returns the tracker's custom title when present" do
+        allow(subject.tracker).to receive(:title).and_return("kustomtitle")
+
+        expect(subject.title).to eq("kustomtitle")
+      end
+
+      it "falls back to a default title built from the problem" do
+        expect(subject.title).to include(problem.message.to_s)
+      end
+    end
+
+    describe "#save" do
+      context "when the tracker plugin has errors" do
+        before { issue_tracker.tracker.options.clear }
+
+        it "returns false" do
+          expect(subject.save).to eq(false)
+        end
+
+        it "adds the tracker errors" do
+          subject.save
+
+          expect(errors).to include("foo is required")
+          expect(errors).to include("bar is required")
+        end
+      end
+
+      it "returns true" do
+        expect(subject.save).to eq(true)
+      end
+
+      it "creates an issue on the tracker" do
+        subject.save
+
+        expect(issue_tracker.tracker.output.count).to eq(1)
+      end
+
+      it "passes the title to the tracker" do
+        subject.save
+
+        saved_issue = issue_tracker.tracker.output.first
+
+        expect(saved_issue.first).to eq(subject.title)
+      end
+
+      it "passes the body to the tracker" do
+        subject.save
+
+        saved_issue = issue_tracker.tracker.output.first
+
+        expect(saved_issue[1]).to eq(body)
+      end
+    end
+  end
+end
diff --git a/spec/models/errbit/issue_tracker_spec.rb b/spec/models/errbit/issue_tracker_spec.rb
new file mode 100644
index 0000000000..8af21ed66b
--- /dev/null
+++ b/spec/models/errbit/issue_tracker_spec.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::IssueTracker, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_issue_trackers table" do
+    expect(described_class.table_name).to eq("errbit_issue_trackers")
+  end
+
+  describe "associations" do
+    it "can belong to an app" do
+      app = create(:errbit_app)
+      tracker = create(:errbit_issue_tracker, app: app)
+
+      expect(tracker.app).to eq(app)
+      expect(app.reload.issue_tracker).to eq(tracker)
+    end
+
+    it "is destroyed when its app is destroyed" do
+      tracker = create(:errbit_issue_tracker)
+
+      expect {
+        tracker.app.destroy
+      }.to change(described_class, :count).by(-1)
+    end
+  end
+
+  describe "#type_tracker" do
+    it "returns the stored value when set" do
+      tracker = described_class.new(type_tracker: "github")
+
+      expect(tracker.type_tracker).to eq("github")
+    end
+
+    it "defaults to 'none' when not set" do
+      tracker = described_class.new
+
+      expect(tracker.type_tracker).to eq("none")
+    end
+  end
+
+  describe "#options" do
+    it "defaults to an empty hash" do
+      expect(described_class.new.options).to eq({})
+    end
+
+    it "stores arbitrary key/values" do
+      tracker = create(:errbit_issue_tracker, options: {"a" => "1", "b" => "2"})
+
+      expect(tracker.reload.options).to eq("a" => "1", "b" => "2")
+    end
+  end
+
+  describe "#tracker" do
+    context "with an unknown type_tracker" do
+      let(:app) { create(:errbit_app) }
+
+      it "returns ErrbitPlugin::NoneIssueTracker" do
+        issue_tracker = described_class.new(type_tracker: "Foo", app: app)
+
+        expect(issue_tracker.tracker).to be_a(ErrbitPlugin::NoneIssueTracker)
+      end
+    end
+
+    it "passes github_repo and bitbucket_repo from the app into the tracker options" do
+      app = create(:errbit_app, github_repo: "owner/gh", bitbucket_repo: "owner/bb")
+      tracker = described_class.new(type_tracker: "Foo", app: app, options: {"extra" => "value"})
+
+      none_tracker = tracker.tracker
+
+      expect(none_tracker).to be_a(ErrbitPlugin::NoneIssueTracker)
+    end
+
+    it "memoizes the tracker instance" do
+      tracker = described_class.new(type_tracker: "Foo")
+
+      expect(tracker.tracker).to equal(tracker.tracker)
+    end
+  end
+end
diff --git a/spec/models/errbit/notice_fingerprinter_spec.rb b/spec/models/errbit/notice_fingerprinter_spec.rb
new file mode 100644
index 0000000000..b5f4035ca1
--- /dev/null
+++ b/spec/models/errbit/notice_fingerprinter_spec.rb
@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NoticeFingerprinter, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_notice_fingerprinters table" do
+    expect(described_class.table_name).to eq("errbit_notice_fingerprinters")
+  end
+
+  describe "defaults" do
+    let(:fingerprinter) { described_class.new }
+
+    it { expect(fingerprinter.error_class).to eq(true) }
+    it { expect(fingerprinter.message).to eq(true) }
+    it { expect(fingerprinter.component).to eq(true) }
+    it { expect(fingerprinter.action).to eq(true) }
+    it { expect(fingerprinter.environment_name).to eq(true) }
+    it { expect(fingerprinter.backtrace_lines).to eq(-1) }
+    it { expect(fingerprinter.source).to be_nil }
+  end
+
+  describe "associations" do
+    it "belongs to an app (optional)" do
+      expect(described_class.new(app: nil).valid?).to eq(true)
+    end
+
+    it "is auto-built when its app is created" do
+      app = create(:errbit_app)
+
+      expect(app.notice_fingerprinter).to be_present
+      expect(app.notice_fingerprinter.app).to eq(app)
+    end
+
+    it "is destroyed when its app is destroyed" do
+      app = create(:errbit_app)
+      app.notice_fingerprinter # force load
+
+      expect {
+        app.destroy
+      }.to change(described_class, :count).by(-1)
+    end
+  end
+
+  describe "#generate" do
+    let(:fingerprinter) { described_class.new }
+    let(:notice) { create(:errbit_notice) }
+    let(:backtrace) { create(:errbit_backtrace) }
+
+    it "generates the same fingerprint for the same notice" do
+      f_1 = fingerprinter.generate("123", notice, backtrace)
+      f_2 = fingerprinter.generate("123", notice, backtrace)
+
+      expect(f_1).to eq(f_2)
+    end
+
+    ["error_class", "message", "component", "action", "environment_name"].each do |attr|
+      it "affects the fingerprint when #{attr} is false" do
+        f_1 = fingerprinter.generate("123", notice, backtrace)
+
+        fingerprinter.send(:"#{attr}=", false)
+        f_2 = fingerprinter.generate("123", notice, backtrace)
+
+        expect(f_1).not_to eq(f_2)
+      end
+    end
+
+    it "is affected by backtrace_lines config" do
+      f_1 = fingerprinter.generate("123", notice, backtrace)
+
+      fingerprinter.backtrace_lines = 1
+      f_2 = fingerprinter.generate("123", notice, backtrace)
+
+      expect(f_1).not_to eq(f_2)
+    end
+
+    context "two backtraces with the same first two lines" do
+      let(:backtrace_1) { create(:errbit_backtrace) }
+      let(:backtrace_2) { create(:errbit_backtrace) }
+
+      before do
+        backtrace_1.lines[0] = backtrace_2.lines[0]
+        backtrace_1.lines[1] = backtrace_2.lines[1]
+        backtrace_1.lines[2] = {"number" => 1, "file" => "a", "method" => "b"}
+      end
+
+      it "produces the same fingerprint when considering two lines" do
+        fingerprinter.backtrace_lines = 2
+
+        f_1 = fingerprinter.generate("123", notice, backtrace_1)
+        f_2 = fingerprinter.generate("123", notice, backtrace_2)
+
+        expect(f_1).to eq(f_2)
+      end
+
+      it "produces different fingerprints when considering three lines" do
+        fingerprinter.backtrace_lines = 3
+
+        f_1 = fingerprinter.generate("123", notice, backtrace_1)
+        f_2 = fingerprinter.generate("123", notice, backtrace_2)
+
+        expect(f_1).not_to eq(f_2)
+      end
+    end
+
+    context "with nil backtrace" do
+      it "produces the same fingerprint across calls" do
+        f_1 = fingerprinter.generate("123", notice, nil)
+        f_2 = fingerprinter.generate("123", notice, nil)
+
+        expect(f_1).to eq(f_2)
+      end
+    end
+  end
+end
diff --git a/spec/models/errbit/notice_spec.rb b/spec/models/errbit/notice_spec.rb
new file mode 100644
index 0000000000..9943b88e15
--- /dev/null
+++ b/spec/models/errbit/notice_spec.rb
@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Notice, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_notices table" do
+    expect(described_class.table_name).to eq("errbit_notices")
+  end
+
+  context "validations" do
+    it "requires a backtrace" do
+      notice = build(:errbit_notice, backtrace: nil)
+
+      expect(notice.valid?).to eq(false)
+      expect(notice.errors[:backtrace]).to include("must exist")
+    end
+
+    it "requires an app" do
+      notice = build(:errbit_notice, app: nil)
+
+      expect(notice.valid?).to eq(false)
+      expect(notice.errors[:app]).to include("must exist")
+    end
+
+    it "requires an err" do
+      notice = build(:errbit_notice, err: nil)
+
+      expect(notice.valid?).to eq(false)
+      expect(notice.errors[:err]).to include("must exist")
+    end
+
+    it "requires server_environment" do
+      notice = build(:errbit_notice, server_environment: nil)
+
+      expect(notice.valid?).to eq(false)
+      expect(notice.errors[:server_environment]).to include("can't be blank")
+    end
+
+    it "requires notifier" do
+      notice = build(:errbit_notice, notifier: nil)
+
+      expect(notice.valid?).to eq(false)
+      expect(notice.errors[:notifier]).to include("can't be blank")
+    end
+  end
+
+  describe "#message=" do
+    let(:long_message) { "x" * (described_class::MESSAGE_LENGTH_LIMIT * 2) }
+
+    it "truncates the message" do
+      notice = create(:errbit_notice, message: long_message)
+
+      expect(long_message.length).to be > described_class::MESSAGE_LENGTH_LIMIT
+      expect(notice.message.length).to eq(described_class::MESSAGE_LENGTH_LIMIT)
+    end
+
+    it "truncates a long multibyte message by bytes" do
+      long_mb_message = "ä" * (described_class::MESSAGE_LENGTH_LIMIT)
+      notice = create(:errbit_notice, message: long_mb_message)
+
+      expect(long_mb_message.bytesize).to be > described_class::MESSAGE_LENGTH_LIMIT
+      expect(notice.message.bytesize).to be <= described_class::MESSAGE_LENGTH_LIMIT
+    end
+  end
+
+  describe "key sanitization" do
+    let(:hash) { {"some.key" => {"$nested.key" => {"$Path" => "/", "some$key" => "key"}}} }
+    let(:hash_sanitized) { {"some&#46;key" => {"&#36;nested&#46;key" => {"&#36;Path" => "/", "some$key" => "key"}}} }
+
+    [:server_environment, :request, :notifier].each do |key|
+      it "replaces . with &#46; and $ with &#36; in keys used in #{key}" do
+        notice = create(:errbit_notice, key => hash)
+
+        expect(notice.send(key)).to eq(hash_sanitized)
+      end
+    end
+  end
+
+  describe "#user_agent" do
+    it "parses a known user agent string" do
+      notice = build(:errbit_notice, request: {"cgi-data" => {
+        "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_7; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.204 Safari/534.16"
+      }})
+
+      expect(notice.user_agent.browser).to eq("Chrome")
+      expect(notice.user_agent.version.to_s).to match(/^10\.0/)
+    end
+
+    it "returns nil when HTTP_USER_AGENT is blank" do
+      notice = build(:errbit_notice)
+
+      expect(notice.user_agent).to be_nil
+    end
+  end
+
+  describe "#user_agent_string" do
+    it "returns a human-readable user agent" do
+      notice = build(:errbit_notice, request: {"cgi-data" => {
+        "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_7; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.204 Safari/534.16"
+      }})
+
+      expect(notice.user_agent_string).to eq("Chrome 10.0.648.204 (OS X 10.6.7)")
+    end
+
+    it "returns 'N/A' when HTTP_USER_AGENT is blank" do
+      notice = build(:errbit_notice)
+
+      expect(notice.user_agent_string).to eq(described_class::UNAVAILABLE)
+    end
+  end
+
+  describe "#host" do
+    it "returns the host when url is valid" do
+      notice = build(:errbit_notice, request: {"url" => "http://example.com/resource/12"})
+
+      expect(notice.host).to eq("example.com")
+    end
+
+    it "returns 'N/A' when url has no host" do
+      notice = build(:errbit_notice, request: {"url" => "file:///path/to/some/resource/12"})
+
+      expect(notice.host).to eq("N/A")
+    end
+
+    it "returns 'N/A' when url is unparseable" do
+      notice = build(:errbit_notice, request: {"url" => "some string"})
+
+      expect(notice.host).to eq("N/A")
+    end
+
+    it "returns 'N/A' when url is missing" do
+      notice = build(:errbit_notice, request: {})
+
+      expect(notice.host).to eq("N/A")
+    end
+  end
+
+  describe "#request" do
+    it "returns an empty hash when not set" do
+      expect(described_class.new.request).to eq({})
+    end
+  end
+
+  describe "#env_vars" do
+    it "returns the cgi-data hash" do
+      notice = described_class.new
+      notice.request = {"cgi-data" => {"ONE" => "TWO"}}
+
+      expect(notice.env_vars).to eq("ONE" => "TWO")
+    end
+
+    it "returns an empty hash when cgi-data is not a hash" do
+      notice = described_class.new
+      notice.request = {"cgi-data" => []}
+
+      expect(notice.env_vars).to eq({})
+    end
+  end
+
+  describe "#environment_name" do
+    it "returns server-environment when present" do
+      notice = build(:errbit_notice, server_environment: {"server-environment" => "staging"})
+
+      expect(notice.environment_name).to eq("staging")
+    end
+
+    it "falls back to environment-name" do
+      notice = build(:errbit_notice, server_environment: {"environment-name" => "production"})
+
+      expect(notice.environment_name).to eq("production")
+    end
+
+    it "defaults to development when both are blank" do
+      notice = build(:errbit_notice, server_environment: {"server-environment" => ""})
+
+      expect(notice.environment_name).to eq("development")
+    end
+  end
+
+  describe "#where" do
+    it "joins component and action with #" do
+      notice = build(:errbit_notice, request: {"component" => "users", "action" => "show"})
+
+      expect(notice.where).to eq("users#show")
+    end
+
+    it "returns just component when action is blank" do
+      notice = build(:errbit_notice, request: {"component" => "users"})
+
+      expect(notice.where).to eq("users")
+    end
+  end
+
+  describe "#filtered_message" do
+    it "removes memory addresses from object strings" do
+      notice = build(:errbit_notice, message: "#<Object:0x007fa2b33d9458>")
+
+      expect(notice.filtered_message).to eq("#<Object>")
+    end
+  end
+
+  describe "scopes" do
+    describe ".ordered" do
+      it "orders by created_at asc" do
+        older = create(:errbit_notice, created_at: 2.days.ago)
+        newer = create(:errbit_notice, created_at: 1.minute.ago)
+
+        ordered = described_class.ordered.to_a
+
+        expect(ordered.index(older)).to be < ordered.index(newer)
+      end
+    end
+
+    describe ".reverse_ordered" do
+      it "orders by created_at desc" do
+        older = create(:errbit_notice, created_at: 2.days.ago)
+        newer = create(:errbit_notice, created_at: 1.minute.ago)
+
+        ordered = described_class.reverse_ordered.to_a
+
+        expect(ordered.index(newer)).to be < ordered.index(older)
+      end
+    end
+
+    describe ".for_errs" do
+      it "returns notices belonging to the given errs" do
+        err = create(:errbit_err)
+        notice = create(:errbit_notice, err: err)
+        create(:errbit_notice)
+
+        expect(described_class.for_errs([err]).to_a).to eq([notice])
+      end
+    end
+  end
+
+  describe "delegation" do
+    it "delegates problem to err" do
+      problem = create(:errbit_problem)
+      err = create(:errbit_err, problem: problem)
+      notice = create(:errbit_notice, err: err)
+
+      expect(notice.problem).to eq(problem)
+    end
+
+    it "delegates backtrace_lines to backtrace" do
+      backtrace = create(:errbit_backtrace)
+      notice = create(:errbit_notice, backtrace: backtrace)
+
+      expect(notice.backtrace_lines).to eq(backtrace.lines)
+    end
+  end
+end
diff --git a/spec/models/errbit/notification_service_spec.rb b/spec/models/errbit/notification_service_spec.rb
new file mode 100644
index 0000000000..e8de4fc833
--- /dev/null
+++ b/spec/models/errbit/notification_service_spec.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NotificationService, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_notification_services table" do
+    expect(described_class.table_name).to eq("errbit_notification_services")
+  end
+
+  describe "single-table inheritance" do
+    it "persists subclass via the type column" do
+      service = create(:errbit_webhook_notification_service, api_token: "https://example.com/hook")
+
+      expect(service[:type]).to eq("Errbit::NotificationServices::WebhookService")
+      expect(described_class.find(service.id)).to be_a(Errbit::NotificationServices::WebhookService)
+    end
+  end
+
+  describe ".label" do
+    it "returns the LABEL constant on the class" do
+      expect(Errbit::NotificationServices::WebhookService.label).to eq("webhook")
+      expect(Errbit::NotificationServices::SlackService.label).to eq("slack")
+    end
+  end
+
+  describe "#label" do
+    it "returns the class label" do
+      service = Errbit::NotificationServices::SlackService.new
+
+      expect(service.label).to eq("slack")
+    end
+  end
+
+  describe "#configured?" do
+    it "is true when api_token is present" do
+      service = described_class.new(api_token: "abc")
+
+      expect(service.configured?).to eq(true)
+    end
+
+    it "is false when api_token is blank" do
+      service = described_class.new
+
+      expect(service.configured?).to eq(false)
+    end
+  end
+
+  describe "#notification_description" do
+    it "formats environment, where, and a truncated message" do
+      problem = build(:errbit_problem,
+        environment: "production",
+        message: "x" * 200)
+
+      allow(problem).to receive(:where).and_return("widgets#show")
+
+      service = described_class.new
+      description = service.notification_description(problem)
+
+      expect(description).to start_with("[production][widgets#show]")
+      expect(description).to include("...")
+    end
+  end
+
+  describe "#notify_at_notices" do
+    context "when per_app_notify_at_notices is false" do
+      before { allow(Errbit::Config).to receive(:per_app_notify_at_notices).and_return(false) }
+
+      it "always returns the global config" do
+        allow(Errbit::Config).to receive(:notify_at_notices).and_return([10])
+        service = described_class.new(notify_at_notices: [1, 2, 3])
+
+        expect(service.notify_at_notices).to eq([10])
+      end
+    end
+
+    context "when per_app_notify_at_notices is true" do
+      before { allow(Errbit::Config).to receive(:per_app_notify_at_notices).and_return(true) }
+
+      it "returns the stored value when present" do
+        service = described_class.new(notify_at_notices: [1, 5])
+
+        expect(service.notify_at_notices).to eq([1, 5])
+      end
+
+      it "falls back to the global config when nothing is stored" do
+        allow(Errbit::Config).to receive(:notify_at_notices).and_return([0])
+        service = described_class.new
+
+        expect(service.notify_at_notices).to eq([0])
+      end
+    end
+  end
+
+  describe "association" do
+    it "can belong to an app" do
+      app = create(:errbit_app)
+      service = create(:errbit_webhook_notification_service, app: app, api_token: "https://example.com/h")
+
+      expect(service.app).to eq(app)
+      expect(app.reload.notification_service).to eq(service)
+    end
+
+    it "is destroyed when its app is destroyed" do
+      service = create(:errbit_webhook_notification_service, api_token: "https://example.com/h")
+
+      expect {
+        service.app.destroy
+      }.to change(described_class, :count).by(-1)
+    end
+  end
+end
diff --git a/spec/models/errbit/notification_services/slack_service_spec.rb b/spec/models/errbit/notification_services/slack_service_spec.rb
new file mode 100644
index 0000000000..d857a13cfd
--- /dev/null
+++ b/spec/models/errbit/notification_services/slack_service_spec.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NotificationServices::SlackService, type: :model do
+  let(:backtrace) do
+    create(:errbit_backtrace,
+      lines: [
+        {"number" => 22, "file" => "/path/to/file/1.rb", "method" => "first_method"},
+        {"number" => 44, "file" => "/path/to/file/2.rb", "method" => "second_method"},
+        {"number" => 11, "file" => "/path/to/file/3.rb", "method" => "third_method"},
+        {"number" => 103, "file" => "/path/to/file/4.rb", "method" => "fourth_method"},
+        {"number" => 923, "file" => "/path/to/file/5.rb", "method" => "fifth_method"},
+        {"number" => 8, "file" => "/path/to/file/6.rb", "method" => "sixth_method"}
+      ])
+  end
+
+  let(:notice) { create(:errbit_notice, backtrace: backtrace) }
+  let(:problem) { notice.err.problem }
+  let(:service_url) { "https://hooks.slack.com/services/XXXXXXXXX/XXXXXXXXX/XXXXXXXXX" }
+  let(:room_id) { "#general" }
+  let(:service) do
+    create(:errbit_slack_notification_service,
+      app: notice.app,
+      service_url: service_url,
+      room_id: room_id)
+  end
+
+  context "validations" do
+    it "requires service_url" do
+      service.service_url = ""
+      service.valid?
+
+      expect(service.errors[:service_url])
+        .to include("You must specify your Slack Hook url")
+
+      service.service_url = service_url
+      service.valid?
+
+      expect(service.errors[:service_url]).to be_blank
+    end
+
+    it "validates the format of room_id" do
+      service.room_id = "INVALID NAME"
+      service.valid?
+
+      expect(service.errors[:room_id])
+        .to include("Slack channel name must be lowercase, with no space, special character, or periods.")
+
+      service.room_id = "#valid-room-name"
+      service.valid?
+
+      expect(service.errors[:room_id]).to be_blank
+    end
+
+    it "allows blank room_id" do
+      service.room_id = nil
+
+      expect(service.valid?).to eq(true)
+    end
+  end
+
+  describe "#configured?" do
+    it "is true when service_url is present" do
+      expect(service.configured?).to eq(true)
+    end
+
+    it "is false when service_url is blank" do
+      service.service_url = nil
+
+      expect(service.configured?).to eq(false)
+    end
+  end
+
+  describe "#message_for_slack" do
+    it "formats a single-line summary including url" do
+      expect(service.message_for_slack(problem))
+        .to include(problem.app.name, problem.environment, problem.error_class.to_s)
+    end
+  end
+
+  describe "#create_notification" do
+    context "with room_id" do
+      it "POSTs the payload to the Slack webhook" do
+        expect(HTTParty).to receive(:post)
+          .with(service.service_url,
+            body: service.post_payload(problem),
+            headers: {"Content-Type" => "application/json"})
+          .and_return(true)
+
+        service.create_notification(problem)
+      end
+
+      it "includes the channel in the payload" do
+        payload = JSON.parse(service.post_payload(problem))
+
+        expect(payload["channel"]).to eq(room_id)
+      end
+    end
+
+    context "without room_id" do
+      let(:room_id) { nil }
+
+      it "omits channel from the payload" do
+        payload = JSON.parse(service.post_payload(problem))
+
+        expect(payload).not_to have_key("channel")
+      end
+    end
+  end
+
+  it "has the icon asset present in the repo" do
+    expect(Rails.root.join("docs/notifications/slack/errbit.png")).to exist
+  end
+end
diff --git a/spec/models/errbit/notification_services/webhook_service_spec.rb b/spec/models/errbit/notification_services/webhook_service_spec.rb
new file mode 100644
index 0000000000..12980d8b7a
--- /dev/null
+++ b/spec/models/errbit/notification_services/webhook_service_spec.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::NotificationServices::WebhookService, type: :model do
+  let(:service) { build(:errbit_webhook_notification_service, api_token: "https://example.com/hook") }
+  let(:problem) { create(:errbit_problem) }
+
+  describe "validations" do
+    it "requires api_token" do
+      service.api_token = ""
+      service.valid?
+
+      expect(service.errors[:base]).to include("You must specify the URL")
+    end
+
+    it "is valid with api_token" do
+      service.api_token = "https://example.com/hook"
+
+      expect(service.valid?).to eq(true)
+    end
+  end
+
+  describe "#message_for_webhook" do
+    it "wraps problem JSON under a :problem key with the url merged in" do
+      payload = service.message_for_webhook(problem)
+
+      expect(payload[:problem]).to be_a(Hash)
+      expect(payload[:problem][:url]).to eq(problem.url)
+    end
+  end
+
+  describe "#create_notification" do
+    it "POSTs the payload to api_token" do
+      payload = service.message_for_webhook(problem)
+
+      expect(HTTParty).to receive(:post)
+        .with(
+          service.api_token,
+          headers: {"Content-Type" => "application/json", "User-Agent" => "Errbit"},
+          body: payload.to_json
+        )
+        .and_return(true)
+
+      service.create_notification(problem)
+    end
+  end
+end
diff --git a/spec/models/errbit/problem_spec.rb b/spec/models/errbit/problem_spec.rb
new file mode 100644
index 0000000000..1f8b63a10c
--- /dev/null
+++ b/spec/models/errbit/problem_spec.rb
@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Problem, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_problems table" do
+    expect(described_class.table_name).to eq("errbit_problems")
+  end
+
+  context "validations" do
+    it "requires an environment" do
+      problem = build(:errbit_problem, environment: nil)
+
+      expect(problem.valid?).to eq(false)
+      expect(problem.errors[:environment]).to include("can't be blank")
+    end
+
+    it "requires an associated app" do
+      problem = build(:errbit_problem, app: nil)
+
+      expect(problem.valid?).to eq(false)
+      expect(problem.errors[:app]).to include("must exist")
+    end
+
+    it "requires first_notice_at" do
+      problem = build(:errbit_problem, first_notice_at: nil)
+
+      expect(problem.valid?).to eq(false)
+      expect(problem.errors[:first_notice_at]).to include("can't be blank")
+    end
+
+    it "requires last_notice_at" do
+      problem = build(:errbit_problem, last_notice_at: nil)
+
+      expect(problem.valid?).to eq(false)
+      expect(problem.errors[:last_notice_at]).to include("can't be blank")
+    end
+  end
+
+  context "defaults" do
+    let(:problem) { build(:errbit_problem) }
+
+    it "sets first_notice_at to now" do
+      expect(problem.first_notice_at).to be_within(5).of(Time.zone.now)
+    end
+
+    it "sets last_notice_at to now" do
+      expect(problem.last_notice_at).to be_within(5).of(Time.zone.now)
+    end
+
+    it "starts unresolved" do
+      expect(problem.resolved).to eq(false)
+    end
+
+    it "starts with zero notices_count" do
+      expect(problem.notices_count).to eq(0)
+    end
+
+    it "starts with zero comments_count" do
+      expect(problem.comments_count).to eq(0)
+    end
+
+    it "initializes user_agents as an empty hash" do
+      expect(problem.user_agents).to eq({})
+    end
+
+    it "initializes messages as an empty hash" do
+      expect(problem.messages).to eq({})
+    end
+
+    it "initializes hosts as an empty hash" do
+      expect(problem.hosts).to eq({})
+    end
+  end
+
+  describe "before_create :cache_app_attributes" do
+    it "stores the app's name" do
+      app = create(:errbit_app, name: "MyApp")
+      problem = create(:errbit_problem, app: app)
+
+      expect(problem.app_name).to eq("MyApp")
+    end
+  end
+
+  describe "scopes" do
+    let!(:resolved_problem) { create(:errbit_problem, resolved: true) }
+    let!(:unresolved_problem) { create(:errbit_problem, resolved: false) }
+
+    describe ".resolved" do
+      it "returns only resolved problems" do
+        expect(described_class.resolved.to_a).to eq([resolved_problem])
+      end
+    end
+
+    describe ".unresolved" do
+      it "returns only unresolved problems" do
+        expect(described_class.unresolved.to_a).to eq([unresolved_problem])
+      end
+    end
+
+    describe ".ordered" do
+      it "orders by last_notice_at desc" do
+        older = create(:errbit_problem, last_notice_at: 2.days.ago)
+        newer = create(:errbit_problem, last_notice_at: 1.minute.ago)
+
+        ordered = described_class.ordered.to_a
+
+        expect(ordered.index(newer)).to be < ordered.index(older)
+      end
+    end
+
+    describe ".for_apps" do
+      it "returns problems belonging to the given apps" do
+        app = create(:errbit_app)
+        problem = create(:errbit_problem, app: app)
+        create(:errbit_problem)
+
+        expect(described_class.for_apps([app]).to_a).to eq([problem])
+      end
+    end
+  end
+
+  describe ".all_else_unresolved" do
+    let!(:resolved_problem) { create(:errbit_problem, resolved: true) }
+    let!(:unresolved_problem) { create(:errbit_problem, resolved: false) }
+
+    it "returns all when fetch_all is true" do
+      expect(described_class.all_else_unresolved(true)).to match_array([resolved_problem, unresolved_problem])
+    end
+
+    it "returns only unresolved when fetch_all is false" do
+      expect(described_class.all_else_unresolved(false).to_a).to eq([unresolved_problem])
+    end
+  end
+
+  describe ".in_env" do
+    it "filters by environment when given" do
+      prod = create(:errbit_problem, environment: "production")
+      create(:errbit_problem, environment: "staging")
+
+      expect(described_class.in_env("production").to_a).to eq([prod])
+    end
+
+    it "returns all when env is blank" do
+      create(:errbit_problem)
+      create(:errbit_problem)
+
+      expect(described_class.in_env("").count).to eq(2)
+    end
+  end
+
+  describe ".filtered" do
+    it "excludes problems by app name with -app:NAME filter" do
+      kept = create(:errbit_problem, app: create(:errbit_app, name: "Kept"))
+      create(:errbit_problem, app: create(:errbit_app, name: "Skip"))
+
+      expect(described_class.filtered("-app:Skip").to_a).to eq([kept])
+    end
+
+    it "supports quoted app names with spaces" do
+      kept = create(:errbit_problem, app: create(:errbit_app, name: "Kept"))
+      create(:errbit_problem, app: create(:errbit_app, name: "My App"))
+
+      expect(described_class.filtered("-app:'My App'").to_a).to eq([kept])
+    end
+
+    it "returns all problems when filter is blank" do
+      create(:errbit_problem)
+      create(:errbit_problem)
+
+      expect(described_class.filtered(nil).count).to eq(2)
+    end
+  end
+
+  describe ".ordered_by" do
+    it "orders by app_name" do
+      a = create(:errbit_problem, app: create(:errbit_app, name: "Aaa"))
+      b = create(:errbit_problem, app: create(:errbit_app, name: "Bbb"))
+
+      expect(described_class.ordered_by("app", :asc).to_a).to eq([a, b])
+      expect(described_class.ordered_by("app", :desc).to_a).to eq([b, a])
+    end
+
+    it "orders by notices_count when sort is count" do
+      low = create(:errbit_problem, notices_count: 1)
+      high = create(:errbit_problem, notices_count: 99)
+
+      expect(described_class.ordered_by("count", :desc).to_a).to eq([high, low])
+    end
+
+    it "raises for an unrecognized sort" do
+      expect {
+        described_class.ordered_by("nope", :asc)
+      }.to raise_error(RuntimeError, /not a recognized sort/)
+    end
+  end
+
+  describe "#resolve!" do
+    it "marks the problem as resolved and stamps resolved_at" do
+      problem = create(:errbit_problem)
+
+      problem.resolve!
+
+      expect(problem.resolved).to eq(true)
+      expect(problem.resolved_at).to be_within(5).of(Time.zone.now)
+    end
+  end
+
+  describe "#unresolve!" do
+    it "marks the problem as unresolved and clears resolved_at" do
+      problem = create(:errbit_problem, resolved: true, resolved_at: Time.zone.now)
+
+      problem.unresolve!
+
+      expect(problem.resolved).to eq(false)
+      expect(problem.resolved_at).to be_nil
+    end
+  end
+
+  describe "#unresolved?" do
+    it "is true when resolved is false" do
+      expect(build(:errbit_problem, resolved: false).unresolved?).to eq(true)
+    end
+
+    it "is false when resolved is true" do
+      expect(build(:errbit_problem, resolved: true).unresolved?).to eq(false)
+    end
+  end
+
+  describe "#link_text" do
+    it "returns the message when present" do
+      problem = build(:errbit_problem, message: "boom", error_class: "RuntimeError")
+
+      expect(problem.link_text).to eq("boom")
+    end
+
+    it "falls back to error_class when message is blank" do
+      problem = build(:errbit_problem, message: "", error_class: "RuntimeError")
+
+      expect(problem.link_text).to eq("RuntimeError")
+    end
+  end
+
+  describe "#uncache_notice" do
+    let(:app) { create(:errbit_app) }
+    let(:problem) { create(:errbit_problem, app: app) }
+    let(:err) { create(:errbit_err, problem: problem) }
+    let!(:first_notice) { Errbit::Problem.cache_notice(problem.id, build(:errbit_notice, err: err, app: app, message: "first").tap { |n| n.created_at = 2.days.ago; n.save! }) && err.notices.find_by(message: "first") }
+    let!(:second_notice) { Errbit::Problem.cache_notice(problem.id, build(:errbit_notice, err: err, app: app, message: "second").tap { |n| n.created_at = 1.day.ago; n.save! }) && err.notices.find_by(message: "second") }
+
+    it "decrements notices_count" do
+      expect { problem.reload.uncache_notice(second_notice) }
+        .to change { problem.reload.notices_count }.from(2).to(1)
+    end
+
+    it "refreshes the cached scalar fields from the latest remaining notice" do
+      problem.reload.uncache_notice(second_notice)
+
+      expect(problem.reload.message).to eq("second")
+    end
+
+    it "drops the message digest entry when its count hits zero" do
+      digest = Digest::MD5.hexdigest("second")
+      expect(problem.reload.messages).to have_key(digest)
+
+      problem.reload.uncache_notice(second_notice)
+
+      expect(problem.reload.messages).not_to have_key(digest)
+    end
+  end
+
+  describe "#issue_type" do
+    it "returns the stored value when set" do
+      problem = build(:errbit_problem, issue_type: "github")
+
+      expect(problem.issue_type).to eq("github")
+    end
+
+    it "falls back to the app's issue tracker type when unset" do
+      app = create(:errbit_app)
+      app.build_issue_tracker(type_tracker: "mock", options: {"foo" => "1"})
+      app.issue_tracker.save!(validate: false)
+      problem = create(:errbit_problem, app: app, issue_type: nil)
+
+      allow(app.issue_tracker).to receive(:configured?).and_return(true)
+      allow(problem.app).to receive(:issue_tracker_configured?).and_return(true)
+      allow(problem.app).to receive(:issue_tracker).and_return(app.issue_tracker)
+
+      expect(problem.issue_type).to eq("mock")
+    end
+
+    it "returns nil when issue_type is unset and the app has no tracker" do
+      problem = create(:errbit_problem, issue_type: nil)
+
+      expect(problem.issue_type).to be_nil
+    end
+  end
+
+  describe "#grouped_notice_count_relative_percentages" do
+    let(:problem) { create(:errbit_problem) }
+    let(:err) { create(:errbit_err, problem: problem) }
+
+    it "returns one entry per bucket as a percentage of the max bucket" do
+      base = Time.zone.parse("2026-05-15 12:00:00")
+      [base + 1.hour, base + 2.hours, base + 2.hours, base + 3.hours, base + 3.hours, base + 3.hours].each do |t|
+        n = build(:errbit_notice, err: err, app: err.app)
+        n.created_at = t
+        n.save!
+      end
+
+      result = problem.grouped_notice_count_relative_percentages(base, "hour")
+
+      expect(result.size).to eq(24)
+      # Bucket-0 (hour 12) has 0; bucket-1 (hour 13) has 1; bucket-2 (hour 14) has 2;
+      # bucket-3 (hour 15) has 3 → max 3 → percentages 0%, 33.3%, 66.6%, 100%, 0%…
+      expect(result[0]).to eq(0)
+      expect(result[1]).to be_within(0.01).of(100.0 / 3)
+      expect(result[2]).to be_within(0.01).of(200.0 / 3)
+      expect(result[3]).to be_within(0.01).of(100.0)
+    end
+
+    it "returns all zeros when there are no notices in the window" do
+      result = problem.grouped_notice_count_relative_percentages(1.year.ago, "day")
+
+      expect(result.size).to eq(14)
+      expect(result.uniq).to eq([0])
+    end
+  end
+
+  describe "Errbit::Notice before_destroy :problem_recache" do
+    let(:app) { create(:errbit_app) }
+    let(:problem) { create(:errbit_problem, app: app) }
+    let(:err) { create(:errbit_err, problem: problem) }
+    let!(:notice_a) do
+      n = build(:errbit_notice, err: err, app: app, message: "A")
+      n.created_at = 2.days.ago
+      n.save!
+      Errbit::Problem.cache_notice(problem.id, n)
+      n
+    end
+    let!(:notice_b) do
+      n = build(:errbit_notice, err: err, app: app, message: "B")
+      n.created_at = 1.day.ago
+      n.save!
+      Errbit::Problem.cache_notice(problem.id, n)
+      n
+    end
+
+    it "decrements the problem's notices_count when a notice is destroyed" do
+      expect { notice_b.destroy }
+        .to change { problem.reload.notices_count }.from(2).to(1)
+    end
+  end
+end
diff --git a/spec/models/errbit/site_config_spec.rb b/spec/models/errbit/site_config_spec.rb
new file mode 100644
index 0000000000..63774559f3
--- /dev/null
+++ b/spec/models/errbit/site_config_spec.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::SiteConfig, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_site_configs table" do
+    expect(described_class.table_name).to eq("errbit_site_configs")
+  end
+
+  describe "fingerprinter field defaults" do
+    subject(:config) { described_class.create! }
+
+    it { expect(config.error_class).to eq(true) }
+    it { expect(config.message).to eq(true) }
+    it { expect(config.component).to eq(true) }
+    it { expect(config.action).to eq(true) }
+    it { expect(config.environment_name).to eq(true) }
+    it { expect(config.backtrace_lines).to eq(-1) }
+  end
+
+  describe ".document" do
+    it "creates a single SiteConfig when none exists" do
+      expect {
+        described_class.document
+      }.to change(described_class, :count).by(1)
+    end
+
+    it "returns the existing SiteConfig when one already exists" do
+      existing = described_class.create!
+
+      result = described_class.document
+
+      expect(result).to eq(existing)
+      expect(described_class.count).to eq(1)
+    end
+
+    it "is idempotent across repeated calls" do
+      first = described_class.document
+      second = described_class.document
+
+      expect(second).to eq(first)
+      expect(described_class.count).to eq(1)
+    end
+  end
+
+  describe "#notice_fingerprinter_attributes" do
+    it "returns the fingerprinter fields plus a site source" do
+      config = described_class.create!(
+        error_class: true,
+        message: false,
+        backtrace_lines: 5,
+        component: true,
+        action: false,
+        environment_name: true
+      )
+
+      expect(config.notice_fingerprinter_attributes).to eq(
+        error_class: true,
+        message: false,
+        backtrace_lines: 5,
+        component: true,
+        action: false,
+        environment_name: true,
+        source: described_class::CONFIG_SOURCE_SITE
+      )
+    end
+
+    it "always marks source as CONFIG_SOURCE_SITE" do
+      config = described_class.create!
+
+      expect(config.notice_fingerprinter_attributes[:source]).to eq("site")
+    end
+  end
+
+  describe "source constants" do
+    it { expect(described_class::CONFIG_SOURCE_SITE).to eq("site") }
+    it { expect(described_class::CONFIG_SOURCE_APP).to eq("app") }
+  end
+end
diff --git a/spec/models/errbit/user_spec.rb b/spec/models/errbit/user_spec.rb
new file mode 100644
index 0000000000..c10f9b2593
--- /dev/null
+++ b/spec/models/errbit/user_spec.rb
@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::User, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_users table" do
+    expect(described_class.table_name).to eq("errbit_users")
+  end
+
+  describe "PER_PAGE" do
+    it { expect(described_class::PER_PAGE).to eq(30) }
+  end
+
+  context "validations" do
+    it "requires that a name is present" do
+      user = build(:errbit_user, name: nil)
+
+      expect(user.valid?).to eq(false)
+      expect(user.errors[:name]).to eq(["can't be blank"])
+    end
+
+    it "requires password without github login" do
+      user = build(:errbit_user, password: nil)
+
+      expect(user.valid?).to eq(false)
+      expect(user.errors[:password]).to eq(["can't be blank"])
+    end
+
+    it "doesn't require password with github login" do
+      user = build(:errbit_user, password: nil, github_login: "biow0lf")
+
+      expect(user.valid?).to eq(true)
+    end
+
+    it "requires uniq github login" do
+      user_1 = create(:errbit_user, github_login: "biow0lf")
+      expect(user_1.valid?).to eq(true)
+
+      user_2 = build(:errbit_user, github_login: "biow0lf")
+      user_2.save
+      expect(user_2.valid?).to eq(false)
+
+      expect(user_2.errors[:github_login]).to eq(["has already been taken"])
+    end
+
+    it "allows blank / null github_login" do
+      user_1 = create(:errbit_user, github_login: " ")
+      expect(user_1.valid?).to eq(true)
+
+      user_2 = build(:errbit_user, github_login: " ")
+      user_2.save
+
+      expect(user_2.valid?).to eq(true)
+    end
+
+    it "disables validations when reset password" do
+      user = build(:errbit_user, email: "")
+      user.save(validate: false)
+
+      expect(user.reset_password("Password123", "Password123")).to eq(true)
+    end
+
+    it "should require a password with minimum of 8 characters" do
+      user = build(:errbit_user)
+
+      user.reset_password("1234567", "1234578")
+
+      expect(user.errors[:password]).to eq(["is too short (minimum is 8 characters)"])
+    end
+  end
+
+  describe "#per_page" do
+    context "when not set" do
+      it "falls back to PER_PAGE constant" do
+        user = build(:errbit_user)
+        user[:per_page] = nil
+
+        expect(user.per_page).to eq(30)
+      end
+    end
+
+    context "when set" do
+      it "returns the stored value" do
+        user = build(:errbit_user)
+        user[:per_page] = 50
+
+        expect(user.per_page).to eq(50)
+      end
+    end
+  end
+
+  describe "#github_login=" do
+    it "normalizes blank strings to nil" do
+      user = build(:errbit_user, github_login: "   ")
+
+      expect(user.github_login).to be_nil
+    end
+
+    it "stores non-blank strings" do
+      user = build(:errbit_user, github_login: "biow0lf")
+
+      expect(user.github_login).to eq("biow0lf")
+    end
+  end
+
+  describe "#github_account?" do
+    it "is true when login and oauth token are present" do
+      user = build(:errbit_user, github_login: "biow0lf", github_oauth_token: "token")
+
+      expect(user.github_account?).to eq(true)
+    end
+
+    it "is false when oauth token is blank" do
+      user = build(:errbit_user, github_login: "biow0lf")
+
+      expect(user.github_account?).to eq(false)
+    end
+  end
+
+  describe "#google_account?" do
+    it "is true when google_uid is present" do
+      user = build(:errbit_user, google_uid: "12345")
+
+      expect(user.google_account?).to eq(true)
+    end
+
+    it "is false when google_uid is blank" do
+      user = build(:errbit_user)
+
+      expect(user.google_account?).to eq(false)
+    end
+  end
+
+  describe ".valid_google_domain?" do
+    context "without an authorized domains list" do
+      before { allow(Errbit::Config).to receive(:google_authorized_domains).and_return("") }
+
+      it "accepts any email" do
+        expect(described_class.valid_google_domain?("anyone@example.com")).to eq(true)
+      end
+    end
+
+    context "with an authorized domains list" do
+      before { allow(Errbit::Config).to receive(:google_authorized_domains).and_return("example.com,foo.org") }
+
+      it "accepts a matching domain" do
+        expect(described_class.valid_google_domain?("user@example.com")).to eq(true)
+      end
+
+      it "rejects a non-matching domain" do
+        expect(described_class.valid_google_domain?("user@other.com")).to eq(false)
+      end
+
+      it "rejects an unparseable email" do
+        expect(described_class.valid_google_domain?("not-an-email")).to eq(false)
+      end
+    end
+  end
+
+  describe ".create_from_google_oauth2" do
+    let(:access_token) do
+      {
+        uid: "uid-123",
+        info: {email: "newuser@example.com", name: "New User"}
+      }
+    end
+
+    it "creates a new user when none exists" do
+      expect {
+        described_class.create_from_google_oauth2(access_token)
+      }.to change(described_class, :count).by(1)
+    end
+
+    it "returns the existing user when email matches" do
+      existing = create(:errbit_user, email: "newuser@example.com")
+
+      result = described_class.create_from_google_oauth2(access_token)
+
+      expect(result).to eq(existing)
+    end
+  end
+
+  describe ".token_authentication_key" do
+    it "returns :auth_token" do
+      expect(described_class.token_authentication_key).to eq(:auth_token)
+    end
+  end
+
+  describe "#ensure_authentication_token" do
+    it "generates a token before save" do
+      user = build(:errbit_user)
+
+      user.save!
+
+      expect(user.authentication_token).to be_present
+    end
+
+    it "does not overwrite an existing token" do
+      user = create(:errbit_user)
+      token = user.authentication_token
+
+      user.update!(name: "Renamed")
+
+      expect(user.authentication_token).to eq(token)
+    end
+  end
+
+  describe "#attributes_for_super_diff" do
+    subject { create(:errbit_user) }
+
+    it { expect(subject.attributes_for_super_diff).to eq(id: subject.id, name: subject.name) }
+  end
+end
diff --git a/spec/models/errbit/watcher_spec.rb b/spec/models/errbit/watcher_spec.rb
new file mode 100644
index 0000000000..02bcc3419f
--- /dev/null
+++ b/spec/models/errbit/watcher_spec.rb
@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::Watcher, type: :model do
+  it "inherits from Errbit::ApplicationRecord" do
+    expect(described_class.ancestors).to include(Errbit::ApplicationRecord)
+  end
+
+  it "uses the errbit_watchers table" do
+    expect(described_class.table_name).to eq("errbit_watchers")
+  end
+
+  context "validations" do
+    it "requires an email address or an associated user" do
+      watcher = build(:errbit_watcher, email: nil, user: nil)
+      expect(watcher.valid?).to eq(false)
+      expect(watcher.errors[:base]).to include("You must specify either a user or an email address")
+
+      watcher.email = "watcher@example.com"
+      expect(watcher.valid?).to eq(true)
+
+      watcher.email = nil
+      expect(watcher.valid?).to eq(false)
+
+      watcher.user = create(:errbit_user)
+      watcher.watcher_type = "user"
+      expect(watcher.valid?).to eq(true)
+    end
+
+    it "requires an associated app" do
+      watcher = build(:errbit_watcher, app: nil)
+
+      expect(watcher.valid?).to eq(false)
+      expect(watcher.errors[:app]).to include("must exist")
+    end
+  end
+
+  describe "#address" do
+    it "returns the user's email address if there is a user" do
+      user = create(:errbit_user, email: "foo@bar.com")
+      watcher = create(:errbit_user_watcher, user: user)
+
+      expect(watcher.address).to eq("foo@bar.com")
+    end
+
+    it "returns the email if there is no user" do
+      watcher = create(:errbit_watcher, email: "widgets@acme.com")
+
+      expect(watcher.address).to eq("widgets@acme.com")
+    end
+  end
+
+  describe "#label" do
+    it "is the user's name when a user is set" do
+      user = create(:errbit_user, name: "Alice")
+      watcher = create(:errbit_user_watcher, user: user)
+
+      expect(watcher.label).to eq("Alice")
+    end
+
+    it "is the email when no user is set" do
+      watcher = create(:errbit_watcher, email: "bob@example.com")
+
+      expect(watcher.label).to eq("bob@example.com")
+    end
+  end
+
+  describe "#email_choosen" do
+    context "with email defined" do
+      it "returns blank" do
+        expect(described_class.new(email: "foo").email_choosen).to eq("")
+      end
+    end
+
+    context "without email defined" do
+      it "returns chosen" do
+        expect(described_class.new(email: "").email_choosen).to eq("chosen")
+      end
+    end
+  end
+
+  describe "before_validation :clear_unused_watcher_type" do
+    it "clears email when watcher_type is user" do
+      user = create(:errbit_user)
+      watcher = build(:errbit_watcher, user: user, email: "stale@example.com", watcher_type: "user")
+
+      watcher.valid?
+
+      expect(watcher.email).to be_nil
+    end
+
+    it "clears user when watcher_type is email" do
+      user = create(:errbit_user)
+      watcher = build(:errbit_watcher, user: user, email: "kept@example.com", watcher_type: "email")
+
+      watcher.valid?
+
+      expect(watcher.user).to be_nil
+      expect(watcher.errbit_user_id).to be_nil
+    end
+  end
+
+  describe "Errbit::App#watched_by?" do
+    let(:app) { create(:errbit_app) }
+    let(:user) { create(:errbit_user) }
+
+    it "is true when the user has a watcher on the app" do
+      create(:errbit_user_watcher, app: app, user: user)
+
+      expect(app.watched_by?(user)).to eq(true)
+    end
+
+    it "is false when the user has no watcher on the app" do
+      expect(app.watched_by?(user)).to eq(false)
+    end
+  end
+end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 374583a2c9..0c501ae4cb 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -12,20 +12,6 @@
       expect(user.errors[:name]).to eq(["can't be blank"])
     end
 
-    it "requires password without github login" do
-      user = build(:user, password: nil)
-
-      expect(user.valid?).to eq(false)
-
-      expect(user.errors[:password]).to eq(["can't be blank"])
-    end
-
-    it "doesn't require password with github login" do
-      user = build(:user, password: nil, github_login: "biow0lf")
-
-      expect(user.valid?).to eq(true)
-    end
-
     it "requires uniq github login" do
       user_1 = create(:user, github_login: "biow0lf")
       expect(user_1.valid?).to eq(true)
@@ -46,32 +32,6 @@
 
       expect(user_2.valid?).to eq(true)
     end
-
-    it "disables validations when reset password" do
-      user = build(:user, email: "")
-      user.save(validate: false)
-
-      expect(user.reset_password("Password123", "Password123")).to eq(true)
-    end
-
-    it "should require a password with minimum of 8 characters" do
-      user = build(:user)
-
-      user.reset_password("1234567", "1234578")
-
-      expect(user.errors[:password]).to eq(["is too short (minimum is 8 characters)"])
-    end
-  end
-
-  context "First user" do
-    it "should be created this admin access via db:seed" do
-      expect do
-        allow($stdout).to receive(:puts).and_return(true)
-        require Rails.root.join("db/seeds.rb")
-      end.to change {
-        User.where(admin: true).count
-      }.by(1)
-    end
   end
 
   describe "#attributes_for_super_diff" do
diff --git a/spec/policies/errbit/app_policy_spec.rb b/spec/policies/errbit/app_policy_spec.rb
new file mode 100644
index 0000000000..bec760d436
--- /dev/null
+++ b/spec/policies/errbit/app_policy_spec.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::AppPolicy do
+  subject { described_class.new(user, record) }
+
+  describe "#initialize" do
+    context "when user is not present" do
+      let(:record) { create(:errbit_app) }
+      let(:user) { nil }
+
+      it { expect { subject }.to raise_error(Pundit::NotAuthorizedError) }
+    end
+  end
+
+  describe "#index" do
+    let(:record) { create(:errbit_app) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to forbid_action(:index) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:index) }
+    end
+  end
+
+  describe "#show?" do
+    let(:record) { create(:errbit_app) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:show) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to permit_action(:show) }
+    end
+  end
+
+  describe "#create?" do
+    let(:record) { Errbit::App.new }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:create) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:create) }
+    end
+  end
+
+  describe "#new?" do
+    let(:record) { Errbit::App.new }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:new) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:new) }
+    end
+  end
+
+  describe "#update?" do
+    let(:record) { create(:errbit_app) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:update) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:update) }
+    end
+  end
+
+  describe "#edit?" do
+    let(:record) { create(:errbit_app) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:edit) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:edit) }
+    end
+  end
+
+  describe "#destroy?" do
+    let(:record) { create(:errbit_app) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to permit_action(:destroy) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:destroy) }
+    end
+  end
+end
+
+RSpec.describe Errbit::AppPolicy::Scope do
+  describe "#resolve" do
+    let(:user) { create(:errbit_user, admin: false) }
+    let!(:app) { create(:errbit_app) }
+    let(:scope) { Errbit::App }
+
+    subject { described_class.new(user, scope) }
+
+    it { expect(subject.resolve).to eq([app]) }
+  end
+end
diff --git a/spec/policies/errbit/application_policy_spec.rb b/spec/policies/errbit/application_policy_spec.rb
new file mode 100644
index 0000000000..e5da00dc77
--- /dev/null
+++ b/spec/policies/errbit/application_policy_spec.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::ApplicationPolicy do
+  let(:record) { create(:errbit_user, admin: false) }
+
+  subject { described_class.new(user, record) }
+
+  context "when user is present" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to forbid_all_actions }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_all_actions }
+    end
+  end
+
+  context "when user is not present" do
+    let(:user) { nil }
+
+    it { expect { subject }.to raise_error(Pundit::NotAuthorizedError) }
+  end
+
+  describe "#permitted_attributes" do
+    let(:user) { create(:errbit_user, admin: false) }
+
+    it {
+      expect { subject.permitted_attributes }
+        .to raise_error(NotImplementedError, "You must define #permitted_attributes in Errbit::ApplicationPolicy")
+    }
+  end
+end
+
+RSpec.describe Errbit::ApplicationPolicy::Scope do
+  describe "#initialize" do
+    context "when user is not present" do
+      let(:user) { nil }
+      let(:scope) { Errbit::User }
+
+      it { expect { described_class.new(user, scope) }.to raise_error(Pundit::NotAuthorizedError) }
+    end
+
+    context "when user is present" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:scope) { double }
+
+      it { expect { described_class.new(user, scope) }.not_to raise_error }
+    end
+  end
+
+  describe "#resolve" do
+    let(:user) { create(:errbit_user, admin: false) }
+    let(:scope) { double }
+
+    subject { described_class.new(user, scope) }
+
+    it {
+      expect { subject.resolve }
+        .to raise_error(NotImplementedError, "You must define #resolve in Errbit::ApplicationPolicy::Scope")
+    }
+  end
+end
diff --git a/spec/policies/errbit/user_policy_spec.rb b/spec/policies/errbit/user_policy_spec.rb
new file mode 100644
index 0000000000..66ed353989
--- /dev/null
+++ b/spec/policies/errbit/user_policy_spec.rb
@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Errbit::UserPolicy do
+  subject { described_class.new(user, record) }
+
+  it "exposes the permitted FIELDS list" do
+    expect(described_class::FIELDS)
+      .to eq([:name, :username, :email, :password, :github_login, :per_page, :time_zone, :password, :password_confirmation])
+  end
+
+  describe "#initialize" do
+    context "when user is not present" do
+      let(:record) { create(:errbit_user) }
+      let(:user) { nil }
+
+      it { expect { subject }.to raise_error(Pundit::NotAuthorizedError) }
+    end
+  end
+
+  describe "#index" do
+    let(:record) { create(:errbit_user, admin: false) }
+
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+
+      it { is_expected.to forbid_action(:index) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:index) }
+    end
+  end
+
+  describe "#show?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to permit_action(:show) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:show) }
+    end
+
+    context "when user is the owner of the record" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { user }
+
+      it { is_expected.to permit_action(:show) }
+    end
+  end
+
+  describe "#create?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { Errbit::User.new }
+
+      it { is_expected.to permit_action(:create) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { Errbit::User.new }
+
+      it { is_expected.to forbid_action(:create) }
+    end
+  end
+
+  describe "#new?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { Errbit::User.new }
+
+      it { is_expected.to permit_action(:new) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { Errbit::User.new }
+
+      it { is_expected.to forbid_action(:new) }
+    end
+  end
+
+  describe "#update?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to permit_action(:update) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:update) }
+    end
+
+    context "when user is the owner of the record" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { user }
+
+      it { is_expected.to permit_action(:update) }
+    end
+  end
+
+  describe "#edit?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to permit_action(:edit) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:edit) }
+    end
+
+    context "when user is the owner of the record" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { user }
+
+      it { is_expected.to permit_action(:edit) }
+    end
+  end
+
+  describe "#destroy?" do
+    context "when user is an admin" do
+      let(:user) { create(:errbit_user, admin: true) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to permit_action(:destroy) }
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { is_expected.to forbid_action(:destroy) }
+    end
+
+    context "when user is the owner of the record" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { user }
+
+      it { is_expected.to forbid_action(:destroy) }
+    end
+  end
+
+  describe "#permitted_attributes" do
+    context "when user is an admin" do
+      context "and record is the same admin user" do
+        let(:user) { create(:errbit_user, admin: true) }
+        let(:record) { user }
+
+        it { expect(subject.permitted_attributes).to eq(described_class::FIELDS) }
+      end
+
+      context "and record is a different user" do
+        let(:user) { create(:errbit_user, admin: true) }
+        let(:record) { create(:errbit_user, admin: false) }
+
+        it { expect(subject.permitted_attributes).to eq(described_class::FIELDS + [:admin]) }
+      end
+    end
+
+    context "when user is not an admin" do
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:record) { create(:errbit_user, admin: false) }
+
+      it { expect(subject.permitted_attributes).to eq(described_class::FIELDS) }
+    end
+  end
+end
+
+RSpec.describe Errbit::UserPolicy::Scope do
+  describe "#resolve" do
+    context "when user is an admin" do
+      let!(:admin) { create(:errbit_user, admin: true) }
+      let!(:user) { create(:errbit_user, admin: false) }
+      let(:scope) { Errbit::User }
+
+      subject { described_class.new(admin, scope) }
+
+      it { expect(subject.resolve).to match_array([admin, user]) }
+    end
+
+    context "when user is not an admin" do
+      let!(:admin) { create(:errbit_user, admin: true) }
+      let(:user) { create(:errbit_user, admin: false) }
+      let(:scope) { Errbit::User }
+
+      subject { described_class.new(user, scope) }
+
+      it { expect(subject.resolve).to eq([user]) }
+    end
+  end
+end
diff --git a/spec/requests/health_controller_spec.rb b/spec/requests/health_controller_spec.rb
index e739d14e19..c767c35497 100644
--- a/spec/requests/health_controller_spec.rb
+++ b/spec/requests/health_controller_spec.rb
@@ -3,23 +3,25 @@
 require "rails_helper"
 
 RSpec.describe HealthController, type: :request do
-  let(:errbit_app) { create(:app, api_key: "APIKEY") }
+  let(:errbit_app) { create(:errbit_app, api_key: "APIKEY") }
 
   describe "api_key_tester" do
-    it "will let you know when the api_key is not valid" do
-      get "/health/api-key-tester?api_key=garbagekey"
+    context "with an unknown api_key" do
+      it "returns 403 with ok=false" do
+        get "/health/api-key-tester?api_key=garbagekey"
 
-      expect(response).to be_forbidden
-
-      expect(response.parsed_body["ok"]).to eq(false)
+        expect(response).to be_forbidden
+        expect(response.parsed_body["ok"]).to eq(false)
+      end
     end
 
-    it "can let you know that the api_key is valid" do
-      get "/health/api-key-tester?api_key=#{errbit_app.api_key}"
-
-      expect(response).to be_successful
+    context "with a valid api_key" do
+      it "returns 200 with ok=true" do
+        get "/health/api-key-tester?api_key=#{errbit_app.api_key}"
 
-      expect(response.parsed_body["ok"]).to eq(true)
+        expect(response).to be_successful
+        expect(response.parsed_body["ok"]).to eq(true)
+      end
     end
   end
 end
diff --git a/spec/requests/notices_controller_spec.rb b/spec/requests/notices_controller_spec.rb
index 263716aaf7..551312a77d 100644
--- a/spec/requests/notices_controller_spec.rb
+++ b/spec/requests/notices_controller_spec.rb
@@ -3,53 +3,52 @@
 require "rails_helper"
 
 RSpec.describe "Notices management", type: :request do
-  let(:errbit_app) { create(:app, api_key: "APIKEY") }
+  let!(:errbit_app) { create(:errbit_app, api_key: "APIKEY") }
 
-  describe "create a new notice" do
-    context "with valid notice" do
+  describe "POST /notifier_api/v2/notices" do
+    context "with a valid notice" do
       let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice.xml").read }
 
-      it "save a new notice" do
-        expect do
+      it "saves a new problem for the app" do
+        expect {
           post "/notifier_api/v2/notices", params: {data: xml}
           expect(response).to be_successful
-        end.to change(errbit_app.problems, :count).by(1)
+        }.to change { errbit_app.problems.count }.by(1)
       end
     end
 
-    context "with notice with empty backtrace" do
+    context "with a notice that has an empty backtrace" do
       let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice_without_line_of_backtrace.xml").read }
 
-      it "save a new notice" do
-        expect do
+      it "saves a new problem for the app" do
+        expect {
           post "/notifier_api/v2/notices", params: {data: xml}
           expect(response).to be_successful
-        end.to change(errbit_app.problems, :count).by(1)
+        }.to change { errbit_app.problems.count }.by(1)
       end
     end
 
-    context "with notice with bad api_key" do
-      let(:errbit_app) { create(:app) }
-
+    context "with an unknown api_key" do
+      let!(:errbit_app) { create(:errbit_app) }
       let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice.xml").read }
 
-      it "not save a new notice and return 422" do
-        expect do
+      it "returns 422 and creates no problem" do
+        expect {
           post "/notifier_api/v2/notices", params: {data: xml}
           expect(response).to have_http_status(:unprocessable_content)
           expect(response.body).to eq("Your API key is unknown")
-        end.not_to change(errbit_app.problems, :count)
+        }.not_to change { errbit_app.problems.count }
       end
     end
 
-    context "with GET request" do
+    context "with a GET request" do
       let(:xml) { Rails.root.join("spec/fixtures/hoptoad_test_notice.xml").read }
 
-      it "save a new notice" do
-        expect do
+      it "saves a new problem for the app" do
+        expect {
           get "/notifier_api/v2/notices", params: {data: xml}
           expect(response).to be_successful
-        end.to change(errbit_app.problems, :count).by(1)
+        }.to change { errbit_app.problems.count }.by(1)
       end
     end
   end
diff --git a/spec/requests/unlink_githubs_controller_spec.rb b/spec/requests/unlink_githubs_controller_spec.rb
index 397c6b36f6..faf858ba49 100644
--- a/spec/requests/unlink_githubs_controller_spec.rb
+++ b/spec/requests/unlink_githubs_controller_spec.rb
@@ -5,51 +5,42 @@
 RSpec.describe UnlinkGithubsController, type: :request do
   describe "#update" do
     context "when user is logged in" do
-      context "when user has access" do
-        let!(:current_user) { create(:user, github_login: "biow0lf", github_oauth_token: "token123") }
+      context "when user unlinks their own GitHub account" do
+        let!(:current_user) { create(:errbit_user, github_login: "biow0lf", github_oauth_token: "token123") }
 
         before { sign_in(current_user) }
-
         before { patch user_unlink_github_path(current_user) }
 
-        it "is expected to unlink github for a user with status found" do
+        it "clears github_login and github_oauth_token and redirects to user_path" do
           expect(response).to redirect_to(user_path(assigns(:user)))
-
           expect(response).to have_http_status(:found)
-
-          expect(assigns(:user).github_login).to eq(nil)
-
-          expect(assigns(:user).github_oauth_token).to eq(nil)
+          expect(assigns(:user).github_login).to be_nil
+          expect(assigns(:user).github_oauth_token).to be_nil
         end
       end
 
-      context "when user has not access" do
-        let!(:current_user) { create(:user, admin: false) }
-
-        let!(:user) { create(:user) }
+      context "when user is not an admin and unlinks another user's GitHub account" do
+        let!(:current_user) { create(:errbit_user, admin: false) }
+        let!(:user) { create(:errbit_user) }
 
         before { sign_in(current_user) }
-
         before { patch user_unlink_github_path(user) }
 
-        it "is expected to redirect to root path with status found" do
+        it "redirects to root with a not-authorized flash" do
           expect(response).to redirect_to(root_path)
-
           expect(response).to have_http_status(:found)
-
           expect(request.flash[:alert]).to eq("You are not authorized to perform this action.")
         end
       end
     end
 
     context "when user is not logged in" do
-      let(:user) { create(:user) }
+      let(:user) { create(:errbit_user) }
 
       before { patch user_unlink_github_path(user) }
 
-      it "is expected to redirect to new user session path with status found" do
+      it "redirects to the sign-in page" do
         expect(response).to redirect_to(new_user_session_path)
-
         expect(response).to have_http_status(:found)
       end
     end
diff --git a/spec/requests/unlink_googles_controller_spec.rb b/spec/requests/unlink_googles_controller_spec.rb
index bd1f943462..8dea7e5d41 100644
--- a/spec/requests/unlink_googles_controller_spec.rb
+++ b/spec/requests/unlink_googles_controller_spec.rb
@@ -5,49 +5,41 @@
 RSpec.describe UnlinkGooglesController, type: :request do
   describe "#update" do
     context "when user is logged in" do
-      context "when user has access" do
-        let!(:current_user) { create(:user, google_uid: "google-uid") }
+      context "when user unlinks their own Google account" do
+        let!(:current_user) { create(:errbit_user, google_uid: "google-uid") }
 
         before { sign_in(current_user) }
-
         before { patch user_unlink_google_path(current_user) }
 
-        it "is expected to unlink github for a user with status found" do
+        it "clears google_uid and redirects to user_path" do
           expect(response).to redirect_to(user_path(assigns(:user)))
-
           expect(response).to have_http_status(:found)
-
-          expect(assigns(:user).google_uid).to eq(nil)
+          expect(assigns(:user).google_uid).to be_nil
         end
       end
 
-      context "when user has not access" do
-        let!(:current_user) { create(:user, admin: false) }
-
-        let!(:user) { create(:user) }
+      context "when user is not an admin and unlinks another user's Google account" do
+        let!(:current_user) { create(:errbit_user, admin: false) }
+        let!(:user) { create(:errbit_user) }
 
         before { sign_in(current_user) }
-
         before { patch user_unlink_google_path(user) }
 
-        it "is expected to redirect to root path with status found" do
+        it "redirects to root with a not-authorized flash" do
           expect(response).to redirect_to(root_path)
-
           expect(response).to have_http_status(:found)
-
           expect(request.flash[:alert]).to eq("You are not authorized to perform this action.")
         end
       end
     end
 
     context "when user is not logged in" do
-      let(:user) { create(:user) }
+      let(:user) { create(:errbit_user) }
 
       before { patch user_unlink_google_path(user) }
 
-      it "is expected to redirect to new user session path with status found" do
+      it "redirects to the sign-in page" do
         expect(response).to redirect_to(new_user_session_path)
-
         expect(response).to have_http_status(:found)
       end
     end
diff --git a/spec/requests/users_controller_spec.rb b/spec/requests/users_controller_spec.rb
index b6e9ed6256..8d7ab4e6f5 100644
--- a/spec/requests/users_controller_spec.rb
+++ b/spec/requests/users_controller_spec.rb
@@ -3,40 +3,33 @@
 require "rails_helper"
 
 RSpec.describe UsersController, type: :request do
-  # before { I18n.locale = "pt-BR" }
-
   describe "#index" do
     context "when user is logged in" do
-      context "when user has access" do
-        let!(:current_user) { create(:user, name: "Jon Snow", admin: true) }
-
-        let!(:user) { create(:user, name: "Tyrion Lannister") }
+      context "when user is an admin" do
+        let!(:current_user) { create(:errbit_user, name: "Aaa Admin", admin: true) }
+        let!(:errbit_b) { create(:errbit_user, name: "Bbb") }
+        let!(:errbit_c) { create(:errbit_user, name: "Ccc") }
 
         before { sign_in(current_user) }
-
         before { get users_path }
 
-        it "is expected to render template index with status ok" do
+        it "renders index with status ok and every user" do
           expect(response).to render_template(:index)
-
           expect(response).to have_http_status(:ok)
-
-          expect(assigns(:users)).to eq([current_user, user])
+          expect(assigns(:users)).to eq([current_user, errbit_b, errbit_c])
         end
       end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
+      context "when user is not an admin" do
+        let!(:current_user) { create(:errbit_user, admin: false) }
+        let!(:other_user) { create(:errbit_user) }
 
         before { sign_in(current_user) }
-
         before { get users_path }
 
-        it "is expected to render template index with status ok" do
+        it "renders index with status ok and only themselves" do
           expect(response).to render_template(:index)
-
           expect(response).to have_http_status(:ok)
-
           expect(assigns(:users)).to eq([current_user])
         end
       end
@@ -45,492 +38,311 @@
     context "when user is not logged in" do
       before { get users_path }
 
-      it "is expected to redirect to new user session path with status found" do
+      it "redirects to sign in" do
         expect(response).to redirect_to(new_user_session_path)
-
         expect(response).to have_http_status(:found)
-
         expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
       end
     end
   end
 
   describe "#show" do
-    context "when user is logged in" do
-      context "when user has access" do
-        let(:current_user) { create(:user, admin: true) }
+    context "when user is an admin" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let(:user) { create(:errbit_user, admin: false) }
 
-        let(:user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
-
-        before { get user_path(user) }
-
-        it "is expected to render template show with status ok" do
-          expect(response).to render_template(:show)
-
-          expect(response).to have_http_status(:ok)
+      before { sign_in(current_user) }
+      before { get user_path(user) }
 
-          expect(assigns(:user)).to eq(user)
-        end
+      it "renders show" do
+        expect(response).to render_template(:show)
+        expect(response).to have_http_status(:ok)
+        expect(assigns(:user)).to eq(user)
       end
+    end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
+    context "when user is not an admin and viewing another user" do
+      let(:current_user) { create(:errbit_user, admin: false) }
+      let(:user) { create(:errbit_user, admin: false) }
 
-        let(:user) { create(:user, admin: false) }
+      before { sign_in(current_user) }
+      before { get user_path(user) }
 
-        before { get user_path(user) }
+      it "redirects to root with not-authorized flash" do
+        expect(response).to redirect_to(root_path)
+        expect(response).to have_http_status(:found)
+        expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
+      end
+    end
 
-        it "is expected to redirect to root path with status found" do
-          expect(response).to redirect_to(root_path)
+    context "when user is not an admin and viewing themselves" do
+      let(:current_user) { create(:errbit_user, admin: false) }
 
-          expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { get user_path(current_user) }
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+      it "renders show" do
+        expect(response).to render_template(:show)
+        expect(response).to have_http_status(:ok)
+        expect(assigns(:user)).to eq(current_user)
       end
     end
 
     context "when user is not logged in" do
-      let!(:user) { create(:user) }
+      let!(:user) { create(:errbit_user) }
 
       before { get user_path(user) }
 
-      it "is expected to redirect to new user session path with status found" do
+      it "redirects to sign in" do
         expect(response).to redirect_to(new_user_session_path)
-
         expect(response).to have_http_status(:found)
-
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
       end
     end
   end
 
   describe "#new" do
-    context "when user is logged in" do
-      context "when user has access" do
-        let(:current_user) { create(:user, admin: true) }
-
-        before { sign_in(current_user) }
-
-        before { get new_user_path }
-
-        it "is expected to render template new with status ok" do
-          expect(response).to render_template(:new)
-
-          expect(response).to have_http_status(:ok)
-
-          expect(assigns(:user).new_record?).to eq(true)
-        end
-      end
-
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
-
-        before { get new_user_path }
+    context "when user is an admin" do
+      let(:current_user) { create(:errbit_user, admin: true) }
 
-        it "is expected to redirect to root path with status found" do
-          expect(response).to redirect_to(root_path)
-
-          expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { get new_user_path }
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+      it "renders new" do
+        expect(response).to render_template(:new)
+        expect(response).to have_http_status(:ok)
+        expect(assigns(:user).new_record?).to eq(true)
       end
     end
 
-    context "when user is not logged in" do
-      before { get new_user_path }
+    context "when user is not an admin" do
+      let(:current_user) { create(:errbit_user, admin: false) }
 
-      it "is expected to redirect to new user session path with status found" do
-        expect(response).to redirect_to(new_user_session_path)
+      before { sign_in(current_user) }
+      before { get new_user_path }
 
+      it "redirects to root with not-authorized flash" do
+        expect(response).to redirect_to(root_path)
         expect(response).to have_http_status(:found)
-
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
       end
     end
   end
 
   describe "#edit" do
-    context "when user is logged in" do
-      context "when user has access" do
-        let(:current_user) { create(:user, admin: true) }
-
-        let!(:user) { create(:user, admin: false) }
+    context "when user is an admin and editing another user" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let!(:user) { create(:errbit_user, admin: false) }
 
-        before { sign_in(current_user) }
-
-        before { get edit_user_path(user) }
-
-        it "is expected to render template edit with status ok" do
-          expect(response).to render_template(:edit)
-
-          expect(response).to have_http_status(:ok)
+      before { sign_in(current_user) }
+      before { get edit_user_path(user) }
 
-          expect(assigns(:user)).to eq(user)
-        end
+      it "renders edit" do
+        expect(response).to render_template(:edit)
+        expect(response).to have_http_status(:ok)
+        expect(assigns(:user)).to eq(user)
       end
+    end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        let(:user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
-
-        before { get edit_user_path(user) }
-
-        it "is expected to redirect to root path with status found" do
-          expect(response).to redirect_to(root_path)
+    context "when user is not an admin and editing another user" do
+      let(:current_user) { create(:errbit_user, admin: false) }
+      let(:user) { create(:errbit_user, admin: false) }
 
-          expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { get edit_user_path(user) }
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+      it "redirects to root with not-authorized flash" do
+        expect(response).to redirect_to(root_path)
+        expect(response).to have_http_status(:found)
       end
     end
 
-    context "when user is not logged in" do
-      let(:user) { create(:user) }
+    context "when user is not an admin and editing themselves" do
+      let(:current_user) { create(:errbit_user, admin: false) }
 
-      before { get edit_user_path(user) }
-
-      it "is expected to redirect to new user session path with status found" do
-        expect(response).to redirect_to(new_user_session_path)
-
-        expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { get edit_user_path(current_user) }
 
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
+      it "renders edit" do
+        expect(response).to render_template(:edit)
+        expect(response).to have_http_status(:ok)
       end
     end
   end
 
   describe "#create" do
-    context "when user is logged in" do
-      context "when user has access" do
-        context "when new record is valid" do
-          let(:current_user) { create(:user, admin: true) }
-
-          before { sign_in(current_user) }
-
-          let(:email) { Faker::Internet.unique.email }
-
-          let(:password) { Faker::Internet.password }
-
-          let(:name) { Faker::Name.unique.name }
-
-          before do
-            expect do
-              post users_path,
-                params: {
-                  user: {
-                    email: email,
-                    name: name,
-                    password: password,
-                    password_confirmation: password,
-                    admin: true
-                  }
-                }
-            end.to change(User, :count).by(1)
-          end
-
-          it "is expected to create a new user with status found" do
-            expect(response).to redirect_to(user_path(assigns(:user)))
-
-            expect(response).to have_http_status(:found)
-
-            expect(request.flash[:success]).to eq(I18n.t("users.create.success", name: name))
-
-            expect(assigns(:user).email).to eq(email)
-
-            expect(assigns(:user).name).to eq(name)
-
-            expect(assigns(:user).admin).to eq(true)
-          end
-        end
-
-        context "when new record is not valid" do
-          let(:current_user) { create(:user, admin: true) }
-
-          before { sign_in(current_user) }
-
-          let(:email) { "" }
-
-          let(:password) { Faker::Internet.password }
-
-          let(:name) { Faker::Name.unique.name }
-
-          before do
-            expect do
-              post users_path,
-                params: {
-                  user: {
-                    email: email,
-                    name: name,
-                    password: password,
-                    password_confirmation: password,
-                    admin: true
-                  }
-                }
-            end.not_to change(User, :count)
-          end
+    context "when user is an admin with valid params" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let(:email) { Faker::Internet.unique.email }
+      let(:password) { Faker::Internet.password }
+      let(:name) { Faker::Name.unique.name }
 
-          it "is expected to render template new with status ok" do
-            expect(response).to render_template(:new)
+      before { sign_in(current_user) }
 
-            expect(response).to have_http_status(:ok)
-          end
-        end
+      before do
+        expect do
+          post users_path,
+            params: {user: {email: email, name: name, password: password, password_confirmation: password, admin: true}}
+        end.to change(Errbit::User, :count).by(1)
       end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
+      it "creates a new Errbit::User and redirects to it" do
+        expect(response).to redirect_to(user_path(assigns(:user)))
+        expect(response).to have_http_status(:found)
+        expect(request.flash[:success]).to eq(I18n.t("users.create.success", name: name))
+        expect(assigns(:user).email).to eq(email)
+        expect(assigns(:user).name).to eq(name)
+        expect(assigns(:user).admin).to eq(true)
+      end
+    end
 
-        let(:email) { Faker::Internet.unique.email }
-
-        let(:password) { Faker::Internet.password }
-
-        let(:name) { Faker::Name.unique.name }
-
-        before do
-          expect do
-            post users_path,
-              params: {
-                user: {
-                  email: email,
-                  name: name,
-                  password: password,
-                  password_confirmation: password,
-                  admin: true
-                }
-              }
-          end.not_to change(User, :count)
-        end
+    context "when user is an admin with invalid params" do
+      let(:current_user) { create(:errbit_user, admin: true) }
 
-        it "is expected to redirect to root path with status found" do
-          expect(response).to redirect_to(root_path)
+      before { sign_in(current_user) }
 
-          expect(response).to have_http_status(:found)
+      before do
+        expect do
+          post users_path,
+            params: {user: {email: "", name: Faker::Name.unique.name, password: "secret123", password_confirmation: "secret123", admin: true}}
+        end.not_to change(Errbit::User, :count)
+      end
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+      it "renders new" do
+        expect(response).to render_template(:new)
+        expect(response).to have_http_status(:ok)
       end
     end
 
-    context "when user is not logged in" do
-      let(:email) { Faker::Internet.unique.email }
+    context "when user is not an admin" do
+      let(:current_user) { create(:errbit_user, admin: false) }
 
-      let(:password) { Faker::Internet.password }
-
-      let(:name) { Faker::Name.unique.name }
+      before { sign_in(current_user) }
 
       before do
         expect do
           post users_path,
-            params: {
-              user: {
-                email: email,
-                name: name,
-                password: password,
-                password_confirmation: password,
-                admin: true
-              }
-            }
-        end.not_to change(User, :count)
+            params: {user: {email: "a@b.com", name: "X", password: "secret123", password_confirmation: "secret123", admin: true}}
+        end.not_to change(Errbit::User, :count)
       end
 
-      it "is expected to redirect to new user session path with status found" do
-        expect(response).to redirect_to(new_user_session_path)
-
+      it "redirects to root with not-authorized flash" do
+        expect(response).to redirect_to(root_path)
         expect(response).to have_http_status(:found)
-
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
       end
     end
   end
 
   describe "#update" do
-    context "when user is logged in" do
-      context "when user has access" do
-        context "when record is valid" do
-          let(:current_user) { create(:user, admin: true) }
-
-          before { sign_in(current_user) }
-
-          let(:user) { create(:user, admin: true, name: "Jon Snow") }
-
-          before do
-            patch user_path(user),
-              params: {
-                user: {
-                  name: "Tyrion Lannister",
-                  admin: false
-                }
-              }
-          end
-
-          it "is expected to redirect to user path user with status ok" do
-            expect(response).to redirect_to(user_path(user))
-
-            expect(response).to have_http_status(:found)
-
-            expect(request.flash[:success]).to eq(I18n.t("users.update.success", name: user.reload.name))
-          end
-        end
+    context "when user is an admin with valid params" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let(:user) { create(:errbit_user, admin: true, name: "Jon Snow") }
 
-        context "when record is not valid" do
-          let(:current_user) { create(:user, admin: true) }
+      before { sign_in(current_user) }
 
-          before { sign_in(current_user) }
-
-          let(:user) { create(:user) }
-
-          before do
-            patch user_path(user),
-              params: {
-                user: {
-                  name: ""
-                }
-              }
-          end
-
-          it "is expected to render template new with status ok" do
-            expect(response).to render_template(:edit)
-
-            expect(response).to have_http_status(:ok)
-          end
-        end
+      before do
+        patch user_path(user), params: {user: {name: "Tyrion Lannister", admin: false}}
       end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
-
-        let(:user) { create(:user, admin: false, name: "Jon Snow") }
-
-        before do
-          patch user_path(user),
-            params: {
-              user: {
-                name: "Tyrion Lannister",
-                admin: true
-              }
-            }
-        end
+      it "updates the user and redirects" do
+        expect(response).to redirect_to(user_path(user))
+        expect(response).to have_http_status(:found)
+        expect(request.flash[:success]).to eq(I18n.t("users.update.success", name: user.reload.name))
+      end
+    end
 
-        it "is expected to redirect to root path with status found" do
-          expect(response).to redirect_to(root_path)
+    context "when user is an admin with invalid params" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let(:user) { create(:errbit_user) }
 
-          expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { patch user_path(user), params: {user: {name: ""}} }
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+      it "renders edit" do
+        expect(response).to render_template(:edit)
+        expect(response).to have_http_status(:ok)
       end
     end
 
-    context "when user is not logged in" do
-      let(:user) { create(:user) }
+    context "when user is not an admin and updating another user" do
+      let(:current_user) { create(:errbit_user, admin: false) }
+      let(:user) { create(:errbit_user, admin: false, name: "Jon Snow") }
 
-      before do
-        patch user_path(user),
-          params: {
-            user: {
-              name: Faker::Name.unique.name
-            }
-          }
+      before { sign_in(current_user) }
+      before { patch user_path(user), params: {user: {name: "Renamed", admin: true}} }
+
+      it "redirects to root with not-authorized flash" do
+        expect(response).to redirect_to(root_path)
       end
+    end
 
-      it "is expected to redirect to new user session path with status found" do
-        expect(response).to redirect_to(new_user_session_path)
+    context "when user is not an admin and updating themselves" do
+      let(:current_user) { create(:errbit_user, admin: false) }
 
-        expect(response).to have_http_status(:found)
+      before { sign_in(current_user) }
+      before { patch user_path(current_user), params: {user: {name: "Renamed"}} }
 
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
+      it "updates and redirects" do
+        expect(response).to redirect_to(user_path(current_user))
+        expect(current_user.reload.name).to eq("Renamed")
       end
     end
   end
 
   describe "#destroy" do
-    context "when user is logged in" do
-      context "when user has access" do
-        let(:current_user) { create(:user, admin: true) }
-
-        let!(:user) { create(:user, admin: false) }
-
-        before { sign_in(current_user) }
-
-        before { expect(UserDestroy).to receive(:new).with(user).and_call_original }
+    context "when user is an admin and destroying another user" do
+      let(:current_user) { create(:errbit_user, admin: true) }
+      let!(:user) { create(:errbit_user, admin: false) }
 
-        before { expect { delete user_path(user) }.to change(User, :count).by(-1) }
+      before { sign_in(current_user) }
 
-        it "is expected to redirect to users path with status found" do
-          expect(response).to redirect_to(users_path)
+      it "calls Errbit::UserDestroy and removes the user" do
+        expect(Errbit::UserDestroy).to receive(:new).with(user).and_call_original
 
-          expect(response).to have_http_status(:found)
+        expect { delete user_path(user) }.to change(Errbit::User, :count).by(-1)
 
-          expect(request.flash[:success]).to eq(I18n.t("users.destroy.success", name: user.name))
-        end
+        expect(response).to redirect_to(users_path)
+        expect(response).to have_http_status(:found)
+        expect(request.flash[:success]).to eq(I18n.t("users.destroy.success", name: user.name))
       end
+    end
 
-      context "when user has not access" do
-        let(:current_user) { create(:user, admin: false) }
-
-        let!(:user) { create(:user, admin: true) }
-
-        before { sign_in(current_user) }
-
-        before { expect(UserDestroy).not_to receive(:new) }
+    context "when user is not an admin and destroying another user" do
+      let(:current_user) { create(:errbit_user, admin: false) }
+      let!(:user) { create(:errbit_user, admin: true) }
 
-        before { expect { delete user_path(user) }.not_to change(User, :count) }
+      before { sign_in(current_user) }
 
-        it "is expected to redirect to users path with status found" do
-          expect(response).to redirect_to(root_path)
+      it "does not call Errbit::UserDestroy and redirects to root" do
+        expect(Errbit::UserDestroy).not_to receive(:new)
 
-          expect(response).to have_http_status(:found)
+        expect { delete user_path(user) }.not_to change(Errbit::User, :count)
 
-          expect(request.flash[:alert]).to eq(I18n.t("controllers.application.user_not_authorized"))
-        end
+        expect(response).to redirect_to(root_path)
       end
+    end
 
-      context "when user try to destroy himself" do
-        let(:current_user) { create(:user) }
-
-        before { sign_in(current_user) }
-
-        before { expect(UserDestroy).not_to receive(:new) }
+    context "when user tries to destroy themselves" do
+      let(:current_user) { create(:errbit_user) }
 
-        before { expect { delete user_path(current_user) }.not_to change(User, :count) }
+      before { sign_in(current_user) }
 
-        it "is expected to redirect to users path with status found" do
-          expect(response).to redirect_to(users_path)
+      it "blocks self-destroy with an error flash" do
+        expect(Errbit::UserDestroy).not_to receive(:new)
 
-          expect(response).to have_http_status(:found)
+        expect { delete user_path(current_user) }.not_to change(Errbit::User, :count)
 
-          expect(request.flash[:error]).to eq(I18n.t("users.destroy.error"))
-        end
+        expect(response).to redirect_to(users_path)
+        expect(request.flash[:error]).to eq(I18n.t("users.destroy.error"))
       end
     end
 
     context "when user is not logged in" do
-      let(:user) { create(:user) }
+      let!(:user) { create(:errbit_user) }
 
       before { delete user_path(user) }
 
-      it "is expected to redirect to new user session path with status found" do
+      it "redirects to sign in" do
         expect(response).to redirect_to(new_user_session_path)
-
         expect(response).to have_http_status(:found)
-
-        expect(request.flash[:alert]).to eq(I18n.t("devise.failure.unauthenticated"))
       end
     end
   end
diff --git a/spec/support/active_record.rb b/spec/support/active_record.rb
new file mode 100644
index 0000000000..582b259d87
--- /dev/null
+++ b/spec/support/active_record.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseRewinder.clean_all
+  end
+
+  config.after do
+    DatabaseRewinder.clean
+  end
+end
diff --git a/spec/support/factory_bot_rails.rb b/spec/support/factory_bot_rails.rb
index 2e7665cc38..699fb133f8 100644
--- a/spec/support/factory_bot_rails.rb
+++ b/spec/support/factory_bot_rails.rb
@@ -2,4 +2,8 @@
 
 RSpec.configure do |config|
   config.include FactoryBot::Syntax::Methods
+
+  config.before(:each) do
+    Faker::UniqueGenerator.clear
+  end
 end
diff --git a/spec/support/macros.rb b/spec/support/macros.rb
index e679b82596..deaf1853e0 100644
--- a/spec/support/macros.rb
+++ b/spec/support/macros.rb
@@ -49,7 +49,7 @@ def it_requires_admin_privileges(options = {})
     before do
       sign_out :user
 
-      sign_in create(:user)
+      sign_in create(:errbit_user)
     end
 
     options[:for].each do |action, method|
diff --git a/spec/support/shoulda-matchers.rb b/spec/support/shoulda-matchers.rb
new file mode 100644
index 0000000000..edcf9dd859
--- /dev/null
+++ b/spec/support/shoulda-matchers.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :rails
+  end
+end
diff --git a/spec/system/sign_in_and_sign_out_spec.rb b/spec/system/sign_in_and_sign_out_spec.rb
index ea0267b533..c9e05d1c55 100644
--- a/spec/system/sign_in_and_sign_out_spec.rb
+++ b/spec/system/sign_in_and_sign_out_spec.rb
@@ -3,10 +3,10 @@
 require "rails_helper"
 
 RSpec.describe "Sign in and sign out with email and password", type: :system, retry: 3 do
-  let!(:user) { create(:user, password: "password") }
+  let!(:user) { create(:errbit_user, password: "password") }
 
-  context "when user successful sign in and sign out" do
-    it "is expected to sign in user and sign out" do
+  context "when user signs in then signs out" do
+    it "signs the user in, then signs them out" do
       visit root_path
 
       expect(page).to have_content(I18n.t("devise.failure.unauthenticated"))
@@ -17,19 +17,17 @@
       click_button I18n.t("devise.sessions.new.sign_in")
 
       expect(page).to have_current_path(root_path)
-
       expect(page).to have_content(I18n.t("devise.sessions.signed_in"))
 
       click_link I18n.t("shared.session.sign_out")
 
       expect(page).to have_current_path(new_user_session_path)
-
       expect(page).to have_content(I18n.t("devise.failure.unauthenticated"))
     end
   end
 
-  context "when user exists but password is wrong" do
-    it "is expected to reject user with wrong password" do
+  context "when user exists but the password is wrong" do
+    it "rejects the user with the invalid-credentials flash" do
       visit root_path
 
       expect(page).to have_content(I18n.t("devise.failure.unauthenticated"))
@@ -40,7 +38,6 @@
       click_button I18n.t("devise.sessions.new.sign_in")
 
       expect(page).to have_current_path(new_user_session_path)
-
       expect(page).to have_content(I18n.t("devise.failure.invalid", authentication_keys: "email"))
     end
   end
diff --git a/spec/system/sign_in_with_github_spec.rb b/spec/system/sign_in_with_github_spec.rb
index 9a51fcad01..12e5a1a742 100644
--- a/spec/system/sign_in_with_github_spec.rb
+++ b/spec/system/sign_in_with_github_spec.rb
@@ -3,16 +3,14 @@
 require "rails_helper"
 
 RSpec.describe "Sign in with GitHub", type: :system, retry: 3 do
-  context "sign in via GitHub with recognized user" do
-    let!(:user) { create(:user, github_login: "biow0lf") }
+  context "when the GitHub user matches a known Errbit::User" do
+    let!(:user) { create(:errbit_user, github_login: "biow0lf") }
 
     before { expect(Errbit::Config).to receive(:github_authentication).and_return(true).twice }
-
     before { OmniAuth.config.mock_auth[:github] = Faker::Omniauth.github(name: "biow0lf") }
-
     after { OmniAuth.config.mock_auth[:github] = nil }
 
-    it "is expected to sign in user via GitHub" do
+    it "signs the user in" do
       visit root_path
 
       click_link "Sign in with GitHub"
@@ -21,8 +19,8 @@
     end
   end
 
-  context "reject unrecognized user" do
-    it "is expected to reject unrecognized user" do
+  context "without a matching Errbit::User" do
+    it "rejects the unrecognized GitHub user" do
       visit root_path
 
       click_link "Sign in with GitHub"
diff --git a/spec/system/sign_in_with_google_spec.rb b/spec/system/sign_in_with_google_spec.rb
index b03eb3fa45..d47a097cec 100644
--- a/spec/system/sign_in_with_google_spec.rb
+++ b/spec/system/sign_in_with_google_spec.rb
@@ -3,16 +3,14 @@
 require "rails_helper"
 
 RSpec.describe "Sign in with Google", type: :system, retry: 3 do
-  context "sign in via Google with recognized user" do
-    let!(:user) { create(:user, google_uid: "123456789") }
+  context "when the Google user matches a known Errbit::User" do
+    let!(:user) { create(:errbit_user, google_uid: "123456789") }
 
     before { expect(Errbit::Config).to receive(:google_authentication).and_return(true) }
-
     before { OmniAuth.config.mock_auth[:google_oauth2] = Faker::Omniauth.google(uid: "123456789") }
-
     after { OmniAuth.config.mock_auth[:google_oauth2] = nil }
 
-    it "is expected to sign in user via Google" do
+    it "signs the user in" do
       visit root_path
 
       click_link "Sign in with Google"
@@ -21,8 +19,8 @@
     end
   end
 
-  context "reject unrecognized user" do
-    it "is expected to reject unrecognized user" do
+  context "without a matching Errbit::User" do
+    it "rejects the unrecognized Google user" do
       visit root_path
 
       click_link "Sign in with Google"
diff --git a/spec/system/sign_in_with_google_with_auto_provision_spec.rb b/spec/system/sign_in_with_google_with_auto_provision_spec.rb
index c3d9843225..8696a60d12 100644
--- a/spec/system/sign_in_with_google_with_auto_provision_spec.rb
+++ b/spec/system/sign_in_with_google_with_auto_provision_spec.rb
@@ -3,16 +3,13 @@
 require "rails_helper"
 
 RSpec.describe "Sign in with Google with auto provision", type: :system, retry: 3 do
-  context "create an account for recognized user if they log in" do
+  context "when auto-provision creates an Errbit::User from a recognized Google account" do
     before { expect(Errbit::Config).to receive(:google_authentication).and_return(true) }
-
     before { expect(Errbit::Config).to receive(:google_auto_provision).and_return(true) }
-
     before { OmniAuth.config.mock_auth[:google_oauth2] = Faker::Omniauth.google(uid: "123456789") }
-
     after { OmniAuth.config.mock_auth[:google_oauth2] = nil }
 
-    it "is expected to create an account" do
+    it "creates the account and signs the user in" do
       visit root_path
 
       click_link "Sign in with Google"
diff --git a/spec/system/sign_in_with_google_with_domain_validation_spec.rb b/spec/system/sign_in_with_google_with_domain_validation_spec.rb
index 75d40b621a..c2e38a4da6 100644
--- a/spec/system/sign_in_with_google_with_domain_validation_spec.rb
+++ b/spec/system/sign_in_with_google_with_domain_validation_spec.rb
@@ -4,17 +4,14 @@
 
 RSpec.describe "Sign in with Google with domain validation", type: :system, retry: 3 do
   before { expect(Errbit::Config).to receive(:google_authentication).and_return(true).at_least(:once).times }
-
   before { expect(Errbit::Config).to receive(:google_auto_provision).and_return(true) }
-
   before { expect(Errbit::Config).to receive(:google_authorized_domains).and_return("example.com").twice }
 
-  context "create an account for recognized user if their account email is from a trusted domain" do
+  context "with a Google email from an authorized domain" do
     before { OmniAuth.config.mock_auth[:google_oauth2] = Faker::Omniauth.google(email: "me@example.com", uid: "123456789") }
-
     after { OmniAuth.config.mock_auth[:google_oauth2] = nil }
 
-    it "is expected to create an account" do
+    it "auto-provisions the Errbit::User and signs them in" do
       visit root_path
 
       click_link "Sign in with Google"
@@ -23,12 +20,11 @@
     end
   end
 
-  context "don't create an account for user if their account email is from an unauthorized domain" do
+  context "with a Google email from an unauthorized domain" do
     before { OmniAuth.config.mock_auth[:google_oauth2] = Faker::Omniauth.google(email: "me@mail.example.com", uid: "123456789") }
-
     after { OmniAuth.config.mock_auth[:google_oauth2] = nil }
 
-    it "is expected to not create an account" do
+    it "does not create an account and shows the domain-unauthorized error" do
       visit root_path
 
       click_link "Sign in with Google"
diff --git a/spec/system/users_spec.rb b/spec/system/users_spec.rb
new file mode 100644
index 0000000000..c5b92c8642
--- /dev/null
+++ b/spec/system/users_spec.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe "Users", type: :system do
+  describe "#index" do
+    # current_user = create(:errbit_user, name: "Ihor Zubkov")
+    #
+    # sign_in(current_user)
+    #
+    # visit users_path
+  end
+end
diff --git a/spec/system/watch_unwatch_app_spec.rb b/spec/system/watch_unwatch_app_spec.rb
index 00643e1593..dd5e753887 100644
--- a/spec/system/watch_unwatch_app_spec.rb
+++ b/spec/system/watch_unwatch_app_spec.rb
@@ -3,10 +3,10 @@
 require "rails_helper"
 
 RSpec.describe "A user can watch and unwatch an application", type: :system, retry: 3 do
-  context "when user log in and watch a project" do
-    it "is expected to log in and watch a project" do
-      current_user = create(:user)
-      app = create(:app)
+  context "when user signs in and watches a project" do
+    it "creates a watcher for the app" do
+      current_user = create(:errbit_user)
+      app = create(:errbit_app)
 
       sign_in(current_user)
 
@@ -19,10 +19,10 @@
     end
   end
 
-  context "when user log in and unwatch a project" do
-    it "is expected to log in and unwatch a project" do
-      current_user = create(:user)
-      app = create(:app)
+  context "when user signs in and unwatches a project" do
+    it "destroys their existing watcher on the app" do
+      current_user = create(:errbit_user)
+      app = create(:errbit_app)
 
       app.watchers.create!(user: current_user)
 
diff --git a/spec/views/apps/edit.html.erb_spec.rb b/spec/views/apps/edit.html.erb_spec.rb
index 3ebd7c6da1..52bc548aea 100644
--- a/spec/views/apps/edit.html.erb_spec.rb
+++ b/spec/views/apps/edit.html.erb_spec.rb
@@ -3,14 +3,14 @@
 require "rails_helper"
 
 RSpec.describe "apps/edit.html.erb", type: :view do
-  let(:app) { stub_model(App) }
+  let(:app) { stub_model(Errbit::App) }
 
-  let(:app_decorate) { AppDecorator.new(app) }
+  let(:app_decorate) { Errbit::AppDecorator.new(app) }
 
   before do
     allow(view).to receive(:app).and_return(app)
     allow(view).to receive(:app_decorate).and_return(app_decorate)
-    allow(controller).to receive(:current_user).and_return(stub_model(User))
+    allow(controller).to receive(:current_user).and_return(stub_model(Errbit::User))
   end
 
   describe "content_for :action_bar" do
@@ -43,7 +43,7 @@ def action_bar
 
   context "with invalid app" do
     let(:app) do
-      app = stub_model(App)
+      app = stub_model(Errbit::App)
       app.errors.add(:base, "You must specify your")
       app
     end
diff --git a/spec/views/apps/new.html.erb_spec.rb b/spec/views/apps/new.html.erb_spec.rb
index 7f5dfab0db..55dd692406 100644
--- a/spec/views/apps/new.html.erb_spec.rb
+++ b/spec/views/apps/new.html.erb_spec.rb
@@ -3,14 +3,14 @@
 require "rails_helper"
 
 RSpec.describe "apps/new.html.erb", type: :view do
-  let(:app) { stub_model(App) }
+  let(:app) { stub_model(Errbit::App) }
 
-  let(:app_decorate) { AppDecorator.new(app) }
+  let(:app_decorate) { Errbit::AppDecorator.new(app) }
 
   before do
     allow(view).to receive(:app).and_return(app)
     allow(view).to receive(:app_decorate).and_return(app_decorate)
-    allow(controller).to receive(:current_user).and_return(stub_model(User))
+    allow(controller).to receive(:current_user).and_return(stub_model(Errbit::User))
   end
 
   describe "content_for :action_bar" do
@@ -27,7 +27,7 @@ def action_bar
 
   context "with invalid app" do
     let(:app) do
-      app = stub_model(App)
+      app = stub_model(Errbit::App)
       app.errors.add(:base, "You must specify your")
       app
     end
diff --git a/spec/views/apps/show.atom.builder_spec.rb b/spec/views/apps/show.atom.builder_spec.rb
index dabe2ec53d..d4a33c797c 100644
--- a/spec/views/apps/show.atom.builder_spec.rb
+++ b/spec/views/apps/show.atom.builder_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "apps/show.atom.builder", type: :view do
-  let(:notice) { create(:notice) }
+  let(:notice) { create(:errbit_notice) }
 
   let(:app) { notice.app }
 
diff --git a/spec/views/apps/show.html.erb_spec.rb b/spec/views/apps/show.html.erb_spec.rb
index ad20c61d1d..403fa08360 100644
--- a/spec/views/apps/show.html.erb_spec.rb
+++ b/spec/views/apps/show.html.erb_spec.rb
@@ -3,9 +3,9 @@
 require "rails_helper"
 
 RSpec.describe "apps/show.html.erb", type: :view do
-  let(:app) { stub_model(App) }
+  let(:app) { stub_model(Errbit::App) }
 
-  let(:user) { stub_model(User) }
+  let(:user) { stub_model(Errbit::User) }
 
   let(:action_bar) do
     view.content_for(:action_bar)
diff --git a/spec/views/issue_trackers/markdown.erb_spec.rb b/spec/views/issue_trackers/markdown.erb_spec.rb
index 97c89aa661..9b518bc8d1 100644
--- a/spec/views/issue_trackers/markdown.erb_spec.rb
+++ b/spec/views/issue_trackers/markdown.erb_spec.rb
@@ -4,14 +4,14 @@
 
 RSpec.describe "issue_trackers/markdown.erb", type: :view do
   let(:problem) do
-    problem = create(:problem)
-    err = create(:err, problem: problem)
-    create(:notice, err: err)
+    problem = create(:errbit_problem)
+    err = create(:errbit_err, problem: problem)
+    create(:errbit_notice, err: err)
     problem
   end
 
   before do
-    allow(view).to receive(:problem).and_return(ProblemDecorator.new(problem))
+    allow(view).to receive(:problem).and_return(Errbit::ProblemDecorator.new(problem))
   end
 
   it "has the problem url" do
diff --git a/spec/views/issue_trackers/text.erb_spec.rb b/spec/views/issue_trackers/text.erb_spec.rb
index df7c570f2e..e7f14210b8 100644
--- a/spec/views/issue_trackers/text.erb_spec.rb
+++ b/spec/views/issue_trackers/text.erb_spec.rb
@@ -4,14 +4,14 @@
 
 RSpec.describe "issue_trackers/text.erb", type: :view do
   let(:problem) do
-    problem = create(:problem)
-    err = create(:err, problem: problem)
-    create(:notice, err: err)
+    problem = create(:errbit_problem)
+    err = create(:errbit_err, problem: problem)
+    create(:errbit_notice, err: err)
     problem
   end
 
   before do
-    allow(view).to receive(:problem).and_return(ProblemDecorator.new(problem))
+    allow(view).to receive(:problem).and_return(Errbit::ProblemDecorator.new(problem))
   end
 
   it "has the problem url" do
diff --git a/spec/views/notices/_summary.html.erb_spec.rb b/spec/views/notices/_summary.html.erb_spec.rb
index 4a252f223a..e1da0116d6 100644
--- a/spec/views/notices/_summary.html.erb_spec.rb
+++ b/spec/views/notices/_summary.html.erb_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "notices/_summary.html.erb", type: :view do
-  let(:notice) { create(:notice, framework: "Rails 3.2.11") }
+  let(:notice) { create(:errbit_notice, framework: "Rails 3.2.11") }
 
   it "renders application framework" do
     render "notices/summary", notice: notice, problem: notice.problem
diff --git a/spec/views/notices/_user_attributes.html.erb_spec.rb b/spec/views/notices/_user_attributes.html.erb_spec.rb
index 8622bd5ccf..5de6a84c03 100644
--- a/spec/views/notices/_user_attributes.html.erb_spec.rb
+++ b/spec/views/notices/_user_attributes.html.erb_spec.rb
@@ -7,7 +7,7 @@
     let(:notice) do
       user_attributes = {"foo" => {"bar" => "https://example.com"}}
 
-      create(:notice, user_attributes: user_attributes)
+      create(:errbit_notice, user_attributes: user_attributes)
     end
 
     it "renders table with user attributes" do
diff --git a/spec/views/problems/index.html.erb_spec.rb b/spec/views/problems/index.html.erb_spec.rb
index 2cd51c7758..25f0ce1a97 100644
--- a/spec/views/problems/index.html.erb_spec.rb
+++ b/spec/views/problems/index.html.erb_spec.rb
@@ -3,9 +3,9 @@
 require "rails_helper"
 
 RSpec.describe "problems/index.html.erb", type: :view do
-  let(:problem_1) { create(:problem) }
+  let(:problem_1) { create(:errbit_problem) }
 
-  let(:problem_2) { create(:problem, app: problem_1.app) }
+  let(:problem_2) { create(:errbit_problem, app: problem_1.app) }
 
   before do
     allow(view).to receive(:selected_problems).and_return([])
@@ -16,7 +16,7 @@
     allow(view).to receive(:params_sort).and_return("last_notice_at")
     allow(view).to receive(:params_order).and_return("asc")
 
-    allow(controller).to receive(:current_user).and_return(create(:user))
+    allow(controller).to receive(:current_user).and_return(create(:errbit_user))
   end
 
   describe "with problem" do
diff --git a/spec/views/problems/show.html.erb_spec.rb b/spec/views/problems/show.html.erb_spec.rb
index 4230407b64..51b5d9362c 100644
--- a/spec/views/problems/show.html.erb_spec.rb
+++ b/spec/views/problems/show.html.erb_spec.rb
@@ -3,9 +3,9 @@
 require "rails_helper"
 
 RSpec.describe "problems/show.html.erb", type: :view do
-  let(:problem) { create(:problem) }
+  let(:problem) { create(:errbit_problem) }
 
-  let(:comment) { create(:comment) }
+  let(:comment) { create(:errbit_comment) }
 
   let(:pivotal_tracker) do
     Class.new(ErrbitPlugin::MockIssueTracker) do
@@ -46,7 +46,7 @@ def configured?
     }
   end
 
-  let(:app) { AppDecorator.new(problem.app) }
+  let(:app) { Errbit::AppDecorator.new(problem.app) }
 
   before do
     allow(view).to receive(:app).and_return(app)
@@ -56,18 +56,27 @@ def configured?
     assign :notices, problem.notices.page(1).per(1)
     assign :notice, problem.notices.first
 
-    allow(controller).to receive(:current_user).and_return(create(:user))
+    allow(controller).to receive(:current_user).and_return(create(:errbit_user))
   end
 
   def with_issue_tracker(tracker, _problem)
     allow(ErrbitPlugin::Registry).to receive(:issue_trackers).and_return(trackers)
 
-    app.issue_tracker = IssueTrackerDecorator.new(
-      IssueTracker.new(type_tracker: tracker, options: {
-        api_token: "token token token",
-        project_id: "1234"
-      })
-    )
+    issue_tracker = Errbit::IssueTracker.new(type_tracker: tracker, options: {
+      api_token: "token token token",
+      project_id: "1234"
+    })
+
+    # Assign without triggering AR autosave (the mock tracker fails validation
+    # by design — but we only need the association readable for rendering).
+    target = app.respond_to?(:object) ? app.object : app
+    target.association(:issue_tracker).target = issue_tracker
+
+    # The view calls `app.issue_tracker.type`, which requires the decorator.
+    # If the spec stubbed view.app with a raw model, re-stub it as decorated.
+    unless app.respond_to?(:object)
+      allow(view).to receive(:app).and_return(Errbit::AppDecorator.new(target))
+    end
   end
 
   describe "content_for :action_bar" do
@@ -118,7 +127,7 @@ def action_bar
 
     it "should link 'up' to app_problems_path if HTTP_REFERER isn't set'" do
       controller.request.env["HTTP_REFERER"] = nil
-      problem = create(:problem_with_comments)
+      problem = create(:errbit_problem_with_comments)
 
       allow(view).to receive(:problem).and_return(problem)
       allow(view).to receive(:app).and_return(problem.app)
@@ -129,15 +138,15 @@ def action_bar
     end
 
     context "create issue links" do
-      let(:app) { create(:app, github_repo: "test_user/test_repo") }
+      let(:app) { create(:errbit_app, github_repo: "test_user/test_repo") }
 
       it "should allow creating issue for github if application has a github tracker" do
-        problem = create(:problem_with_comments, app: app)
-
-        with_issue_tracker("github", problem)
+        problem = create(:errbit_problem_with_comments, app: app)
 
         allow(view).to receive(:problem).and_return(problem)
-        allow(view).to receive(:app).and_return(problem.app)
+        allow(view).to receive(:app).and_return(Errbit::AppDecorator.new(problem.app))
+
+        with_issue_tracker("github", problem)
 
         render
 
@@ -145,9 +154,9 @@ def action_bar
       end
 
       context "without issue tracker associate on app" do
-        let(:problem) { Problem.new(new_record: false, app: app) }
+        let(:problem) { stub_model(Errbit::Problem, app: app) }
 
-        let(:app) { App.new(new_record: false) }
+        let(:app) { stub_model(Errbit::App) }
 
         it "not see link to create issue" do
           render
@@ -162,14 +171,14 @@ def action_bar
         end
 
         context "with app having github_repo" do
-          let(:app) { App.new(new_record: false, github_repo: "foo/bar") }
+          let(:app) { stub_model(Errbit::App, github_repo: "foo/bar") }
 
-          let(:problem) { Problem.new(new_record: false, app: app) }
+          let(:problem) { stub_model(Errbit::Problem, app: app) }
 
           before do
             problem.issue_link = nil
 
-            user = create(:user, github_login: "test_user", github_oauth_token: "abcdef")
+            user = create(:errbit_user, github_login: "test_user", github_oauth_token: "abcdef")
 
             allow(controller).to receive(:current_user).and_return(user)
           end
@@ -212,7 +221,7 @@ def action_bar
 
   describe "content_for :comments" do
     before do
-      problem = create(:problem_with_comments)
+      problem = create(:errbit_problem_with_comments)
       allow(view).to receive(:problem).and_return(problem)
       allow(view).to receive(:app).and_return(problem.app)
       allow(Errbit::Config).to receive(:use_gravatar).and_return(true)
@@ -238,9 +247,15 @@ def action_bar
     it "displays comment when comment has no user" do
       with_issue_tracker("pivotal", problem)
 
-      first_comment = view.problem.comments.first
-      first_comment.user.destroy
-      first_comment.reload
+      # Simulate a comment whose author is missing — DB-level FKs + the
+      # User → Comment cascade rule out actually deleting the user, so stub
+      # `user` on the first comment only. The other two retain their user so
+      # gravatars still render.
+      orphan_id = view.problem.comments.ordered.first.id
+      original_user = Errbit::Comment.instance_method(:user)
+      allow_any_instance_of(Errbit::Comment).to receive(:user) do |comment|
+        (comment.id == orphan_id) ? nil : original_user.bind_call(comment)
+      end
 
       render
 
diff --git a/spec/views/problems/show.ics.erb_spec.rb b/spec/views/problems/show.ics.erb_spec.rb
index 246ed587c2..495c25c609 100644
--- a/spec/views/problems/show.ics.erb_spec.rb
+++ b/spec/views/problems/show.ics.erb_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "problems/show.ics.erb", type: :view do
-  let(:problem) { ProblemDecorator.new(create(:problem)) }
+  let(:problem) { Errbit::ProblemDecorator.new(create(:errbit_problem)) }
 
   before do
     allow(view).to receive(:problem).and_return(problem)
diff --git a/spec/views/users/edit.html.erb_spec.rb b/spec/views/users/edit.html.erb_spec.rb
index 62741043a1..272e5b1243 100644
--- a/spec/views/users/edit.html.erb_spec.rb
+++ b/spec/views/users/edit.html.erb_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "users/edit.html.erb", type: :view do
-  let(:user) { stub_model(User, name: "shingara") }
+  let(:user) { stub_model(Errbit::User, name: "shingara") }
 
   before do
     allow(view).to receive(:current_user).and_return(user)
diff --git a/spec/views/users/index.html.erb_spec.rb b/spec/views/users/index.html.erb_spec.rb
index 523d47f7d8..7dda507437 100644
--- a/spec/views/users/index.html.erb_spec.rb
+++ b/spec/views/users/index.html.erb_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "users/index.html.erb", type: :view do
-  let(:user) { create(:user) }
+  let(:user) { create(:errbit_user) }
 
   before { assign(:users, Kaminari.paginate_array([user], total_count: 1).page(1)) }
 
diff --git a/spec/views/users/new.html.erb_spec.rb b/spec/views/users/new.html.erb_spec.rb
index ab8b94ff6b..43641d2cc4 100644
--- a/spec/views/users/new.html.erb_spec.rb
+++ b/spec/views/users/new.html.erb_spec.rb
@@ -3,7 +3,7 @@
 require "rails_helper"
 
 RSpec.describe "users/new.html.erb", type: :view do
-  let(:user) { stub_model(User) }
+  let(:user) { stub_model(Errbit::User) }
 
   before do
     allow(view).to receive(:current_user).and_return(user)
diff --git a/spec/views/users/show.html.erb_spec.rb b/spec/views/users/show.html.erb_spec.rb
index 48c2f92f3c..809c3d2216 100644
--- a/spec/views/users/show.html.erb_spec.rb
+++ b/spec/views/users/show.html.erb_spec.rb
@@ -4,12 +4,12 @@
 
 RSpec.describe "users/show.html.erb", type: :view do
   let(:user) do
-    stub_model(User, created_at: Time.zone.now, email: "test@example.com")
+    stub_model(Errbit::User, created_at: Time.zone.now, email: "test@example.com")
   end
 
   before do
     allow(Errbit::Config).to receive(:github_authentication).and_return(true)
-    allow(controller).to receive(:current_user).and_return(stub_model(User))
+    allow(controller).to receive(:current_user).and_return(stub_model(Errbit::User))
     assign(:user, user)
   end