diff --git a/app/celery/provider_tasks.py b/app/celery/provider_tasks.py
index ca81361f2..631dfa9c7 100644
--- a/app/celery/provider_tasks.py
+++ b/app/celery/provider_tasks.py
@@ -13,7 +13,6 @@ from app import notify_celery, statsd_client, clients, create_uuid
 from app.clients.email import EmailClientException
 from app.clients.sms import SmsClientException
 from app.dao.notifications_dao import (
-    update_provider_stats,
     get_notification_by_id,
     dao_update_notification,
     update_notification_status_by_id
@@ -78,13 +77,6 @@ def send_sms_to_provider(self, service_id, notification_id):
                 )
                 notification.billable_units = get_sms_fragment_count(template.replaced_content_count)
 
-                update_provider_stats(
-                    notification_id,
-                    SMS_TYPE,
-                    provider.get_name(),
-                    billable_units=notification.billable_units
-                )
-
             notification.sent_at = datetime.utcnow()
             notification.sent_by = provider.get_name()
             notification.status = 'sending'
@@ -101,7 +93,7 @@ def send_sms_to_provider(self, service_id, notification_id):
                     "RETRY FAILED: task send_sms_to_provider failed for notification {}".format(notification.id),
                     e
                 )
-                update_notification_status_by_id(notification.id, 'technical-failure', 'failure')
+                update_notification_status_by_id(notification.id, 'technical-failure')
 
         current_app.logger.info(
             "SMS {} sent to provider at {}".format(notification_id, notification.sent_at)
@@ -163,12 +155,6 @@ def send_email_to_provider(self, service_id, notification_id):
                     reply_to_address=service.reply_to_email_address,
                 )
 
-                update_provider_stats(
-                    notification_id,
-                    EMAIL_TYPE,
-                    provider.get_name(),
-                    billable_units=1
-                )
             notification.reference = reference
             notification.sent_at = datetime.utcnow()
             notification.sent_by = provider.get_name(),
@@ -186,7 +172,7 @@ def send_email_to_provider(self, service_id, notification_id):
                     "RETRY FAILED: task send_email_to_provider failed for notification {}".format(notification.id),
                     e
                 )
-                update_notification_status_by_id(notification.id, 'technical-failure', 'failure')
+                update_notification_status_by_id(notification.id, 'technical-failure')
 
         current_app.logger.info(
             "Email {} sent to provider at {}".format(notification_id, notification.sent_at)
diff --git a/app/celery/scheduled_tasks.py b/app/celery/scheduled_tasks.py
index 5606ecb2d..b4dfbd671 100644
--- a/app/celery/scheduled_tasks.py
+++ b/app/celery/scheduled_tasks.py
@@ -91,10 +91,10 @@ def timeout_notifications():
                 seconds=current_app.config.get('SENDING_NOTIFICATIONS_TIMEOUT_PERIOD')
             ):
                 # TODO: think about making this a bulk update rather than one at a time.
-                updated = update_notification_status_by_id(noti.id, 'temporary-failure', STATISTICS_FAILURE)
+                updated = update_notification_status_by_id(noti.id, 'temporary-failure')
                 if updated:
-                    current_app.logger.info(("Timeout period reached for notification ({})"
-                                             ", status has been updated.").format(noti.id))
+                    current_app.logger.info(
+                        "Timeout period reached for notification ({}), status has been updated.".format(noti.id))
         except Exception as e:
             current_app.logger.exception(e)
             current_app.logger.error((
diff --git a/app/celery/tasks.py b/app/celery/tasks.py
index 9dc332469..d31ed4b6f 100644
--- a/app/celery/tasks.py
+++ b/app/celery/tasks.py
@@ -2,7 +2,6 @@ import itertools
 from datetime import (datetime)
 
 from flask import current_app
-from monotonic import monotonic
 from notifications_utils.recipients import (
     RecipientCSV,
     allowed_to_send_to
@@ -13,7 +12,6 @@ from sqlalchemy.exc import SQLAlchemyError
 from app import (
     create_uuid,
     DATETIME_FORMAT,
-    DATE_FORMAT,
     notify_celery,
     encryption
 )
@@ -23,11 +21,8 @@ from app.dao.jobs_dao import (
     dao_update_job,
     dao_get_job_by_id
 )
-from app.dao.notifications_dao import (
-    dao_create_notification,
-    dao_get_notification_statistics_for_service_and_day
-)
-from app.dao.services_dao import dao_fetch_service_by_id
+from app.dao.notifications_dao import (dao_create_notification)
+from app.dao.services_dao import dao_fetch_service_by_id, dao_fetch_todays_stats_for_service
 from app.dao.templates_dao import dao_get_template_by_id
 from app.models import (
     Notification,
@@ -46,14 +41,7 @@ def process_job(job_id):
 
     service = job.service
 
-    stats = dao_get_notification_statistics_for_service_and_day(
-        service_id=service.id,
-        day=job.created_at.strftime(DATE_FORMAT)
-    )
-
-    total_sent = 0
-    if stats:
-        total_sent = stats.emails_requested + stats.sms_requested
+    total_sent = sum(row.count for row in dao_fetch_todays_stats_for_service(service.id))
 
     if total_sent + job.notification_count > service.message_limit:
         job.status = 'sending limits exceeded'
@@ -212,7 +200,7 @@ def _save_notification(created_at, notification, notification_id, service_id, no
         api_key_id=api_key_id,
         key_type=key_type
     )
-    dao_create_notification(notification_db_object, notification_type)
+    dao_create_notification(notification_db_object)
 
 
 def service_allowed_to_send_to(recipient, service):
diff --git a/app/dao/notifications_dao.py b/app/dao/notifications_dao.py
index 597ab5968..ef1a9f60e 100644
--- a/app/dao/notifications_dao.py
+++ b/app/dao/notifications_dao.py
@@ -16,19 +16,9 @@ from app.models import (
     Service,
     Notification,
     NotificationHistory,
-    Job,
     NotificationStatistics,
-    TemplateStatistics,
-    SMS_TYPE,
-    EMAIL_TYPE,
-    Template,
-    ProviderStatistics,
-    ProviderDetails)
-from app.clients import (
-    STATISTICS_FAILURE,
-    STATISTICS_DELIVERED,
-    STATISTICS_REQUESTED
-)
+    Template)
+
 from app.dao.dao_utils import transactional
 from app.statsd_decorators import statsd
 
@@ -124,40 +114,7 @@ def dao_get_last_template_usage(template_id):
 
 @statsd(namespace="dao")
 @transactional
-def dao_create_notification(notification, notification_type):
-    if notification.job_id:
-        db.session.query(Job).filter_by(
-            id=notification.job_id
-        ).update({
-            Job.notifications_sent: Job.notifications_sent + 1,
-            Job.updated_at: datetime.utcnow()
-        })
-
-    update_count = db.session.query(NotificationStatistics).filter_by(
-        day=notification.created_at.date(),
-        service_id=notification.service_id
-    ).update(_update_notification_stats_query(notification_type, 'requested'))
-
-    if update_count == 0:
-        stats = NotificationStatistics(
-            day=notification.created_at.date(),
-            service_id=notification.service_id,
-            sms_requested=1 if notification_type == SMS_TYPE else 0,
-            emails_requested=1 if notification_type == EMAIL_TYPE else 0
-        )
-        db.session.add(stats)
-
-    update_count = db.session.query(TemplateStatistics).filter_by(
-        day=date.today(),
-        service_id=notification.service_id,
-        template_id=notification.template_id
-    ).update({'usage_count': TemplateStatistics.usage_count + 1, 'updated_at': datetime.utcnow()})
-
-    if update_count == 0:
-        template_stats = TemplateStatistics(template_id=notification.template_id,
-                                            service_id=notification.service_id)
-        db.session.add(template_stats)
-
+def dao_create_notification(notification):
     if not notification.id:
         # need to populate defaulted fields before we create the notification history object
         notification.id = uuid.uuid4()
@@ -165,51 +122,10 @@ def dao_create_notification(notification, notification_type):
         notification.status = 'created'
 
     notification_history = NotificationHistory.from_notification(notification)
-
     db.session.add(notification)
     db.session.add(notification_history)
 
 
-def _update_notification_stats_query(notification_type, status):
-    mapping = {
-        SMS_TYPE: {
-            STATISTICS_REQUESTED: NotificationStatistics.sms_requested,
-            STATISTICS_DELIVERED: NotificationStatistics.sms_delivered,
-            STATISTICS_FAILURE: NotificationStatistics.sms_failed
-        },
-        EMAIL_TYPE: {
-            STATISTICS_REQUESTED: NotificationStatistics.emails_requested,
-            STATISTICS_DELIVERED: NotificationStatistics.emails_delivered,
-            STATISTICS_FAILURE: NotificationStatistics.emails_failed
-        }
-    }
-    return {
-        mapping[notification_type][status]: mapping[notification_type][status] + 1
-    }
-
-
-def _update_statistics(notification, notification_statistics_status):
-    if notification.job_id:
-        db.session.query(Job).filter_by(
-            id=notification.job_id
-        ).update(_update_job_stats_query(notification_statistics_status))
-
-    db.session.query(NotificationStatistics).filter_by(
-        day=notification.created_at.date(),
-        service_id=notification.service_id
-    ).update(
-        _update_notification_stats_query(notification.notification_type, notification_statistics_status)
-    )
-
-
-def _update_job_stats_query(status):
-    mapping = {
-        STATISTICS_FAILURE: Job.notifications_failed,
-        STATISTICS_DELIVERED: Job.notifications_delivered
-    }
-    return {mapping[status]: mapping[status] + 1}
-
-
 def _decide_permanent_temporary_failure(current_status, status):
     # Firetext will send pending, then send either succes or fail.
     # If we go from pending to delivered we need to set failure type as temporary-failure
@@ -219,12 +135,8 @@ def _decide_permanent_temporary_failure(current_status, status):
     return status
 
 
-def _update_notification_status(notification, status, notification_statistics_status):
+def _update_notification_status(notification, status):
     status = _decide_permanent_temporary_failure(current_status=notification.status, status=status)
-
-    if notification_statistics_status:
-        _update_statistics(notification, notification_statistics_status)
-
     notification.status = status
     dao_update_notification(notification)
     return True
@@ -232,7 +144,7 @@ def _update_notification_status(notification, status, notification_statistics_st
 
 @statsd(namespace="dao")
 @transactional
-def update_notification_status_by_id(notification_id, status, notification_statistics_status=None):
+def update_notification_status_by_id(notification_id, status):
     notification = Notification.query.with_lockmode("update").filter(
         Notification.id == notification_id,
         or_(Notification.status == 'created',
@@ -244,25 +156,24 @@ def update_notification_status_by_id(notification_id, status, notification_stati
 
     return _update_notification_status(
         notification=notification,
-        status=status,
-        notification_statistics_status=notification_statistics_status
+        status=status
     )
 
 
 @statsd(namespace="dao")
 @transactional
-def update_notification_status_by_reference(reference, status, notification_statistics_status):
-    notification = Notification.query.filter(Notification.reference == reference,
-                                             or_(Notification.status == 'sending',
-                                                 Notification.status == 'pending')
-                                             ).first()
+def update_notification_status_by_reference(reference, status):
+    notification = Notification.query.filter(
+        Notification.reference == reference,
+        or_(Notification.status == 'sending',
+            Notification.status == 'pending')).first()
+
     if not notification:
         return False
 
     return _update_notification_status(
         notification=notification,
-        status=status,
-        notification_statistics_status=notification_statistics_status
+        status=status
     )
 
 
@@ -275,33 +186,6 @@ def dao_update_notification(notification):
     db.session.commit()
 
 
-@statsd(namespace="dao")
-@transactional
-def update_provider_stats(
-        id_,
-        notification_type,
-        provider_name,
-        billable_units=1):
-    notification = Notification.query.filter(Notification.id == id_).one()
-    provider = ProviderDetails.query.filter_by(identifier=provider_name).one()
-
-    update_count = db.session.query(ProviderStatistics).filter_by(
-        day=date.today(),
-        service_id=notification.service_id,
-        provider_id=provider.id
-    ).update({'unit_count': ProviderStatistics.unit_count + billable_units})
-
-    if update_count == 0:
-        provider_stats = ProviderStatistics(
-            day=notification.created_at.date(),
-            service_id=notification.service_id,
-            provider_id=provider.id,
-            unit_count=billable_units
-        )
-
-        db.session.add(provider_stats)
-
-
 @statsd(namespace="dao")
 def get_notification_for_job(service_id, job_id, notification_id):
     return Notification.query.filter_by(service_id=service_id, job_id=job_id, id=notification_id).one()
diff --git a/app/models.py b/app/models.py
index 6bb870b6d..17e60f51c 100644
--- a/app/models.py
+++ b/app/models.py
@@ -511,7 +511,9 @@ class NotificationHistory(db.Model):
 
     @classmethod
     def from_notification(cls, notification):
-        return cls(**{c.name: getattr(notification, c.name) for c in cls.__table__.columns})
+        history = cls(**{c.name: getattr(notification, c.name) for c in cls.__table__.columns})
+        history.template = notification.template
+        return history
 
     def update_from_notification(self, notification):
         for c in self.__table__.columns:
diff --git a/app/notifications/process_client_response.py b/app/notifications/process_client_response.py
index 737ad21c0..8f7690b3c 100644
--- a/app/notifications/process_client_response.py
+++ b/app/notifications/process_client_response.py
@@ -6,9 +6,10 @@ from app.dao import notifications_dao
 from app.clients.sms.firetext import get_firetext_responses
 from app.clients.sms.mmg import get_mmg_responses
 
-sms_response_mapper = {'MMG': get_mmg_responses,
-                       'Firetext': get_firetext_responses
-                       }
+sms_response_mapper = {
+    'MMG': get_mmg_responses,
+    'Firetext': get_firetext_responses
+}
 
 
 def validate_callback_data(data, fields, client_name):
@@ -49,14 +50,11 @@ def process_sms_client_response(status, reference, client_name):
         return success, msg
 
     notification_status = response_dict['notification_status']
-    notification_statistics_status = response_dict['notification_statistics_status']
     notification_status_message = response_dict['message']
     notification_success = response_dict['success']
 
     # record stats
-    if not notifications_dao.update_notification_status_by_id(reference,
-                                                              notification_status,
-                                                              notification_statistics_status):
+    if not notifications_dao.update_notification_status_by_id(reference, notification_status):
         status_error = "{} callback failed: notification {} either not found or already updated " \
                        "from sending. Status {}".format(client_name,
                                                         reference,
@@ -69,6 +67,6 @@ def process_sms_client_response(status, reference, client_name):
                                                                                     reference,
                                                                                     notification_status_message))
 
-    statsd_client.incr('callback.{}.{}'.format(client_name.lower(), notification_statistics_status))
+    statsd_client.incr('callback.{}.{}'.format(client_name.lower(), notification_status))
     success = "{} callback succeeded. reference {} updated".format(client_name, reference)
     return success, errors
diff --git a/app/notifications/rest.py b/app/notifications/rest.py
index 8e4af63b2..f9fa85e2f 100644
--- a/app/notifications/rest.py
+++ b/app/notifications/rest.py
@@ -14,6 +14,7 @@ from notifications_utils.template import Template
 from notifications_utils.renderers import PassThrough
 from app.clients.email.aws_ses import get_aws_responses
 from app import api_user, encryption, create_uuid, DATETIME_FORMAT, DATE_FORMAT, statsd_client
+from app.dao.services_dao import dao_fetch_todays_stats_for_service
 from app.models import KEY_TYPE_TEAM
 from app.dao import (
     templates_dao,
@@ -74,7 +75,6 @@ def process_ses_response():
             raise InvalidRequest(error, status_code=400)
 
         notification_status = aws_response_dict['notification_status']
-        notification_statistics_status = aws_response_dict['notification_statistics_status']
 
         try:
             source = ses_message['mail']['source']
@@ -89,8 +89,7 @@ def process_ses_response():
             reference = ses_message['mail']['messageId']
             if not notifications_dao.update_notification_status_by_reference(
                     reference,
-                    notification_status,
-                    notification_statistics_status
+                    notification_status
             ):
                 error = "SES callback failed: notification either not found or already updated " \
                         "from sending. Status {}".format(notification_status)
@@ -104,7 +103,7 @@ def process_ses_response():
                     )
                 )
 
-            statsd_client.incr('callback.ses.{}'.format(notification_statistics_status))
+            statsd_client.incr('callback.ses.{}'.format(notification_status))
             return jsonify(
                 result="success", message="SES callback succeeded"
             ), 200
@@ -214,18 +213,11 @@ def send_notification(notification_type):
     service_id = str(api_user.service_id)
     service = services_dao.dao_fetch_service_by_id(service_id)
 
-    service_stats = notifications_dao.dao_get_notification_statistics_for_service_and_day(
-        service_id,
-        datetime.today().strftime(DATE_FORMAT)
-    )
+    service_stats = sum(row.count for row in dao_fetch_todays_stats_for_service(service.id))
 
-    if service_stats:
-        total_sms_count = service_stats.sms_requested
-        total_email_count = service_stats.emails_requested
-
-        if (total_email_count + total_sms_count >= service.message_limit):
-            error = 'Exceeded send limits ({}) for today'.format(service.message_limit)
-            raise InvalidRequest(error, status_code=429)
+    if service_stats >= service.message_limit:
+        error = 'Exceeded send limits ({}) for today'.format(service.message_limit)
+        raise InvalidRequest(error, status_code=429)
 
     notification, errors = (
         sms_template_notification_schema if notification_type == SMS_TYPE else email_notification_schema
diff --git a/tests/app/celery/test_provider_tasks.py b/tests/app/celery/test_provider_tasks.py
index 6d8139d96..08a6026e9 100644
--- a/tests/app/celery/test_provider_tasks.py
+++ b/tests/app/celery/test_provider_tasks.py
@@ -241,23 +241,6 @@ def test_should_call_send_sms_response_task_if_research_mode(notify_db, sample_s
     assert not persisted_notification.personalisation
 
 
-def test_should_update_provider_stats_on_success(notify_db, sample_service, sample_notification, mocker):
-    provider_stats = provider_statistics_dao.get_provider_statistics(sample_service).all()
-    assert len(provider_stats) == 0
-
-    mocker.patch('app.mmg_client.send_sms')
-    mocker.patch('app.mmg_client.get_name', return_value="mmg")
-
-    send_sms_to_provider(
-        sample_notification.service_id,
-        sample_notification.id
-    )
-
-    updated_provider_stats = provider_statistics_dao.get_provider_statistics(sample_service).all()
-    assert updated_provider_stats[0].provider.identifier == 'mmg'
-    assert updated_provider_stats[0].unit_count == 1
-
-
 @pytest.mark.parametrize('research_mode,key_type', [
     (True, KEY_TYPE_NORMAL),
     (False, KEY_TYPE_TEST)
@@ -325,12 +308,6 @@ def test_should_go_into_technical_error_if_exceeds_retries(
 
     db_notification = Notification.query.filter_by(id=notification.id).one()
     assert db_notification.status == 'technical-failure'
-    notification_stats = NotificationStatistics.query.filter_by(service_id=notification.service.id).first()
-    assert notification_stats.sms_requested == 1
-    assert notification_stats.sms_failed == 1
-    job = Job.query.get(notification.job.id)
-    assert job.notification_count == 1
-    assert job.notifications_failed == 1
 
 
 def test_should_send_sms_sender_from_service_if_present(
@@ -439,12 +416,6 @@ def test_send_email_to_provider_should_go_into_technical_error_if_exceeds_retrie
 
     db_notification = Notification.query.filter_by(id=notification.id).one()
     assert db_notification.status == 'technical-failure'
-    notification_stats = NotificationStatistics.query.filter_by(service_id=notification.service.id).first()
-    assert notification_stats.emails_requested == 1
-    assert notification_stats.emails_failed == 1
-    job = Job.query.get(notification.job.id)
-    assert job.notification_count == 1
-    assert job.notifications_failed == 1
 
 
 def test_send_email_to_provider_should_not_send_to_provider_when_status_is_not_created(notify_db, notify_db_session,
diff --git a/tests/app/conftest.py b/tests/app/conftest.py
index 495b8ec48..a14dbb5fc 100644
--- a/tests/app/conftest.py
+++ b/tests/app/conftest.py
@@ -366,7 +366,7 @@ def sample_notification(notify_db,
         data['job_row_number'] = job_row_number
     notification = Notification(**data)
     if create:
-        dao_create_notification(notification, template.template_type)
+        dao_create_notification(notification)
     return notification
 
 
diff --git a/tests/app/dao/test_notification_dao.py b/tests/app/dao/test_notification_dao.py
index 933746c48..44cd88079 100644
--- a/tests/app/dao/test_notification_dao.py
+++ b/tests/app/dao/test_notification_dao.py
@@ -33,8 +33,7 @@ from app.dao.notifications_dao import (
     get_notifications_for_job,
     get_notifications_for_service,
     update_notification_status_by_id,
-    update_notification_status_by_reference,
-    update_provider_stats,
+    update_notification_status_by_reference
 )
 
 from notifications_utils.template import get_sms_fragment_count
@@ -49,7 +48,6 @@ def test_should_have_decorated_notifications_dao_functions():
     assert dao_create_notification.__wrapped__.__name__ == 'dao_create_notification'  # noqa
     assert update_notification_status_by_id.__wrapped__.__name__ == 'update_notification_status_by_id'  # noqa
     assert dao_update_notification.__wrapped__.__name__ == 'dao_update_notification'  # noqa
-    assert update_provider_stats.__wrapped__.__name__ == 'update_provider_stats'  # noqa
     assert update_notification_status_by_reference.__wrapped__.__name__ == 'update_notification_status_by_reference'  # noqa
     assert get_notification_for_job.__wrapped__.__name__ == 'get_notification_for_job'  # noqa
     assert get_notifications_for_job.__wrapped__.__name__ == 'get_notifications_for_job'  # noqa
@@ -232,33 +230,28 @@ def test_should_by_able_to_update_status_by_reference(sample_email_template, ses
     data = _notification_json(sample_email_template, status='sending')
 
     notification = Notification(**data)
-    dao_create_notification(
-        notification,
-        sample_email_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.get(notification.id).status == "sending"
     notification.reference = 'reference'
     dao_update_notification(notification)
 
-    update_notification_status_by_reference('reference', 'delivered', 'delivered')
+    update_notification_status_by_reference('reference', 'delivered')
     assert Notification.query.get(notification.id).status == 'delivered'
-    _assert_notification_stats(notification.service_id, emails_delivered=1, emails_requested=1, emails_failed=0)
 
 
 def test_should_by_able_to_update_status_by_id(sample_template, sample_job, mmg_provider):
     with freeze_time('2000-01-01 12:00:00'):
         data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
         notification = Notification(**data)
-        dao_create_notification(notification, sample_template.template_type)
+        dao_create_notification(notification)
 
     assert Notification.query.get(notification.id).status == 'sending'
 
     with freeze_time('2000-01-02 12:00:00'):
-        assert update_notification_status_by_id(notification.id, 'delivered', 'delivered')
+        assert update_notification_status_by_id(notification.id, 'delivered')
 
     assert Notification.query.get(notification.id).status == 'delivered'
-    _assert_notification_stats(notification.service_id, sms_delivered=1, sms_requested=1, sms_failed=0)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=1, failed=0)
     assert notification.updated_at == datetime(2000, 1, 2, 12, 0, 0)
 
 
@@ -266,7 +259,7 @@ def test_should_not_update_status_by_id_if_not_sending_and_does_not_update_job(n
     notification = sample_notification(notify_db, notify_db_session, status='delivered')
     job = Job.query.get(notification.job_id)
     assert Notification.query.get(notification.id).status == 'delivered'
-    assert not update_notification_status_by_id(notification.id, 'failed', 'failure')
+    assert not update_notification_status_by_id(notification.id, 'failed')
     assert Notification.query.get(notification.id).status == 'delivered'
     assert job == Job.query.get(notification.job_id)
 
@@ -274,58 +267,46 @@ def test_should_not_update_status_by_id_if_not_sending_and_does_not_update_job(n
 def test_should_update_status_if_created(notify_db, notify_db_session):
     notification = sample_notification(notify_db, notify_db_session, status='created')
     assert Notification.query.get(notification.id).status == 'created'
-    assert update_notification_status_by_id(notification.id, 'failed', 'failure')
+    assert update_notification_status_by_id(notification.id, 'failed')
 
 
 def test_should_by_able_to_update_status_by_id_from_pending_to_delivered(sample_template, sample_job):
     data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
     assert Notification.query.get(notification.id).status == 'sending'
     assert update_notification_status_by_id(notification_id=notification.id, status='pending')
     assert Notification.query.get(notification.id).status == 'pending'
-    _assert_notification_stats(notification.service_id, sms_requested=1, sms_delivered=0, sms_failed=0)
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=0)
 
-    assert update_notification_status_by_id(notification.id, 'delivered', 'delivered')
+    assert update_notification_status_by_id(notification.id, 'delivered')
     assert Notification.query.get(notification.id).status == 'delivered'
-    _assert_notification_stats(notification.service_id, sms_requested=1, sms_delivered=1, sms_failed=0)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=1, failed=0)
 
 
 def test_should_by_able_to_update_status_by_id_from_pending_to_temporary_failure(sample_template, sample_job):
     data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
     assert Notification.query.get(notification.id).status == 'sending'
     assert update_notification_status_by_id(notification_id=notification.id, status='pending')
     assert Notification.query.get(notification.id).status == 'pending'
-    _assert_notification_stats(notification.service_id, sms_requested=1, sms_delivered=0, sms_failed=0)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=0, failed=0)
 
     assert update_notification_status_by_id(
         notification.id,
-        status='permanent-failure',
-        notification_statistics_status='failure')
+        status='permanent-failure')
     assert Notification.query.get(notification.id).status == 'temporary-failure'
-    _assert_notification_stats(notification.service_id, sms_delivered=0, sms_requested=1, sms_failed=1)
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=1)
 
 
 def test_should_by_able_to_update_status_by_id_from_sending_to_permanent_failure(sample_template, sample_job):
     data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
     assert Notification.query.get(notification.id).status == 'sending'
 
     assert update_notification_status_by_id(
         notification.id,
-        status='permanent-failure',
-        notification_statistics_status='failure'
+        status='permanent-failure'
     )
     assert Notification.query.get(notification.id).status == 'permanent-failure'
-    _assert_notification_stats(notification.service_id, sms_requested=1, sms_delivered=0, sms_failed=1)
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=1)
 
 
 def test_should_not_update_status_one_notification_status_is_delivered(notify_db, notify_db_session,
@@ -336,90 +317,28 @@ def test_should_not_update_status_one_notification_status_is_delivered(notify_db
                                        status='sending')
     assert Notification.query.get(notification.id).status == "sending"
 
-    update_provider_stats(
-        notification.id,
-        'email',
-        ses_provider.identifier)
     notification.reference = 'reference'
     dao_update_notification(notification)
-    update_notification_status_by_reference('reference', 'delivered', 'delivered')
+    update_notification_status_by_reference('reference', 'delivered')
     assert Notification.query.get(notification.id).status == 'delivered'
 
-    update_notification_status_by_reference('reference', 'failed', 'temporary-failure')
+    update_notification_status_by_reference('reference', 'failed')
     assert Notification.query.get(notification.id).status == 'delivered'
-    _assert_notification_stats(notification.service_id, emails_requested=1, emails_delivered=1, emails_failed=0)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=1, failed=0)
-
-
-def test_should_be_able_to_record_statistics_failure_for_sms(notify_db, notify_db_session, ):
-    notification = sample_notification(notify_db=notify_db, notify_db_session=notify_db_session, status='sending')
-    assert Notification.query.get(notification.id).status == 'sending'
-
-    assert update_notification_status_by_id(notification.id, 'permanent-failure', 'failure')
-    assert Notification.query.get(notification.id).status == 'permanent-failure'
-    _assert_notification_stats(notification.service_id, sms_requested=1, sms_delivered=0, sms_failed=1)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=0, failed=1)
-
-
-def test_should_be_able_to_record_statistics_failure_for_email(sample_email_template, sample_job, ses_provider):
-    data = _notification_json(sample_email_template, job_id=sample_job.id, status='sending')
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_email_template.template_type)
-
-    update_provider_stats(
-        notification.id,
-        'email',
-        ses_provider.identifier)
-    notification.reference = 'reference'
-    dao_update_notification(notification)
-    count = update_notification_status_by_reference('reference', 'failed', 'failure')
-    assert count == 1
-    assert Notification.query.get(notification.id).status == 'failed'
-    _assert_notification_stats(notification.service_id, emails_requested=1, emails_delivered=0, emails_failed=1)
-    _assert_job_stats(notification.job_id, sent=1, count=1, delivered=0, failed=1)
 
 
 def test_should_return_zero_count_if_no_notification_with_id():
-    assert not update_notification_status_by_id(str(uuid.uuid4()), 'delivered', 'delivered')
+    assert not update_notification_status_by_id(str(uuid.uuid4()), 'delivered')
 
 
 def test_should_return_zero_count_if_no_notification_with_reference():
-    assert not update_notification_status_by_reference('something', 'delivered', 'delivered')
-
-
-def test_should_be_able_to_get_statistics_for_a_service(sample_template, mmg_provider):
-    data = _notification_json(sample_template)
-
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-
-    _assert_notification_stats(notification.service_id, sms_requested=1,
-                               notification_created_at=notification.created_at.date())
-
-
-def test_should_be_able_to_get_statistics_for_a_service_for_a_day(sample_template, mmg_provider):
-    now = datetime.utcnow()
-    data = _notification_json(sample_template)
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-    stat = dao_get_notification_statistics_for_service_and_day(
-        sample_template.service.id, now.date()
-    )
-    assert stat.emails_requested == 0
-    assert stat.emails_failed == 0
-    assert stat.emails_delivered == 0
-    assert stat.sms_requested == 1
-    assert stat.sms_failed == 0
-    assert stat.sms_delivered == 0
-    assert stat.day == notification.created_at.date()
-    assert stat.service_id == notification.service_id
+    assert not update_notification_status_by_reference('something', 'delivered')
 
 
 def test_should_return_none_if_no_statistics_for_a_service_for_a_day(sample_template, mmg_provider):
     data = _notification_json(sample_template)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
     assert not dao_get_notification_statistics_for_service_and_day(
         sample_template.service.id, (datetime.utcnow() - timedelta(days=1)).date())
 
@@ -430,11 +349,9 @@ def test_should_be_able_to_get_all_statistics_for_a_service(sample_template, mmg
     notification_1 = Notification(**data)
     notification_2 = Notification(**data)
     notification_3 = Notification(**data)
-    dao_create_notification(notification_1, sample_template.template_type)
-    dao_create_notification(notification_2, sample_template.template_type)
-    dao_create_notification(notification_3, sample_template.template_type)
-
-    _assert_notification_stats(sample_template.service.id, sms_requested=3)
+    dao_create_notification(notification_1)
+    dao_create_notification(notification_2)
+    dao_create_notification(notification_3)
 
 
 def test_create_notification_creates_notification_with_personalisation(notify_db, notify_db_session,
@@ -461,22 +378,9 @@ def test_create_notification_creates_notification_with_personalisation(notify_db
     assert data.created_at == notification_from_db.created_at
     assert notification_from_db.status == 'created'
     assert {'name': 'Jo'} == notification_from_db.personalisation
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=0)
-
-    stats = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_template_with_placeholders.service.id).first()
-    assert stats.emails_requested == 0
-    assert stats.sms_requested == 1
-
-    template_stats = TemplateStatistics.query.filter(
-        TemplateStatistics.service_id == sample_template_with_placeholders.service.id,
-        TemplateStatistics.template_id == sample_template_with_placeholders.id).first()
-    assert template_stats.service_id == sample_template_with_placeholders.service.id
-    assert template_stats.template_id == sample_template_with_placeholders.id
-    assert template_stats.usage_count == 1
 
 
-def test_save_notification_creates_sms_and_template_stats(sample_template, sample_job, mmg_provider):
+def test_save_notification_creates_sms(sample_template, sample_job, mmg_provider):
     assert Notification.query.count() == 0
     assert NotificationStatistics.query.count() == 0
     assert TemplateStatistics.query.count() == 0
@@ -484,7 +388,7 @@ def test_save_notification_creates_sms_and_template_stats(sample_template, sampl
     data = _notification_json(sample_template, job_id=sample_job.id)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -496,20 +400,9 @@ def test_save_notification_creates_sms_and_template_stats(sample_template, sampl
     assert data['template_version'] == notification_from_db.template_version
     assert data['created_at'] == notification_from_db.created_at
     assert notification_from_db.status == 'created'
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=0)
-
-    stats = NotificationStatistics.query.filter(NotificationStatistics.service_id == sample_template.service.id).first()
-    assert stats.emails_requested == 0
-    assert stats.sms_requested == 1
-
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.service_id == sample_template.service.id
-    assert template_stats.template_id == sample_template.id
-    assert template_stats.usage_count == 1
 
 
-def test_save_notification_and_create_email_and_template_stats(sample_email_template, sample_job, ses_provider):
+def test_save_notification_and_create_email(sample_email_template, sample_job, ses_provider):
     assert Notification.query.count() == 0
     assert NotificationStatistics.query.count() == 0
     assert TemplateStatistics.query.count() == 0
@@ -517,7 +410,7 @@ def test_save_notification_and_create_email_and_template_stats(sample_email_temp
     data = _notification_json(sample_email_template, job_id=sample_job.id)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_email_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -529,109 +422,37 @@ def test_save_notification_and_create_email_and_template_stats(sample_email_temp
     assert data['template_version'] == notification_from_db.template_version
     assert data['created_at'] == notification_from_db.created_at
     assert notification_from_db.status == 'created'
-    _assert_job_stats(sample_job.id, sent=1, count=1, delivered=0, failed=0)
-
-    stats = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_email_template.service.id).first()
-
-    assert stats.emails_requested == 1
-    assert stats.sms_requested == 0
-
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_email_template.service.id,
-                                                     TemplateStatistics.template_id == sample_email_template.id).first()  # noqa
-
-    assert template_stats.service_id == sample_email_template.service.id
-    assert template_stats.template_id == sample_email_template.id
-    assert template_stats.usage_count == 1
 
 
-@freeze_time("2016-01-01 00:00:00.000000")
-def test_save_notification_handles_midnight_properly(sample_template, sample_job, mmg_provider):
-    assert Notification.query.count() == 0
-    data = _notification_json(sample_template, sample_job.id)
-
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-
-    assert Notification.query.count() == 1
-
-    stats = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_template.service.id).first()
-
-    assert stats.day == date(2016, 1, 1)
-
-
-@freeze_time("2016-01-01 23:59:59.999999")
-def test_save_notification_handles_just_before_midnight_properly(sample_template, sample_job, mmg_provider):
-    assert Notification.query.count() == 0
-    data = _notification_json(sample_template, job_id=sample_job.id)
-
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-
-    assert Notification.query.count() == 1
-
-    stats = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_template.service.id).first()
-
-    assert stats.day == date(2016, 1, 1)
-
-
-def test_save_notification_and_increment_email_stats(sample_email_template, sample_job, ses_provider):
+def test_save_notification(sample_email_template, sample_job, ses_provider):
     assert Notification.query.count() == 0
     data = _notification_json(sample_email_template, job_id=sample_job.id)
 
     notification_1 = Notification(**data)
     notification_2 = Notification(**data)
-    dao_create_notification(notification_1, sample_email_template.template_type)
+    dao_create_notification(notification_1)
 
     assert Notification.query.count() == 1
 
-    stats1 = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_email_template.service.id).first()
-
-    assert stats1.emails_requested == 1
-    assert stats1.sms_requested == 0
-
-    dao_create_notification(notification_2, sample_email_template.template_type)
+    dao_create_notification(notification_2)
 
     assert Notification.query.count() == 2
 
-    stats2 = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_email_template.service.id).first()
 
-    assert stats2.emails_requested == 2
-    assert stats2.sms_requested == 0
-
-
-def test_save_notification_and_increment_sms_stats(sample_template, sample_job, mmg_provider):
+def test_save_notification(sample_template, sample_job, mmg_provider):
     assert Notification.query.count() == 0
     data = _notification_json(sample_template, sample_job.id)
 
     notification_1 = Notification(**data)
     notification_2 = Notification(**data)
-    dao_create_notification(notification_1, sample_template.template_type)
+    dao_create_notification(notification_1)
 
     assert Notification.query.count() == 1
 
-    stats1 = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_template.service.id
-    ).first()
-
-    assert stats1.emails_requested == 0
-    assert stats1.sms_requested == 1
-
-    dao_create_notification(notification_2, sample_template.template_type)
+    dao_create_notification(notification_2)
 
     assert Notification.query.count() == 2
 
-    stats2 = NotificationStatistics.query.filter(
-        NotificationStatistics.service_id == sample_template.service.id
-    ).first()
-
-    assert stats2.emails_requested == 0
-    assert stats2.sms_requested == 2
-
 
 def test_not_save_notification_and_not_create_stats_on_commit_error(sample_template, sample_job, mmg_provider):
     random_id = str(uuid.uuid4())
@@ -641,7 +462,7 @@ def test_not_save_notification_and_not_create_stats_on_commit_error(sample_templ
 
     notification = Notification(**data)
     with pytest.raises(SQLAlchemyError):
-        dao_create_notification(notification, sample_template.template_type)
+        dao_create_notification(notification)
 
     assert Notification.query.count() == 0
     assert Job.query.get(sample_job.id).notifications_sent == 0
@@ -654,7 +475,7 @@ def test_save_notification_and_increment_job(sample_template, sample_job, mmg_pr
     data = _notification_json(sample_template, job_id=sample_job.id)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -666,34 +487,10 @@ def test_save_notification_and_increment_job(sample_template, sample_job, mmg_pr
     assert data['template_version'] == notification_from_db.template_version
     assert data['created_at'] == notification_from_db.created_at
     assert notification_from_db.status == 'created'
-    assert Job.query.get(sample_job.id).notifications_sent == 1
 
     notification_2 = Notification(**data)
-    dao_create_notification(notification_2, sample_template.template_type)
+    dao_create_notification(notification_2)
     assert Notification.query.count() == 2
-    # count is off because the count is defaulted to 1 in the sample_job
-    _assert_job_stats(sample_job.id, sent=2, count=1)
-
-
-def test_should_not_increment_job_if_notification_fails_to_persist(sample_template, sample_job, mmg_provider):
-    random_id = str(uuid.uuid4())
-    assert Notification.query.count() == 0
-    data = _notification_json(sample_template, job_id=sample_job.id, id=random_id)
-
-    notification_1 = Notification(**data)
-    dao_create_notification(notification_1, sample_template.template_type)
-
-    assert Notification.query.count() == 1
-    assert Job.query.get(sample_job.id).notifications_sent == 1
-    job_last_updated_at = Job.query.get(sample_job.id).updated_at
-
-    notification_2 = Notification(**data)
-    with pytest.raises(SQLAlchemyError):
-        dao_create_notification(notification_2, sample_template.template_type)
-
-    assert Notification.query.count() == 1
-    assert Job.query.get(sample_job.id).notifications_sent == 1
-    assert Job.query.get(sample_job.id).updated_at == job_last_updated_at
 
 
 def test_save_notification_and_increment_correct_job(notify_db, notify_db_session, sample_template, mmg_provider):
@@ -705,7 +502,7 @@ def test_save_notification_and_increment_correct_job(notify_db, notify_db_sessio
     data = _notification_json(sample_template, job_id=job_1.id)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -718,8 +515,6 @@ def test_save_notification_and_increment_correct_job(notify_db, notify_db_sessio
     assert data['created_at'] == notification_from_db.created_at
     assert notification_from_db.status == 'created'
     assert job_1.id != job_2.id
-    _assert_job_stats(job_id=job_1.id, sent=1, count=1)
-    _assert_job_stats(job_id=job_2.id, sent=0, count=1)
 
 
 def test_save_notification_with_no_job(sample_template, mmg_provider):
@@ -727,7 +522,7 @@ def test_save_notification_with_no_job(sample_template, mmg_provider):
     data = _notification_json(sample_template)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -754,7 +549,7 @@ def test_save_notification_no_job_id(sample_template, mmg_provider):
     data = _notification_json(sample_template)
 
     notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
     notification_from_db = Notification.query.all()[0]
@@ -788,7 +583,6 @@ def test_get_all_notifications_for_job(notify_db, notify_db_session, sample_job)
 
     notifications_from_db = get_notifications_for_job(sample_job.service.id, sample_job.id).items
     assert len(notifications_from_db) == 5
-    _assert_notification_stats(sample_job.service.id, sms_requested=5)
 
 
 def test_get_all_notifications_for_job_by_status(notify_db, notify_db_session, sample_job):
@@ -870,120 +664,6 @@ def test_should_not_delete_failed_notifications_before_seven_days(notify_db, not
     assert Notification.query.first().to == 'do_not_delete'
 
 
-@freeze_time("2016-03-30")
-def test_save_new_notification_creates_template_stats(sample_template, sample_job, mmg_provider):
-    assert Notification.query.count() == 0
-    assert TemplateStatistics.query.count() == 0
-    data = _notification_json(sample_template, job_id=sample_job.id)
-
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-
-    assert TemplateStatistics.query.count() == 1
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.service_id == sample_template.service.id
-    assert template_stats.template_id == sample_template.id
-    assert template_stats.usage_count == 1
-    assert template_stats.day == date(2016, 3, 30)
-
-
-@freeze_time("2016-03-30")
-def test_save_new_notification_creates_template_stats_per_day(sample_template, sample_job, mmg_provider):
-    assert Notification.query.count() == 0
-    assert TemplateStatistics.query.count() == 0
-    data = _notification_json(sample_template, job_id=sample_job.id)
-
-    notification = Notification(**data)
-    dao_create_notification(notification, sample_template.template_type)
-
-    assert TemplateStatistics.query.count() == 1
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.service_id == sample_template.service.id
-    assert template_stats.template_id == sample_template.id
-    assert template_stats.usage_count == 1
-    assert template_stats.day == date(2016, 3, 30)
-
-    # move on one day
-    with freeze_time('2016-03-31'):
-        assert TemplateStatistics.query.count() == 1
-        new_notification = Notification(**data)
-        dao_create_notification(new_notification, sample_template.template_type)
-
-    assert TemplateStatistics.query.count() == 2
-    first_stats = TemplateStatistics.query.filter(TemplateStatistics.day == datetime(2016, 3, 30)).first()
-    second_stats = TemplateStatistics.query.filter(TemplateStatistics.day == datetime(2016, 3, 31)).first()
-
-    assert first_stats.template_id == second_stats.template_id
-    assert first_stats.service_id == second_stats.service_id
-
-    assert first_stats.day == date(2016, 3, 30)
-    assert first_stats.usage_count == 1
-
-    assert second_stats.day == date(2016, 3, 31)
-    assert second_stats.usage_count == 1
-
-
-def test_save_another_notification_increments_template_stats(sample_template, sample_job, mmg_provider):
-    assert Notification.query.count() == 0
-    assert TemplateStatistics.query.count() == 0
-    data = _notification_json(sample_template, job_id=sample_job.id)
-
-    notification_1 = Notification(**data)
-    notification_2 = Notification(**data)
-    dao_create_notification(notification_1, sample_template.template_type)
-
-    assert TemplateStatistics.query.count() == 1
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.service_id == sample_template.service.id
-    assert template_stats.template_id == sample_template.id
-    assert template_stats.usage_count == 1
-
-    dao_create_notification(notification_2, sample_template.template_type)
-
-    assert TemplateStatistics.query.count() == 1
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.usage_count == 2
-
-
-def test_successful_notification_inserts_followed_by_failure_does_not_increment_template_stats(sample_template,
-                                                                                               sample_job,
-                                                                                               mmg_provider):
-    assert Notification.query.count() == 0
-    assert NotificationStatistics.query.count() == 0
-    assert TemplateStatistics.query.count() == 0
-
-    data = _notification_json(sample_template, job_id=sample_job.id)
-
-    notification_1 = Notification(**data)
-    notification_2 = Notification(**data)
-    notification_3 = Notification(**data)
-    dao_create_notification(notification_1, sample_template.template_type)
-    dao_create_notification(notification_2, sample_template.template_type)
-    dao_create_notification(notification_3, sample_template.template_type)
-
-    _assert_notification_stats(sample_template.service.id, sms_requested=3)
-
-    assert TemplateStatistics.query.count() == 1
-    template_stats = TemplateStatistics.query.filter(TemplateStatistics.service_id == sample_template.service.id,
-                                                     TemplateStatistics.template_id == sample_template.id).first()
-    assert template_stats.service_id == sample_template.service.id
-    assert template_stats.template_id == sample_template.id
-    assert template_stats.usage_count == 3
-
-    failing_notification = Notification(**data)
-    try:
-        # Mess up db in really bad way
-        db.session.execute('DROP TABLE TEMPLATE_STATISTICS')
-        dao_create_notification(failing_notification, sample_template.template_type)
-    except Exception as e:
-        # There should be no additional notification stats or counts
-        _assert_notification_stats(sample_template.service.id, sms_requested=3)
-
-
 @freeze_time("2016-01-10")
 def test_should_limit_notifications_return_by_day_limit_plus_one(notify_db, notify_db_session, sample_service):
     assert len(Notification.query.all()) == 0
@@ -1024,7 +704,7 @@ def test_creating_notification_adds_to_notification_history(sample_template):
     data = _notification_json(sample_template)
     notification = Notification(**data)
 
-    dao_create_notification(notification, sample_template.template_type)
+    dao_create_notification(notification)
 
     assert Notification.query.count() == 1
 
@@ -1069,26 +749,3 @@ def _notification_json(sample_template, job_id=None, id=None, status=None):
     if status:
         data.update({'status': status})
     return data
-
-
-def _assert_notification_stats(service_id,
-                               emails_delivered=0, emails_requested=0, emails_failed=0,
-                               sms_delivered=0, sms_requested=0, sms_failed=0,
-                               notification_created_at=None):
-    stats = NotificationStatistics.query.filter_by(service_id=service_id).all()
-    assert len(stats) == 1
-    assert stats[0].emails_delivered == emails_delivered
-    assert stats[0].emails_requested == emails_requested
-    assert stats[0].emails_failed == emails_failed
-    assert stats[0].sms_delivered == sms_delivered
-    assert stats[0].sms_requested == sms_requested
-    assert stats[0].sms_failed == sms_failed
-    assert stats[0].day == notification_created_at if notification_created_at else True
-
-
-def _assert_job_stats(job_id, sent=0, count=0, delivered=0, failed=0):
-    job = Job.query.get(job_id)
-    assert job.notifications_sent == sent
-    assert job.notification_count == count
-    assert job.notifications_delivered == delivered
-    assert job.notifications_failed == failed
diff --git a/tests/app/dao/test_provider_statistics_dao.py b/tests/app/dao/test_provider_statistics_dao.py
index 955aa3c23..2a1faad4e 100644
--- a/tests/app/dao/test_provider_statistics_dao.py
+++ b/tests/app/dao/test_provider_statistics_dao.py
@@ -4,92 +4,7 @@ import uuid
 import pytest
 
 from app.models import NotificationHistory, KEY_TYPE_NORMAL, KEY_TYPE_TEAM, KEY_TYPE_TEST, NOTIFICATION_STATUS_TYPES
-from app.dao.notifications_dao import update_provider_stats
-from app.dao.provider_statistics_dao import get_provider_statistics, get_fragment_count
-from tests.app.conftest import sample_notification as create_sample_notification
-
-
-def test_should_update_provider_statistics_sms(notify_db,
-                                               notify_db_session,
-                                               sample_template,
-                                               mmg_provider):
-    n1 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_template)
-    update_provider_stats(n1.id, 'sms', mmg_provider.identifier)
-    provider_stats = get_provider_statistics(
-        sample_template.service,
-        providers=[mmg_provider.identifier]).one()
-    assert provider_stats.unit_count == 1
-
-
-def test_should_update_provider_statistics_email(notify_db,
-                                                 notify_db_session,
-                                                 sample_email_template,
-                                                 ses_provider):
-    n1 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_email_template)
-    update_provider_stats(n1.id, 'email', ses_provider.identifier)
-    provider_stats = get_provider_statistics(
-        sample_email_template.service,
-        providers=[ses_provider.identifier]).one()
-    assert provider_stats.unit_count == 1
-
-
-def test_should_update_provider_statistics_sms_multi(notify_db,
-                                                     notify_db_session,
-                                                     sample_template,
-                                                     mmg_provider):
-    n1 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_template,
-        billable_units=1)
-    update_provider_stats(n1.id, 'sms', mmg_provider.identifier, n1.billable_units)
-    n2 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_template,
-        billable_units=2)
-    update_provider_stats(n2.id, 'sms', mmg_provider.identifier, n2.billable_units)
-    n3 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_template,
-        billable_units=4)
-    update_provider_stats(n3.id, 'sms', mmg_provider.identifier, n3.billable_units)
-    provider_stats = get_provider_statistics(
-        sample_template.service,
-        providers=[mmg_provider.identifier]).one()
-    assert provider_stats.unit_count == 7
-
-
-def test_should_update_provider_statistics_email_multi(notify_db,
-                                                       notify_db_session,
-                                                       sample_email_template,
-                                                       ses_provider):
-    n1 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_email_template)
-    update_provider_stats(n1.id, 'email', ses_provider.identifier)
-    n2 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_email_template)
-    update_provider_stats(n2.id, 'email', ses_provider.identifier)
-    n3 = create_sample_notification(
-        notify_db,
-        notify_db_session,
-        template=sample_email_template)
-    update_provider_stats(n3.id, 'email', ses_provider.identifier)
-    provider_stats = get_provider_statistics(
-        sample_email_template.service,
-        providers=[ses_provider.identifier]).one()
-    assert provider_stats.unit_count == 3
+from app.dao.provider_statistics_dao import get_fragment_count
 
 
 def test_get_fragment_count_with_no_data(sample_template):
diff --git a/tests/app/notifications/rest/test_callbacks.py b/tests/app/notifications/rest/test_callbacks.py
index b6fc84757..47d99a2ef 100644
--- a/tests/app/notifications/rest/test_callbacks.py
+++ b/tests/app/notifications/rest/test_callbacks.py
@@ -162,10 +162,6 @@ def test_firetext_callback_should_update_notification_status(notify_api, sample_
             updated = get_notification_by_id(sample_notification.id)
             assert updated.status == 'delivered'
             assert get_notification_by_id(sample_notification.id).status == 'delivered'
-            stats = get_notification_stats(sample_notification.service_id)
-            assert stats.sms_delivered == 1
-            assert stats.sms_requested == 1
-            assert stats.sms_failed == 0
 
 
 def test_firetext_callback_should_update_notification_status_failed(notify_api, sample_notification, mocker):
@@ -189,10 +185,6 @@ def test_firetext_callback_should_update_notification_status_failed(notify_api,
                 sample_notification.id
             )
             assert get_notification_by_id(sample_notification.id).status == 'permanent-failure'
-            stats = get_notification_stats(sample_notification.service_id)
-            assert stats.sms_delivered == 0
-            assert stats.sms_requested == 1
-            assert stats.sms_failed == 1
 
 
 def test_firetext_callback_should_update_notification_status_pending(notify_api, notify_db, notify_db_session, mocker):
@@ -217,10 +209,6 @@ def test_firetext_callback_should_update_notification_status_pending(notify_api,
                 notification.id
             )
             assert get_notification_by_id(notification.id).status == 'pending'
-            stats = get_notification_stats(notification.service_id)
-            assert stats.sms_delivered == 0
-            assert stats.sms_requested == 1
-            assert stats.sms_failed == 0
 
 
 def test_firetext_callback_should_update_multiple_notification_status_sent(
@@ -257,11 +245,6 @@ def test_firetext_callback_should_update_multiple_notification_status_sent(
                 ),
                 headers=[('Content-Type', 'application/x-www-form-urlencoded')])
 
-            stats = get_notification_stats(notification1.service_id)
-            assert stats.sms_delivered == 3
-            assert stats.sms_requested == 3
-            assert stats.sms_failed == 0
-
 
 def test_process_mmg_response_return_200_when_cid_is_send_sms_code(notify_api):
     with notify_api.test_request_context():
@@ -481,10 +464,6 @@ def test_ses_callback_should_update_notification_status(
             assert json_resp['result'] == 'success'
             assert json_resp['message'] == 'SES callback succeeded'
             assert get_notification_by_id(notification.id).status == 'delivered'
-            stats = get_notification_stats(notification.service_id)
-            assert stats.emails_delivered == 1
-            assert stats.emails_requested == 1
-            assert stats.emails_failed == 0
 
 
 def test_ses_callback_should_update_multiple_notification_status_sent(
@@ -536,11 +515,6 @@ def test_ses_callback_should_update_multiple_notification_status_sent(
             assert resp2.status_code == 200
             assert resp3.status_code == 200
 
-            stats = get_notification_stats(notification1.service_id)
-            assert stats.emails_delivered == 3
-            assert stats.emails_requested == 3
-            assert stats.emails_failed == 0
-
 
 def test_ses_callback_should_set_status_to_temporary_failure(notify_api,
                                                              notify_db,
@@ -568,10 +542,6 @@ def test_ses_callback_should_set_status_to_temporary_failure(notify_api,
             assert json_resp['result'] == 'success'
             assert json_resp['message'] == 'SES callback succeeded'
             assert get_notification_by_id(notification.id).status == 'temporary-failure'
-            stats = get_notification_stats(notification.service_id)
-            assert stats.emails_delivered == 0
-            assert stats.emails_requested == 1
-            assert stats.emails_failed == 1
 
 
 def test_ses_callback_should_not_set_status_once_status_is_delivered(notify_api,
@@ -628,10 +598,6 @@ def test_ses_callback_should_set_status_to_permanent_failure(notify_api,
             assert json_resp['result'] == 'success'
             assert json_resp['message'] == 'SES callback succeeded'
             assert get_notification_by_id(notification.id).status == 'permanent-failure'
-            stats = get_notification_stats(notification.service_id)
-            assert stats.emails_delivered == 0
-            assert stats.emails_requested == 1
-            assert stats.emails_failed == 1
 
 
 def test_should_handle_invite_email_callbacks(notify_api, notify_db, notify_db_session):
diff --git a/tests/app/notifications/test_process_client_response.py b/tests/app/notifications/test_process_client_response.py
index 6e2f5d46d..b2e14b67c 100644
--- a/tests/app/notifications/test_process_client_response.py
+++ b/tests/app/notifications/test_process_client_response.py
@@ -68,43 +68,3 @@ def test_process_sms_response_returns_error_for_unknown_status():
     success, error = process_sms_client_response(status='000', reference=str(uuid.uuid4()), client_name='Firetext')
     assert success is None
     assert error == "{} callback failed: status {} not found.".format('Firetext', '000')
-
-
-def test_process_sms_response_updates_notification_stats_for_valid_request(notify_db,
-                                                                           notify_db_session,
-                                                                           sample_notification):
-    stats = NotificationStatistics.query.all()
-    assert len(stats) == 1
-    assert stats[0].sms_requested == 1
-    assert stats[0].sms_delivered == 0
-    assert stats[0].sms_failed == 0
-    success, error = process_sms_client_response(status='0', reference=str(sample_notification.id),
-                                                 client_name='Firetext')
-    assert error is None
-    assert success == "{} callback succeeded. reference {} updated".format('Firetext', sample_notification.id)
-    stats = NotificationStatistics.query.all()
-    assert len(stats) == 1
-    assert stats[0].sms_requested == 1
-    assert stats[0].sms_delivered == 1
-    assert stats[0].sms_failed == 0
-
-
-def test_process_sms_response_updates_notification_stats_for_valid_request_with_failed_status(notify_api,
-                                                                                              notify_db,
-                                                                                              notify_db_session,
-                                                                                              sample_notification):
-    with notify_api.test_request_context():
-        stats = NotificationStatistics.query.all()
-        assert len(stats) == 1
-        assert stats[0].sms_requested == 1
-        assert stats[0].sms_delivered == 0
-        assert stats[0].sms_failed == 0
-        success, error = process_sms_client_response(status='1', reference=str(sample_notification.id),
-                                                     client_name='Firetext')
-        assert success == "{} callback succeeded. reference {} updated".format('Firetext', sample_notification.id)
-        assert error is None
-        stats = NotificationStatistics.query.all()
-        assert len(stats) == 1
-        assert stats[0].sms_requested == 1
-        assert stats[0].sms_delivered == 0
-        assert stats[0].sms_failed == 1