diff --git a/src/Commands/AboutCommandGroup.cs b/src/Commands/AboutCommandGroup.cs
index 760d96b..50e7de7 100644
--- a/src/Commands/AboutCommandGroup.cs
+++ b/src/Commands/AboutCommandGroup.cs
@@ -5,6 +5,7 @@ using Boyfriend.Services;
 using JetBrains.Annotations;
 using Remora.Commands.Attributes;
 using Remora.Commands.Groups;
+using Remora.Discord.API.Abstractions.Objects;
 using Remora.Discord.API.Abstractions.Rest;
 using Remora.Discord.Commands.Attributes;
 using Remora.Discord.Commands.Conditions;
@@ -47,7 +48,7 @@ public class AboutCommandGroup : CommandGroup {
     [RequireContext(ChannelContext.Guild)]
     [Description("Shows Boyfriend's developers")]
     [UsedImplicitly]
-    public async Task<Result> SendAboutBotAsync() {
+    public async Task<Result> ExecuteAboutAsync() {
         if (!_context.TryGetContextIDs(out var guildId, out _, out _))
             return Result.FromError(
                 new ArgumentNullError(nameof(_context), "Unable to retrieve necessary IDs from command context"));
@@ -59,6 +60,10 @@ public class AboutCommandGroup : CommandGroup {
         var cfg = await _dataService.GetSettings(guildId.Value, CancellationToken);
         Messages.Culture = GuildSettings.Language.Get(cfg);
 
+        return await SendAboutBotAsync(currentUser, CancellationToken);
+    }
+
+    private async Task<Result> SendAboutBotAsync(IUser currentUser, CancellationToken ct = default) {
         var builder = new StringBuilder().AppendLine(Markdown.Bold(Messages.AboutTitleDevelopers));
         foreach (var dev in Developers)
             builder.AppendLine($"@{dev} — {$"AboutDeveloper@{dev}".Localized()}");
@@ -73,6 +78,6 @@ public class AboutCommandGroup : CommandGroup {
             .WithImageUrl("https://cdn.upload.systems/uploads/JFAaX5vr.png")
             .Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/BanCommandGroup.cs b/src/Commands/BanCommandGroup.cs
index 51529aa..a8672a2 100644
--- a/src/Commands/BanCommandGroup.cs
+++ b/src/Commands/BanCommandGroup.cs
@@ -66,7 +66,7 @@ public class BanCommandGroup : CommandGroup {
     [RequireBotDiscordPermissions(DiscordPermission.BanMembers)]
     [Description("Ban user")]
     [UsedImplicitly]
-    public async Task<Result> ExecuteBan(
+    public async Task<Result> ExecuteBanAsync(
         [Description("User to ban")]  IUser     target,
         [Description("Ban reason")]   string    reason,
         [Description("Ban duration")] TimeSpan? duration = null) {
@@ -84,25 +84,26 @@ public class BanCommandGroup : CommandGroup {
         if (!guildResult.IsDefined(out var guild))
             return Result.FromError(guildResult);
 
-        return await BanUserAsync(target, reason, duration, guild, channelId.Value, user, currentUser);
-    }
-
-    private async Task<Result> BanUserAsync(
-        IUser target, string reason, TimeSpan? duration, IGuild guild, Snowflake channelId,
-        IUser user,   IUser  currentUser) {
         var data = await _dataService.GetData(guild.ID, CancellationToken);
         Messages.Culture = GuildSettings.Language.Get(data.Settings);
 
-        var existingBanResult = await _guildApi.GetGuildBanAsync(guild.ID, target.ID, CancellationToken);
+        return await BanUserAsync(
+            target, reason, duration, guild, data, channelId.Value, user, currentUser, CancellationToken);
+    }
+
+    private async Task<Result> BanUserAsync(
+        IUser target, string reason,      TimeSpan?         duration, IGuild guild, GuildData data, Snowflake channelId,
+        IUser user,   IUser  currentUser, CancellationToken ct = default) {
+        var existingBanResult = await _guildApi.GetGuildBanAsync(guild.ID, target.ID, ct);
         if (existingBanResult.IsDefined()) {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.UserAlreadyBanned, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, ct);
         }
 
         var interactionResult
-            = await _utility.CheckInteractionsAsync(guild.ID, user.ID, target.ID, "Ban", CancellationToken);
+            = await _utility.CheckInteractionsAsync(guild.ID, user.ID, target.ID, "Ban", ct);
         if (!interactionResult.IsSuccess)
             return Result.FromError(interactionResult);
 
@@ -110,7 +111,7 @@ public class BanCommandGroup : CommandGroup {
             var errorEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(errorEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(errorEmbed, ct);
         }
 
         var builder = new StringBuilder().AppendLine(string.Format(Messages.DescriptionActionReason, reason));
@@ -122,7 +123,7 @@ public class BanCommandGroup : CommandGroup {
         var title = string.Format(Messages.UserBanned, target.GetTag());
         var description = builder.ToString();
 
-        var dmChannelResult = await _userApi.CreateDMAsync(target.ID, CancellationToken);
+        var dmChannelResult = await _userApi.CreateDMAsync(target.ID, ct);
         if (dmChannelResult.IsDefined(out var dmChannel)) {
             var dmEmbed = new EmbedBuilder().WithGuildTitle(guild)
                 .WithTitle(Messages.YouWereBanned)
@@ -134,12 +135,12 @@ public class BanCommandGroup : CommandGroup {
 
             if (!dmEmbed.IsDefined(out var dmBuilt))
                 return Result.FromError(dmEmbed);
-            await _channelApi.CreateMessageAsync(dmChannel.ID, embeds: new[] { dmBuilt }, ct: CancellationToken);
+            await _channelApi.CreateMessageAsync(dmChannel.ID, embeds: new[] { dmBuilt }, ct: ct);
         }
 
         var banResult = await _guildApi.CreateGuildBanAsync(
             guild.ID, target.ID, reason: $"({user.GetTag()}) {reason}".EncodeHeader(),
-            ct: CancellationToken);
+            ct: ct);
         if (!banResult.IsSuccess)
             return Result.FromError(banResult.Error);
         var memberData = data.GetMemberData(target.ID);
@@ -152,11 +153,11 @@ public class BanCommandGroup : CommandGroup {
             .WithColour(ColorsList.Green).Build();
 
         var logResult = _utility.LogActionAsync(
-            data.Settings, channelId, user, title, description, target, CancellationToken);
+            data.Settings, channelId, user, title, description, target, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 
     /// <summary>
@@ -171,7 +172,7 @@ public class BanCommandGroup : CommandGroup {
     ///     A feedback sending result which may or may not have succeeded. A successful result does not mean that the user
     ///     was unbanned and vice-versa.
     /// </returns>
-    /// <seealso cref="ExecuteBan" />
+    /// <seealso cref="ExecuteBanAsync" />
     /// <seealso cref="GuildUpdateService.TickGuildAsync"/>
     [Command("unban")]
     [DiscordDefaultMemberPermissions(DiscordPermission.BanMembers)]
@@ -196,25 +197,27 @@ public class BanCommandGroup : CommandGroup {
         if (!userResult.IsDefined(out var user))
             return Result.FromError(userResult);
 
-        return await UnbanUserAsync(target, reason, guildId.Value, channelId.Value, user, currentUser);
+        var data = await _dataService.GetData(guildId.Value, CancellationToken);
+        Messages.Culture = GuildSettings.Language.Get(data.Settings);
+
+        return await UnbanUserAsync(
+            target, reason, guildId.Value, data, channelId.Value, user, currentUser, CancellationToken);
     }
 
     private async Task<Result> UnbanUserAsync(
-        IUser target, string reason, Snowflake guildId, Snowflake channelId, IUser user, IUser currentUser) {
-        var cfg = await _dataService.GetSettings(guildId, CancellationToken);
-        Messages.Culture = GuildSettings.Language.Get(cfg);
-
-        var existingBanResult = await _guildApi.GetGuildBanAsync(guildId, target.ID, CancellationToken);
+        IUser target,      string            reason, Snowflake guildId, GuildData data, Snowflake channelId, IUser user,
+        IUser currentUser, CancellationToken ct = default) {
+        var existingBanResult = await _guildApi.GetGuildBanAsync(guildId, target.ID, ct);
         if (!existingBanResult.IsDefined()) {
             var errorEmbed = new EmbedBuilder().WithSmallTitle(Messages.UserNotBanned, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(errorEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(errorEmbed, ct);
         }
 
         var unbanResult = await _guildApi.RemoveGuildBanAsync(
             guildId, target.ID, $"({user.GetTag()}) {reason}".EncodeHeader(),
-            ct: CancellationToken);
+            ct);
         if (!unbanResult.IsSuccess)
             return Result.FromError(unbanResult.Error);
 
@@ -224,10 +227,10 @@ public class BanCommandGroup : CommandGroup {
 
         var title = string.Format(Messages.UserUnbanned, target.GetTag());
         var description = string.Format(Messages.DescriptionActionReason, reason);
-        var logResult = _utility.LogActionAsync(cfg, channelId, user, title, description, target, CancellationToken);
+        var logResult = _utility.LogActionAsync(data.Settings, channelId, user, title, description, target, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/ClearCommandGroup.cs b/src/Commands/ClearCommandGroup.cs
index ce1787c..46ddc24 100644
--- a/src/Commands/ClearCommandGroup.cs
+++ b/src/Commands/ClearCommandGroup.cs
@@ -76,15 +76,15 @@ public class ClearCommandGroup : CommandGroup {
         if (!currentUserResult.IsDefined(out var currentUser))
             return Result.FromError(currentUserResult);
 
-        return await ClearMessagesAsync(amount, guildId.Value, channelId.Value, messages, user, currentUser);
+        var data = await _dataService.GetData(guildId.Value, CancellationToken);
+        Messages.Culture = GuildSettings.Language.Get(data.Settings);
+
+        return await ClearMessagesAsync(amount, data, channelId.Value, messages, user, currentUser, CancellationToken);
     }
 
     private async Task<Result> ClearMessagesAsync(
-        int   amount, Snowflake guildId, Snowflake channelId, IReadOnlyList<IMessage> messages,
-        IUser user,   IUser     currentUser) {
-        var cfg = await _dataService.GetSettings(guildId, CancellationToken);
-        Messages.Culture = GuildSettings.Language.Get(cfg);
-
+        int   amount, GuildData data,        Snowflake         channelId, IReadOnlyList<IMessage> messages,
+        IUser user,   IUser     currentUser, CancellationToken ct = default) {
         var idList = new List<Snowflake>(messages.Count);
         var builder = new StringBuilder().AppendLine(Mention.Channel(channelId)).AppendLine();
         for (var i = messages.Count - 1; i >= 1; i--) { // '>= 1' to skip last message ('Boyfriend is thinking...')
@@ -98,18 +98,18 @@ public class ClearCommandGroup : CommandGroup {
         var description = builder.ToString();
 
         var deleteResult = await _channelApi.BulkDeleteMessagesAsync(
-            channelId, idList, user.GetTag().EncodeHeader(), CancellationToken);
+            channelId, idList, user.GetTag().EncodeHeader(), ct);
         if (!deleteResult.IsSuccess)
             return Result.FromError(deleteResult.Error);
 
         var logResult = _utility.LogActionAsync(
-            cfg, channelId, user, title, description, currentUser, CancellationToken);
+            data.Settings, channelId, user, title, description, currentUser, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
         var embed = new EmbedBuilder().WithSmallTitle(title, currentUser)
             .WithColour(ColorsList.Green).Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/KickCommandGroup.cs b/src/Commands/KickCommandGroup.cs
index 7a9fe0c..9111b7f 100644
--- a/src/Commands/KickCommandGroup.cs
+++ b/src/Commands/KickCommandGroup.cs
@@ -90,13 +90,14 @@ public class KickCommandGroup : CommandGroup {
             return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
         }
 
-        return await KickUserAsync(target, reason, guild, channelId.Value, data, user, currentUser);
+        return await KickUserAsync(target, reason, guild, channelId.Value, data, user, currentUser, CancellationToken);
     }
 
     private async Task<Result> KickUserAsync(
-        IUser target, string reason, IGuild guild, Snowflake channelId, GuildData data, IUser user, IUser currentUser) {
+        IUser target, string reason, IGuild guild, Snowflake channelId, GuildData data, IUser user, IUser currentUser,
+        CancellationToken ct = default) {
         var interactionResult
-            = await _utility.CheckInteractionsAsync(guild.ID, user.ID, target.ID, "Kick", CancellationToken);
+            = await _utility.CheckInteractionsAsync(guild.ID, user.ID, target.ID, "Kick", ct);
         if (!interactionResult.IsSuccess)
             return Result.FromError(interactionResult);
 
@@ -104,10 +105,10 @@ public class KickCommandGroup : CommandGroup {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, ct);
         }
 
-        var dmChannelResult = await _userApi.CreateDMAsync(target.ID, CancellationToken);
+        var dmChannelResult = await _userApi.CreateDMAsync(target.ID, ct);
         if (dmChannelResult.IsDefined(out var dmChannel)) {
             var dmEmbed = new EmbedBuilder().WithGuildTitle(guild)
                 .WithTitle(Messages.YouWereKicked)
@@ -119,12 +120,12 @@ public class KickCommandGroup : CommandGroup {
 
             if (!dmEmbed.IsDefined(out var dmBuilt))
                 return Result.FromError(dmEmbed);
-            await _channelApi.CreateMessageAsync(dmChannel.ID, embeds: new[] { dmBuilt }, ct: CancellationToken);
+            await _channelApi.CreateMessageAsync(dmChannel.ID, embeds: new[] { dmBuilt }, ct: ct);
         }
 
         var kickResult = await _guildApi.RemoveGuildMemberAsync(
             guild.ID, target.ID, $"({user.GetTag()}) {reason}".EncodeHeader(),
-            CancellationToken);
+            ct);
         if (!kickResult.IsSuccess)
             return Result.FromError(kickResult.Error);
         data.GetMemberData(target.ID).Roles.Clear();
@@ -132,7 +133,7 @@ public class KickCommandGroup : CommandGroup {
         var title = string.Format(Messages.UserKicked, target.GetTag());
         var description = string.Format(Messages.DescriptionActionReason, reason);
         var logResult = _utility.LogActionAsync(
-            data.Settings, channelId, user, title, description, target, CancellationToken);
+            data.Settings, channelId, user, title, description, target, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
@@ -140,6 +141,6 @@ public class KickCommandGroup : CommandGroup {
                 string.Format(Messages.UserKicked, target.GetTag()), target)
             .WithColour(ColorsList.Green).Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/MuteCommandGroup.cs b/src/Commands/MuteCommandGroup.cs
index c572b78..14895d5 100644
--- a/src/Commands/MuteCommandGroup.cs
+++ b/src/Commands/MuteCommandGroup.cs
@@ -91,15 +91,16 @@ public class MuteCommandGroup : CommandGroup {
             return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
         }
 
-        return await MuteUserAsync(target, reason, duration, guildId.Value, data, channelId.Value, user, currentUser);
+        return await MuteUserAsync(
+            target, reason, duration, guildId.Value, data, channelId.Value, user, currentUser, CancellationToken);
     }
 
     private async Task<Result> MuteUserAsync(
-        IUser target, string reason, TimeSpan duration, Snowflake guildId, GuildData data, Snowflake channelId,
-        IUser user,   IUser  currentUser) {
+        IUser target, string reason,      TimeSpan duration, Snowflake guildId, GuildData data, Snowflake channelId,
+        IUser user,   IUser  currentUser, CancellationToken ct = default) {
         var interactionResult
             = await _utility.CheckInteractionsAsync(
-                guildId, user.ID, target.ID, "Mute", CancellationToken);
+                guildId, user.ID, target.ID, "Mute", ct);
         if (!interactionResult.IsSuccess)
             return Result.FromError(interactionResult);
 
@@ -107,13 +108,13 @@ public class MuteCommandGroup : CommandGroup {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, ct);
         }
 
         var until = DateTimeOffset.UtcNow.Add(duration); // >:)
         var muteResult = await _guildApi.ModifyGuildMemberAsync(
             guildId, target.ID, reason: $"({user.GetTag()}) {reason}".EncodeHeader(),
-            communicationDisabledUntil: until, ct: CancellationToken);
+            communicationDisabledUntil: until, ct: ct);
         if (!muteResult.IsSuccess)
             return Result.FromError(muteResult.Error);
 
@@ -124,7 +125,7 @@ public class MuteCommandGroup : CommandGroup {
                     Messages.DescriptionActionExpiresAt, Markdown.Timestamp(until))).ToString();
 
         var logResult = _utility.LogActionAsync(
-            data.Settings, channelId, user, title, description, target, CancellationToken);
+            data.Settings, channelId, user, title, description, target, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
@@ -132,7 +133,7 @@ public class MuteCommandGroup : CommandGroup {
                 string.Format(Messages.UserMuted, target.GetTag()), target)
             .WithColour(ColorsList.Green).Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 
     /// <summary>
@@ -185,15 +186,16 @@ public class MuteCommandGroup : CommandGroup {
             return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
         }
 
-        return await UnmuteUserAsync(target, reason, guildId.Value, data, channelId.Value, user, currentUser);
+        return await UnmuteUserAsync(
+            target, reason, guildId.Value, data, channelId.Value, user, currentUser, CancellationToken);
     }
 
     private async Task<Result> UnmuteUserAsync(
-        IUser target, string reason, Snowflake guildId, GuildData data, Snowflake channelId, IUser user,
-        IUser currentUser) {
+        IUser target,      string            reason, Snowflake guildId, GuildData data, Snowflake channelId, IUser user,
+        IUser currentUser, CancellationToken ct = default) {
         var interactionResult
             = await _utility.CheckInteractionsAsync(
-                guildId, user.ID, target.ID, "Unmute", CancellationToken);
+                guildId, user.ID, target.ID, "Unmute", ct);
         if (!interactionResult.IsSuccess)
             return Result.FromError(interactionResult);
 
@@ -201,19 +203,19 @@ public class MuteCommandGroup : CommandGroup {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, currentUser)
                 .WithColour(ColorsList.Red).Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, ct);
         }
 
         var unmuteResult = await _guildApi.ModifyGuildMemberAsync(
             guildId, target.ID, $"({user.GetTag()}) {reason}".EncodeHeader(),
-            communicationDisabledUntil: null, ct: CancellationToken);
+            communicationDisabledUntil: null, ct: ct);
         if (!unmuteResult.IsSuccess)
             return Result.FromError(unmuteResult.Error);
 
         var title = string.Format(Messages.UserUnmuted, target.GetTag());
         var description = string.Format(Messages.DescriptionActionReason, reason);
         var logResult = _utility.LogActionAsync(
-            data.Settings, channelId, user, title, description, target, CancellationToken);
+            data.Settings, channelId, user, title, description, target, ct);
         if (!logResult.IsSuccess)
             return Result.FromError(logResult.Error);
 
@@ -221,6 +223,6 @@ public class MuteCommandGroup : CommandGroup {
                 string.Format(Messages.UserUnmuted, target.GetTag()), target)
             .WithColour(ColorsList.Green).Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/PingCommandGroup.cs b/src/Commands/PingCommandGroup.cs
index 5819336..83b04c9 100644
--- a/src/Commands/PingCommandGroup.cs
+++ b/src/Commands/PingCommandGroup.cs
@@ -4,6 +4,7 @@ using Boyfriend.Services;
 using JetBrains.Annotations;
 using Remora.Commands.Attributes;
 using Remora.Commands.Groups;
+using Remora.Discord.API.Abstractions.Objects;
 using Remora.Discord.API.Abstractions.Rest;
 using Remora.Discord.Commands.Attributes;
 using Remora.Discord.Commands.Conditions;
@@ -11,6 +12,7 @@ using Remora.Discord.Commands.Contexts;
 using Remora.Discord.Commands.Feedback.Services;
 using Remora.Discord.Extensions.Embeds;
 using Remora.Discord.Gateway;
+using Remora.Rest.Core;
 using Remora.Results;
 
 namespace Boyfriend.Commands;
@@ -49,7 +51,7 @@ public class PingCommandGroup : CommandGroup {
     [DiscordDefaultDMPermission(false)]
     [RequireContext(ChannelContext.Guild)]
     [UsedImplicitly]
-    public async Task<Result> SendPingAsync() {
+    public async Task<Result> ExecutePingAsync() {
         if (!_context.TryGetContextIDs(out var guildId, out var channelId, out _))
             return Result.FromError(
                 new ArgumentNullError(nameof(_context), "Unable to retrieve necessary IDs from command context"));
@@ -61,11 +63,16 @@ public class PingCommandGroup : CommandGroup {
         var cfg = await _dataService.GetSettings(guildId.Value, CancellationToken);
         Messages.Culture = GuildSettings.Language.Get(cfg);
 
+        return await SendLatencyAsync(channelId.Value, currentUser, CancellationToken);
+    }
+
+    private async Task<Result> SendLatencyAsync(
+        Snowflake channelId, IUser currentUser, CancellationToken ct = default) {
         var latency = _client.Latency.TotalMilliseconds;
         if (latency is 0) {
             // No heartbeat has occurred, estimate latency from local time and "Boyfriend is thinking..." message
             var lastMessageResult = await _channelApi.GetChannelMessagesAsync(
-                channelId.Value, limit: 1, ct: CancellationToken);
+                channelId, limit: 1, ct: ct);
             if (!lastMessageResult.IsDefined(out var lastMessage))
                 return Result.FromError(lastMessageResult);
             latency = DateTimeOffset.UtcNow.Subtract(lastMessage.Single().Timestamp).TotalMilliseconds;
@@ -78,6 +85,6 @@ public class PingCommandGroup : CommandGroup {
             .WithCurrentTimestamp()
             .Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/RemindCommandGroup.cs b/src/Commands/RemindCommandGroup.cs
index 954e84a..90016f6 100644
--- a/src/Commands/RemindCommandGroup.cs
+++ b/src/Commands/RemindCommandGroup.cs
@@ -4,6 +4,7 @@ using Boyfriend.Services;
 using JetBrains.Annotations;
 using Remora.Commands.Attributes;
 using Remora.Commands.Groups;
+using Remora.Discord.API.Abstractions.Objects;
 using Remora.Discord.API.Abstractions.Rest;
 using Remora.Discord.Commands.Attributes;
 using Remora.Discord.Commands.Conditions;
@@ -11,6 +12,7 @@ using Remora.Discord.Commands.Contexts;
 using Remora.Discord.Commands.Feedback.Services;
 using Remora.Discord.Extensions.Embeds;
 using Remora.Discord.Extensions.Formatting;
+using Remora.Rest.Core;
 using Remora.Results;
 
 namespace Boyfriend.Commands;
@@ -45,7 +47,7 @@ public class RemindCommandGroup : CommandGroup {
     [DiscordDefaultDMPermission(false)]
     [RequireContext(ChannelContext.Guild)]
     [UsedImplicitly]
-    public async Task<Result> AddReminderAsync(
+    public async Task<Result> ExecuteReminderAsync(
         [Description("After what period of time mention the reminder")]
         TimeSpan @in,
         [Description("Reminder message")] string message) {
@@ -57,12 +59,21 @@ public class RemindCommandGroup : CommandGroup {
         if (!userResult.IsDefined(out var user))
             return Result.FromError(userResult);
 
+        var data = await _dataService.GetData(guildId.Value, CancellationToken);
+        Messages.Culture = GuildSettings.Language.Get(data.Settings);
+
+        return await AddReminderAsync(@in, message, data, channelId.Value, user, CancellationToken);
+    }
+
+    private async Task<Result> AddReminderAsync(
+        TimeSpan  @in,       string message, GuildData         data,
+        Snowflake channelId, IUser  user,    CancellationToken ct = default) {
         var remindAt = DateTimeOffset.UtcNow.Add(@in);
 
-        (await _dataService.GetMemberData(guildId.Value, userId.Value, CancellationToken)).Reminders.Add(
+        data.GetMemberData(user.ID).Reminders.Add(
             new Reminder {
                 At = remindAt,
-                Channel = channelId.Value.Value,
+                Channel = channelId.Value,
                 Text = message
             });
 
@@ -71,6 +82,6 @@ public class RemindCommandGroup : CommandGroup {
             .WithColour(ColorsList.Green)
             .Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }
diff --git a/src/Commands/SettingsCommandGroup.cs b/src/Commands/SettingsCommandGroup.cs
index d2d28be..741f10e 100644
--- a/src/Commands/SettingsCommandGroup.cs
+++ b/src/Commands/SettingsCommandGroup.cs
@@ -1,5 +1,6 @@
 using System.ComponentModel;
 using System.Text;
+using System.Text.Json.Nodes;
 using Boyfriend.Data;
 using Boyfriend.Data.Options;
 using Boyfriend.Services;
@@ -66,7 +67,7 @@ public class SettingsCommandGroup : CommandGroup {
     [RequireDiscordPermission(DiscordPermission.ManageGuild)]
     [Description("Shows settings list for this server")]
     [UsedImplicitly]
-    public async Task<Result> ListSettingsAsync() {
+    public async Task<Result> ExecuteSettingsListAsync() {
         if (!_context.TryGetContextIDs(out var guildId, out _, out _))
             return Result.FromError(
                 new ArgumentNullError(nameof(_context), "Unable to retrieve necessary IDs from command context"));
@@ -78,6 +79,10 @@ public class SettingsCommandGroup : CommandGroup {
         var cfg = await _dataService.GetSettings(guildId.Value, CancellationToken);
         Messages.Culture = GuildSettings.Language.Get(cfg);
 
+        return await SendSettingsListAsync(cfg, currentUser, CancellationToken);
+    }
+
+    private async Task<Result> SendSettingsListAsync(JsonNode cfg, IUser currentUser, CancellationToken ct = default) {
         var builder = new StringBuilder();
 
         foreach (var option in AllOptions) {
@@ -91,7 +96,7 @@ public class SettingsCommandGroup : CommandGroup {
             .WithColour(ColorsList.Default)
             .Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 
     /// <summary>
@@ -107,7 +112,7 @@ public class SettingsCommandGroup : CommandGroup {
     [RequireDiscordPermission(DiscordPermission.ManageGuild)]
     [Description("Change settings for this server")]
     [UsedImplicitly]
-    public async Task<Result> EditSettingsAsync(
+    public async Task<Result> ExecuteSettingsAsync(
         [Description("The setting whose value you want to change")]
         string setting,
         [Description("Setting value")] string value) {
@@ -119,33 +124,38 @@ public class SettingsCommandGroup : CommandGroup {
         if (!currentUserResult.IsDefined(out var currentUser))
             return Result.FromError(currentUserResult);
 
-        var cfg = await _dataService.GetSettings(guildId.Value, CancellationToken);
-        Messages.Culture = GuildSettings.Language.Get(cfg);
+        var data = await _dataService.GetData(guildId.Value, CancellationToken);
+        Messages.Culture = GuildSettings.Language.Get(data.Settings);
 
+        return await EditSettingAsync(setting, value, data, currentUser, CancellationToken);
+    }
+
+    private async Task<Result> EditSettingAsync(
+        string setting, string value, GuildData data, IUser currentUser, CancellationToken ct = default) {
         var option = AllOptions.Single(
             o => string.Equals(setting, o.Name, StringComparison.InvariantCultureIgnoreCase));
 
-        var setResult = option.Set(cfg, value);
+        var setResult = option.Set(data.Settings, value);
         if (!setResult.IsSuccess) {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.SettingNotChanged, currentUser)
                 .WithDescription(setResult.Error.Message)
                 .WithColour(ColorsList.Red)
                 .Build();
 
-            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, CancellationToken);
+            return await _feedbackService.SendContextualEmbedResultAsync(failedEmbed, ct);
         }
 
         var builder = new StringBuilder();
 
         builder.Append(Markdown.InlineCode(option.Name))
             .Append($" {Messages.SettingIsNow} ")
-            .Append(option.Display(cfg));
+            .Append(option.Display(data.Settings));
 
         var embed = new EmbedBuilder().WithSmallTitle(Messages.SettingSuccessfullyChanged, currentUser)
             .WithDescription(builder.ToString())
             .WithColour(ColorsList.Green)
             .Build();
 
-        return await _feedbackService.SendContextualEmbedResultAsync(embed, CancellationToken);
+        return await _feedbackService.SendContextualEmbedResultAsync(embed, ct);
     }
 }