diff --git a/HISTORY.rst b/HISTORY.rst
index e614f25825..4c90b6e9cf 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -138,6 +138,7 @@
   for compatibility with version 3.2 settings.
   These are now a fallback if the new 'DATABASES'
   setting is not specified.
+- Refactor the initial setting bootstrap code.
 
 3.2.10 (2019-XX-XX)
 ===================
diff --git a/mayan/apps/smart_settings/classes.py b/mayan/apps/smart_settings/classes.py
index c63dd7763f..43d16a1393 100644
--- a/mayan/apps/smart_settings/classes.py
+++ b/mayan/apps/smart_settings/classes.py
@@ -18,12 +18,32 @@ from django.utils.encoding import (
 
 from mayan.apps.common.serialization import yaml_dump, yaml_load
 
-from .utils import read_configuration_file
-
 logger = logging.getLogger(__name__)
 SMART_SETTINGS_NAMESPACES_NAME = 'SMART_SETTINGS_NAMESPACES'
 
 
+def read_configuration_file(filepath):
+    try:
+        with open(filepath) as file_object:
+            file_object.seek(0, os.SEEK_END)
+            if file_object.tell():
+                file_object.seek(0)
+                try:
+                    return yaml_load(stream=file_object)
+                except yaml.YAMLError as exception:
+                    exit(
+                        'Error loading configuration file: {}; {}'.format(
+                            filepath, exception
+                        )
+                    )
+    except IOError as exception:
+        if exception.errno == errno.ENOENT:
+            # No config file, return empty dictionary
+            return {}
+        else:
+            raise
+
+
 @python_2_unicode_compatible
 class Namespace(object):
     _registry = {}
@@ -169,7 +189,7 @@ class Setting(object):
         # Cache content of config file to speed up initial boot up
         if not cls._config_file_cache:
             cls._config_file_cache = read_configuration_file(
-                path=settings.CONFIGURATION_FILEPATH
+                filepath=settings.CONFIGURATION_FILEPATH
             )
 
         return cls._config_file_cache
diff --git a/mayan/apps/smart_settings/literals.py b/mayan/apps/smart_settings/literals.py
index 4ce0d04ada..20e6389c55 100644
--- a/mayan/apps/smart_settings/literals.py
+++ b/mayan/apps/smart_settings/literals.py
@@ -1,43 +1,4 @@
 from __future__ import unicode_literals
 
-# Default in YAML format
-BOOTSTRAP_SETTING_LIST = (
-    {'name': 'ALLOWED_HOSTS', 'default': "['127.0.0.1', 'localhost', '[::1]']"},
-    {'name': 'APPEND_SLASH'},
-    {'name': 'AUTH_PASSWORD_VALIDATORS'},
-    {'name': 'COMMON_DISABLED_APPS'},
-    {'name': 'COMMON_EXTRA_APPS'},
-    {'name': 'DATA_UPLOAD_MAX_MEMORY_SIZE'},
-    {'name': 'DATABASES'},
-    {'name': 'DATABASE_ENGINE'},
-    {'name': 'DATABASE_NAME'},
-    {'name': 'DATABASE_USER'},
-    {'name': 'DATABASE_PASSWORD'},
-    {'name': 'DATABASE_HOST'},
-    {'name': 'DATABASE_PORT'},
-    {'name': 'DATABASE_CONN_MAX_AGE'},
-    {'name': 'DEBUG', 'default': 'false'},
-    {'name': 'DEFAULT_FROM_EMAIL'},
-    {'name': 'DISALLOWED_USER_AGENTS'},
-    {'name': 'EMAIL_BACKEND'},
-    {'name': 'EMAIL_HOST'},
-    {'name': 'EMAIL_HOST_PASSWORD'},
-    {'name': 'EMAIL_HOST_USER'},
-    {'name': 'EMAIL_PORT'},
-    {'name': 'EMAIL_TIMEOUT'},
-    {'name': 'EMAIL_USE_SSL'},
-    {'name': 'EMAIL_USE_TLS'},
-    {'name': 'FILE_UPLOAD_MAX_MEMORY_SIZE'},
-    {'name': 'HOME_VIEW'},
-    {'name': 'INSTALLED_APPS'},
-    {'name': 'INTERNAL_IPS', 'default': "['127.0.0.1']"},
-    {'name': 'LANGUAGES'},
-    {'name': 'LANGUAGE_CODE'},
-    {'name': 'LOGIN_REDIRECT_URL', 'default': 'common:home'},
-    {'name': 'LOGIN_URL', 'default': 'authentication:login_view'},
-    {'name': 'LOGOUT_REDIRECT_URL', 'default': 'authentication:login_view'},
-    {'name': 'STATIC_URL'},
-    {'name': 'STATICFILES_STORAGE'},
-    {'name': 'TIME_ZONE'},
-    {'name': 'WSGI_APPLICATION'}
-)
+CONFIGURATION_FILENAME = 'config.yml'
+CONFIGURATION_LAST_GOOD_FILENAME = 'config_backup.yml'
diff --git a/mayan/apps/smart_settings/utils.py b/mayan/apps/smart_settings/utils.py
index 9d9d6dbc91..efe5ee820b 100644
--- a/mayan/apps/smart_settings/utils.py
+++ b/mayan/apps/smart_settings/utils.py
@@ -5,73 +5,369 @@ import os
 
 import yaml
 
-try:
-    from yaml import CSafeLoader as SafeLoader
-except ImportError:
-    from yaml import SafeLoader
+from mayan.apps.common.serialization import yaml_load
 
-from .literals import BOOTSTRAP_SETTING_LIST
+from .literals import (
+    CONFIGURATION_FILENAME, CONFIGURATION_LAST_GOOD_FILENAME
+)
 
 
-def get_default(name, fallback_default=None):
-    for item in BOOTSTRAP_SETTING_LIST:
-        if item['name'] == name:
-            return item.get('default', fallback_default)
+class SettingNamespaceSingleton(object):
+    """
+    Self hosting bootstrap setting class.
+    Allow managing setting in a compatible way before Mayan EDMS starts.
+    """
+    _setting_kwargs = {}
+    _settings = {}
 
-    return fallback_default
+    class SettingNotFound(Exception):
+        """Mostly a stand-in or typecast for KeyError for readability."""
 
-
-def get_environment_variables():
-    result = {}
-
-    for setting in BOOTSTRAP_SETTING_LIST:
-        environment_value = os.environ.get('MAYAN_{}'.format(setting['name']))
-        if environment_value:
-            environment_value = yaml.load(stream=environment_value, Loader=SafeLoader)
-            result[setting['name']] = environment_value
-
-    return result
-
-
-def get_environment_setting(name, fallback_default=None):
-    value = os.environ.get(
-        'MAYAN_{}'.format(name), get_default(
-            name=name, fallback_default=fallback_default
-        )
-    )
-
-    if value:
-        return yaml.load(stream=value, Loader=SafeLoader)
-
-
-def read_configuration_file(path):
-    try:
-        with open(path) as file_object:
-            file_object.seek(0, os.SEEK_END)
-            if file_object.tell():
-                file_object.seek(0)
-                try:
-                    return yaml.load(stream=file_object, Loader=SafeLoader)
-                except yaml.YAMLError as exception:
-                    exit(
-                        'Error loading configuration file: {}; {}'.format(
-                            path, exception
+    @classmethod
+    def load_config_file(cls, filepath):
+        try:
+            with open(filepath) as file_object:
+                file_object.seek(0, os.SEEK_END)
+                if file_object.tell():
+                    file_object.seek(0)
+                    try:
+                        return yaml_load(stream=file_object)
+                    except yaml.YAMLError as exception:
+                        exit(
+                            'Error loading configuration file: {}; {}'.format(
+                                filepath, exception
+                            )
                         )
-                    )
-    except IOError as exception:
-        if exception.errno == errno.ENOENT:
-            return {}  # No config file, return empty dictionary
+        except IOError as exception:
+            if exception.errno == errno.ENOENT:
+                # No config file, return empty dictionary
+                return {}
+            else:
+                raise
+
+    @classmethod
+    def register_setting(cls, name, klass, kwargs=None):
+        cls._settings[name] = klass
+        cls._setting_kwargs[name] = kwargs or {}
+
+    def __init__(self, global_symbol_table):
+        self.global_symbol_table = global_symbol_table
+        self.settings = {}
+        for name, klass in self.__class__._settings.items():
+            kwargs = self.__class__._setting_kwargs[name].copy()
+            kwargs['name'] = name
+            setting = klass(**kwargs)
+            setting.namespace = self
+            self.settings[name] = setting
+
+    def get_config_file_setting(self, name):
+        """
+        Wrapper for load_config_file to cache the result.
+        """
+        if hasattr(self, '_cache_file_data'):
+            file_data = self._cache_file_data
         else:
-            raise
+            filepath = self.get_setting_value(
+                name='CONFIGURATION_FILEPATH'
+            )
+
+            file_data = self.load_config_file(filepath=filepath)
+
+        try:
+            return file_data[name]
+        except KeyError:
+            raise SettingNamespaceSingleton.SettingNotFound
+
+    def get_setting_value(self, name):
+        """
+        Wrapper that calls the individual setting .get_value method.
+        Convenience method to allow returning setting values from the
+        namespace.
+        """
+        try:
+            return self.settings[name].get_value()
+        except KeyError:
+            raise SettingNamespaceSingleton.SettingNotFound
+
+    def get_values(self, only_critical=False):
+        """
+        Return a dictionary will all the settings and their respective
+        resolved values.
+        """
+        result = {}
+        for name, setting in self.settings.items():
+            # If only_critical is set to True load only the settings with
+            # the critical flag. Otherwise load all.
+            if only_critical and setting.critical or not only_critical:
+                try:
+                    result[name] = setting.get_value()
+                except SettingNamespaceSingleton.SettingNotFound:
+                    """
+                    Not critical, we just avoid adding it to the result
+                    dictionary.
+                    """
+
+        return result
+
+    def update_globals(self, only_critical=False):
+        """
+        Insert all resolved values into the symbol table of the caller.
+        """
+        result = self.get_values(only_critical=only_critical)
+        self.global_symbol_table.update(result)
 
 
-def yaml_loads(data, error_message=None):
-    if not error_message:
-        error_message = 'Error loading: {}; {}'
+class BaseSetting(object):
+    def __init__(
+        self, name, critical=False, has_default=False, default_value=None
+    ):
+        self.critical = critical
+        self.name = name
+        self.has_default = has_default
+        self.default_value = default_value
 
-    try:
-        return yaml.load(stream=data, Loader=SafeLoader)
-    except yaml.YAMLError as exception:
-        exit(
-            error_message.format(data, exception)
+    def _get_environment_value(self):
+        return os.environ.get(self.get_environment_name())
+
+    def get_default_value(self):
+        return self.default_value
+
+    def get_environment_name(self):
+        return 'MAYAN_{}'.format(self.name)
+
+    def get_value(self):
+        """
+        By default will try to get the value from the namespace symbol table,
+        then the configuration file, and finally from the environment.
+        """
+        try:
+            return self.namespace.global_symbol_table.get(
+                self.name, self.namespace.get_config_file_setting(name=self.name)
+            )
+        except SettingNamespaceSingleton.SettingNotFound:
+            return self.load_environment_value()
+
+    def load_environment_value(self):
+        value = self._get_environment_value()
+
+        if value:
+            try:
+                return yaml_load(stream=value)
+            except yaml.YAMLError as exception:
+                exit(
+                    'Error loading setting environment value: {}; {}'.format(
+                        self.name, exception
+                    )
+                )
+        else:
+            if self.has_default:
+                return self.get_default_value()
+            else:
+                raise SettingNamespaceSingleton.SettingNotFound
+
+
+class FilesystemBootstrapSetting(BaseSetting):
+    def __init__(self, name, critical=False, path_parts=None):
+        self.critical = critical
+        self.has_default = True
+        self.name = name
+        self.path_parts = path_parts
+
+    def get_default_value(self):
+        """
+        The default value of this setting class is not static but calculated.
+        """
+        return os.path.join(
+            # Can't use BASE_DIR from django.conf.settings
+            # Use it from the global_symbol_table which should be the same
+            self.namespace.global_symbol_table.get('BASE_DIR'), *self.path_parts
         )
+
+    def get_value(self):
+        """
+        It is not possible to look for this setting in the config file
+        because not even the config file setup has completed.
+        This setting only supports being set from the environment.
+        """
+        return self.load_environment_value()
+
+
+# FilesystemBootstrapSetting setting
+
+SettingNamespaceSingleton.register_setting(
+    name='CONFIGURATION_FILEPATH', klass=FilesystemBootstrapSetting,
+    kwargs={
+        'critical': True, 'path_parts': ('media', CONFIGURATION_FILENAME,)
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='CONFIGURATION_LAST_GOOD_FILEPATH', klass=FilesystemBootstrapSetting,
+    kwargs={
+        'critical': True, 'path_parts': ('media', CONFIGURATION_LAST_GOOD_FILENAME,)
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='MEDIA_ROOT', klass=FilesystemBootstrapSetting, kwargs={
+        'critical': True, 'path_parts': ('media',)
+    }
+)
+
+# Normal settings
+
+SettingNamespaceSingleton.register_setting(
+    name='ALLOWED_HOSTS', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': ['127.0.0.1', 'localhost', '[::1]']
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='APPEND_SLASH', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='AUTH_PASSWORD_VALIDATORS', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATA_UPLOAD_MAX_MEMORY_SIZE', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASES', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DEBUG', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': False
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DEFAULT_FROM_EMAIL', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='DISALLOWED_USER_AGENTS', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_BACKEND', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_HOST', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_HOST_PASSWORD', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_HOST_USER', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_PORT', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_TIMEOUT', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_USE_SSL', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='EMAIL_USE_TLS', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='FILE_UPLOAD_MAX_MEMORY_SIZE', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='INTERNAL_IPS', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': ['127.0.0.1']
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='LOGIN_REDIRECT_URL', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': 'common:home'
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='LOGIN_URL', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': 'authentication:login_view'
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='LOGOUT_REDIRECT_URL', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': 'authentication:login_view'
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='LANGUAGES', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='LANGUAGE_CODE', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='STATIC_URL', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='STATICFILES_STORAGE', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='TIME_ZONE', klass=BaseSetting,
+)
+SettingNamespaceSingleton.register_setting(
+    name='WSGI_APPLICATION', klass=BaseSetting,
+)
+
+# Celery
+
+SettingNamespaceSingleton.register_setting(
+    name='CELERY_TASK_ALWAYS_EAGER', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': True
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='CELERY_BROKER_URL', klass=BaseSetting
+)
+SettingNamespaceSingleton.register_setting(
+    name='CELERY_RESULT_BACKEND', klass=BaseSetting
+)
+
+# Mayan
+
+SettingNamespaceSingleton.register_setting(
+    name='COMMON_DISABLED_APPS', klass=BaseSetting, kwargs={
+        'critical': True, 'has_default': True, 'default_value': ()
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='COMMON_EXTRA_APPS', klass=BaseSetting, kwargs={
+        'critical': True, 'has_default': True, 'default_value': ()
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_ENGINE', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_NAME', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_USER', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_PASSWORD', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_HOST', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_PORT', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
+SettingNamespaceSingleton.register_setting(
+    name='DATABASE_CONN_MAX_AGE', klass=BaseSetting, kwargs={
+        'has_default': True, 'default_value': None
+    }
+)
diff --git a/mayan/settings/base.py b/mayan/settings/base.py
index 546d8ad072..24efde7066 100644
--- a/mayan/settings/base.py
+++ b/mayan/settings/base.py
@@ -1,14 +1,3 @@
-"""
-Django settings for mayan10 project.
-
-Generated by 'django-admin startproject' using Django 1.10.4.
-
-For more information on this file, see
-https://docs.djangoproject.com/en/1.10/topics/settings/
-
-For the full list of settings and their values, see
-https://docs.djangoproject.com/en/1.10/ref/settings/
-"""
 from __future__ import unicode_literals
 
 import os
@@ -17,15 +6,9 @@ import sys
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.translation import ugettext_lazy as _
 
-from mayan.apps.smart_settings.literals import BOOTSTRAP_SETTING_LIST
-from mayan.apps.smart_settings.utils import (
-    get_environment_setting, get_environment_variables, read_configuration_file
-)
+from mayan.apps.smart_settings.utils import SettingNamespaceSingleton
 
-from .literals import (
-    CONFIGURATION_FILENAME, CONFIGURATION_LAST_GOOD_FILENAME,
-    DEFAULT_SECRET_KEY, SECRET_KEY_FILENAME, SYSTEM_DIR
-)
+from .literals import DEFAULT_SECRET_KEY, SECRET_KEY_FILENAME, SYSTEM_DIR
 
 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 
@@ -34,9 +17,17 @@ BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 # Quick-start development settings - unsuitable for production
 # See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/
 
-MEDIA_ROOT = get_environment_setting(
-    name='MEDIA_ROOT', fallback_default=os.path.join(BASE_DIR, 'media')
-)
+setting_namespace = SettingNamespaceSingleton(global_symbol_table=globals())
+if 'revertsettings' in sys.argv:
+    setting_namespace.update_globals(only_critical=True)
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.sqlite3',
+            'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),  # NOQA: F821
+        }
+    }
+else:
+    setting_namespace.update_globals()
 
 # SECURITY WARNING: keep the secret key used in production secret!
 environment_secret_key = os.environ.get('MAYAN_SECRET_KEY')
@@ -44,15 +35,12 @@ if environment_secret_key:
     SECRET_KEY = environment_secret_key
 else:
     try:
-        with open(os.path.join(MEDIA_ROOT, SYSTEM_DIR, SECRET_KEY_FILENAME)) as file_object:
+        with open(os.path.join(MEDIA_ROOT, SYSTEM_DIR, SECRET_KEY_FILENAME)) as file_object:  # NOQA: F821
             SECRET_KEY = file_object.read().strip()
     except IOError:
         SECRET_KEY = DEFAULT_SECRET_KEY
 
 # SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = get_environment_setting(name='DEBUG')
-
-ALLOWED_HOSTS = get_environment_setting(name='ALLOWED_HOSTS')
 
 # Application definition
 
@@ -243,7 +231,7 @@ LANGUAGES = (
 SITE_ID = 1
 
 STATIC_ROOT = os.environ.get(
-    'MAYAN_STATIC_ROOT', os.path.join(MEDIA_ROOT, 'static')
+    'MAYAN_STATIC_ROOT', os.path.join(MEDIA_ROOT, 'static')  # NOQA: F821
 )
 
 STATICFILES_FINDERS = (
@@ -255,13 +243,6 @@ STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
 
 TEST_RUNNER = 'mayan.apps.common.tests.runner.MayanTestRunner'
 
-# --------- Django -------------------
-
-LOGIN_URL = get_environment_setting(name='LOGIN_URL')
-LOGIN_REDIRECT_URL = get_environment_setting(name='LOGIN_REDIRECT_URL')
-LOGOUT_REDIRECT_URL = get_environment_setting(name='LOGOUT_REDIRECT_URL')
-INTERNAL_IPS = get_environment_setting(name='INTERNAL_IPS')
-
 # ---------- Django REST framework -----------
 
 REST_FRAMEWORK = {
@@ -283,12 +264,6 @@ PAGINATION_SETTINGS = {
 
 # ----------- Celery ----------
 
-CELERY_BROKER_URL = get_environment_setting(name='CELERY_BROKER_URL')
-CELERY_RESULT_BACKEND = get_environment_setting(name='CELERY_RESULT_BACKEND')
-CELERY_TASK_ALWAYS_EAGER = get_environment_setting(
-    name='CELERY_TASK_ALWAYS_EAGER'
-)
-
 CELERY_ACCEPT_CONTENT = ('json',)
 CELERY_BEAT_SCHEDULE = {}
 CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers.DatabaseScheduler'
@@ -329,54 +304,6 @@ SWAGGER_SETTINGS = {
 AJAX_REDIRECT_CODE = 278
 
 BASE_INSTALLED_APPS = INSTALLED_APPS
-COMMON_EXTRA_APPS = ()
-COMMON_DISABLED_APPS = ()
-
-CONFIGURATION_FILEPATH = get_environment_setting(
-    name='CONFIGURATION_FILEPATH', fallback_default=os.path.join(
-        MEDIA_ROOT, CONFIGURATION_FILENAME
-    )
-)
-
-CONFIGURATION_LAST_GOOD_FILEPATH = get_environment_setting(
-    name='CONFIGURATION_LAST_GOOD_FILEPATH', fallback_default=os.path.join(
-        MEDIA_ROOT, CONFIGURATION_LAST_GOOD_FILENAME
-    )
-)
-
-if 'revertsettings' not in sys.argv:
-    configuration_result = read_configuration_file(CONFIGURATION_FILEPATH)
-    environment_result = get_environment_variables()
-
-    for setting in BOOTSTRAP_SETTING_LIST:
-        if setting['name'] in configuration_result:
-            globals().update(
-                {setting['name']: configuration_result[setting['name']]}
-            )
-        elif setting['name'] in environment_result:
-            globals().update(
-                {setting['name']: environment_result[setting['name']]}
-            )
-        else:
-            # Apply the default only if it has not yet been defined previously
-            # in this module.
-            if setting['name'] not in globals():
-                globals().update(
-                    {
-                        setting['name']: get_environment_setting(
-                            name=setting['name']
-                        )
-                    }
-                )
-else:
-    # Safe fallback to allow the revertsettings command to complete.
-    DATABASES = {
-        'default': {
-            'ENGINE': 'django.db.backends.sqlite3',
-            'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),
-        }
-    }
-
 
 for app in INSTALLED_APPS:
     if 'mayan.apps.{}'.format(app) in BASE_INSTALLED_APPS:
@@ -385,32 +312,31 @@ for app in INSTALLED_APPS:
             'in https://docs.mayan-edms.com/releases/3.2.html#backward-incompatible-changes'
         )
 
-
-for APP in (COMMON_EXTRA_APPS or ()):
+for APP in (COMMON_EXTRA_APPS or ()):  # NOQA: F821
     INSTALLED_APPS = INSTALLED_APPS + (APP,)
 
 
 INSTALLED_APPS = [
-    APP for APP in INSTALLED_APPS if APP not in (COMMON_DISABLED_APPS or ())
+    APP for APP in INSTALLED_APPS if APP not in (COMMON_DISABLED_APPS or ())  # NOQA: F821
 ]
 
 if not DATABASES:
-    if DATABASE_ENGINE:
+    if DATABASE_ENGINE:  # NOQA: F821
         DATABASES = {
             'default': {
-                'ENGINE': DATABASE_ENGINE,
-                'NAME': DATABASE_NAME,
-                'USER': DATABASE_USER,
-                'PASSWORD': DATABASE_PASSWORD,
-                'HOST': DATABASE_HOST,
-                'PORT': DATABASE_PORT,
-                'CONN_MAX_AGE': DATABASE_CONN_MAX_AGE
+                'ENGINE': DATABASE_ENGINE,  # NOQA: F821
+                'NAME': DATABASE_NAME,  # NOQA: F821
+                'USER': DATABASE_USER,  # NOQA: F821
+                'PASSWORD': DATABASE_PASSWORD,  # NOQA: F821
+                'HOST': DATABASE_HOST,  # NOQA: F821
+                'PORT': DATABASE_PORT,  # NOQA: F821
+                'CONN_MAX_AGE': DATABASE_CONN_MAX_AGE  # NOQA: F821
             }
         }
     else:
         DATABASES = {
             'default': {
                 'ENGINE': 'django.db.backends.sqlite3',
-                'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),
+                'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),  # NOQA: F821
             }
         }
diff --git a/mayan/settings/development.py b/mayan/settings/development.py
index 8668627db3..794765fafb 100644
--- a/mayan/settings/development.py
+++ b/mayan/settings/development.py
@@ -1,33 +1,28 @@
 from __future__ import absolute_import, unicode_literals
 
-from mayan.apps.smart_settings.utils import get_environment_setting
-
 from . import *  # NOQA
 
 ALLOWED_HOSTS = ['*']
 
 DEBUG = True
 
-CELERY_TASK_ALWAYS_EAGER = get_environment_setting(
-    name='CELERY_TASK_ALWAYS_EAGER', fallback_default='true'
-)
-CELERY_TASK_EAGER_PROPAGATES = CELERY_TASK_ALWAYS_EAGER
+CELERY_TASK_EAGER_PROPAGATES = CELERY_TASK_ALWAYS_EAGER  # NOQA: F405
 
 EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
 
-if 'rosetta' not in INSTALLED_APPS:
+if 'rosetta' not in INSTALLED_APPS:   # NOQA: F405
     try:
-        import rosetta
+        import rosetta  # NOQA: F401
     except ImportError:
         pass
     else:
-        INSTALLED_APPS += (
+        INSTALLED_APPS += (  # NOQA: F405
             'rosetta',
         )
 
 if 'django_extensions' not in INSTALLED_APPS:
     try:
-        import django_extensions
+        import django_extensions  # NOQA: F401
     except ImportError:
         pass
     else:
@@ -37,7 +32,7 @@ if 'django_extensions' not in INSTALLED_APPS:
 
 ROOT_URLCONF = 'mayan.urls.development'
 
-TEMPLATES[0]['OPTIONS']['loaders'] = (
+TEMPLATES[0]['OPTIONS']['loaders'] = (  # NOQA: F405
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 )
diff --git a/mayan/settings/development_ddt.py b/mayan/settings/development_ddt.py
index 55dad05548..a5d9fe948e 100644
--- a/mayan/settings/development_ddt.py
+++ b/mayan/settings/development_ddt.py
@@ -6,11 +6,11 @@ from .development import *  # NOQA
 # see https://github.com/django-debug-toolbar/django-debug-toolbar/issues/524
 DEBUG_TOOLBAR_PATCH_SETTINGS = False
 
-if 'debug_toolbar' not in INSTALLED_APPS:
-    INSTALLED_APPS += (
+if 'debug_toolbar' not in INSTALLED_APPS:  # NOQA: F405
+    INSTALLED_APPS += (  # NOQA: F405
         'debug_toolbar',
     )
 
 MIDDLEWARE_CLASSES = (
     'debug_toolbar.middleware.DebugToolbarMiddleware',
-) + MIDDLEWARE_CLASSES
+) + MIDDLEWARE_CLASSES  # NOQA: F405
diff --git a/mayan/settings/literals.py b/mayan/settings/literals.py
index b30b20544b..fd4ea1e65a 100644
--- a/mayan/settings/literals.py
+++ b/mayan/settings/literals.py
@@ -3,6 +3,3 @@ from __future__ import unicode_literals
 DEFAULT_SECRET_KEY = 'secret-key-missing!'
 SECRET_KEY_FILENAME = 'SECRET_KEY'
 SYSTEM_DIR = 'system'
-
-CONFIGURATION_FILENAME = 'config.yml'
-CONFIGURATION_LAST_GOOD_FILENAME = 'config_backup.yml'
diff --git a/mayan/settings/production.py b/mayan/settings/production.py
index fe7ba1a037..ecc9b20814 100644
--- a/mayan/settings/production.py
+++ b/mayan/settings/production.py
@@ -4,7 +4,7 @@ from . import *  # NOQA
 
 CELERY_TASK_ALWAYS_EAGER = False
 
-TEMPLATES[0]['OPTIONS']['loaders'] = (
+TEMPLATES[0]['OPTIONS']['loaders'] = (  # NOQA: F405
     (
         'django.template.loaders.cached.Loader', (
             'django.template.loaders.filesystem.Loader',
diff --git a/mayan/settings/testing/base.py b/mayan/settings/testing/base.py
index 4eb37026c1..8a4475cb7a 100644
--- a/mayan/settings/testing/base.py
+++ b/mayan/settings/testing/base.py
@@ -12,7 +12,7 @@ DOCUMENT_PARSING_AUTO_PARSING = False
 
 FILE_METADATA_AUTO_PROCESS = False
 
-INSTALLED_APPS += ('test_without_migrations',)
+INSTALLED_APPS += ('test_without_migrations',)  # NOQA: F405
 
 INSTALLED_APPS = [
     cls for cls in INSTALLED_APPS if cls != 'whitenoise.runserver_nostatic'
@@ -21,7 +21,7 @@ INSTALLED_APPS = [
 # Remove whitenoise from middlewares. Causes out of memory errors during test
 # suit
 MIDDLEWARE = [
-    cls for cls in MIDDLEWARE if cls != 'whitenoise.middleware.WhiteNoiseMiddleware'
+    cls for cls in MIDDLEWARE if cls != 'whitenoise.middleware.WhiteNoiseMiddleware'  # NOQA: F405
 ]
 
 # Remove middlewares not used for tests
@@ -48,7 +48,7 @@ PASSWORD_HASHERS = (
 STATICFILES_STORAGE = None
 
 # Cache templates in memory
-TEMPLATES[0]['OPTIONS']['loaders'] = (
+TEMPLATES[0]['OPTIONS']['loaders'] = (  # NOQA: F405
     (
         'django.template.loaders.cached.Loader', (
             'django.template.loaders.filesystem.Loader',
diff --git a/mayan/settings/testing/gitlab-ci/base.py b/mayan/settings/testing/gitlab-ci/base.py
index 738748eb99..eb890b44b0 100644
--- a/mayan/settings/testing/gitlab-ci/base.py
+++ b/mayan/settings/testing/gitlab-ci/base.py
@@ -3,4 +3,3 @@ from __future__ import unicode_literals
 from ..base import *  # NOQA
 
 SIGNATURES_GPG_PATH = '/usr/bin/gpg1'
-