diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index 6cdb77e..fe4a854 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -1,70 +1,70 @@
 class ApplicationController < ActionController::Base
   # Prevent CSRF attacks by raising an exception.
   # For APIs, you may want to use :null_session instead.
   protect_from_forgery with: :exception
 
   attr_writer :breadcrumb
   helper_method :admin?
   helper_method :dnssec?
 
   def admin?
     return false if params.key?('user')
     return false if current_user.nil?
 
     @admin_count ||= begin
                        current_user
                        .groups
                        .where(name: WebDNS.settings[:admin_group]).count
                      end
 
     @admin_count != 0
   end
 
   def admin_only!
     return if admin?
 
     redirect_to root_path, alert: 'Admin only area!'
   end
 
   def dnssec?
     WebDNS.settings[:dnssec]
   end
 
   private
 
   def group
     @group ||= edit_group_scope.find(params[:group_id] || params[:id])
   end
 
   def domain
     @domain ||= edit_domain_scope.find(params[:domain_id] || params[:id])
   end
 
   def record
     @record ||= record_scope.find(params[:record_id] || params[:id])
   end
 
   def show_group_scope
     @show_group_scope ||= current_user.groups
   end
 
   def edit_group_scope
     @edit_group_scope ||= admin? ? Group.all : show_group_scope
   end
 
   def show_domain_scope
     @show_domain_scope ||= Domain.where(group: show_group_scope)
   end
 
   def edit_domain_scope
     @edit_domain_scope ||= admin? ? Domain.all : Domain.where(group: show_group_scope)
   end
 
   def record_scope
     @record_scope ||= domain.records
   end
 
   def notification
-    Notification.instance
+    Notification.instance if WebDNS.settings[:notifications]
   end
 end
diff --git a/app/controllers/domains_controller.rb b/app/controllers/domains_controller.rb
index 70678b0..694661e 100644
--- a/app/controllers/domains_controller.rb
+++ b/app/controllers/domains_controller.rb
@@ -1,89 +1,89 @@
 class DomainsController < ApplicationController
   before_action :authenticate_user!
 
   before_action :domain, only: [:show, :edit, :edit_dnssec, :update, :destroy]
   before_action :group,  only: [:show, :edit, :edit_dnssec, :update, :destroy]
 
   helper_method :edit_group_scope
 
   # GET /domains
   def index
     @domains = show_domain_scope.includes(:group, :soa).all
   end
 
   # GET /domains/1
   def show
     @record = Record.new(domain_id: @domain.id)
   end
 
   # GET /domains/new
   def new
     @domain = Domain.new(new_domain_params)
   end
 
   # GET /domains/1/edit
   def edit
   end
 
   # GET /domains/1/edit_dnssec
   def edit_dnssec
   end
 
   # POST /domains
   def create
     @domain = Domain.new(domain_params)
 
     if @domain.save
       notify_domain(@domain, :create)
       redirect_to @domain, notice: "#{@domain.name} was successfully created."
     else
       render :new
     end
   end
 
   # PATCH/PUT /domains/1
   def update
     if @domain.update(domain_params)
       notify_domain(@domain, :update)
       redirect_to @domain, notice: "#{@domain.name} was successfully updated."
     else
       if domain_params[:dnssec] # DNSSEC form
         render :edit_dnssec
       else
         render :edit
       end
     end
   end
 
   # DELETE /domains/1
   def destroy
     if @domain.remove
       notify_domain(@domain, :destroy)
       redirect_to domains_url, notice: "#{@domain.name} is scheduled for removal."
     else
       redirect_to domains_url, alert: "#{@domain.name} cannot be deleted! (state '#{@domain.state}')"
     end
   end
 
   private
 
   def group
     domain.group
   end
 
   def new_domain_params
     params.permit(:group_id)
   end
 
   def domain_params
     params.require(:domain).tap { |d|
       # Make sure group id is permitted (belongs to edit_group_scope)
       d[:group_id] = edit_group_scope.find_by_id(d[:group_id]).try(:id)
     }.permit(:name, :type, :master, :group_id, :dnssec, :dnssec_parent, :dnssec_parent_authority)
   end
 
   def notify_domain(*args)
-    notification.notify_domain(current_user, *args)
+    notification.notify_domain(current_user, *args) if WebDNS.settings[:notifications]
   end
 
 end
diff --git a/app/controllers/records_controller.rb b/app/controllers/records_controller.rb
index 839c64a..4baf816 100644
--- a/app/controllers/records_controller.rb
+++ b/app/controllers/records_controller.rb
@@ -1,79 +1,79 @@
 class RecordsController < ApplicationController
   before_action :authenticate_user!
 
   before_action :domain, except: [:search]
   before_action :record, only: [:edit, :update, :destroy]
 
   # GET /records/new
   def new
     @record = domain.records.build
   end
 
   # GET /records/1/edit
   def edit
   end
 
   # POST /records
   def create
     @record = domain.records.new(new_record_params)
 
     if @record.save
       notify_record(@record, :create)
       redirect_to domain, notice: 'Record was successfully created.'
     else
       flash[:alert] = 'There were some errors creating the record!'
       render :new
     end
   end
 
   # PATCH/PUT /records/1
   def update
     if @record.update(edit_record_params)
       notify_record(@record, :update)
       redirect_to domain, notice: 'Record was successfully updated.'
     else
       render :edit
     end
   end
 
   # DELETE /records/1
   def destroy
     @record.destroy
     notify_record(@record, :destroy)
     redirect_to domain, notice: 'Record was successfully destroyed.'
   end
 
   # GET /search
   def search
     @records = Record
                .where(domain: show_domain_scope)
                .includes(:domain)
                .search(params[:q]) # scope by domain
 
     @records = Record.smart_order(@records)
   end
 
   private
 
   def edit_record_params
     if @record.type == 'SOA'
       permitted = [:contact, :serial, :refresh, :retry, :expire, :nx]
     else
       permitted = [:name, :content, :ttl, :prio, :disabled]
     end
 
     params.require(:record).permit(*permitted).tap { |r|
       r[:drop_privileges] = true if not admin?
     }
   end
 
   def new_record_params
     params.require(:record).permit(:name, :content, :ttl, :type, :prio).tap { |r|
       r[:drop_privileges] = true if not admin?
     }
   end
 
   def notify_record(*args)
-    notification.notify_record(current_user, *args)
+    notification.notify_record(current_user, *args) if WebDNS.settings[:notifications]
   end
 end