100 files changed, 1662 insertions, 526 deletions

diff --git a/bot/__main__.py b/bot/__main__.py
index fe2cf90e6..8770ac31b 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -9,7 +9,9 @@ from sentry_sdk.integrations.redis import RedisIntegration
 
 from bot import constants, patches
 from bot.bot import Bot
+from bot.utils.extensions import EXTENSIONS
 
+# Set up Sentry.
 sentry_logging = LoggingIntegration(
     level=logging.DEBUG,
     event_level=logging.WARNING
@@ -24,6 +26,7 @@ sentry_sdk.init(
     ]
 )
 
+# Instantiate the bot.
 allowed_roles = [discord.Object(id_) for id_ in constants.MODERATION_ROLES]
 bot = Bot(
     command_prefix=when_mentioned_or(constants.Bot.prefix),
@@ -33,50 +36,13 @@ bot = Bot(
     allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles)
 )
 
-# Internal/debug
-bot.load_extension("bot.cogs.config_verifier")
-bot.load_extension("bot.cogs.error_handler")
-bot.load_extension("bot.cogs.filtering")
-bot.load_extension("bot.cogs.logging")
-bot.load_extension("bot.cogs.security")
+# Load extensions.
+extensions = set(EXTENSIONS)  # Create a mutable copy.
+if not constants.HelpChannels.enable:
+    extensions.remove("bot.exts.help_channels")
 
-# Commands, etc
-bot.load_extension("bot.cogs.antimalware")
-bot.load_extension("bot.cogs.antispam")
-bot.load_extension("bot.cogs.bot")
-bot.load_extension("bot.cogs.clean")
-bot.load_extension("bot.cogs.doc")
-bot.load_extension("bot.cogs.extensions")
-bot.load_extension("bot.cogs.help")
-bot.load_extension("bot.cogs.verification")
-
-# Feature cogs
-bot.load_extension("bot.cogs.alias")
-bot.load_extension("bot.cogs.defcon")
-bot.load_extension("bot.cogs.dm_relay")
-bot.load_extension("bot.cogs.duck_pond")
-bot.load_extension("bot.cogs.eval")
-bot.load_extension("bot.cogs.filter_lists")
-bot.load_extension("bot.cogs.information")
-bot.load_extension("bot.cogs.jams")
-bot.load_extension("bot.cogs.moderation")
-bot.load_extension("bot.cogs.off_topic_names")
-bot.load_extension("bot.cogs.python_news")
-bot.load_extension("bot.cogs.reddit")
-bot.load_extension("bot.cogs.reminders")
-bot.load_extension("bot.cogs.site")
-bot.load_extension("bot.cogs.snekbox")
-bot.load_extension("bot.cogs.source")
-bot.load_extension("bot.cogs.stats")
-bot.load_extension("bot.cogs.sync")
-bot.load_extension("bot.cogs.tags")
-bot.load_extension("bot.cogs.token_remover")
-bot.load_extension("bot.cogs.utils")
-bot.load_extension("bot.cogs.watchchannels")
-bot.load_extension("bot.cogs.webhook_remover")
-
-if constants.HelpChannels.enable:
-    bot.load_extension("bot.cogs.help_channels")
+for extension in extensions:
+    bot.load_extension(extension)
 
 # Apply `message_edited_at` patch if discord.py did not yet release a bug fix.
 if not hasattr(discord.message.Message, '_handle_edited_timestamp'):
diff --git a/bot/cogs/moderation/__init__.py b/bot/cogs/moderation/__init__.py
deleted file mode 100644
index 995187ef0..000000000
--- a/bot/cogs/moderation/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from bot.bot import Bot
-from .incidents import Incidents
-from .infractions import Infractions
-from .management import ModManagement
-from .modlog import ModLog
-from .silence import Silence
-from .slowmode import Slowmode
-from .superstarify import Superstarify
-
-
-def setup(bot: Bot) -> None:
-    """Load the Incidents, Infractions, ModManagement, ModLog, Silence, Slowmode and Superstarify cogs."""
-    bot.add_cog(Incidents(bot))
-    bot.add_cog(Infractions(bot))
-    bot.add_cog(ModLog(bot))
-    bot.add_cog(ModManagement(bot))
-    bot.add_cog(Silence(bot))
-    bot.add_cog(Slowmode(bot))
-    bot.add_cog(Superstarify(bot))
diff --git a/bot/cogs/sync/__init__.py b/bot/cogs/sync/__init__.py
deleted file mode 100644
index fe7df4e9b..000000000
--- a/bot/cogs/sync/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from bot.bot import Bot
-from .cog import Sync
-
-
-def setup(bot: Bot) -> None:
-    """Load the Sync cog."""
-    bot.add_cog(Sync(bot))
diff --git a/bot/cogs/verification.py b/bot/cogs/verification.py
deleted file mode 100644
index 300c7f315..000000000
--- a/bot/cogs/verification.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import logging
-from contextlib import suppress
-
-from discord import Colour, Forbidden, Message, NotFound, Object
-from discord.ext.commands import Cog, Context, command
-
-from bot import constants
-from bot.bot import Bot
-from bot.cogs.moderation import ModLog
-from bot.decorators import has_no_roles, in_whitelist
-from bot.utils.checks import InWhitelistCheckFailure, has_no_roles_check
-
-log = logging.getLogger(__name__)
-
-WELCOME_MESSAGE = f"""
-Hello! Welcome to the server, and thanks for verifying yourself!
-
-For your records, these are the documents you accepted:
-
-`1)` Our rules, here: <https://pythondiscord.com/pages/rules>
-`2)` Our privacy policy, here: <https://pythondiscord.com/pages/privacy> - you can find information on how to have \
-your information removed here as well.
-
-Feel free to review them at any point!
-
-Additionally, if you'd like to receive notifications for the announcements \
-we post in <#{constants.Channels.announcements}>
-from time to time, you can send `!subscribe` to <#{constants.Channels.bot_commands}> at any time \
-to assign yourself the **Announcements** role. We'll mention this role every time we make an announcement.
-
-If you'd like to unsubscribe from the announcement notifications, simply send `!unsubscribe` to \
-<#{constants.Channels.bot_commands}>.
-"""
-
-BOT_MESSAGE_DELETE_DELAY = 10
-
-
-class Verification(Cog):
-    """User verification and role self-management."""
-
-    def __init__(self, bot: Bot):
-        self.bot = bot
-
-    @property
-    def mod_log(self) -> ModLog:
-        """Get currently loaded ModLog cog instance."""
-        return self.bot.get_cog("ModLog")
-
-    @Cog.listener()
-    async def on_message(self, message: Message) -> None:
-        """Check new message event for messages to the checkpoint channel & process."""
-        if message.channel.id != constants.Channels.verification:
-            return  # Only listen for #checkpoint messages
-
-        if message.author.bot:
-            # They're a bot, delete their message after the delay.
-            await message.delete(delay=BOT_MESSAGE_DELETE_DELAY)
-            return
-
-        # if a user mentions a role or guild member
-        # alert the mods in mod-alerts channel
-        if message.mentions or message.role_mentions:
-            log.debug(
-                f"{message.author} mentioned one or more users "
-                f"and/or roles in {message.channel.name}"
-            )
-
-            embed_text = (
-                f"{message.author.mention} sent a message in "
-                f"{message.channel.mention} that contained user and/or role mentions."
-                f"\n\n**Original message:**\n>>> {message.content}"
-            )
-
-            # Send pretty mod log embed to mod-alerts
-            await self.mod_log.send_log_message(
-                icon_url=constants.Icons.filtering,
-                colour=Colour(constants.Colours.soft_red),
-                title=f"User/Role mentioned in {message.channel.name}",
-                text=embed_text,
-                thumbnail=message.author.avatar_url_as(static_format="png"),
-                channel_id=constants.Channels.mod_alerts,
-            )
-
-        ctx: Context = await self.bot.get_context(message)
-        if ctx.command is not None and ctx.command.name == "accept":
-            return
-
-        if any(r.id == constants.Roles.verified for r in ctx.author.roles):
-            log.info(
-                f"{ctx.author} posted '{ctx.message.content}' "
-                "in the verification channel, but is already verified."
-            )
-            return
-
-        log.debug(
-            f"{ctx.author} posted '{ctx.message.content}' in the verification "
-            "channel. We are providing instructions how to verify."
-        )
-        await ctx.send(
-            f"{ctx.author.mention} Please type `!accept` to verify that you accept our rules, "
-            f"and gain access to the rest of the server.",
-            delete_after=20
-        )
-
-        log.trace(f"Deleting the message posted by {ctx.author}")
-        with suppress(NotFound):
-            await ctx.message.delete()
-
-    @command(name='accept', aliases=('verify', 'verified', 'accepted'), hidden=True)
-    @has_no_roles(constants.Roles.verified)
-    @in_whitelist(channels=(constants.Channels.verification,))
-    async def accept_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
-        """Accept our rules and gain access to the rest of the server."""
-        log.debug(f"{ctx.author} called !accept. Assigning the 'Developer' role.")
-        await ctx.author.add_roles(Object(constants.Roles.verified), reason="Accepted the rules")
-        try:
-            await ctx.author.send(WELCOME_MESSAGE)
-        except Forbidden:
-            log.info(f"Sending welcome message failed for {ctx.author}.")
-        finally:
-            log.trace(f"Deleting accept message by {ctx.author}.")
-            with suppress(NotFound):
-                self.mod_log.ignore(constants.Event.message_delete, ctx.message.id)
-                await ctx.message.delete()
-
-    @command(name='subscribe')
-    @in_whitelist(channels=(constants.Channels.bot_commands,))
-    async def subscribe_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
-        """Subscribe to announcement notifications by assigning yourself the role."""
-        has_role = False
-
-        for role in ctx.author.roles:
-            if role.id == constants.Roles.announcements:
-                has_role = True
-                break
-
-        if has_role:
-            await ctx.send(f"{ctx.author.mention} You're already subscribed!")
-            return
-
-        log.debug(f"{ctx.author} called !subscribe. Assigning the 'Announcements' role.")
-        await ctx.author.add_roles(Object(constants.Roles.announcements), reason="Subscribed to announcements")
-
-        log.trace(f"Deleting the message posted by {ctx.author}.")
-
-        await ctx.send(
-            f"{ctx.author.mention} Subscribed to <#{constants.Channels.announcements}> notifications.",
-        )
-
-    @command(name='unsubscribe')
-    @in_whitelist(channels=(constants.Channels.bot_commands,))
-    async def unsubscribe_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
-        """Unsubscribe from announcement notifications by removing the role from yourself."""
-        has_role = False
-
-        for role in ctx.author.roles:
-            if role.id == constants.Roles.announcements:
-                has_role = True
-                break
-
-        if not has_role:
-            await ctx.send(f"{ctx.author.mention} You're already unsubscribed!")
-            return
-
-        log.debug(f"{ctx.author} called !unsubscribe. Removing the 'Announcements' role.")
-        await ctx.author.remove_roles(Object(constants.Roles.announcements), reason="Unsubscribed from announcements")
-
-        log.trace(f"Deleting the message posted by {ctx.author}.")
-
-        await ctx.send(
-            f"{ctx.author.mention} Unsubscribed from <#{constants.Channels.announcements}> notifications."
-        )
-
-    # This cannot be static (must have a __func__ attribute).
-    async def cog_command_error(self, ctx: Context, error: Exception) -> None:
-        """Check for & ignore any InWhitelistCheckFailure."""
-        if isinstance(error, InWhitelistCheckFailure):
-            error.handled = True
-
-    @staticmethod
-    async def bot_check(ctx: Context) -> bool:
-        """Block any command within the verification channel that is not !accept."""
-        is_verification = ctx.channel.id == constants.Channels.verification
-        if is_verification and await has_no_roles_check(ctx, *constants.MODERATION_ROLES):
-            return ctx.command.name == "accept"
-        else:
-            return True
-
-
-def setup(bot: Bot) -> None:
-    """Load the Verification cog."""
-    bot.add_cog(Verification(bot))
diff --git a/bot/cogs/watchchannels/__init__.py b/bot/cogs/watchchannels/__init__.py
deleted file mode 100644
index 69d118df6..000000000
--- a/bot/cogs/watchchannels/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from bot.bot import Bot
-from .bigbrother import BigBrother
-from .talentpool import TalentPool
-
-
-def setup(bot: Bot) -> None:
-    """Load the BigBrother and TalentPool cogs."""
-    bot.add_cog(BigBrother(bot))
-    bot.add_cog(TalentPool(bot))
diff --git a/bot/constants.py b/bot/constants.py
index 17fe34e95..17f14fec0 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -461,6 +461,7 @@ class Roles(metaclass=YAMLGetter):
     partners: int
     python_community: int
     team_leaders: int
+    unverified: int
     verified: int  # This is the Developers role on PyDis, here named verified for readability reasons.
 
 
@@ -468,6 +469,7 @@ class Guild(metaclass=YAMLGetter):
     section = "guild"
 
     id: int
+    invite: str  # Discord invite, gets embedded in chat
     moderation_channels: List[int]
     moderation_roles: List[int]
     modlog_blacklist: List[int]
@@ -578,6 +580,16 @@ class PythonNews(metaclass=YAMLGetter):
     webhook: int
 
 
+class Verification(metaclass=YAMLGetter):
+    section = "verification"
+
+    unverified_after: int
+    kicked_after: int
+    reminder_frequency: int
+    bot_message_delete_delay: int
+    kick_confirmation_threshold: float
+
+
 class Event(Enum):
     """
     Event names. This does not include every event (for example, raw
diff --git a/bot/cogs/__init__.py b/bot/exts/__init__.py
index e69de29bb..e69de29bb 100644
--- a/bot/cogs/__init__.py
+++ b/bot/exts/__init__.py
diff --git a/tests/bot/cogs/__init__.py b/bot/exts/backend/__init__.py
index e69de29bb..e69de29bb 100644
--- a/tests/bot/cogs/__init__.py
+++ b/bot/exts/backend/__init__.py
diff --git a/bot/cogs/alias.py b/bot/exts/backend/alias.py
index c6ba8d6f3..c6ba8d6f3 100644
--- a/bot/cogs/alias.py
+++ b/bot/exts/backend/alias.py
diff --git a/bot/cogs/config_verifier.py b/bot/exts/backend/config_verifier.py
index d72c6c22e..d72c6c22e 100644
--- a/bot/cogs/config_verifier.py
+++ b/bot/exts/backend/config_verifier.py
diff --git a/bot/cogs/error_handler.py b/bot/exts/backend/error_handler.py
index f9d4de638..f9d4de638 100644
--- a/bot/cogs/error_handler.py
+++ b/bot/exts/backend/error_handler.py
diff --git a/bot/cogs/logging.py b/bot/exts/backend/logging.py
index 94fa2b139..94fa2b139 100644
--- a/bot/cogs/logging.py
+++ b/bot/exts/backend/logging.py
diff --git a/bot/exts/backend/sync/__init__.py b/bot/exts/backend/sync/__init__.py
new file mode 100644
index 000000000..829098f79
--- /dev/null
+++ b/bot/exts/backend/sync/__init__.py
@@ -0,0 +1,8 @@
+from bot.bot import Bot
+
+
+def setup(bot: Bot) -> None:
+    """Load the Sync cog."""
+    # Defer import to reduce side effects from importing the sync package.
+    from bot.exts.backend.sync._cog import Sync
+    bot.add_cog(Sync(bot))
diff --git a/bot/cogs/sync/cog.py b/bot/exts/backend/sync/_cog.py
index 5ace957e7..6e85e2b7d 100644
--- a/bot/cogs/sync/cog.py
+++ b/bot/exts/backend/sync/_cog.py
@@ -8,7 +8,7 @@ from discord.ext.commands import Cog, Context
 from bot import constants
 from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.cogs.sync import syncers
+from bot.exts.backend.sync import _syncers
 
 log = logging.getLogger(__name__)
 
@@ -18,8 +18,8 @@ class Sync(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self.role_syncer = syncers.RoleSyncer(self.bot)
-        self.user_syncer = syncers.UserSyncer(self.bot)
+        self.role_syncer = _syncers.RoleSyncer(self.bot)
+        self.user_syncer = _syncers.UserSyncer(self.bot)
 
         self.bot.loop.create_task(self.sync_guild())
 
diff --git a/bot/cogs/sync/syncers.py b/bot/exts/backend/sync/_syncers.py
index f7ba811bc..f7ba811bc 100644
--- a/bot/cogs/sync/syncers.py
+++ b/bot/exts/backend/sync/_syncers.py
diff --git a/tests/bot/cogs/moderation/__init__.py b/bot/exts/filters/__init__.py
index e69de29bb..e69de29bb 100644
--- a/tests/bot/cogs/moderation/__init__.py
+++ b/bot/exts/filters/__init__.py
diff --git a/bot/cogs/antimalware.py b/bot/exts/filters/antimalware.py
index 7894ec48f..7894ec48f 100644
--- a/bot/cogs/antimalware.py
+++ b/bot/exts/filters/antimalware.py
diff --git a/bot/cogs/antispam.py b/bot/exts/filters/antispam.py
index 3ad487d8c..2e7e32d9a 100644
--- a/bot/cogs/antispam.py
+++ b/bot/exts/filters/antispam.py
@@ -11,7 +11,6 @@ from discord.ext.commands import Cog
 
 from bot import rules
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
 from bot.constants import (
     AntiSpam as AntiSpamConfig, Channels,
     Colours, DEBUG_MODE, Event, Filter,
@@ -19,6 +18,7 @@ from bot.constants import (
     STAFF_ROLES,
 )
 from bot.converters import Duration
+from bot.exts.moderation.modlog import ModLog
 from bot.utils.messages import send_attachments
 
 
diff --git a/bot/cogs/filter_lists.py b/bot/exts/filters/filter_lists.py
index 232c1e48b..232c1e48b 100644
--- a/bot/cogs/filter_lists.py
+++ b/bot/exts/filters/filter_lists.py
diff --git a/bot/cogs/filtering.py b/bot/exts/filters/filtering.py
index 99b659bff..2751ed7f6 100644
--- a/bot/cogs/filtering.py
+++ b/bot/exts/filters/filtering.py
@@ -13,11 +13,11 @@ from discord.utils import escape_markdown
 
 from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
 from bot.constants import (
     Channels, Colours,
     Filter, Icons, URLs
 )
+from bot.exts.moderation.modlog import ModLog
 from bot.utils.redis_cache import RedisCache
 from bot.utils.regex import INVITE_RE
 from bot.utils.scheduling import Scheduler
diff --git a/bot/cogs/security.py b/bot/exts/filters/security.py
index c680c5e27..c680c5e27 100644
--- a/bot/cogs/security.py
+++ b/bot/exts/filters/security.py
diff --git a/bot/cogs/token_remover.py b/bot/exts/filters/token_remover.py
index ef979f222..0eda3dc6a 100644
--- a/bot/cogs/token_remover.py
+++ b/bot/exts/filters/token_remover.py
@@ -9,8 +9,8 @@ from discord.ext.commands import Cog
 
 from bot import utils
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
 from bot.constants import Channels, Colours, Event, Icons
+from bot.exts.moderation.modlog import ModLog
 
 log = logging.getLogger(__name__)
 
diff --git a/bot/cogs/webhook_remover.py b/bot/exts/filters/webhook_remover.py
index 5812da87c..ca126ebf5 100644
--- a/bot/cogs/webhook_remover.py
+++ b/bot/exts/filters/webhook_remover.py
@@ -5,8 +5,8 @@ from discord import Colour, Message, NotFound
 from discord.ext.commands import Cog
 
 from bot.bot import Bot
-from bot.cogs.moderation.modlog import ModLog
 from bot.constants import Channels, Colours, Event, Icons
+from bot.exts.moderation.modlog import ModLog
 
 WEBHOOK_URL_RE = re.compile(r"((?:https?://)?discord(?:app)?\.com/api/webhooks/\d+/)\S+/?", re.IGNORECASE)
 
diff --git a/tests/bot/cogs/sync/__init__.py b/bot/exts/fun/__init__.py
index e69de29bb..e69de29bb 100644
--- a/tests/bot/cogs/sync/__init__.py
+++ b/bot/exts/fun/__init__.py
diff --git a/bot/cogs/duck_pond.py b/bot/exts/fun/duck_pond.py
index 7021069fa..7021069fa 100644
--- a/bot/cogs/duck_pond.py
+++ b/bot/exts/fun/duck_pond.py
diff --git a/bot/cogs/off_topic_names.py b/bot/exts/fun/off_topic_names.py
index b9d235fa2..b9d235fa2 100644
--- a/bot/cogs/off_topic_names.py
+++ b/bot/exts/fun/off_topic_names.py
diff --git a/bot/cogs/help_channels.py b/bot/exts/help_channels.py
index 17142071f..17142071f 100644
--- a/bot/cogs/help_channels.py
+++ b/bot/exts/help_channels.py
diff --git a/bot/exts/info/__init__.py b/bot/exts/info/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/bot/exts/info/__init__.py
diff --git a/bot/cogs/doc.py b/bot/exts/info/doc.py
index e50b9b32b..e50b9b32b 100644
--- a/bot/cogs/doc.py
+++ b/bot/exts/info/doc.py
diff --git a/bot/cogs/help.py b/bot/exts/info/help.py
index 99d503f5c..99d503f5c 100644
--- a/bot/cogs/help.py
+++ b/bot/exts/info/help.py
diff --git a/bot/cogs/information.py b/bot/exts/info/information.py
index 581b3a227..581b3a227 100644
--- a/bot/cogs/information.py
+++ b/bot/exts/info/information.py
diff --git a/bot/cogs/python_news.py b/bot/exts/info/python_news.py
index 0ab5738a4..0ab5738a4 100644
--- a/bot/cogs/python_news.py
+++ b/bot/exts/info/python_news.py
diff --git a/bot/cogs/reddit.py b/bot/exts/info/reddit.py
index 635162308..635162308 100644
--- a/bot/cogs/reddit.py
+++ b/bot/exts/info/reddit.py
diff --git a/bot/cogs/site.py b/bot/exts/info/site.py
index 2d3a3d9f3..2d3a3d9f3 100644
--- a/bot/cogs/site.py
+++ b/bot/exts/info/site.py
diff --git a/bot/cogs/source.py b/bot/exts/info/source.py
index 205e0ba81..205e0ba81 100644
--- a/bot/cogs/source.py
+++ b/bot/exts/info/source.py
diff --git a/bot/cogs/stats.py b/bot/exts/info/stats.py
index d42f55466..d42f55466 100644
--- a/bot/cogs/stats.py
+++ b/bot/exts/info/stats.py
diff --git a/bot/cogs/tags.py b/bot/exts/info/tags.py
index d01647312..d01647312 100644
--- a/bot/cogs/tags.py
+++ b/bot/exts/info/tags.py
diff --git a/bot/exts/moderation/__init__.py b/bot/exts/moderation/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/bot/exts/moderation/__init__.py
diff --git a/bot/cogs/defcon.py b/bot/exts/moderation/defcon.py
index 64d47c6c6..3bf462877 100644
--- a/bot/cogs/defcon.py
+++ b/bot/exts/moderation/defcon.py
@@ -9,8 +9,8 @@ from discord import Colour, Embed, Member
 from discord.ext.commands import Cog, Context, group, has_any_role
 
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
 from bot.constants import Channels, Colours, Emojis, Event, Icons, MODERATION_ROLES, Roles
+from bot.exts.moderation.modlog import ModLog
 
 log = logging.getLogger(__name__)
 
diff --git a/bot/cogs/dm_relay.py b/bot/exts/moderation/dm_relay.py
index 7a3fe49bb..7a3fe49bb 100644
--- a/bot/cogs/dm_relay.py
+++ b/bot/exts/moderation/dm_relay.py
diff --git a/bot/cogs/moderation/incidents.py b/bot/exts/moderation/incidents.py
index 3605ab1d2..e49913552 100644
--- a/bot/cogs/moderation/incidents.py
+++ b/bot/exts/moderation/incidents.py
@@ -405,3 +405,8 @@ class Incidents(Cog):
         """Pass `message` to `add_signals` if and only if it satisfies `is_incident`."""
         if is_incident(message):
             await add_signals(message)
+
+
+def setup(bot: Bot) -> None:
+    """Load the Incidents cog."""
+    bot.add_cog(Incidents(bot))
diff --git a/bot/exts/moderation/infraction/__init__.py b/bot/exts/moderation/infraction/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/bot/exts/moderation/infraction/__init__.py
diff --git a/bot/cogs/moderation/scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 051f6c52c..cf48ef2ac 100644
--- a/bot/cogs/moderation/scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -13,11 +13,11 @@ from bot import constants
 from bot.api import ResponseCodeError
 from bot.bot import Bot
 from bot.constants import Colours, STAFF_CHANNELS
+from bot.exts.moderation.infraction import _utils
+from bot.exts.moderation.infraction._utils import UserSnowflake
+from bot.exts.moderation.modlog import ModLog
 from bot.utils import time
 from bot.utils.scheduling import Scheduler
-from . import utils
-from .modlog import ModLog
-from .utils import UserSnowflake
 
 log = logging.getLogger(__name__)
 
@@ -56,7 +56,7 @@ class InfractionScheduler:
 
     async def reapply_infraction(
         self,
-        infraction: utils.Infraction,
+        infraction: _utils.Infraction,
         apply_coro: t.Optional[t.Awaitable]
     ) -> None:
         """Reapply an infraction if it's still active or deactivate it if less than 60 sec left."""
@@ -80,13 +80,13 @@ class InfractionScheduler:
     async def apply_infraction(
         self,
         ctx: Context,
-        infraction: utils.Infraction,
+        infraction: _utils.Infraction,
         user: UserSnowflake,
         action_coro: t.Optional[t.Awaitable] = None
     ) -> None:
         """Apply an infraction to the user, log the infraction, and optionally notify the user."""
         infr_type = infraction["type"]
-        icon = utils.INFRACTION_ICONS[infr_type][0]
+        icon = _utils.INFRACTION_ICONS[infr_type][0]
         reason = infraction["reason"]
         expiry = time.format_infraction_with_duration(infraction["expires_at"])
         id_ = infraction['id']
@@ -126,7 +126,7 @@ class InfractionScheduler:
                 log.error(f"Failed to DM {user.id}: could not fetch user (status {e.status})")
             else:
                 # Accordingly display whether the user was successfully notified via DM.
-                if await utils.notify_infraction(user, infr_type, expiry, reason, icon):
+                if await _utils.notify_infraction(user, infr_type, expiry, reason, icon):
                     dm_result = ":incoming_envelope: "
                     dm_log_text = "\nDM: Sent"
 
@@ -318,7 +318,7 @@ class InfractionScheduler:
 
         # Send a log message to the mod log.
         await self.mod_log.send_log_message(
-            icon_url=utils.INFRACTION_ICONS[infr_type][1],
+            icon_url=_utils.INFRACTION_ICONS[infr_type][1],
             colour=Colours.soft_green,
             title=f"Infraction {log_title}: {infr_type}",
             thumbnail=user.avatar_url_as(static_format="png"),
@@ -329,7 +329,7 @@ class InfractionScheduler:
 
     async def deactivate_infraction(
         self,
-        infraction: utils.Infraction,
+        infraction: _utils.Infraction,
         send_log: bool = True
     ) -> t.Dict[str, str]:
         """
@@ -434,7 +434,7 @@ class InfractionScheduler:
 
             log.trace(f"Sending deactivation mod log for infraction #{id_}.")
             await self.mod_log.send_log_message(
-                icon_url=utils.INFRACTION_ICONS[type_][1],
+                icon_url=_utils.INFRACTION_ICONS[type_][1],
                 colour=Colours.soft_green,
                 title=f"Infraction {log_title}: {type_}",
                 thumbnail=avatar,
@@ -446,7 +446,7 @@ class InfractionScheduler:
         return log_text
 
     @abstractmethod
-    async def _pardon_action(self, infraction: utils.Infraction) -> t.Optional[t.Dict[str, str]]:
+    async def _pardon_action(self, infraction: _utils.Infraction) -> t.Optional[t.Dict[str, str]]:
         """
         Execute deactivation steps specific to the infraction's type and return a log dict.
 
@@ -454,7 +454,7 @@ class InfractionScheduler:
         """
         raise NotImplementedError
 
-    def schedule_expiration(self, infraction: utils.Infraction) -> None:
+    def schedule_expiration(self, infraction: _utils.Infraction) -> None:
         """
         Marks an infraction expired after the delay from time of scheduling to time of expiration.
 
diff --git a/bot/cogs/moderation/utils.py b/bot/exts/moderation/infraction/_utils.py
index f21272102..1d91964f1 100644
--- a/bot/cogs/moderation/utils.py
+++ b/bot/exts/moderation/infraction/_utils.py
@@ -1,5 +1,4 @@
 import logging
-import textwrap
 import typing as t
 from datetime import datetime
 
@@ -28,6 +27,18 @@ UserObject = t.Union[discord.Member, discord.User]
 UserSnowflake = t.Union[UserObject, discord.Object]
 Infraction = t.Dict[str, t.Union[str, int, bool]]
 
+APPEAL_EMAIL = "[email protected]"
+
+INFRACTION_TITLE = f"Please review our rules over at {RULES_URL}"
+INFRACTION_APPEAL_FOOTER = f"To appeal this infraction, send an e-mail to {APPEAL_EMAIL}"
+INFRACTION_AUTHOR_NAME = "Infraction information"
+
+INFRACTION_DESCRIPTION_TEMPLATE = (
+    "**Type:** {type}\n"
+    "**Expires:** {expires}\n"
+    "**Reason:** {reason}\n"
+)
+
 
 async def post_user(ctx: Context, user: UserSnowflake) -> t.Optional[dict]:
     """
@@ -142,25 +153,27 @@ async def notify_infraction(
     """DM a user about their new infraction and return True if the DM is successful."""
     log.trace(f"Sending {user} a DM about their {infr_type} infraction.")
 
-    text = textwrap.dedent(f"""
-        **Type:** {infr_type.capitalize()}
-        **Expires:** {expires_at or "N/A"}
-        **Reason:** {reason or "No reason provided."}
-    """)
+    text = INFRACTION_DESCRIPTION_TEMPLATE.format(
+        type=infr_type.capitalize(),
+        expires=expires_at or "N/A",
+        reason=reason or "No reason provided."
+    )
+
+    # For case when other fields than reason is too long and this reach limit, then force-shorten string
+    if len(text) > 2048:
+        text = f"{text[:2045]}..."
 
     embed = discord.Embed(
-        description=textwrap.shorten(text, width=2048, placeholder="..."),
+        description=text,
         colour=Colours.soft_red
     )
 
-    embed.set_author(name="Infraction information", icon_url=icon_url, url=RULES_URL)
-    embed.title = f"Please review our rules over at {RULES_URL}"
+    embed.set_author(name=INFRACTION_AUTHOR_NAME, icon_url=icon_url, url=RULES_URL)
+    embed.title = INFRACTION_TITLE
     embed.url = RULES_URL
 
     if infr_type in APPEALABLE_INFRACTIONS:
-        embed.set_footer(
-            text="To appeal this infraction, send an e-mail to [email protected]"
-        )
+        embed.set_footer(text=INFRACTION_APPEAL_FOOTER)
 
     return await send_private_embed(user, embed)
 
diff --git a/bot/cogs/moderation/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 8f0def2bc..5fa62d3c4 100644
--- a/bot/cogs/moderation/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -12,9 +12,9 @@ from bot.bot import Bot
 from bot.constants import Event
 from bot.converters import Expiry, FetchedMember
 from bot.decorators import respect_role_hierarchy
-from . import utils
-from .scheduler import InfractionScheduler
-from .utils import UserSnowflake
+from bot.exts.moderation.infraction import _utils
+from bot.exts.moderation.infraction._scheduler import InfractionScheduler
+from bot.exts.moderation.infraction._utils import UserSnowflake
 
 log = logging.getLogger(__name__)
 
@@ -54,7 +54,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     @command()
     async def warn(self, ctx: Context, user: Member, *, reason: t.Optional[str] = None) -> None:
         """Warn a user for the given reason."""
-        infraction = await utils.post_infraction(ctx, user, "warning", reason, active=False)
+        infraction = await _utils.post_infraction(ctx, user, "warning", reason, active=False)
         if infraction is None:
             return
 
@@ -124,7 +124,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     @command(hidden=True)
     async def note(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str] = None) -> None:
         """Create a private note for a user with the given reason without notifying the user."""
-        infraction = await utils.post_infraction(ctx, user, "note", reason, hidden=True, active=False)
+        infraction = await _utils.post_infraction(ctx, user, "note", reason, hidden=True, active=False)
         if infraction is None:
             return
 
@@ -212,10 +212,10 @@ class Infractions(InfractionScheduler, commands.Cog):
 
     async def apply_mute(self, ctx: Context, user: Member, reason: t.Optional[str], **kwargs) -> None:
         """Apply a mute infraction with kwargs passed to `post_infraction`."""
-        if await utils.get_active_infraction(ctx, user, "mute"):
+        if await _utils.get_active_infraction(ctx, user, "mute"):
             return
 
-        infraction = await utils.post_infraction(ctx, user, "mute", reason, active=True, **kwargs)
+        infraction = await _utils.post_infraction(ctx, user, "mute", reason, active=True, **kwargs)
         if infraction is None:
             return
 
@@ -232,7 +232,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     @respect_role_hierarchy()
     async def apply_kick(self, ctx: Context, user: Member, reason: t.Optional[str], **kwargs) -> None:
         """Apply a kick infraction with kwargs passed to `post_infraction`."""
-        infraction = await utils.post_infraction(ctx, user, "kick", reason, active=False, **kwargs)
+        infraction = await _utils.post_infraction(ctx, user, "kick", reason, active=False, **kwargs)
         if infraction is None:
             return
 
@@ -253,7 +253,7 @@ class Infractions(InfractionScheduler, commands.Cog):
         """
         # In the case of a permanent ban, we don't need get_active_infractions to tell us if one is active
         is_temporary = kwargs.get("expires_at") is not None
-        active_infraction = await utils.get_active_infraction(ctx, user, "ban", is_temporary)
+        active_infraction = await _utils.get_active_infraction(ctx, user, "ban", is_temporary)
 
         if active_infraction:
             if is_temporary:
@@ -268,7 +268,7 @@ class Infractions(InfractionScheduler, commands.Cog):
             log.trace("Old tempban is being replaced by new permaban.")
             await self.pardon_infraction(ctx, "ban", user, is_temporary)
 
-        infraction = await utils.post_infraction(ctx, user, "ban", reason, active=True, **kwargs)
+        infraction = await _utils.post_infraction(ctx, user, "ban", reason, active=True, **kwargs)
         if infraction is None:
             return
 
@@ -308,11 +308,11 @@ class Infractions(InfractionScheduler, commands.Cog):
             await user.remove_roles(self._muted_role, reason=reason)
 
             # DM the user about the expiration.
-            notified = await utils.notify_pardon(
+            notified = await _utils.notify_pardon(
                 user=user,
                 title="You have been unmuted",
                 content="You may now send messages in the server.",
-                icon_url=utils.INFRACTION_ICONS["mute"][1]
+                icon_url=_utils.INFRACTION_ICONS["mute"][1]
             )
 
             log_text["Member"] = f"{user.mention}(`{user.id}`)"
@@ -338,7 +338,7 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         return log_text
 
-    async def _pardon_action(self, infraction: utils.Infraction) -> t.Optional[t.Dict[str, str]]:
+    async def _pardon_action(self, infraction: _utils.Infraction) -> t.Optional[t.Dict[str, str]]:
         """
         Execute deactivation steps specific to the infraction's type and return a log dict.
 
@@ -367,3 +367,8 @@ class Infractions(InfractionScheduler, commands.Cog):
             if discord.User in error.converters or discord.Member in error.converters:
                 await ctx.send(str(error.errors[0]))
                 error.handled = True
+
+
+def setup(bot: Bot) -> None:
+    """Load the Infractions cog."""
+    bot.add_cog(Infractions(bot))
diff --git a/bot/cogs/moderation/management.py b/bot/exts/moderation/infraction/management.py
index 83342ac90..15ee28537 100644
--- a/bot/cogs/moderation/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -10,12 +10,12 @@ from discord.ext.commands import Context
 from bot import constants
 from bot.bot import Bot
 from bot.converters import Expiry, InfractionSearchQuery, allowed_strings, proxy_user
+from bot.exts.moderation.infraction import _utils
+from bot.exts.moderation.infraction.infractions import Infractions
+from bot.exts.moderation.modlog import ModLog
 from bot.pagination import LinePaginator
 from bot.utils import time
 from bot.utils.checks import in_whitelist_check
-from . import utils
-from .infractions import Infractions
-from .modlog import ModLog
 
 log = logging.getLogger(__name__)
 
@@ -220,7 +220,7 @@ class ModManagement(commands.Cog):
         self,
         ctx: Context,
         embed: discord.Embed,
-        infractions: t.Iterable[utils.Infraction]
+        infractions: t.Iterable[_utils.Infraction]
     ) -> None:
         """Send a paginated embed of infractions for the specified user."""
         if not infractions:
@@ -241,7 +241,7 @@ class ModManagement(commands.Cog):
             max_size=1000
         )
 
-    def infraction_to_string(self, infraction: utils.Infraction) -> str:
+    def infraction_to_string(self, infraction: _utils.Infraction) -> str:
         """Convert the infraction object to a string representation."""
         actor_id = infraction["actor"]
         guild = self.bot.get_guild(constants.Guild.id)
@@ -303,3 +303,8 @@ class ModManagement(commands.Cog):
             if discord.User in error.converters:
                 await ctx.send(str(error.errors[0]))
                 error.handled = True
+
+
+def setup(bot: Bot) -> None:
+    """Load the ModManagement cog."""
+    bot.add_cog(ModManagement(bot))
diff --git a/bot/cogs/moderation/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 081c2d0b9..29f41f2ab 100644
--- a/bot/cogs/moderation/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -11,9 +11,9 @@ from discord.ext.commands import Cog, Context, command, has_any_role
 from bot import constants
 from bot.bot import Bot
 from bot.converters import Expiry
+from bot.exts.moderation.infraction import _utils
+from bot.exts.moderation.infraction._scheduler import InfractionScheduler
 from bot.utils.time import format_infraction
-from . import utils
-from .scheduler import InfractionScheduler
 
 log = logging.getLogger(__name__)
 NICKNAME_POLICY_URL = "https://pythondiscord.com/pages/rules/#nickname-policy"
@@ -66,7 +66,7 @@ class Superstarify(InfractionScheduler, Cog):
             reason=f"Superstarified member tried to escape the prison: {infraction['id']}"
         )
 
-        notified = await utils.notify_infraction(
+        notified = await _utils.notify_infraction(
             user=after,
             infr_type="Superstarify",
             expires_at=format_infraction(infraction["expires_at"]),
@@ -75,7 +75,7 @@ class Superstarify(InfractionScheduler, Cog):
                 f"from **{before.display_name}** to **{after.display_name}**, but as you "
                 "are currently in superstar-prison, you do not have permission to do so."
             ),
-            icon_url=utils.INFRACTION_ICONS["superstar"][0]
+            icon_url=_utils.INFRACTION_ICONS["superstar"][0]
         )
 
         if not notified:
@@ -129,12 +129,12 @@ class Superstarify(InfractionScheduler, Cog):
         An optional reason can be provided. If no reason is given, the original name will be shown
         in a generated reason.
         """
-        if await utils.get_active_infraction(ctx, member, "superstar"):
+        if await _utils.get_active_infraction(ctx, member, "superstar"):
             return
 
         # Post the infraction to the API
         reason = reason or f"old nick: {member.display_name}"
-        infraction = await utils.post_infraction(ctx, member, "superstar", reason, duration, active=True)
+        infraction = await _utils.post_infraction(ctx, member, "superstar", reason, duration, active=True)
         id_ = infraction["id"]
 
         old_nick = member.display_name
@@ -148,11 +148,11 @@ class Superstarify(InfractionScheduler, Cog):
         self.schedule_expiration(infraction)
 
         # Send a DM to the user to notify them of their new infraction.
-        await utils.notify_infraction(
+        await _utils.notify_infraction(
             user=member,
             infr_type="Superstarify",
             expires_at=expiry_str,
-            icon_url=utils.INFRACTION_ICONS["superstar"][0],
+            icon_url=_utils.INFRACTION_ICONS["superstar"][0],
             reason=f"Your nickname didn't comply with our [nickname policy]({NICKNAME_POLICY_URL})."
         )
 
@@ -175,7 +175,7 @@ class Superstarify(InfractionScheduler, Cog):
         # Log to the mod log channel.
         log.trace(f"Sending apply mod log for superstar #{id_}.")
         await self.mod_log.send_log_message(
-            icon_url=utils.INFRACTION_ICONS["superstar"][0],
+            icon_url=_utils.INFRACTION_ICONS["superstar"][0],
             colour=Colour.gold(),
             title="Member achieved superstardom",
             thumbnail=member.avatar_url_as(static_format="png"),
@@ -195,7 +195,7 @@ class Superstarify(InfractionScheduler, Cog):
         """Remove the superstarify infraction and allow the user to change their nickname."""
         await self.pardon_infraction(ctx, "superstar", member)
 
-    async def _pardon_action(self, infraction: utils.Infraction) -> t.Optional[t.Dict[str, str]]:
+    async def _pardon_action(self, infraction: _utils.Infraction) -> t.Optional[t.Dict[str, str]]:
         """Pardon a superstar infraction and return a log dict."""
         if infraction["type"] != "superstar":
             return
@@ -212,11 +212,11 @@ class Superstarify(InfractionScheduler, Cog):
             return {}
 
         # DM the user about the expiration.
-        notified = await utils.notify_pardon(
+        notified = await _utils.notify_pardon(
             user=user,
             title="You are no longer superstarified",
             content="You may now change your nickname on the server.",
-            icon_url=utils.INFRACTION_ICONS["superstar"][1]
+            icon_url=_utils.INFRACTION_ICONS["superstar"][1]
         )
 
         return {
@@ -236,3 +236,8 @@ class Superstarify(InfractionScheduler, Cog):
     async def cog_check(self, ctx: Context) -> bool:
         """Only allow moderators to invoke the commands in this cog."""
         return await has_any_role(*constants.MODERATION_ROLES).predicate(ctx)
+
+
+def setup(bot: Bot) -> None:
+    """Load the Superstarify cog."""
+    bot.add_cog(Superstarify(bot))
diff --git a/bot/cogs/moderation/modlog.py b/bot/exts/moderation/modlog.py
index 5f30d3744..b0d9b5b2b 100644
--- a/bot/cogs/moderation/modlog.py
+++ b/bot/exts/moderation/modlog.py
@@ -834,3 +834,8 @@ class ModLog(Cog, name="ModLog"):
             thumbnail=member.avatar_url_as(static_format="png"),
             channel_id=Channels.voice_log
         )
+
+
+def setup(bot: Bot) -> None:
+    """Load the ModLog cog."""
+    bot.add_cog(ModLog(bot))
diff --git a/bot/cogs/moderation/silence.py b/bot/exts/moderation/silence.py
index ecc9f8d22..ac0c1c85e 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -162,3 +162,8 @@ class Silence(commands.Cog):
     async def cog_check(self, ctx: Context) -> bool:
         """Only allow moderators to invoke the commands in this cog."""
         return await commands.has_any_role(*MODERATION_ROLES).predicate(ctx)
+
+
+def setup(bot: Bot) -> None:
+    """Load the Silence cog."""
+    bot.add_cog(Silence(bot))
diff --git a/bot/cogs/moderation/slowmode.py b/bot/exts/moderation/slowmode.py
index efd862aa5..efd862aa5 100644
--- a/bot/cogs/moderation/slowmode.py
+++ b/bot/exts/moderation/slowmode.py
diff --git a/bot/exts/moderation/verification.py b/bot/exts/moderation/verification.py
new file mode 100644
index 000000000..8ec68ac1e
--- /dev/null
+++ b/bot/exts/moderation/verification.py
@@ -0,0 +1,752 @@
+import asyncio
+import logging
+import typing as t
+from contextlib import suppress
+from datetime import datetime, timedelta
+
+import discord
+from discord.ext import tasks
+from discord.ext.commands import Cog, Context, command, group, has_any_role
+from discord.utils import snowflake_time
+
+from bot import constants
+from bot.bot import Bot
+from bot.decorators import has_no_roles, in_whitelist
+from bot.exts.moderation.modlog import ModLog
+from bot.utils.checks import InWhitelistCheckFailure, has_no_roles_check
+from bot.utils.redis_cache import RedisCache
+
+log = logging.getLogger(__name__)
+
+# Sent via DMs once user joins the guild
+ON_JOIN_MESSAGE = f"""
+Hello! Welcome to Python Discord!
+
+As a new user, you have read-only access to a few select channels to give you a taste of what our server is like.
+
+In order to see the rest of the channels and to send messages, you first have to accept our rules. To do so, \
+please visit <#{constants.Channels.verification}>. Thank you!
+"""
+
+# Sent via DMs once user verifies
+VERIFIED_MESSAGE = f"""
+Thanks for verifying yourself!
+
+For your records, these are the documents you accepted:
+
+`1)` Our rules, here: <https://pythondiscord.com/pages/rules>
+`2)` Our privacy policy, here: <https://pythondiscord.com/pages/privacy> - you can find information on how to have \
+your information removed here as well.
+
+Feel free to review them at any point!
+
+Additionally, if you'd like to receive notifications for the announcements \
+we post in <#{constants.Channels.announcements}>
+from time to time, you can send `!subscribe` to <#{constants.Channels.bot_commands}> at any time \
+to assign yourself the **Announcements** role. We'll mention this role every time we make an announcement.
+
+If you'd like to unsubscribe from the announcement notifications, simply send `!unsubscribe` to \
+<#{constants.Channels.bot_commands}>.
+"""
+
+# Sent via DMs to users kicked for failing to verify
+KICKED_MESSAGE = f"""
+Hi! You have been automatically kicked from Python Discord as you have failed to accept our rules \
+within `{constants.Verification.kicked_after}` days. If this was an accident, please feel free to join us again!
+
+{constants.Guild.invite}
+"""
+
+# Sent periodically in the verification channel
+REMINDER_MESSAGE = f"""
+<@&{constants.Roles.unverified}>
+
+Welcome to Python Discord! Please read the documents mentioned above and type `!accept` to gain permissions \
+to send messages in the community!
+
+You will be kicked if you don't verify within `{constants.Verification.kicked_after}` days.
+""".strip()
+
+# An async function taking a Member param
+Request = t.Callable[[discord.Member], t.Awaitable]
+
+
+class StopExecution(Exception):
+    """Signals that a task should halt immediately & alert admins."""
+
+    def __init__(self, reason: discord.HTTPException) -> None:
+        super().__init__()
+        self.reason = reason
+
+
+class Limit(t.NamedTuple):
+    """Composition over config for throttling requests."""
+
+    batch_size: int  # Amount of requests after which to pause
+    sleep_secs: int  # Sleep this many seconds after each batch
+
+
+def mention_role(role_id: int) -> discord.AllowedMentions:
+    """Construct an allowed mentions instance that allows pinging `role_id`."""
+    return discord.AllowedMentions(roles=[discord.Object(role_id)])
+
+
+def is_verified(member: discord.Member) -> bool:
+    """
+    Check whether `member` is considered verified.
+
+    Members are considered verified if they have at least 1 role other than
+    the default role (@everyone) and the @Unverified role.
+    """
+    unverified_roles = {
+        member.guild.get_role(constants.Roles.unverified),
+        member.guild.default_role,
+    }
+    return len(set(member.roles) - unverified_roles) > 0
+
+
+class Verification(Cog):
+    """
+    User verification and role management.
+
+    There are two internal tasks in this cog:
+
+    * `update_unverified_members`
+        * Unverified members are given the @Unverified role after configured `unverified_after` days
+        * Unverified members are kicked after configured `kicked_after` days
+    * `ping_unverified`
+        * Periodically ping the @Unverified role in the verification channel
+
+    Statistics are collected in the 'verification.' namespace.
+
+    Moderators+ can use the `verification` command group to start or stop both internal
+    tasks, if necessary. Settings are persisted in Redis across sessions.
+
+    Additionally, this cog offers the !accept, !subscribe and !unsubscribe commands,
+    and keeps the verification channel clean by deleting messages.
+    """
+
+    # Persist task settings & last sent `REMINDER_MESSAGE` id
+    # RedisCache[
+    #   "tasks_running": int (0 or 1),
+    #   "last_reminder": int (discord.Message.id),
+    # ]
+    task_cache = RedisCache()
+
+    def __init__(self, bot: Bot) -> None:
+        """Start internal tasks."""
+        self.bot = bot
+        self.bot.loop.create_task(self._maybe_start_tasks())
+
+    def cog_unload(self) -> None:
+        """
+        Cancel internal tasks.
+
+        This is necessary, as tasks are not automatically cancelled on cog unload.
+        """
+        self._stop_tasks(gracefully=False)
+
+    @property
+    def mod_log(self) -> ModLog:
+        """Get currently loaded ModLog cog instance."""
+        return self.bot.get_cog("ModLog")
+
+    async def _maybe_start_tasks(self) -> None:
+        """
+        Poll Redis to check whether internal tasks should start.
+
+        Redis must be interfaced with from an async function.
+        """
+        log.trace("Checking whether background tasks should begin")
+        setting: t.Optional[int] = await self.task_cache.get("tasks_running")  # This can be None if never set
+
+        if setting:
+            log.trace("Background tasks will be started")
+            self.update_unverified_members.start()
+            self.ping_unverified.start()
+
+    def _stop_tasks(self, *, gracefully: bool) -> None:
+        """
+        Stop the update users & ping @Unverified tasks.
+
+        If `gracefully` is True, the tasks will be able to finish their current iteration.
+        Otherwise, they are cancelled immediately.
+        """
+        log.info(f"Stopping internal tasks ({gracefully=})")
+        if gracefully:
+            self.update_unverified_members.stop()
+            self.ping_unverified.stop()
+        else:
+            self.update_unverified_members.cancel()
+            self.ping_unverified.cancel()
+
+    # region: automatically update unverified users
+
+    async def _verify_kick(self, n_members: int) -> bool:
+        """
+        Determine whether `n_members` is a reasonable amount of members to kick.
+
+        First, `n_members` is checked against the size of the PyDis guild. If `n_members` are
+        more than the configured `kick_confirmation_threshold` of the guild, the operation
+        must be confirmed by staff in #core-dev. Otherwise, the operation is seen as safe.
+        """
+        log.debug(f"Checking whether {n_members} members are safe to kick")
+
+        await self.bot.wait_until_guild_available()  # Ensure cache is populated before we grab the guild
+        pydis = self.bot.get_guild(constants.Guild.id)
+
+        percentage = n_members / len(pydis.members)
+        if percentage < constants.Verification.kick_confirmation_threshold:
+            log.debug(f"Kicking {percentage:.2%} of the guild's population is seen as safe")
+            return True
+
+        # Since `n_members` is a suspiciously large number, we will ask for confirmation
+        log.debug("Amount of users is too large, requesting staff confirmation")
+
+        core_dev_channel = pydis.get_channel(constants.Channels.dev_core)
+        core_dev_ping = f"<@&{constants.Roles.core_developers}>"
+
+        confirmation_msg = await core_dev_channel.send(
+            f"{core_dev_ping} Verification determined that `{n_members}` members should be kicked as they haven't "
+            f"verified in `{constants.Verification.kicked_after}` days. This is `{percentage:.2%}` of the guild's "
+            f"population. Proceed?",
+            allowed_mentions=mention_role(constants.Roles.core_developers),
+        )
+
+        options = (constants.Emojis.incident_actioned, constants.Emojis.incident_unactioned)
+        for option in options:
+            await confirmation_msg.add_reaction(option)
+
+        core_dev_ids = [member.id for member in pydis.get_role(constants.Roles.core_developers).members]
+
+        def check(reaction: discord.Reaction, user: discord.User) -> bool:
+            """Check whether `reaction` is a valid reaction to `confirmation_msg`."""
+            return (
+                reaction.message.id == confirmation_msg.id  # Reacted to `confirmation_msg`
+                and str(reaction.emoji) in options  # With one of `options`
+                and user.id in core_dev_ids  # By a core developer
+            )
+
+        timeout = 60 * 5  # Seconds, i.e. 5 minutes
+        try:
+            choice, _ = await self.bot.wait_for("reaction_add", check=check, timeout=timeout)
+        except asyncio.TimeoutError:
+            log.debug("Staff prompt not answered, aborting operation")
+            return False
+        finally:
+            with suppress(discord.HTTPException):
+                await confirmation_msg.clear_reactions()
+
+        result = str(choice) == constants.Emojis.incident_actioned
+        log.debug(f"Received answer: {choice}, result: {result}")
+
+        # Edit the prompt message to reflect the final choice
+        if result is True:
+            result_msg = f":ok_hand: {core_dev_ping} Request to kick `{n_members}` members was authorized!"
+        else:
+            result_msg = f":warning: {core_dev_ping} Request to kick `{n_members}` members was denied!"
+
+        with suppress(discord.HTTPException):
+            await confirmation_msg.edit(content=result_msg)
+
+        return result
+
+    async def _alert_admins(self, exception: discord.HTTPException) -> None:
+        """
+        Ping @Admins with information about `exception`.
+
+        This is used when a critical `exception` caused a verification task to abort.
+        """
+        await self.bot.wait_until_guild_available()
+        log.info(f"Sending admin alert regarding exception: {exception}")
+
+        admins_channel = self.bot.get_guild(constants.Guild.id).get_channel(constants.Channels.admins)
+        ping = f"<@&{constants.Roles.admins}>"
+
+        await admins_channel.send(
+            f"{ping} Aborted updating unverified users due to the following exception:\n"
+            f"```{exception}```\n"
+            f"Internal tasks will be stopped.",
+            allowed_mentions=mention_role(constants.Roles.admins),
+        )
+
+    async def _send_requests(self, members: t.Collection[discord.Member], request: Request, limit: Limit) -> int:
+        """
+        Pass `members` one by one to `request` handling Discord exceptions.
+
+        This coroutine serves as a generic `request` executor for kicking members and adding
+        roles, as it allows us to define the error handling logic in one place only.
+
+        Any `request` has the ability to completely abort the execution by raising `StopExecution`.
+        In such a case, the @Admins will be alerted of the reason attribute.
+
+        To avoid rate-limits, pass a `limit` configuring the batch size and the amount of seconds
+        to sleep between batches.
+
+        Returns the amount of successful requests. Failed requests are logged at info level.
+        """
+        log.info(f"Sending {len(members)} requests")
+        n_success, bad_statuses = 0, set()
+
+        for progress, member in enumerate(members, start=1):
+            if is_verified(member):  # Member could have verified in the meantime
+                continue
+            try:
+                await request(member)
+            except StopExecution as stop_execution:
+                await self._alert_admins(stop_execution.reason)
+                await self.task_cache.set("tasks_running", 0)
+                self._stop_tasks(gracefully=True)  # Gracefully finish current iteration, then stop
+                break
+            except discord.HTTPException as http_exc:
+                bad_statuses.add(http_exc.status)
+            else:
+                n_success += 1
+
+            if progress % limit.batch_size == 0:
+                log.trace(f"Processed {progress} requests, pausing for {limit.sleep_secs} seconds")
+                await asyncio.sleep(limit.sleep_secs)
+
+        if bad_statuses:
+            log.info(f"Failed to send {len(members) - n_success} requests due to following statuses: {bad_statuses}")
+
+        return n_success
+
+    async def _kick_members(self, members: t.Collection[discord.Member]) -> int:
+        """
+        Kick `members` from the PyDis guild.
+
+        Due to strict ratelimits on sending messages (120 requests / 60 secs), we sleep for a second
+        after each 2 requests to allow breathing room for other features.
+
+        Note that this is a potentially destructive operation. Returns the amount of successful requests.
+        """
+        log.info(f"Kicking {len(members)} members (not verified after {constants.Verification.kicked_after} days)")
+
+        async def kick_request(member: discord.Member) -> None:
+            """Send `KICKED_MESSAGE` to `member` and kick them from the guild."""
+            try:
+                await member.send(KICKED_MESSAGE)
+            except discord.Forbidden as exc_403:
+                log.trace(f"DM dispatch failed on 403 error with code: {exc_403.code}")
+                if exc_403.code != 50_007:  # 403 raised for any other reason than disabled DMs
+                    raise StopExecution(reason=exc_403)
+            await member.kick(reason=f"User has not verified in {constants.Verification.kicked_after} days")
+
+        n_kicked = await self._send_requests(members, kick_request, Limit(batch_size=2, sleep_secs=1))
+        self.bot.stats.incr("verification.kicked", count=n_kicked)
+
+        return n_kicked
+
+    async def _give_role(self, members: t.Collection[discord.Member], role: discord.Role) -> int:
+        """
+        Give `role` to all `members`.
+
+        We pause for a second after batches of 25 requests to ensure ratelimits aren't exceeded.
+
+        Returns the amount of successful requests.
+        """
+        log.info(
+            f"Assigning {role} role to {len(members)} members (not verified "
+            f"after {constants.Verification.unverified_after} days)"
+        )
+
+        async def role_request(member: discord.Member) -> None:
+            """Add `role` to `member`."""
+            await member.add_roles(role, reason=f"Not verified after {constants.Verification.unverified_after} days")
+
+        return await self._send_requests(members, role_request, Limit(batch_size=25, sleep_secs=1))
+
+    async def _check_members(self) -> t.Tuple[t.Set[discord.Member], t.Set[discord.Member]]:
+        """
+        Check in on the verification status of PyDis members.
+
+        This coroutine finds two sets of users:
+        * Not verified after configured `unverified_after` days, should be given the @Unverified role
+        * Not verified after configured `kicked_after` days, should be kicked from the guild
+
+        These sets are always disjoint, i.e. share no common members.
+        """
+        await self.bot.wait_until_guild_available()  # Ensure cache is ready
+        pydis = self.bot.get_guild(constants.Guild.id)
+
+        unverified = pydis.get_role(constants.Roles.unverified)
+        current_dt = datetime.utcnow()  # Discord timestamps are UTC
+
+        # Users to be given the @Unverified role, and those to be kicked, these should be entirely disjoint
+        for_role, for_kick = set(), set()
+
+        log.debug("Checking verification status of guild members")
+        for member in pydis.members:
+
+            # Skip verified members, bots, and members for which we do not know their join date,
+            # this should be extremely rare but docs mention that it can happen
+            if is_verified(member) or member.bot or member.joined_at is None:
+                continue
+
+            # At this point, we know that `member` is an unverified user, and we will decide what
+            # to do with them based on time passed since their join date
+            since_join = current_dt - member.joined_at
+
+            if since_join > timedelta(days=constants.Verification.kicked_after):
+                for_kick.add(member)  # User should be removed from the guild
+
+            elif (
+                since_join > timedelta(days=constants.Verification.unverified_after)
+                and unverified not in member.roles
+            ):
+                for_role.add(member)  # User should be given the @Unverified role
+
+        log.debug(f"Found {len(for_role)} users for {unverified} role, {len(for_kick)} users to be kicked")
+        return for_role, for_kick
+
+    @tasks.loop(minutes=30)
+    async def update_unverified_members(self) -> None:
+        """
+        Periodically call `_check_members` and update unverified members accordingly.
+
+        After each run, a summary will be sent to the modlog channel. If a suspiciously high
+        amount of members to be kicked is found, the operation is guarded by `_verify_kick`.
+        """
+        log.info("Updating unverified guild members")
+
+        await self.bot.wait_until_guild_available()
+        unverified = self.bot.get_guild(constants.Guild.id).get_role(constants.Roles.unverified)
+
+        for_role, for_kick = await self._check_members()
+
+        if not for_role:
+            role_report = f"Found no users to be assigned the {unverified.mention} role."
+        else:
+            n_roles = await self._give_role(for_role, unverified)
+            role_report = f"Assigned {unverified.mention} role to `{n_roles}`/`{len(for_role)}` members."
+
+        if not for_kick:
+            kick_report = "Found no users to be kicked."
+        elif not await self._verify_kick(len(for_kick)):
+            kick_report = f"Not authorized to kick `{len(for_kick)}` members."
+        else:
+            n_kicks = await self._kick_members(for_kick)
+            kick_report = f"Kicked `{n_kicks}`/`{len(for_kick)}` members from the guild."
+
+        await self.mod_log.send_log_message(
+            icon_url=self.bot.user.avatar_url,
+            colour=discord.Colour.blurple(),
+            title="Verification system",
+            text=f"{kick_report}\n{role_report}",
+        )
+
+    # endregion
+    # region: periodically ping @Unverified
+
+    @tasks.loop(hours=constants.Verification.reminder_frequency)
+    async def ping_unverified(self) -> None:
+        """
+        Delete latest `REMINDER_MESSAGE` and send it again.
+
+        This utilizes RedisCache to persist the latest reminder message id.
+        """
+        await self.bot.wait_until_guild_available()
+        verification = self.bot.get_guild(constants.Guild.id).get_channel(constants.Channels.verification)
+
+        last_reminder: t.Optional[int] = await self.task_cache.get("last_reminder")
+
+        if last_reminder is not None:
+            log.trace(f"Found verification reminder message in cache, deleting: {last_reminder}")
+
+            with suppress(discord.HTTPException):  # If something goes wrong, just ignore it
+                await self.bot.http.delete_message(verification.id, last_reminder)
+
+        log.trace("Sending verification reminder")
+        new_reminder = await verification.send(
+            REMINDER_MESSAGE, allowed_mentions=mention_role(constants.Roles.unverified),
+        )
+
+        await self.task_cache.set("last_reminder", new_reminder.id)
+
+    @ping_unverified.before_loop
+    async def _before_first_ping(self) -> None:
+        """
+        Sleep until `REMINDER_MESSAGE` should be sent again.
+
+        If latest reminder is not cached, exit instantly. Otherwise, wait wait until the
+        configured `reminder_frequency` has passed.
+        """
+        last_reminder: t.Optional[int] = await self.task_cache.get("last_reminder")
+
+        if last_reminder is None:
+            log.trace("Latest verification reminder message not cached, task will not wait")
+            return
+
+        # Convert cached message id into a timestamp
+        time_since = datetime.utcnow() - snowflake_time(last_reminder)
+        log.trace(f"Time since latest verification reminder: {time_since}")
+
+        to_sleep = timedelta(hours=constants.Verification.reminder_frequency) - time_since
+        log.trace(f"Time to sleep until next ping: {to_sleep}")
+
+        # Delta can be negative if `reminder_frequency` has already passed
+        secs = max(to_sleep.total_seconds(), 0)
+        await asyncio.sleep(secs)
+
+    # endregion
+    # region: listeners
+
+    @Cog.listener()
+    async def on_member_join(self, member: discord.Member) -> None:
+        """Attempt to send initial direct message to each new member."""
+        if member.guild.id != constants.Guild.id:
+            return  # Only listen for PyDis events
+
+        log.trace(f"Sending on join message to new member: {member.id}")
+        with suppress(discord.Forbidden):
+            await member.send(ON_JOIN_MESSAGE)
+
+    @Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        """Check new message event for messages to the checkpoint channel & process."""
+        if message.channel.id != constants.Channels.verification:
+            return  # Only listen for #checkpoint messages
+
+        if message.content == REMINDER_MESSAGE:
+            return  # Ignore bots own verification reminder
+
+        if message.author.bot:
+            # They're a bot, delete their message after the delay.
+            await message.delete(delay=constants.Verification.bot_message_delete_delay)
+            return
+
+        # if a user mentions a role or guild member
+        # alert the mods in mod-alerts channel
+        if message.mentions or message.role_mentions:
+            log.debug(
+                f"{message.author} mentioned one or more users "
+                f"and/or roles in {message.channel.name}"
+            )
+
+            embed_text = (
+                f"{message.author.mention} sent a message in "
+                f"{message.channel.mention} that contained user and/or role mentions."
+                f"\n\n**Original message:**\n>>> {message.content}"
+            )
+
+            # Send pretty mod log embed to mod-alerts
+            await self.mod_log.send_log_message(
+                icon_url=constants.Icons.filtering,
+                colour=discord.Colour(constants.Colours.soft_red),
+                title=f"User/Role mentioned in {message.channel.name}",
+                text=embed_text,
+                thumbnail=message.author.avatar_url_as(static_format="png"),
+                channel_id=constants.Channels.mod_alerts,
+            )
+
+        ctx: Context = await self.bot.get_context(message)
+        if ctx.command is not None and ctx.command.name == "accept":
+            return
+
+        if any(r.id == constants.Roles.verified for r in ctx.author.roles):
+            log.info(
+                f"{ctx.author} posted '{ctx.message.content}' "
+                "in the verification channel, but is already verified."
+            )
+            return
+
+        log.debug(
+            f"{ctx.author} posted '{ctx.message.content}' in the verification "
+            "channel. We are providing instructions how to verify."
+        )
+        await ctx.send(
+            f"{ctx.author.mention} Please type `!accept` to verify that you accept our rules, "
+            f"and gain access to the rest of the server.",
+            delete_after=20
+        )
+
+        log.trace(f"Deleting the message posted by {ctx.author}")
+        with suppress(discord.NotFound):
+            await ctx.message.delete()
+
+    # endregion
+    # region: task management commands
+
+    @has_any_role(*constants.MODERATION_ROLES)
+    @group(name="verification")
+    async def verification_group(self, ctx: Context) -> None:
+        """Manage internal verification tasks."""
+        if ctx.invoked_subcommand is None:
+            await ctx.send_help(ctx.command)
+
+    @verification_group.command(name="status")
+    async def status_cmd(self, ctx: Context) -> None:
+        """Check whether verification tasks are running."""
+        log.trace("Checking status of verification tasks")
+
+        if self.update_unverified_members.is_running():
+            update_status = f"{constants.Emojis.incident_actioned} Member update task is running."
+        else:
+            update_status = f"{constants.Emojis.incident_unactioned} Member update task is **not** running."
+
+        mention = f"<@&{constants.Roles.unverified}>"
+        if self.ping_unverified.is_running():
+            ping_status = f"{constants.Emojis.incident_actioned} Ping {mention} task is running."
+        else:
+            ping_status = f"{constants.Emojis.incident_unactioned} Ping {mention} task is **not** running."
+
+        embed = discord.Embed(
+            title="Verification system",
+            description=f"{update_status}\n{ping_status}",
+            colour=discord.Colour.blurple(),
+        )
+        await ctx.send(embed=embed)
+
+    @verification_group.command(name="start")
+    async def start_cmd(self, ctx: Context) -> None:
+        """Start verification tasks if they are not already running."""
+        log.info("Starting verification tasks")
+
+        if not self.update_unverified_members.is_running():
+            self.update_unverified_members.start()
+
+        if not self.ping_unverified.is_running():
+            self.ping_unverified.start()
+
+        await self.task_cache.set("tasks_running", 1)
+
+        colour = discord.Colour.blurple()
+        await ctx.send(embed=discord.Embed(title="Verification system", description="Done. :ok_hand:", colour=colour))
+
+    @verification_group.command(name="stop", aliases=["kill"])
+    async def stop_cmd(self, ctx: Context) -> None:
+        """Stop verification tasks."""
+        log.info("Stopping verification tasks")
+
+        self._stop_tasks(gracefully=False)
+        await self.task_cache.set("tasks_running", 0)
+
+        colour = discord.Colour.blurple()
+        await ctx.send(embed=discord.Embed(title="Verification system", description="Tasks canceled.", colour=colour))
+
+    # endregion
+    # region: accept and subscribe commands
+
+    def _bump_verified_stats(self, verified_member: discord.Member) -> None:
+        """
+        Increment verification stats for `verified_member`.
+
+        Each member falls into one of the three categories:
+            * Verified within 24 hours after joining
+            * Does not have @Unverified role yet
+            * Does have @Unverified role
+
+        Stats for member kicking are handled separately.
+        """
+        if verified_member.joined_at is None:  # Docs mention this can happen
+            return
+
+        if (datetime.utcnow() - verified_member.joined_at) < timedelta(hours=24):
+            category = "accepted_on_day_one"
+        elif constants.Roles.unverified not in [role.id for role in verified_member.roles]:
+            category = "accepted_before_unverified"
+        else:
+            category = "accepted_after_unverified"
+
+        log.trace(f"Bumping verification stats in category: {category}")
+        self.bot.stats.incr(f"verification.{category}")
+
+    @command(name='accept', aliases=('verify', 'verified', 'accepted'), hidden=True)
+    @has_no_roles(constants.Roles.verified)
+    @in_whitelist(channels=(constants.Channels.verification,))
+    async def accept_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
+        """Accept our rules and gain access to the rest of the server."""
+        log.debug(f"{ctx.author} called !accept. Assigning the 'Developer' role.")
+        await ctx.author.add_roles(discord.Object(constants.Roles.verified), reason="Accepted the rules")
+
+        self._bump_verified_stats(ctx.author)  # This checks for @Unverified so make sure it's not yet removed
+
+        if constants.Roles.unverified in [role.id for role in ctx.author.roles]:
+            log.debug(f"Removing Unverified role from: {ctx.author}")
+            await ctx.author.remove_roles(discord.Object(constants.Roles.unverified))
+
+        try:
+            await ctx.author.send(VERIFIED_MESSAGE)
+        except discord.Forbidden:
+            log.info(f"Sending welcome message failed for {ctx.author}.")
+        finally:
+            log.trace(f"Deleting accept message by {ctx.author}.")
+            with suppress(discord.NotFound):
+                self.mod_log.ignore(constants.Event.message_delete, ctx.message.id)
+                await ctx.message.delete()
+
+    @command(name='subscribe')
+    @in_whitelist(channels=(constants.Channels.bot_commands,))
+    async def subscribe_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
+        """Subscribe to announcement notifications by assigning yourself the role."""
+        has_role = False
+
+        for role in ctx.author.roles:
+            if role.id == constants.Roles.announcements:
+                has_role = True
+                break
+
+        if has_role:
+            await ctx.send(f"{ctx.author.mention} You're already subscribed!")
+            return
+
+        log.debug(f"{ctx.author} called !subscribe. Assigning the 'Announcements' role.")
+        await ctx.author.add_roles(discord.Object(constants.Roles.announcements), reason="Subscribed to announcements")
+
+        log.trace(f"Deleting the message posted by {ctx.author}.")
+
+        await ctx.send(
+            f"{ctx.author.mention} Subscribed to <#{constants.Channels.announcements}> notifications.",
+        )
+
+    @command(name='unsubscribe')
+    @in_whitelist(channels=(constants.Channels.bot_commands,))
+    async def unsubscribe_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
+        """Unsubscribe from announcement notifications by removing the role from yourself."""
+        has_role = False
+
+        for role in ctx.author.roles:
+            if role.id == constants.Roles.announcements:
+                has_role = True
+                break
+
+        if not has_role:
+            await ctx.send(f"{ctx.author.mention} You're already unsubscribed!")
+            return
+
+        log.debug(f"{ctx.author} called !unsubscribe. Removing the 'Announcements' role.")
+        await ctx.author.remove_roles(
+            discord.Object(constants.Roles.announcements), reason="Unsubscribed from announcements"
+        )
+
+        log.trace(f"Deleting the message posted by {ctx.author}.")
+
+        await ctx.send(
+            f"{ctx.author.mention} Unsubscribed from <#{constants.Channels.announcements}> notifications."
+        )
+
+    # endregion
+    # region: miscellaneous
+
+    # This cannot be static (must have a __func__ attribute).
+    async def cog_command_error(self, ctx: Context, error: Exception) -> None:
+        """Check for & ignore any InWhitelistCheckFailure."""
+        if isinstance(error, InWhitelistCheckFailure):
+            error.handled = True
+
+    @staticmethod
+    async def bot_check(ctx: Context) -> bool:
+        """Block any command within the verification channel that is not !accept."""
+        is_verification = ctx.channel.id == constants.Channels.verification
+        if is_verification and await has_no_roles_check(ctx, *constants.MODERATION_ROLES):
+            return ctx.command.name == "accept"
+        else:
+            return True
+
+    # endregion
+
+
+def setup(bot: Bot) -> None:
+    """Load the Verification cog."""
+    bot.add_cog(Verification(bot))
diff --git a/bot/exts/moderation/watchchannels/__init__.py b/bot/exts/moderation/watchchannels/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/bot/exts/moderation/watchchannels/__init__.py
diff --git a/bot/cogs/watchchannels/watchchannel.py b/bot/exts/moderation/watchchannels/_watchchannel.py
index a58b604c0..7118dee02 100644
--- a/bot/cogs/watchchannels/watchchannel.py
+++ b/bot/exts/moderation/watchchannels/_watchchannel.py
@@ -14,10 +14,10 @@ from discord.ext.commands import Cog, Context
 
 from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
-from bot.cogs.token_remover import TokenRemover
-from bot.cogs.webhook_remover import WEBHOOK_URL_RE
 from bot.constants import BigBrother as BigBrotherConfig, Guild as GuildConfig, Icons
+from bot.exts.filters.token_remover import TokenRemover
+from bot.exts.filters.webhook_remover import WEBHOOK_URL_RE
+from bot.exts.moderation.modlog import ModLog
 from bot.pagination import LinePaginator
 from bot.utils import CogABCMeta, messages
 from bot.utils.time import time_since
diff --git a/bot/cogs/watchchannels/bigbrother.py b/bot/exts/moderation/watchchannels/bigbrother.py
index af0354cf8..3b44056d3 100644
--- a/bot/cogs/watchchannels/bigbrother.py
+++ b/bot/exts/moderation/watchchannels/bigbrother.py
@@ -5,10 +5,10 @@ from collections import ChainMap
 from discord.ext.commands import Cog, Context, group, has_any_role
 
 from bot.bot import Bot
-from bot.cogs.moderation.utils import post_infraction
 from bot.constants import Channels, MODERATION_ROLES, Webhooks
 from bot.converters import FetchedMember
-from .watchchannel import WatchChannel
+from bot.exts.moderation.infraction._utils import post_infraction
+from bot.exts.moderation.watchchannels._watchchannel import WatchChannel
 
 log = logging.getLogger(__name__)
 
@@ -162,3 +162,8 @@ class BigBrother(WatchChannel, Cog, name="Big Brother"):
             message = ":x: The specified user is currently not being watched."
 
         await ctx.send(message)
+
+
+def setup(bot: Bot) -> None:
+    """Load the BigBrother cog."""
+    bot.add_cog(BigBrother(bot))
diff --git a/bot/cogs/watchchannels/talentpool.py b/bot/exts/moderation/watchchannels/talentpool.py
index d0a829f4e..a77dbe156 100644
--- a/bot/cogs/watchchannels/talentpool.py
+++ b/bot/exts/moderation/watchchannels/talentpool.py
@@ -10,9 +10,9 @@ from bot.api import ResponseCodeError
 from bot.bot import Bot
 from bot.constants import Channels, Guild, MODERATION_ROLES, STAFF_ROLES, Webhooks
 from bot.converters import FetchedMember
+from bot.exts.moderation.watchchannels._watchchannel import WatchChannel
 from bot.pagination import LinePaginator
 from bot.utils import time
-from .watchchannel import WatchChannel
 
 log = logging.getLogger(__name__)
 
@@ -277,3 +277,8 @@ class TalentPool(WatchChannel, Cog, name="Talentpool"):
             )
 
         return lines.strip()
+
+
+def setup(bot: Bot) -> None:
+    """Load the TalentPool cog."""
+    bot.add_cog(TalentPool(bot))
diff --git a/bot/exts/utils/__init__.py b/bot/exts/utils/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/bot/exts/utils/__init__.py
diff --git a/bot/cogs/bot.py b/bot/exts/utils/bot.py
index 6b8269729..7ed487d47 100644
--- a/bot/cogs/bot.py
+++ b/bot/exts/utils/bot.py
@@ -8,9 +8,9 @@ from discord import Embed, Message, RawMessageUpdateEvent, TextChannel
 from discord.ext.commands import Cog, Context, command, group, has_any_role
 
 from bot.bot import Bot
-from bot.cogs.token_remover import TokenRemover
-from bot.cogs.webhook_remover import WEBHOOK_URL_RE
 from bot.constants import Categories, Channels, DEBUG_MODE, Guild, MODERATION_ROLES, Roles, URLs
+from bot.exts.filters.token_remover import TokenRemover
+from bot.exts.filters.webhook_remover import WEBHOOK_URL_RE
 from bot.utils.messages import wait_for_deletion
 
 log = logging.getLogger(__name__)
diff --git a/bot/cogs/clean.py b/bot/exts/utils/clean.py
index 7f8873e36..236603dba 100644
--- a/bot/cogs/clean.py
+++ b/bot/exts/utils/clean.py
@@ -8,10 +8,10 @@ from discord.ext import commands
 from discord.ext.commands import Cog, Context, group, has_any_role
 
 from bot.bot import Bot
-from bot.cogs.moderation import ModLog
 from bot.constants import (
     Channels, CleanMessages, Colours, Event, Icons, MODERATION_ROLES, NEGATIVE_REPLIES
 )
+from bot.exts.moderation.modlog import ModLog
 
 log = logging.getLogger(__name__)
 
diff --git a/bot/cogs/eval.py b/bot/exts/utils/eval.py
index 468831365..6419b320e 100644
--- a/bot/cogs/eval.py
+++ b/bot/exts/utils/eval.py
@@ -14,6 +14,7 @@ from discord.ext.commands import Cog, Context, group, has_any_role
 from bot.bot import Bot
 from bot.constants import Roles
 from bot.interpreter import Interpreter
+from bot.utils import find_nth_occurrence, send_to_paste_service
 
 log = logging.getLogger(__name__)
 
@@ -170,6 +171,30 @@ async def func():  # (None,) -> Any
             res = traceback.format_exc()
 
         out, embed = self._format(code, res)
+        out = out.rstrip("\n")  # Strip empty lines from output
+
+        # Truncate output to max 15 lines or 1500 characters
+        newline_truncate_index = find_nth_occurrence(out, "\n", 15)
+
+        if newline_truncate_index is None or newline_truncate_index > 1500:
+            truncate_index = 1500
+        else:
+            truncate_index = newline_truncate_index
+
+        if len(out) > truncate_index:
+            paste_link = await send_to_paste_service(self.bot.http_session, out, extension="py")
+            if paste_link is not None:
+                paste_text = f"full contents at {paste_link}"
+            else:
+                paste_text = "failed to upload contents to paste service."
+
+            await ctx.send(
+                f"```py\n{out[:truncate_index]}\n```"
+                f"... response truncated; {paste_text}",
+                embed=embed
+            )
+            return
+
         await ctx.send(f"```py\n{out}```", embed=embed)
 
     @group(name='internal', aliases=('int',))
diff --git a/bot/cogs/extensions.py b/bot/exts/utils/extensions.py
index 5977e6f3c..418db0150 100644
--- a/bot/cogs/extensions.py
+++ b/bot/exts/utils/extensions.py
@@ -2,24 +2,22 @@ import functools
 import logging
 import typing as t
 from enum import Enum
-from pkgutil import iter_modules
 
 from discord import Colour, Embed
 from discord.ext import commands
 from discord.ext.commands import Context, group
 
+from bot import exts
 from bot.bot import Bot
 from bot.constants import Emojis, MODERATION_ROLES, Roles, URLs
 from bot.pagination import LinePaginator
+from bot.utils.extensions import EXTENSIONS, unqualify
 
 log = logging.getLogger(__name__)
 
-UNLOAD_BLACKLIST = {"bot.cogs.extensions", "bot.cogs.modlog"}
-EXTENSIONS = frozenset(
-    ext.name
-    for ext in iter_modules(("bot/cogs",), "bot.cogs.")
-    if ext.name[-1] != "_"
-)
+
+UNLOAD_BLACKLIST = {f"{exts.__name__}.utils.extensions", f"{exts.__name__}.moderation.modlog"}
+BASE_PATH_LEN = len(exts.__name__.split("."))
 
 
 class Action(Enum):
@@ -46,11 +44,25 @@ class Extension(commands.Converter):
 
         argument = argument.lower()
 
-        if "." not in argument:
-            argument = f"bot.cogs.{argument}"
-
         if argument in EXTENSIONS:
             return argument
+        elif (qualified_arg := f"{exts.__name__}.{argument}") in EXTENSIONS:
+            return qualified_arg
+
+        matches = []
+        for ext in EXTENSIONS:
+            if argument == unqualify(ext):
+                matches.append(ext)
+
+        if len(matches) > 1:
+            matches.sort()
+            names = "\n".join(matches)
+            raise commands.BadArgument(
+                f":x: `{argument}` is an ambiguous extension name. "
+                f"Please use one of the following fully-qualified names.```\n{names}```"
+            )
+        elif matches:
+            return matches[0]
         else:
             raise commands.BadArgument(f":x: Could not find the extension `{argument}`.")
 
@@ -138,27 +150,44 @@ class Extensions(commands.Cog):
         Grey indicates that the extension is unloaded.
         Green indicates that the extension is currently loaded.
         """
-        embed = Embed()
-        lines = []
-
-        embed.colour = Colour.blurple()
+        embed = Embed(colour=Colour.blurple())
         embed.set_author(
             name="Extensions List",
             url=URLs.github_bot_repo,
             icon_url=URLs.bot_avatar
         )
 
-        for ext in sorted(list(EXTENSIONS)):
+        lines = []
+        categories = self.group_extension_statuses()
+        for category, extensions in sorted(categories.items()):
+            # Treat each category as a single line by concatenating everything.
+            # This ensures the paginator will not cut off a page in the middle of a category.
+            category = category.replace("_", " ").title()
+            extensions = "\n".join(sorted(extensions))
+            lines.append(f"**{category}**\n{extensions}\n")
+
+        log.debug(f"{ctx.author} requested a list of all cogs. Returning a paginated list.")
+        await LinePaginator.paginate(lines, ctx, embed, scale_to_size=700, empty=False)
+
+    def group_extension_statuses(self) -> t.Mapping[str, str]:
+        """Return a mapping of extension names and statuses to their categories."""
+        categories = {}
+
+        for ext in EXTENSIONS:
             if ext in self.bot.extensions:
                 status = Emojis.status_online
             else:
                 status = Emojis.status_offline
 
-            ext = ext.rsplit(".", 1)[1]
-            lines.append(f"{status}  {ext}")
+            path = ext.split(".")
+            if len(path) > BASE_PATH_LEN + 1:
+                category = " - ".join(path[BASE_PATH_LEN:-1])
+            else:
+                category = "uncategorised"
 
-        log.debug(f"{ctx.author} requested a list of all cogs. Returning a paginated list.")
-        await LinePaginator.paginate(lines, ctx, embed, max_size=300, empty=False)
+            categories.setdefault(category, []).append(f"{status}  {path[-1]}")
+
+        return categories
 
     def batch_manage(self, action: Action, *extensions: str) -> str:
         """
diff --git a/bot/cogs/jams.py b/bot/exts/utils/jams.py
index 1c0988343..1c0988343 100644
--- a/bot/cogs/jams.py
+++ b/bot/exts/utils/jams.py
diff --git a/bot/cogs/reminders.py b/bot/exts/utils/reminders.py
index 6806f2889..6806f2889 100644
--- a/bot/cogs/reminders.py
+++ b/bot/exts/utils/reminders.py
diff --git a/bot/cogs/snekbox.py b/bot/exts/utils/snekbox.py
index 63e6d7f31..03bf454ac 100644
--- a/bot/cogs/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -14,6 +14,7 @@ from discord.ext.commands import Cog, Context, command, guild_only
 from bot.bot import Bot
 from bot.constants import Categories, Channels, Roles, URLs
 from bot.decorators import in_whitelist
+from bot.utils import send_to_paste_service
 from bot.utils.messages import wait_for_deletion
 
 log = logging.getLogger(__name__)
@@ -71,17 +72,7 @@ class Snekbox(Cog):
         if len(output) > MAX_PASTE_LEN:
             log.info("Full output is too long to upload")
             return "too long to upload"
-
-        url = URLs.paste_service.format(key="documents")
-        try:
-            async with self.bot.http_session.post(url, data=output, raise_for_status=True) as resp:
-                data = await resp.json()
-
-            if "key" in data:
-                return URLs.paste_service.format(key=data["key"])
-        except Exception:
-            # 400 (Bad Request) means there are too many characters
-            log.exception("Failed to upload full output to paste service!")
+        return await send_to_paste_service(self.bot.http_session, output, extension="txt")
 
     @staticmethod
     def prepare_input(code: str) -> str:
diff --git a/bot/cogs/utils.py b/bot/exts/utils/utils.py
index 6b6941064..6b6941064 100644
--- a/bot/cogs/utils.py
+++ b/bot/exts/utils/utils.py
diff --git a/bot/rules/burst_shared.py b/bot/rules/burst_shared.py
index bbe9271b3..0e66df69c 100644
--- a/bot/rules/burst_shared.py
+++ b/bot/rules/burst_shared.py
@@ -2,11 +2,20 @@ from typing import Dict, Iterable, List, Optional, Tuple
 
 from discord import Member, Message
 
+from bot.constants import Channels
+
 
 async def apply(
     last_message: Message, recent_messages: List[Message], config: Dict[str, int]
 ) -> Optional[Tuple[str, Iterable[Member], Iterable[Message]]]:
-    """Detects repeated messages sent by multiple users."""
+    """
+    Detects repeated messages sent by multiple users.
+
+    This filter never triggers in the verification channel.
+    """
+    if last_message.channel.id == Channels.verification:
+        return
+
     total_recent = len(recent_messages)
 
     if total_recent > config['max']:
diff --git a/bot/utils/__init__.py b/bot/utils/__init__.py
index 5a6e1811b..3e93fcb06 100644
--- a/bot/utils/__init__.py
+++ b/bot/utils/__init__.py
@@ -1,18 +1,5 @@
-from abc import ABCMeta
-
-from discord.ext.commands import CogMeta
-
+from bot.utils.helpers import CogABCMeta, find_nth_occurrence, pad_base64
 from bot.utils.redis_cache import RedisCache
+from bot.utils.services import send_to_paste_service
 
-__all__ = ['RedisCache', 'CogABCMeta']
-
-
-class CogABCMeta(CogMeta, ABCMeta):
-    """Metaclass for ABCs meant to be implemented as Cogs."""
-
-    pass
-
-
-def pad_base64(data: str) -> str:
-    """Return base64 `data` with padding characters to ensure its length is a multiple of 4."""
-    return data + "=" * (-len(data) % 4)
+__all__ = ['RedisCache', 'CogABCMeta', 'find_nth_occurrence', 'pad_base64', 'send_to_paste_service']
diff --git a/bot/utils/extensions.py b/bot/utils/extensions.py
new file mode 100644
index 000000000..50350ea8d
--- /dev/null
+++ b/bot/utils/extensions.py
@@ -0,0 +1,34 @@
+import importlib
+import inspect
+import pkgutil
+from typing import Iterator, NoReturn
+
+from bot import exts
+
+
+def unqualify(name: str) -> str:
+    """Return an unqualified name given a qualified module/package `name`."""
+    return name.rsplit(".", maxsplit=1)[-1]
+
+
+def walk_extensions() -> Iterator[str]:
+    """Yield extension names from the bot.exts subpackage."""
+
+    def on_error(name: str) -> NoReturn:
+        raise ImportError(name=name)  # pragma: no cover
+
+    for module in pkgutil.walk_packages(exts.__path__, f"{exts.__name__}.", onerror=on_error):
+        if unqualify(module.name).startswith("_"):
+            # Ignore module/package names starting with an underscore.
+            continue
+
+        if module.ispkg:
+            imported = importlib.import_module(module.name)
+            if not inspect.isfunction(getattr(imported, "setup", None)):
+                # If it lacks a setup function, it's not an extension.
+                continue
+
+        yield module.name
+
+
+EXTENSIONS = frozenset(walk_extensions())
diff --git a/bot/utils/helpers.py b/bot/utils/helpers.py
new file mode 100644
index 000000000..d9b60af07
--- /dev/null
+++ b/bot/utils/helpers.py
@@ -0,0 +1,23 @@
+from abc import ABCMeta
+from typing import Optional
+
+from discord.ext.commands import CogMeta
+
+
+class CogABCMeta(CogMeta, ABCMeta):
+    """Metaclass for ABCs meant to be implemented as Cogs."""
+
+
+def find_nth_occurrence(string: str, substring: str, n: int) -> Optional[int]:
+    """Return index of `n`th occurrence of `substring` in `string`, or None if not found."""
+    index = 0
+    for _ in range(n):
+        index = string.find(substring, index+1)
+        if index == -1:
+            return None
+    return index
+
+
+def pad_base64(data: str) -> str:
+    """Return base64 `data` with padding characters to ensure its length is a multiple of 4."""
+    return data + "=" * (-len(data) % 4)
diff --git a/bot/utils/services.py b/bot/utils/services.py
new file mode 100644
index 000000000..087b9f969
--- /dev/null
+++ b/bot/utils/services.py
@@ -0,0 +1,54 @@
+import logging
+from typing import Optional
+
+from aiohttp import ClientConnectorError, ClientSession
+
+from bot.constants import URLs
+
+log = logging.getLogger(__name__)
+
+FAILED_REQUEST_ATTEMPTS = 3
+
+
+async def send_to_paste_service(http_session: ClientSession, contents: str, *, extension: str = "") -> Optional[str]:
+    """
+    Upload `contents` to the paste service.
+
+    `http_session` should be the current running ClientSession from aiohttp
+    `extension` is added to the output URL
+
+    When an error occurs, `None` is returned, otherwise the generated URL with the suffix.
+    """
+    extension = extension and f".{extension}"
+    log.debug(f"Sending contents of size {len(contents.encode())} bytes to paste service.")
+    paste_url = URLs.paste_service.format(key="documents")
+    for attempt in range(1, FAILED_REQUEST_ATTEMPTS + 1):
+        try:
+            async with http_session.post(paste_url, data=contents) as response:
+                response_json = await response.json()
+        except ClientConnectorError:
+            log.warning(
+                f"Failed to connect to paste service at url {paste_url}, "
+                f"trying again ({attempt}/{FAILED_REQUEST_ATTEMPTS})."
+            )
+            continue
+        except Exception:
+            log.exception(
+                f"An unexpected error has occurred during handling of the request, "
+                f"trying again ({attempt}/{FAILED_REQUEST_ATTEMPTS})."
+            )
+            continue
+
+        if "message" in response_json:
+            log.warning(
+                f"Paste service returned error {response_json['message']} with status code {response.status}, "
+                f"trying again ({attempt}/{FAILED_REQUEST_ATTEMPTS})."
+            )
+            continue
+        elif "key" in response_json:
+            log.info(f"Successfully uploaded contents to paste service behind key {response_json['key']}.")
+            return URLs.paste_service.format(key=response_json['key']) + extension
+        log.warning(
+            f"Got unexpected JSON response from paste service: {response_json}\n"
+            f"trying again ({attempt}/{FAILED_REQUEST_ATTEMPTS})."
+        )
diff --git a/config-default.yml b/config-default.yml
index 6e7cff92d..58651f548 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -76,9 +76,10 @@ style:
         ducky_maul:     &DUCKY_MAUL     640137724958867467
         ducky_santa:    &DUCKY_SANTA    655360331002019870
 
-        upvotes:        "<:upvotes:638729835245731840>"
-        comments:       "<:comments:638729835073765387>"
-        user:           "<:user:638729835442602003>"
+        # emotes used for #reddit
+        upvotes:        "<:reddit_upvotes:755845219890757644>"
+        comments:       "<:reddit_comments:755845255001014384>"
+        user:           "<:reddit_users:755845303822974997>"
 
     icons:
         crown_blurple: "https://cdn.discordapp.com/emojis/469964153289965568.png"
@@ -134,6 +135,7 @@ style:
 
 guild:
     id: 267624335836053506
+    invite: "https://discord.gg/python"
 
     categories:
         help_available:                     691405807388196926
@@ -236,8 +238,8 @@ guild:
         partners:                               323426753857191936
         python_community:   &PY_COMMUNITY_ROLE  458226413825294336
 
-        # This is the Developers role on PyDis, here named verified for readability reasons
-        verified:                               352427296948486144
+        unverified:                             739794855945044069
+        verified:                               352427296948486144  # @Developers on PyDis
 
         # Staff
         admins:             &ADMINS_ROLE    267628507062992896
@@ -489,5 +491,18 @@ python_news:
     channel: *PYNEWS_CHANNEL
     webhook: *PYNEWS_WEBHOOK
 
+
+verification:
+    unverified_after: 3  # Days after which non-Developers receive the @Unverified role
+    kicked_after: 30  # Days after which non-Developers get kicked from the guild
+    reminder_frequency: 28  # Hours between @Unverified pings
+    bot_message_delete_delay: 10  # Seconds before deleting bots response in #verification
+
+    # Number in range [0, 1] determining the percentage of unverified users that are safe
+    # to be kicked from the guild in one batch, any larger amount will require staff confirmation,
+    # set this to 0 to require explicit approval for batches of any size
+    kick_confirmation_threshold: 0.01  # 1%
+
+
 config:
     required_keys: ['bot.token']
diff --git a/tests/bot/exts/__init__.py b/tests/bot/exts/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/__init__.py
diff --git a/tests/bot/exts/backend/__init__.py b/tests/bot/exts/backend/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/backend/__init__.py
diff --git a/tests/bot/exts/backend/sync/__init__.py b/tests/bot/exts/backend/sync/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/backend/sync/__init__.py
diff --git a/tests/bot/cogs/sync/test_base.py b/tests/bot/exts/backend/sync/test_base.py
index 70aea2bab..886c243cf 100644
--- a/tests/bot/cogs/sync/test_base.py
+++ b/tests/bot/exts/backend/sync/test_base.py
@@ -6,7 +6,7 @@ import discord
 
 from bot import constants
 from bot.api import ResponseCodeError
-from bot.cogs.sync.syncers import Syncer, _Diff
+from bot.exts.backend.sync._syncers import Syncer, _Diff
 from tests import helpers
 
 
diff --git a/tests/bot/cogs/sync/test_cog.py b/tests/bot/exts/backend/sync/test_cog.py
index 120bc991d..1b89564f2 100644
--- a/tests/bot/cogs/sync/test_cog.py
+++ b/tests/bot/exts/backend/sync/test_cog.py
@@ -5,8 +5,9 @@ import discord
 
 from bot import constants
 from bot.api import ResponseCodeError
-from bot.cogs import sync
-from bot.cogs.sync.syncers import Syncer
+from bot.exts.backend import sync
+from bot.exts.backend.sync._cog import Sync
+from bot.exts.backend.sync._syncers import Syncer
 from tests import helpers
 from tests.base import CommandTestCase
 
@@ -29,19 +30,19 @@ class SyncCogTestCase(unittest.IsolatedAsyncioTestCase):
         self.bot = helpers.MockBot()
 
         self.role_syncer_patcher = mock.patch(
-            "bot.cogs.sync.syncers.RoleSyncer",
+            "bot.exts.backend.sync._syncers.RoleSyncer",
             autospec=Syncer,
             spec_set=True
         )
         self.user_syncer_patcher = mock.patch(
-            "bot.cogs.sync.syncers.UserSyncer",
+            "bot.exts.backend.sync._syncers.UserSyncer",
             autospec=Syncer,
             spec_set=True
         )
         self.RoleSyncer = self.role_syncer_patcher.start()
         self.UserSyncer = self.user_syncer_patcher.start()
 
-        self.cog = sync.Sync(self.bot)
+        self.cog = Sync(self.bot)
 
     def tearDown(self):
         self.role_syncer_patcher.stop()
@@ -59,7 +60,7 @@ class SyncCogTestCase(unittest.IsolatedAsyncioTestCase):
 class SyncCogTests(SyncCogTestCase):
     """Tests for the Sync cog."""
 
-    @mock.patch.object(sync.Sync, "sync_guild", new_callable=mock.MagicMock)
+    @mock.patch.object(Sync, "sync_guild", new_callable=mock.MagicMock)
     def test_sync_cog_init(self, sync_guild):
         """Should instantiate syncers and run a sync for the guild."""
         # Reset because a Sync cog was already instantiated in setUp.
@@ -70,7 +71,7 @@ class SyncCogTests(SyncCogTestCase):
         mock_sync_guild_coro = mock.MagicMock()
         sync_guild.return_value = mock_sync_guild_coro
 
-        sync.Sync(self.bot)
+        Sync(self.bot)
 
         self.RoleSyncer.assert_called_once_with(self.bot)
         self.UserSyncer.assert_called_once_with(self.bot)
@@ -131,7 +132,7 @@ class SyncCogListenerTests(SyncCogTestCase):
         super().setUp()
         self.cog.patch_user = mock.AsyncMock(spec_set=self.cog.patch_user)
 
-        self.guild_id_patcher = mock.patch("bot.cogs.sync.cog.constants.Guild.id", 5)
+        self.guild_id_patcher = mock.patch("bot.exts.backend.sync._cog.constants.Guild.id", 5)
         self.guild_id = self.guild_id_patcher.start()
 
         self.guild = helpers.MockGuild(id=self.guild_id)
diff --git a/tests/bot/cogs/sync/test_roles.py b/tests/bot/exts/backend/sync/test_roles.py
index 79eee98f4..7b9f40cad 100644
--- a/tests/bot/cogs/sync/test_roles.py
+++ b/tests/bot/exts/backend/sync/test_roles.py
@@ -3,7 +3,7 @@ from unittest import mock
 
 import discord
 
-from bot.cogs.sync.syncers import RoleSyncer, _Diff, _Role
+from bot.exts.backend.sync._syncers import RoleSyncer, _Diff, _Role
 from tests import helpers
 
 
diff --git a/tests/bot/cogs/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index 002a947ad..c0a1da35c 100644
--- a/tests/bot/cogs/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -1,7 +1,7 @@
 import unittest
 from unittest import mock
 
-from bot.cogs.sync.syncers import UserSyncer, _Diff, _User
+from bot.exts.backend.sync._syncers import UserSyncer, _Diff, _User
 from tests import helpers
 
 
diff --git a/tests/bot/cogs/test_logging.py b/tests/bot/exts/backend/test_logging.py
index 8a18fdcd6..466f207d9 100644
--- a/tests/bot/cogs/test_logging.py
+++ b/tests/bot/exts/backend/test_logging.py
@@ -2,7 +2,7 @@ import unittest
 from unittest.mock import patch
 
 from bot import constants
-from bot.cogs.logging import Logging
+from bot.exts.backend.logging import Logging
 from tests.helpers import MockBot, MockTextChannel
 
 
@@ -14,7 +14,7 @@ class LoggingTests(unittest.IsolatedAsyncioTestCase):
         self.cog = Logging(self.bot)
         self.dev_log = MockTextChannel(id=1234, name="dev-log")
 
-    @patch("bot.cogs.logging.DEBUG_MODE", False)
+    @patch("bot.exts.backend.logging.DEBUG_MODE", False)
     async def test_debug_mode_false(self):
         """Should send connected message to dev-log."""
         self.bot.get_channel.return_value = self.dev_log
@@ -24,7 +24,7 @@ class LoggingTests(unittest.IsolatedAsyncioTestCase):
         self.bot.get_channel.assert_called_once_with(constants.Channels.dev_log)
         self.dev_log.send.assert_awaited_once()
 
-    @patch("bot.cogs.logging.DEBUG_MODE", True)
+    @patch("bot.exts.backend.logging.DEBUG_MODE", True)
     async def test_debug_mode_true(self):
         """Should not send anything to dev-log."""
         await self.cog.startup_greeting()
diff --git a/tests/bot/exts/filters/__init__.py b/tests/bot/exts/filters/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/filters/__init__.py
diff --git a/tests/bot/cogs/test_antimalware.py b/tests/bot/exts/filters/test_antimalware.py
index f50c0492d..3393c6cdc 100644
--- a/tests/bot/cogs/test_antimalware.py
+++ b/tests/bot/exts/filters/test_antimalware.py
@@ -3,8 +3,8 @@ from unittest.mock import AsyncMock, Mock
 
 from discord import NotFound
 
-from bot.cogs import antimalware
 from bot.constants import Channels, STAFF_ROLES
+from bot.exts.filters import antimalware
 from tests.helpers import MockAttachment, MockBot, MockMessage, MockRole
 
 
diff --git a/tests/bot/cogs/test_antispam.py b/tests/bot/exts/filters/test_antispam.py
index ce5472c71..6a0e4fded 100644
--- a/tests/bot/cogs/test_antispam.py
+++ b/tests/bot/exts/filters/test_antispam.py
@@ -1,6 +1,6 @@
 import unittest
 
-from bot.cogs import antispam
+from bot.exts.filters import antispam
 
 
 class AntispamConfigurationValidationTests(unittest.TestCase):
diff --git a/tests/bot/cogs/test_security.py b/tests/bot/exts/filters/test_security.py
index 9d1a62f7e..c0c3baa42 100644
--- a/tests/bot/cogs/test_security.py
+++ b/tests/bot/exts/filters/test_security.py
@@ -3,7 +3,7 @@ from unittest.mock import MagicMock
 
 from discord.ext.commands import NoPrivateMessage
 
-from bot.cogs import security
+from bot.exts.filters import security
 from tests.helpers import MockBot, MockContext
 
 
diff --git a/tests/bot/cogs/test_token_remover.py b/tests/bot/exts/filters/test_token_remover.py
index 3349caa73..a0ff8a877 100644
--- a/tests/bot/cogs/test_token_remover.py
+++ b/tests/bot/exts/filters/test_token_remover.py
@@ -6,9 +6,9 @@ from unittest.mock import MagicMock
 from discord import Colour, NotFound
 
 from bot import constants
-from bot.cogs import token_remover
-from bot.cogs.moderation import ModLog
-from bot.cogs.token_remover import Token, TokenRemover
+from bot.exts.filters import token_remover
+from bot.exts.filters.token_remover import Token, TokenRemover
+from bot.exts.moderation.modlog import ModLog
 from tests.helpers import MockBot, MockMessage, autospec
 
 
@@ -132,7 +132,7 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
             await cog.on_message(msg)
             find_token_in_message.assert_not_called()
 
-    @autospec("bot.cogs.token_remover", "TOKEN_RE")
+    @autospec("bot.exts.filters.token_remover", "TOKEN_RE")
     def test_find_token_no_matches(self, token_re):
         """None should be returned if the regex matches no tokens in a message."""
         token_re.finditer.return_value = ()
@@ -143,8 +143,8 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
         token_re.finditer.assert_called_once_with(self.msg.content)
 
     @autospec(TokenRemover, "is_valid_user_id", "is_valid_timestamp")
-    @autospec("bot.cogs.token_remover", "Token")
-    @autospec("bot.cogs.token_remover", "TOKEN_RE")
+    @autospec("bot.exts.filters.token_remover", "Token")
+    @autospec("bot.exts.filters.token_remover", "TOKEN_RE")
     def test_find_token_valid_match(self, token_re, token_cls, is_valid_id, is_valid_timestamp):
         """The first match with a valid user ID and timestamp should be returned as a `Token`."""
         matches = [
@@ -167,8 +167,8 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
         token_re.finditer.assert_called_once_with(self.msg.content)
 
     @autospec(TokenRemover, "is_valid_user_id", "is_valid_timestamp")
-    @autospec("bot.cogs.token_remover", "Token")
-    @autospec("bot.cogs.token_remover", "TOKEN_RE")
+    @autospec("bot.exts.filters.token_remover", "Token")
+    @autospec("bot.exts.filters.token_remover", "TOKEN_RE")
     def test_find_token_invalid_matches(self, token_re, token_cls, is_valid_id, is_valid_timestamp):
         """None should be returned if no matches have valid user IDs or timestamps."""
         token_re.finditer.return_value = [mock.create_autospec(Match, spec_set=True, instance=True)]
@@ -230,7 +230,7 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
         results = [match[0] for match in results]
         self.assertCountEqual((token_1, token_2), results)
 
-    @autospec("bot.cogs.token_remover", "LOG_MESSAGE")
+    @autospec("bot.exts.filters.token_remover", "LOG_MESSAGE")
     def test_format_log_message(self, log_message):
         """Should correctly format the log message with info from the message and token."""
         token = Token("NDY3MjIzMjMwNjUwNzc3NjQx", "XsySD_", "s45jqDV_Iisn-symw0yDRrk_jf4")
@@ -249,7 +249,7 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
         )
 
     @mock.patch.object(TokenRemover, "mod_log", new_callable=mock.PropertyMock)
-    @autospec("bot.cogs.token_remover", "log")
+    @autospec("bot.exts.filters.token_remover", "log")
     @autospec(TokenRemover, "format_log_message")
     async def test_take_action(self, format_log_message, logger, mod_log_property):
         """Should delete the message and send a mod log."""
@@ -299,7 +299,7 @@ class TokenRemoverTests(unittest.IsolatedAsyncioTestCase):
 class TokenRemoverExtensionTests(unittest.TestCase):
     """Tests for the token_remover extension."""
 
-    @autospec("bot.cogs.token_remover", "TokenRemover")
+    @autospec("bot.exts.filters.token_remover", "TokenRemover")
     def test_extension_setup(self, cog):
         """The TokenRemover cog should be added."""
         bot = MockBot()
diff --git a/tests/bot/exts/fun/__init__.py b/tests/bot/exts/fun/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/fun/__init__.py
diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/exts/fun/test_duck_pond.py
index cfe10aebf..704b08066 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/exts/fun/test_duck_pond.py
@@ -7,11 +7,11 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import discord
 
 from bot import constants
-from bot.cogs import duck_pond
+from bot.exts.fun import duck_pond
 from tests import base
 from tests import helpers
 
-MODULE_PATH = "bot.cogs.duck_pond"
+MODULE_PATH = "bot.exts.fun.duck_pond"
 
 
 class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
@@ -63,7 +63,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
         self.bot.fetch_webhook.side_effect = discord.HTTPException(response=MagicMock(), message="Not found.")
         self.cog.webhook_id = 1
 
-        log = logging.getLogger('bot.cogs.duck_pond')
+        log = logging.getLogger(MODULE_PATH)
         with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
             asyncio.run(self.cog.fetch_webhook())
 
@@ -282,7 +282,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
         side_effects = (discord.errors.Forbidden(MagicMock(), ""), discord.errors.NotFound(MagicMock(), ""))
 
         self.cog.webhook = helpers.MockAsyncWebhook()
-        log = logging.getLogger("bot.cogs.duck_pond")
+        log = logging.getLogger(MODULE_PATH)
 
         for side_effect in side_effects:  # pragma: no cover
             send_attachments.side_effect = side_effect
@@ -300,7 +300,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
         message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
 
         self.cog.webhook = helpers.MockAsyncWebhook()
-        log = logging.getLogger("bot.cogs.duck_pond")
+        log = logging.getLogger(MODULE_PATH)
 
         side_effect = discord.HTTPException(MagicMock(), "")
         send_attachments.side_effect = side_effect
diff --git a/tests/bot/exts/info/__init__.py b/tests/bot/exts/info/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/info/__init__.py
diff --git a/tests/bot/cogs/test_information.py b/tests/bot/exts/info/test_information.py
index 77b0ddf17..ba8d5d608 100644
--- a/tests/bot/cogs/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -6,11 +6,11 @@ import unittest.mock
 import discord
 
 from bot import constants
-from bot.cogs import information
+from bot.exts.info import information
 from bot.utils.checks import InWhitelistCheckFailure
 from tests import helpers
 
-COG_PATH = "bot.cogs.information.Information"
+COG_PATH = "bot.exts.info.information.Information"
 
 
 class InformationCogTests(unittest.TestCase):
@@ -97,7 +97,7 @@ class InformationCogTests(unittest.TestCase):
         self.assertEqual(admin_embed.title, "Admins info")
         self.assertEqual(admin_embed.colour, discord.Colour.red())
 
-    @unittest.mock.patch('bot.cogs.information.time_since')
+    @unittest.mock.patch('bot.exts.info.information.time_since')
     def test_server_info_command(self, time_since_patch):
         time_since_patch.return_value = '2 days ago'
 
@@ -339,8 +339,8 @@ class UserInfractionHelperMethodTests(unittest.TestCase):
         self._method_subtests(self.cog.user_nomination_counts, test_values, header)
 
 
[email protected]("bot.cogs.information.time_since", new=unittest.mock.MagicMock(return_value="1 year ago"))
[email protected]("bot.cogs.information.constants.MODERATION_CHANNELS", new=[50])
[email protected]("bot.exts.info.information.time_since", new=unittest.mock.MagicMock(return_value="1 year ago"))
[email protected]("bot.exts.info.information.constants.MODERATION_CHANNELS", new=[50])
 class UserEmbedTests(unittest.TestCase):
     """Tests for the creation of the `!user` embed."""
 
@@ -515,7 +515,7 @@ class UserEmbedTests(unittest.TestCase):
         self.assertEqual(embed.thumbnail.url, "avatar url")
 
 
[email protected]("bot.cogs.information.constants")
[email protected]("bot.exts.info.information.constants")
 class UserCommandTests(unittest.TestCase):
     """Tests for the `!user` command."""
 
@@ -554,7 +554,7 @@ class UserCommandTests(unittest.TestCase):
         with self.assertRaises(InWhitelistCheckFailure, msg=msg):
             asyncio.run(self.cog.user_info.callback(self.cog, ctx))
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
+    @unittest.mock.patch("bot.exts.info.information.Information.create_user_embed")
     def test_regular_user_may_use_command_in_bot_commands_channel(self, create_embed, constants):
         """A regular user should be allowed to use `!user` targeting themselves in bot-commands."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -567,7 +567,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.author)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
+    @unittest.mock.patch("bot.exts.info.information.Information.create_user_embed")
     def test_regular_user_can_explicitly_target_themselves(self, create_embed, constants):
         """A user should target itself with `!user` when a `user` argument was not provided."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -580,7 +580,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.author)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
+    @unittest.mock.patch("bot.exts.info.information.Information.create_user_embed")
     def test_staff_members_can_bypass_channel_restriction(self, create_embed, constants):
         """Staff members should be able to bypass the bot-commands channel restriction."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -593,7 +593,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.moderator)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
+    @unittest.mock.patch("bot.exts.info.information.Information.create_user_embed")
     def test_moderators_can_target_another_member(self, create_embed, constants):
         """A moderator should be able to use `!user` targeting another user."""
         constants.MODERATION_ROLES = [self.moderator_role.id]
diff --git a/tests/bot/exts/moderation/__init__.py b/tests/bot/exts/moderation/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/moderation/__init__.py
diff --git a/tests/bot/exts/moderation/infraction/__init__.py b/tests/bot/exts/moderation/infraction/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/moderation/infraction/__init__.py
diff --git a/tests/bot/cogs/moderation/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index da4e92ccc..be1b649e1 100644
--- a/tests/bot/cogs/moderation/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -2,7 +2,7 @@ import textwrap
 import unittest
 from unittest.mock import AsyncMock, Mock, patch
 
-from bot.cogs.moderation.infractions import Infractions
+from bot.exts.moderation.infraction.infractions import Infractions
 from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole
 
 
@@ -17,8 +17,8 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
         self.guild = MockGuild(id=4567)
         self.ctx = MockContext(bot=self.bot, author=self.user, guild=self.guild)
 
-    @patch("bot.cogs.moderation.utils.get_active_infraction")
-    @patch("bot.cogs.moderation.utils.post_infraction")
+    @patch("bot.exts.moderation.infraction._utils.get_active_infraction")
+    @patch("bot.exts.moderation.infraction._utils.post_infraction")
     async def test_apply_ban_reason_truncation(self, post_infraction_mock, get_active_mock):
         """Should truncate reason for `ctx.guild.ban`."""
         get_active_mock.return_value = None
@@ -39,7 +39,7 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
             self.ctx, {"foo": "bar"}, self.target, self.ctx.guild.ban.return_value
         )
 
-    @patch("bot.cogs.moderation.utils.post_infraction")
+    @patch("bot.exts.moderation.infraction._utils.post_infraction")
     async def test_apply_kick_reason_truncation(self, post_infraction_mock):
         """Should truncate reason for `Member.kick`."""
         post_infraction_mock.return_value = {"foo": "bar"}
diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
new file mode 100644
index 000000000..5b62463e0
--- /dev/null
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -0,0 +1,359 @@
+import unittest
+from collections import namedtuple
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, call, patch
+
+from discord import Embed, Forbidden, HTTPException, NotFound
+
+from bot.api import ResponseCodeError
+from bot.constants import Colours, Icons
+from bot.exts.moderation.infraction import _utils as utils
+from tests.helpers import MockBot, MockContext, MockMember, MockUser
+
+
+class ModerationUtilsTests(unittest.IsolatedAsyncioTestCase):
+    """Tests Moderation utils."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.member = MockMember(id=1234)
+        self.user = MockUser(id=1234)
+        self.ctx = MockContext(bot=self.bot, author=self.member)
+
+    async def test_post_user(self):
+        """Should POST a new user and return the response if successful or otherwise send an error message."""
+        user = MockUser(discriminator=5678, id=1234, name="Test user")
+        not_user = MagicMock(discriminator=3333, id=5678, name="Wrong user")
+        test_cases = [
+            {
+                "user": user,
+                "post_result": "bar",
+                "raise_error": None,
+                "payload": {
+                    "discriminator": 5678,
+                    "id": self.user.id,
+                    "in_guild": False,
+                    "name": "Test user",
+                    "roles": []
+                }
+            },
+            {
+                "user": self.member,
+                "post_result": "foo",
+                "raise_error": ResponseCodeError(MagicMock(status=400), "foo"),
+                "payload": {
+                    "discriminator": 0,
+                    "id": self.member.id,
+                    "in_guild": False,
+                    "name": "Name unknown",
+                    "roles": []
+                }
+            },
+            {
+                "user": not_user,
+                "post_result": "bar",
+                "raise_error": None,
+                "payload": {
+                    "discriminator": not_user.discriminator,
+                    "id": not_user.id,
+                    "in_guild": False,
+                    "name": not_user.name,
+                    "roles": []
+                }
+            }
+        ]
+
+        for case in test_cases:
+            user = case["user"]
+            post_result = case["post_result"]
+            raise_error = case["raise_error"]
+            payload = case["payload"]
+
+            with self.subTest(user=user, post_result=post_result, raise_error=raise_error, payload=payload):
+                self.bot.api_client.post.reset_mock(side_effect=True)
+                self.ctx.bot.api_client.post.return_value = post_result
+
+                self.ctx.bot.api_client.post.side_effect = raise_error
+
+                result = await utils.post_user(self.ctx, user)
+
+                if raise_error:
+                    self.assertIsNone(result)
+                    self.ctx.send.assert_awaited_once()
+                    self.assertIn(str(raise_error.status), self.ctx.send.call_args[0][0])
+                else:
+                    self.assertEqual(result, post_result)
+                    self.bot.api_client.post.assert_awaited_once_with("bot/users", json=payload)
+
+    async def test_get_active_infraction(self):
+        """
+        Should request the API for active infractions and return infraction if the user has one or `None` otherwise.
+
+        A message should be sent to the context indicating a user already has an infraction, if that's the case.
+        """
+        test_case = namedtuple("test_case", ["get_return_value", "expected_output", "infraction_nr", "send_msg"])
+        test_cases = [
+            test_case([], None, None, True),
+            test_case([{"id": 123987}], {"id": 123987}, "123987", False),
+            test_case([{"id": 123987}], {"id": 123987}, "123987", True)
+        ]
+
+        for case in test_cases:
+            with self.subTest(return_value=case.get_return_value, expected=case.expected_output):
+                self.bot.api_client.get.reset_mock()
+                self.ctx.send.reset_mock()
+
+                params = {
+                    "active": "true",
+                    "type": "ban",
+                    "user__id": str(self.member.id)
+                }
+
+                self.bot.api_client.get.return_value = case.get_return_value
+
+                result = await utils.get_active_infraction(self.ctx, self.member, "ban", send_msg=case.send_msg)
+                self.assertEqual(result, case.expected_output)
+                self.bot.api_client.get.assert_awaited_once_with("bot/infractions", params=params)
+
+                if case.send_msg and case.get_return_value:
+                    self.ctx.send.assert_awaited_once()
+                    sent_message = self.ctx.send.call_args[0][0]
+                    self.assertIn(case.infraction_nr, sent_message)
+                    self.assertIn("ban", sent_message)
+                else:
+                    self.ctx.send.assert_not_awaited()
+
+    @patch("bot.exts.moderation.infraction._utils.send_private_embed")
+    async def test_notify_infraction(self, send_private_embed_mock):
+        """
+        Should send an embed of a certain format as a DM and return `True` if DM successful.
+
+        Appealable infractions should have the appeal message in the embed's footer.
+        """
+        test_cases = [
+            {
+                "args": (self.user, "ban", "2020-02-26 09:20 (23 hours and 59 minutes)"),
+                "expected_output": Embed(
+                    title=utils.INFRACTION_TITLE,
+                    description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
+                        type="Ban",
+                        expires="2020-02-26 09:20 (23 hours and 59 minutes)",
+                        reason="No reason provided."
+                    ),
+                    colour=Colours.soft_red,
+                    url=utils.RULES_URL
+                ).set_author(
+                    name=utils.INFRACTION_AUTHOR_NAME,
+                    url=utils.RULES_URL,
+                    icon_url=Icons.token_removed
+                ).set_footer(text=utils.INFRACTION_APPEAL_FOOTER),
+                "send_result": True
+            },
+            {
+                "args": (self.user, "warning", None, "Test reason."),
+                "expected_output": Embed(
+                    title=utils.INFRACTION_TITLE,
+                    description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
+                        type="Warning",
+                        expires="N/A",
+                        reason="Test reason."
+                    ),
+                    colour=Colours.soft_red,
+                    url=utils.RULES_URL
+                ).set_author(
+                    name=utils.INFRACTION_AUTHOR_NAME,
+                    url=utils.RULES_URL,
+                    icon_url=Icons.token_removed
+                ),
+                "send_result": False
+            },
+            {
+                "args": (self.user, "note", None, None, Icons.defcon_denied),
+                "expected_output": Embed(
+                    title=utils.INFRACTION_TITLE,
+                    description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
+                        type="Note",
+                        expires="N/A",
+                        reason="No reason provided."
+                    ),
+                    colour=Colours.soft_red,
+                    url=utils.RULES_URL
+                ).set_author(
+                    name=utils.INFRACTION_AUTHOR_NAME,
+                    url=utils.RULES_URL,
+                    icon_url=Icons.defcon_denied
+                ),
+                "send_result": False
+            },
+            {
+                "args": (self.user, "mute", "2020-02-26 09:20 (23 hours and 59 minutes)", "Test", Icons.defcon_denied),
+                "expected_output": Embed(
+                    title=utils.INFRACTION_TITLE,
+                    description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
+                        type="Mute",
+                        expires="2020-02-26 09:20 (23 hours and 59 minutes)",
+                        reason="Test"
+                    ),
+                    colour=Colours.soft_red,
+                    url=utils.RULES_URL
+                ).set_author(
+                    name=utils.INFRACTION_AUTHOR_NAME,
+                    url=utils.RULES_URL,
+                    icon_url=Icons.defcon_denied
+                ).set_footer(text=utils.INFRACTION_APPEAL_FOOTER),
+                "send_result": False
+            },
+            {
+                "args": (self.user, "mute", None, "foo bar" * 4000, Icons.defcon_denied),
+                "expected_output": Embed(
+                    title=utils.INFRACTION_TITLE,
+                    description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
+                        type="Mute",
+                        expires="N/A",
+                        reason="foo bar" * 4000
+                    )[:2045] + "...",
+                    colour=Colours.soft_red,
+                    url=utils.RULES_URL
+                ).set_author(
+                    name=utils.INFRACTION_AUTHOR_NAME,
+                    url=utils.RULES_URL,
+                    icon_url=Icons.defcon_denied
+                ).set_footer(text=utils.INFRACTION_APPEAL_FOOTER),
+                "send_result": True
+            }
+        ]
+
+        for case in test_cases:
+            with self.subTest(args=case["args"], expected=case["expected_output"], send=case["send_result"]):
+                send_private_embed_mock.reset_mock()
+
+                send_private_embed_mock.return_value = case["send_result"]
+                result = await utils.notify_infraction(*case["args"])
+
+                self.assertEqual(case["send_result"], result)
+
+                embed = send_private_embed_mock.call_args[0][1]
+
+                self.assertEqual(embed.to_dict(), case["expected_output"].to_dict())
+
+                send_private_embed_mock.assert_awaited_once_with(case["args"][0], embed)
+
+    @patch("bot.exts.moderation.infraction._utils.send_private_embed")
+    async def test_notify_pardon(self, send_private_embed_mock):
+        """Should send an embed of a certain format as a DM and return `True` if DM successful."""
+        test_case = namedtuple("test_case", ["args", "icon", "send_result"])
+        test_cases = [
+            test_case((self.user, "Test title", "Example content"), Icons.user_verified, True),
+            test_case((self.user, "Test title", "Example content", Icons.user_update), Icons.user_update, False)
+        ]
+
+        for case in test_cases:
+            expected = Embed(
+                description="Example content",
+                colour=Colours.soft_green
+            ).set_author(
+                name="Test title",
+                icon_url=case.icon
+            )
+
+            with self.subTest(args=case.args, expected=expected):
+                send_private_embed_mock.reset_mock()
+
+                send_private_embed_mock.return_value = case.send_result
+
+                result = await utils.notify_pardon(*case.args)
+                self.assertEqual(case.send_result, result)
+
+                embed = send_private_embed_mock.call_args[0][1]
+                self.assertEqual(embed.to_dict(), expected.to_dict())
+
+                send_private_embed_mock.assert_awaited_once_with(case.args[0], embed)
+
+    async def test_send_private_embed(self):
+        """Should DM the user and return `True` on success or `False` on failure."""
+        embed = Embed(title="Test", description="Test val")
+
+        test_case = namedtuple("test_case", ["expected_output", "raised_exception"])
+        test_cases = [
+            test_case(True, None),
+            test_case(False, HTTPException(AsyncMock(), AsyncMock())),
+            test_case(False, Forbidden(AsyncMock(), AsyncMock())),
+            test_case(False, NotFound(AsyncMock(), AsyncMock()))
+        ]
+
+        for case in test_cases:
+            with self.subTest(expected=case.expected_output, raised=case.raised_exception):
+                self.user.send.reset_mock(side_effect=True)
+                self.user.send.side_effect = case.raised_exception
+
+                result = await utils.send_private_embed(self.user, embed)
+
+                self.assertEqual(result, case.expected_output)
+                self.user.send.assert_awaited_once_with(embed=embed)
+
+
+class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
+    """Tests for the `post_infraction` function."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.member = MockMember(id=1234)
+        self.user = MockUser(id=1234)
+        self.ctx = MockContext(bot=self.bot, author=self.member)
+
+    async def test_normal_post_infraction(self):
+        """Should return response from POST request if there are no errors."""
+        now = datetime.now()
+        payload = {
+            "actor": self.ctx.author.id,
+            "hidden": True,
+            "reason": "Test reason",
+            "type": "ban",
+            "user": self.member.id,
+            "active": False,
+            "expires_at": now.isoformat()
+        }
+
+        self.ctx.bot.api_client.post.return_value = "foo"
+        actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
+
+        self.assertEqual(actual, "foo")
+        self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
+
+    async def test_unknown_error_post_infraction(self):
+        """Should send an error message to chat when a non-400 error occurs."""
+        self.ctx.bot.api_client.post.side_effect = ResponseCodeError(AsyncMock(), AsyncMock())
+        self.ctx.bot.api_client.post.side_effect.status = 500
+
+        actual = await utils.post_infraction(self.ctx, self.user, "ban", "Test reason")
+        self.assertIsNone(actual)
+
+        self.assertTrue("500" in self.ctx.send.call_args[0][0])
+
+    @patch("bot.exts.moderation.infraction._utils.post_user", return_value=None)
+    async def test_user_not_found_none_post_infraction(self, post_user_mock):
+        """Should abort and return `None` when a new user fails to be posted."""
+        self.bot.api_client.post.side_effect = ResponseCodeError(MagicMock(status=400), {"user": "foo"})
+
+        actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
+        self.assertIsNone(actual)
+        post_user_mock.assert_awaited_once_with(self.ctx, self.user)
+
+    @patch("bot.exts.moderation.infraction._utils.post_user", return_value="bar")
+    async def test_first_fail_second_success_user_post_infraction(self, post_user_mock):
+        """Should post the user if they don't exist, POST infraction again, and return the response if successful."""
+        payload = {
+            "actor": self.ctx.author.id,
+            "hidden": False,
+            "reason": "Test reason",
+            "type": "mute",
+            "user": self.user.id,
+            "active": True
+        }
+
+        self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
+
+        actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
+        self.assertEqual(actual, "foo")
+        self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
+        post_user_mock.assert_awaited_once_with(self.ctx, self.user)
diff --git a/tests/bot/cogs/moderation/test_incidents.py b/tests/bot/exts/moderation/test_incidents.py
index 435a1cd51..cbf7f7bcf 100644
--- a/tests/bot/cogs/moderation/test_incidents.py
+++ b/tests/bot/exts/moderation/test_incidents.py
@@ -8,8 +8,8 @@ from unittest.mock import AsyncMock, MagicMock, call, patch
 import aiohttp
 import discord
 
-from bot.cogs.moderation import Incidents, incidents
 from bot.constants import Colours
+from bot.exts.moderation import incidents
 from tests.helpers import (
     MockAsyncWebhook,
     MockAttachment,
@@ -130,7 +130,7 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
         incident = MockMessage(content="this is an incident", attachments=[attachment])
 
         # Patch `download_file` to return our `file`
-        with patch("bot.cogs.moderation.incidents.download_file", AsyncMock(return_value=file)):
+        with patch("bot.exts.moderation.incidents.download_file", AsyncMock(return_value=file)):
             embed, returned_file = await incidents.make_embed(incident, incidents.Signal.ACTIONED, MockMember())
 
         self.assertIs(file, returned_file)
@@ -142,7 +142,7 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
         incident = MockMessage(content="this is an incident", attachments=[attachment])
 
         # Patch `download_file` to return None as if the download failed
-        with patch("bot.cogs.moderation.incidents.download_file", AsyncMock(return_value=None)):
+        with patch("bot.exts.moderation.incidents.download_file", AsyncMock(return_value=None)):
             embed, returned_file = await incidents.make_embed(incident, incidents.Signal.ACTIONED, MockMember())
 
         self.assertIsNone(returned_file)
@@ -215,7 +215,7 @@ class TestOwnReactions(unittest.TestCase):
         self.assertSetEqual(incidents.own_reactions(message), {"A", "B"})
 
 
-@patch("bot.cogs.moderation.incidents.ALL_SIGNALS", {"A", "B"})
+@patch("bot.exts.moderation.incidents.ALL_SIGNALS", {"A", "B"})
 class TestHasSignals(unittest.TestCase):
     """
     Assertions for the `has_signals` function.
@@ -229,7 +229,7 @@ class TestHasSignals(unittest.TestCase):
         message = MockMessage()
         own_reactions = MagicMock(return_value={"A", "B"})
 
-        with patch("bot.cogs.moderation.incidents.own_reactions", own_reactions):
+        with patch("bot.exts.moderation.incidents.own_reactions", own_reactions):
             self.assertTrue(incidents.has_signals(message))
 
     def test_has_signals_false(self):
@@ -237,11 +237,11 @@ class TestHasSignals(unittest.TestCase):
         message = MockMessage()
         own_reactions = MagicMock(return_value={"A", "C"})
 
-        with patch("bot.cogs.moderation.incidents.own_reactions", own_reactions):
+        with patch("bot.exts.moderation.incidents.own_reactions", own_reactions):
             self.assertFalse(incidents.has_signals(message))
 
 
-@patch("bot.cogs.moderation.incidents.Signal", MockSignal)
+@patch("bot.exts.moderation.incidents.Signal", MockSignal)
 class TestAddSignals(unittest.IsolatedAsyncioTestCase):
     """
     Assertions for the `add_signals` coroutine.
@@ -255,19 +255,19 @@ class TestAddSignals(unittest.IsolatedAsyncioTestCase):
         """Prepare a mock incident message for tests to use."""
         self.incident = MockMessage()
 
-    @patch("bot.cogs.moderation.incidents.own_reactions", MagicMock(return_value=set()))
+    @patch("bot.exts.moderation.incidents.own_reactions", MagicMock(return_value=set()))
     async def test_add_signals_missing(self):
         """All emoji are added when none are present."""
         await incidents.add_signals(self.incident)
         self.incident.add_reaction.assert_has_calls([call("A"), call("B")])
 
-    @patch("bot.cogs.moderation.incidents.own_reactions", MagicMock(return_value={"A"}))
+    @patch("bot.exts.moderation.incidents.own_reactions", MagicMock(return_value={"A"}))
     async def test_add_signals_partial(self):
         """Only missing emoji are added when some are present."""
         await incidents.add_signals(self.incident)
         self.incident.add_reaction.assert_has_calls([call("B")])
 
-    @patch("bot.cogs.moderation.incidents.own_reactions", MagicMock(return_value={"A", "B"}))
+    @patch("bot.exts.moderation.incidents.own_reactions", MagicMock(return_value={"A", "B"}))
     async def test_add_signals_present(self):
         """No emoji are added when all are present."""
         await incidents.add_signals(self.incident)
@@ -290,7 +290,7 @@ class TestIncidents(unittest.IsolatedAsyncioTestCase):
         Note that this will not schedule `crawl_incidents` in the background, as everything
         is being mocked. The `crawl_task` attribute will end up being None.
         """
-        self.cog_instance = Incidents(MockBot())
+        self.cog_instance = incidents.Incidents(MockBot())
 
 
 @patch("asyncio.sleep", AsyncMock())  # Prevent the coro from sleeping to speed up the test
@@ -326,25 +326,25 @@ class TestCrawlIncidents(TestIncidents):
         await self.cog_instance.crawl_incidents()
         self.cog_instance.bot.wait_until_guild_available.assert_awaited()
 
-    @patch("bot.cogs.moderation.incidents.add_signals", AsyncMock())
-    @patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=False))  # Message doesn't qualify
-    @patch("bot.cogs.moderation.incidents.has_signals", MagicMock(return_value=False))
+    @patch("bot.exts.moderation.incidents.add_signals", AsyncMock())
+    @patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=False))  # Message doesn't qualify
+    @patch("bot.exts.moderation.incidents.has_signals", MagicMock(return_value=False))
     async def test_crawl_incidents_noop_if_is_not_incident(self):
         """Signals are not added for a non-incident message."""
         await self.cog_instance.crawl_incidents()
         incidents.add_signals.assert_not_awaited()
 
-    @patch("bot.cogs.moderation.incidents.add_signals", AsyncMock())
-    @patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=True))  # Message qualifies
-    @patch("bot.cogs.moderation.incidents.has_signals", MagicMock(return_value=True))  # But already has signals
+    @patch("bot.exts.moderation.incidents.add_signals", AsyncMock())
+    @patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=True))  # Message qualifies
+    @patch("bot.exts.moderation.incidents.has_signals", MagicMock(return_value=True))  # But already has signals
     async def test_crawl_incidents_noop_if_message_already_has_signals(self):
         """Signals are not added for messages which already have them."""
         await self.cog_instance.crawl_incidents()
         incidents.add_signals.assert_not_awaited()
 
-    @patch("bot.cogs.moderation.incidents.add_signals", AsyncMock())
-    @patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=True))  # Message qualifies
-    @patch("bot.cogs.moderation.incidents.has_signals", MagicMock(return_value=False))  # And doesn't have signals
+    @patch("bot.exts.moderation.incidents.add_signals", AsyncMock())
+    @patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=True))  # Message qualifies
+    @patch("bot.exts.moderation.incidents.has_signals", MagicMock(return_value=False))  # And doesn't have signals
     async def test_crawl_incidents_add_signals_called(self):
         """Message has signals added as it does not have them yet and qualifies as an incident."""
         await self.cog_instance.crawl_incidents()
@@ -384,7 +384,7 @@ class TestArchive(TestIncidents):
         )
         built_embed = MagicMock(discord.Embed, id=123)  # We patch `make_embed` to return this
 
-        with patch("bot.cogs.moderation.incidents.make_embed", AsyncMock(return_value=(built_embed, None))):
+        with patch("bot.exts.moderation.incidents.make_embed", AsyncMock(return_value=(built_embed, None))):
             archive_return = await self.cog_instance.archive(incident, MagicMock(value="A"), MockMember())
 
         # Now we check that the webhook was given the correct args, and that `archive` returned True
@@ -451,8 +451,8 @@ class TestMakeConfirmationTask(TestIncidents):
         self.assertFalse(created_check(payload=MagicMock(message_id=0)))
 
 
-@patch("bot.cogs.moderation.incidents.ALLOWED_ROLES", {1, 2})
-@patch("bot.cogs.moderation.incidents.Incidents.make_confirmation_task", AsyncMock())  # Generic awaitable
+@patch("bot.exts.moderation.incidents.ALLOWED_ROLES", {1, 2})
+@patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", AsyncMock())  # Generic awaitable
 class TestProcessEvent(TestIncidents):
     """Tests for the `Incidents.process_event` coroutine."""
 
@@ -479,7 +479,7 @@ class TestProcessEvent(TestIncidents):
 
     async def test_process_event_no_archive_on_investigating(self):
         """Message is not archived on `Signal.INVESTIGATING`."""
-        with patch("bot.cogs.moderation.incidents.Incidents.archive", AsyncMock()) as mocked_archive:
+        with patch("bot.exts.moderation.incidents.Incidents.archive", AsyncMock()) as mocked_archive:
             await self.cog_instance.process_event(
                 reaction=incidents.Signal.INVESTIGATING.value,
                 incident=MockMessage(),
@@ -497,7 +497,7 @@ class TestProcessEvent(TestIncidents):
         """
         incident = MockMessage()
 
-        with patch("bot.cogs.moderation.incidents.Incidents.archive", AsyncMock(return_value=False)):
+        with patch("bot.exts.moderation.incidents.Incidents.archive", AsyncMock(return_value=False)):
             await self.cog_instance.process_event(
                 reaction=incidents.Signal.ACTIONED.value,
                 incident=incident,
@@ -510,7 +510,7 @@ class TestProcessEvent(TestIncidents):
         """Task given by `Incidents.make_confirmation_task` is awaited before method exits."""
         mock_task = AsyncMock()
 
-        with patch("bot.cogs.moderation.incidents.Incidents.make_confirmation_task", mock_task):
+        with patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", mock_task):
             await self.cog_instance.process_event(
                 reaction=incidents.Signal.ACTIONED.value,
                 incident=MockMessage(),
@@ -530,7 +530,7 @@ class TestProcessEvent(TestIncidents):
         mock_task = AsyncMock(side_effect=asyncio.TimeoutError())
 
         try:
-            with patch("bot.cogs.moderation.incidents.Incidents.make_confirmation_task", mock_task):
+            with patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", mock_task):
                 await self.cog_instance.process_event(
                     reaction=incidents.Signal.ACTIONED.value,
                     incident=MockMessage(),
@@ -712,7 +712,7 @@ class TestOnRawReactionAdd(TestIncidents):
         self.cog_instance.process_event = AsyncMock()
         self.cog_instance.resolve_message = AsyncMock(return_value=MockMessage())
 
-        with patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=False)):
+        with patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=False)):
             await self.cog_instance.on_raw_reaction_add(self.payload)
 
         self.cog_instance.process_event.assert_not_called()
@@ -733,7 +733,7 @@ class TestOnRawReactionAdd(TestIncidents):
         self.cog_instance.process_event = AsyncMock()
         self.cog_instance.resolve_message = AsyncMock(return_value=incident)
 
-        with patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=True)):
+        with patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=True)):
             await self.cog_instance.on_raw_reaction_add(self.payload)
 
         self.cog_instance.process_event.assert_called_with(
@@ -751,20 +751,20 @@ class TestOnMessage(TestIncidents):
     function is tested in `TestIsIncident` - here we do not worry about it.
     """
 
-    @patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=True))
+    @patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=True))
     async def test_on_message_incident(self):
         """Messages qualifying as incidents are passed to `add_signals`."""
         incident = MockMessage()
 
-        with patch("bot.cogs.moderation.incidents.add_signals", AsyncMock()) as mock_add_signals:
+        with patch("bot.exts.moderation.incidents.add_signals", AsyncMock()) as mock_add_signals:
             await self.cog_instance.on_message(incident)
 
         mock_add_signals.assert_called_once_with(incident)
 
-    @patch("bot.cogs.moderation.incidents.is_incident", MagicMock(return_value=False))
+    @patch("bot.exts.moderation.incidents.is_incident", MagicMock(return_value=False))
     async def test_on_message_non_incident(self):
         """Messages not qualifying as incidents are ignored."""
-        with patch("bot.cogs.moderation.incidents.add_signals", AsyncMock()) as mock_add_signals:
+        with patch("bot.exts.moderation.incidents.add_signals", AsyncMock()) as mock_add_signals:
             await self.cog_instance.on_message(MockMessage())
 
         mock_add_signals.assert_not_called()
diff --git a/tests/bot/cogs/moderation/test_modlog.py b/tests/bot/exts/moderation/test_modlog.py
index f2809f40a..f8f142484 100644
--- a/tests/bot/cogs/moderation/test_modlog.py
+++ b/tests/bot/exts/moderation/test_modlog.py
@@ -2,7 +2,7 @@ import unittest
 
 import discord
 
-from bot.cogs.moderation.modlog import ModLog
+from bot.exts.moderation.modlog import ModLog
 from tests.helpers import MockBot, MockTextChannel
 
 
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 5a664b1f8..e2d44c637 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -4,8 +4,8 @@ from unittest.mock import MagicMock, Mock
 
 from discord import PermissionOverwrite
 
-from bot.cogs.moderation.silence import Silence, SilenceNotifier
 from bot.constants import Channels, Emojis, Guild, Roles
+from bot.exts.moderation.silence import Silence, SilenceNotifier
 from tests.helpers import MockBot, MockContext, MockTextChannel
 
 
@@ -99,7 +99,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
-    @mock.patch("bot.cogs.moderation.silence.SilenceNotifier")
+    @mock.patch("bot.exts.moderation.silence.SilenceNotifier")
     async def test_instance_vars_got_notifier(self, notifier):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
@@ -238,7 +238,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         del mock_permissions_dict['send_messages']
         self.assertDictEqual(mock_permissions_dict, new_permissions)
 
-    @mock.patch("bot.cogs.moderation.silence.asyncio")
+    @mock.patch("bot.exts.moderation.silence.asyncio")
     @mock.patch.object(Silence, "_mod_alerts_channel", create=True)
     def test_cog_unload_starts_task(self, alert_channel, asyncio_mock):
         """Task for sending an alert was created with present `muted_channels`."""
@@ -247,14 +247,14 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
             alert_channel.send.assert_called_once_with(f"<@&{Roles.moderators}> channels left silenced on cog unload: ")
             asyncio_mock.create_task.assert_called_once_with(alert_channel.send())
 
-    @mock.patch("bot.cogs.moderation.silence.asyncio")
+    @mock.patch("bot.exts.moderation.silence.asyncio")
     def test_cog_unload_skips_task_start(self, asyncio_mock):
         """No task created with no channels."""
         self.cog.cog_unload()
         asyncio_mock.create_task.assert_not_called()
 
     @mock.patch("discord.ext.commands.has_any_role")
-    @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
+    @mock.patch("bot.exts.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
     async def test_cog_check(self, role_check):
         """Role check is called with `MODERATION_ROLES`"""
         role_check.return_value.predicate = mock.AsyncMock()
diff --git a/tests/bot/cogs/test_slowmode.py b/tests/bot/exts/moderation/test_slowmode.py
index 5e6d6a26a..dad751e0d 100644
--- a/tests/bot/cogs/test_slowmode.py
+++ b/tests/bot/exts/moderation/test_slowmode.py
@@ -3,8 +3,8 @@ from unittest import mock
 
 from dateutil.relativedelta import relativedelta
 
-from bot.cogs.moderation.slowmode import Slowmode
 from bot.constants import Emojis
+from bot.exts.moderation.slowmode import Slowmode
 from tests.helpers import MockBot, MockContext, MockTextChannel
 
 
@@ -103,8 +103,8 @@ class SlowmodeTests(unittest.IsolatedAsyncioTestCase):
             f'{Emojis.check_mark} The slowmode delay for #meta has been reset to 0 seconds.'
         )
 
-    @mock.patch("bot.cogs.moderation.slowmode.has_any_role")
-    @mock.patch("bot.cogs.moderation.slowmode.MODERATION_ROLES", new=(1, 2, 3))
+    @mock.patch("bot.exts.moderation.slowmode.has_any_role")
+    @mock.patch("bot.exts.moderation.slowmode.MODERATION_ROLES", new=(1, 2, 3))
     async def test_cog_check(self, role_check):
         """Role check is called with `MODERATION_ROLES`"""
         role_check.return_value.predicate = mock.AsyncMock()
diff --git a/tests/bot/cogs/test_cogs.py b/tests/bot/exts/test_cogs.py
index 30a04422a..f8e120262 100644
--- a/tests/bot/cogs/test_cogs.py
+++ b/tests/bot/exts/test_cogs.py
@@ -10,7 +10,7 @@ from unittest import mock
 
 from discord.ext import commands
 
-from bot import cogs
+from bot import exts
 
 
 class CommandNameTests(unittest.TestCase):
@@ -29,13 +29,14 @@ class CommandNameTests(unittest.TestCase):
 
     @staticmethod
     def walk_modules() -> t.Iterator[ModuleType]:
-        """Yield imported modules from the bot.cogs subpackage."""
+        """Yield imported modules from the bot.exts subpackage."""
         def on_error(name: str) -> t.NoReturn:
             raise ImportError(name=name)  # pragma: no cover
 
         # The mock prevents asyncio.get_event_loop() from being called.
         with mock.patch("discord.ext.tasks.loop"):
-            for module in pkgutil.walk_packages(cogs.__path__, "bot.cogs.", onerror=on_error):
+            prefix = f"{exts.__name__}."
+            for module in pkgutil.walk_packages(exts.__path__, prefix, onerror=on_error):
                 if not module.ispkg:
                     yield importlib.import_module(module.name)
 
diff --git a/tests/bot/exts/utils/__init__.py b/tests/bot/exts/utils/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/exts/utils/__init__.py
diff --git a/tests/bot/cogs/test_jams.py b/tests/bot/exts/utils/test_jams.py
index b4ad8535f..45e7b5b51 100644
--- a/tests/bot/cogs/test_jams.py
+++ b/tests/bot/exts/utils/test_jams.py
@@ -3,8 +3,8 @@ from unittest.mock import AsyncMock, MagicMock, create_autospec
 
 from discord import CategoryChannel
 
-from bot.cogs import jams
 from bot.constants import Roles
+from bot.exts.utils import jams
 from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole, MockTextChannel
 
 
diff --git a/tests/bot/cogs/test_snekbox.py b/tests/bot/exts/utils/test_snekbox.py
index 343e37db9..c272a4756 100644
--- a/tests/bot/cogs/test_snekbox.py
+++ b/tests/bot/exts/utils/test_snekbox.py
@@ -1,13 +1,12 @@
 import asyncio
-import logging
 import unittest
 from unittest.mock import AsyncMock, MagicMock, Mock, call, create_autospec, patch
 
 from discord.ext import commands
 
 from bot import constants
-from bot.cogs import snekbox
-from bot.cogs.snekbox import Snekbox
+from bot.exts.utils import snekbox
+from bot.exts.utils.snekbox import Snekbox
 from tests.helpers import MockBot, MockContext, MockMessage, MockReaction, MockUser
 
 
@@ -39,43 +38,14 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
         result = await self.cog.upload_output("-" * (snekbox.MAX_PASTE_LEN + 1))
         self.assertEqual(result, "too long to upload")
 
-    async def test_upload_output(self):
+    @patch("bot.exts.utils.snekbox.send_to_paste_service")
+    async def test_upload_output(self, mock_paste_util):
         """Upload the eval output to the URLs.paste_service.format(key="documents") endpoint."""
-        key = "MarkDiamond"
-        resp = MagicMock()
-        resp.json = AsyncMock(return_value={"key": key})
-
-        context_manager = MagicMock()
-        context_manager.__aenter__.return_value = resp
-        self.bot.http_session.post.return_value = context_manager
-
-        self.assertEqual(
-            await self.cog.upload_output("My awesome output"),
-            constants.URLs.paste_service.format(key=key)
-        )
-        self.bot.http_session.post.assert_called_with(
-            constants.URLs.paste_service.format(key="documents"),
-            data="My awesome output",
-            raise_for_status=True
+        await self.cog.upload_output("Test output.")
+        mock_paste_util.assert_called_once_with(
+            self.bot.http_session, "Test output.", extension="txt"
         )
 
-    async def test_upload_output_gracefully_fallback_if_exception_during_request(self):
-        """Output upload gracefully fallback if the upload fail."""
-        resp = MagicMock()
-        resp.json = AsyncMock(side_effect=Exception)
-
-        context_manager = MagicMock()
-        context_manager.__aenter__.return_value = resp
-        self.bot.http_session.post.return_value = context_manager
-
-        log = logging.getLogger("bot.cogs.snekbox")
-        with self.assertLogs(logger=log, level='ERROR'):
-            await self.cog.upload_output('My awesome output!')
-
-    async def test_upload_output_gracefully_fallback_if_no_key_in_response(self):
-        """Output upload gracefully fallback if there is no key entry in the response body."""
-        self.assertEqual((await self.cog.upload_output('My awesome output!')), None)
-
     def test_prepare_input(self):
         cases = (
             ('print("Hello world!")', 'print("Hello world!")', 'non-formatted'),
@@ -99,14 +69,14 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
                 actual = self.cog.get_results_message({'stdout': stdout, 'returncode': returncode})
                 self.assertEqual(actual, expected)
 
-    @patch('bot.cogs.snekbox.Signals', side_effect=ValueError)
+    @patch('bot.exts.utils.snekbox.Signals', side_effect=ValueError)
     def test_get_results_message_invalid_signal(self, mock_signals: Mock):
         self.assertEqual(
             self.cog.get_results_message({'stdout': '', 'returncode': 127}),
             ('Your eval job has completed with return code 127', '')
         )
 
-    @patch('bot.cogs.snekbox.Signals')
+    @patch('bot.exts.utils.snekbox.Signals')
     def test_get_results_message_valid_signal(self, mock_signals: Mock):
         mock_signals.return_value.name = 'SIGTEST'
         self.assertEqual(
@@ -296,7 +266,7 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
         self.cog.get_results_message.assert_called_once_with({'stdout': 'ERROR', 'returncode': 127})
         self.cog.format_output.assert_not_called()
 
-    @patch("bot.cogs.snekbox.partial")
+    @patch("bot.exts.utils.snekbox.partial")
     async def test_continue_eval_does_continue(self, partial_mock):
         """Test that the continue_eval function does continue if required conditions are met."""
         ctx = MockContext(message=MockMessage(add_reaction=AsyncMock(), clear_reactions=AsyncMock()))
diff --git a/tests/bot/utils/test_services.py b/tests/bot/utils/test_services.py
new file mode 100644
index 000000000..5e0855704
--- /dev/null
+++ b/tests/bot/utils/test_services.py
@@ -0,0 +1,74 @@
+import logging
+import unittest
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
+
+from aiohttp import ClientConnectorError
+
+from bot.utils.services import FAILED_REQUEST_ATTEMPTS, send_to_paste_service
+
+
+class PasteTests(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        self.http_session = MagicMock()
+
+    @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
+    async def test_url_and_sent_contents(self):
+        """Correct url was used and post was called with expected data."""
+        response = MagicMock(
+            json=AsyncMock(return_value={"key": ""})
+        )
+        self.http_session.post().__aenter__.return_value = response
+        self.http_session.post.reset_mock()
+        await send_to_paste_service(self.http_session, "Content")
+        self.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
+
+    @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
+    async def test_paste_returns_correct_url_on_success(self):
+        """Url with specified extension is returned on successful requests."""
+        key = "paste_key"
+        test_cases = (
+            (f"https://paste_service.com/{key}.txt", "txt"),
+            (f"https://paste_service.com/{key}.py", "py"),
+            (f"https://paste_service.com/{key}", ""),
+        )
+        response = MagicMock(
+            json=AsyncMock(return_value={"key": key})
+        )
+        self.http_session.post().__aenter__.return_value = response
+
+        for expected_output, extension in test_cases:
+            with self.subTest(msg=f"Send contents with extension {repr(extension)}"):
+                self.assertEqual(
+                    await send_to_paste_service(self.http_session, "", extension=extension),
+                    expected_output
+                )
+
+    async def test_request_repeated_on_json_errors(self):
+        """Json with error message and invalid json are handled as errors and requests repeated."""
+        test_cases = ({"message": "error"}, {"unexpected_key": None}, {})
+        self.http_session.post().__aenter__.return_value = response = MagicMock()
+        self.http_session.post.reset_mock()
+
+        for error_json in test_cases:
+            with self.subTest(error_json=error_json):
+                response.json = AsyncMock(return_value=error_json)
+                result = await send_to_paste_service(self.http_session, "")
+                self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+                self.assertIsNone(result)
+
+            self.http_session.post.reset_mock()
+
+    async def test_request_repeated_on_connection_errors(self):
+        """Requests are repeated in the case of connection errors."""
+        self.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
+        result = await send_to_paste_service(self.http_session, "")
+        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.assertIsNone(result)
+
+    async def test_general_error_handled_and_request_repeated(self):
+        """All `Exception`s are handled, logged and request repeated."""
+        self.http_session.post = MagicMock(side_effect=Exception)
+        result = await send_to_paste_service(self.http_session, "")
+        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.assertLogs("bot.utils", logging.ERROR)
+        self.assertIsNone(result)