diff --git a/CHANGELOG.md b/CHANGELOG.md
index 32697a06b..d9bf547fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -87,10 +87,15 @@ Please ADD ALL Changes to the UNRELEASED SECTION and not a specific release
 - CloudFormation template restructured into the shared format, with parameters only where the deploy workflow passes them and all other settings in a Settings mapping (#427)
 - ECS application logs in /ecs/<ApplicationName>/ are kept for 30 days instead of never expiring, using the same LogRetentionInDays setting as the API Gateway access logs (#421)
 - The ECS service is now named after the application, so it can be found by name in the DiscordBots cluster (#421)
+- Discord notifications are sent through a channel webhook (Discord:WebhookUrl / DISCORD__WEBHOOKURL) instead of a Discord.Net bot login (#423)
+- Startup fails if the Discord webhook URL is missing or not an absolute https URL (#423)
+- Discord notifications are truncated to Discord's embed length limits instead of being rejected by Discord when a title, description, field or total length is exceeded (#423)
+- Push notifications show only the first line of each commit message instead of the full message (#423)
 ### Deprecated
 ### Removed
 - Removed NuGet audit suppressions for Scriban 6.2.0 vulnerabilities now that the transitive dependency has been dropped
 - TaskExecutionRole CloudFormation parameter (#419)
+- Discord.Net dependency, release channel support and the Discord:Token, Discord:Server, Discord:Channel and Discord:ReleaseChannel settings (#423)
 ### Deployment Changes
 - ECS service deployment circuit breaker with rollback, so tasks that fail to start (e.g. a missing secret key) fail the deploy quickly (#419)
 - ECS tasks now read their secrets at start-up using the ecsTaskExecutionRole execution role, which must have secretsmanager:GetSecretValue on the BuildBot secret (#419)
@@ -99,6 +104,7 @@ Please ADD ALL Changes to the UNRELEASED SECTION and not a specific release
 - This deploy replaces the ECS service, target group and listener rule (#421)
 - Payloads over 10 MB are rejected by API Gateway (#421)
 - The deploy user needs logs:PutRetentionPolicy on the /ecs/* log group, because the stack now sets a 30-day retention on it (#421)
+- The BuildBot Secrets Manager secret must contain a DISCORD_WEBHOOK key (an https Discord webhook URL) before deploying; the DISCORD_TOKEN, DISCORD_SERVER, DISCORD_CHANNEL and DISCORD_RELEASE_CHANNEL keys are no longer used (#423)
 
 <!--
 Releases that have at least been deployed to staging, BUT NOT necessarily released to live.  Changes should be moved from [Unreleased] into here as they are merged into the appropriate release branch
diff --git a/COVERAGE.md b/COVERAGE.md
index 390c5a296..204bd308f 100644
--- a/COVERAGE.md
+++ b/COVERAGE.md
@@ -8,13 +8,13 @@ Generated by the AI Coverage phase. Do not edit by hand.
 | --- | --- |
 | BuildBot | n/a (no instrumented lines) |
 | BuildBot.CloudFormation | 100.0% |
-| BuildBot.Discord | 96.8% |
+| BuildBot.Discord | 100.0% |
 | BuildBot.GitHub | 100.0% |
 | BuildBot.Health | 100.0% |
 | BuildBot.Json | 100.0% |
 | BuildBot.ServiceModel | 100.0% |
 | BuildBot.Watchtower | 100.0% |
-| **Overall (.NET)** | **99.2%** |
+| **Overall (.NET)** | **100.0%** |
 
 ## Node
 
@@ -30,4 +30,4 @@ excluded
 
 ---
 
-Captured at commit `5838d6adf7b290fa6688493d7b506ecb2b56ab84` on 2026-10-16.
+Captured at commit `21531fa8f8a0eaaa7c7981d2b08325401cbd5f8a` on 2026-10-19.
diff --git a/Dockerfile b/Dockerfile
index affef2c42..e5a2e5ae7 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-# chiseled-extra is needed over chiseled for Discord
+# chiseled-extra is needed over chiseled for ICU, as globalization invariant mode is disabled
 #FROM mcr.microsoft.com/dotnet/runtime-deps:9.0-noble-chiseled-extra
 FROM mcr.microsoft.com/dotnet/runtime-deps:11.0-resolute-chiseled-extra
 
diff --git a/README.md b/README.md
index bca536ba9..8d22e1e06 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@ FunFair's Build Discord Bot
 | Setting                | Environment variable    | Type   | Default | Description                                                                                                                                                                                                                                                                                                                                                  |
 |------------------------|-------------------------|--------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `GitHub:WebhookSecret` | `GITHUB__WEBHOOKSECRET` | string | (empty) | Shared secret configured on the GitHub webhook, used to verify the HMAC-SHA256 `X-Hub-Signature-256` header on `/github/*` requests. Requests with a missing or invalid signature are rejected with 401. When empty, signatures are not verified and a warning is logged at startup. In AWS it is read from the Secrets Manager key `GITHUB_WEBHOOK_SECRET`. |
+| `Discord:WebhookUrl`   | `DISCORD__WEBHOOKURL`   | URL    | (empty) | Discord channel webhook URL that build, deployment and container messages are posted to. Required: startup fails if it is empty or not an absolute `https` URL. The URL contains the webhook token, so treat it as a secret. In AWS it is read from the Secrets Manager key `DISCORD_WEBHOOK`.                                                               |
 
 ## Deployment
 
diff --git a/cloudformation.json b/cloudformation.json
index 9a961f1b4..59b8821a6 100644
--- a/cloudformation.json
+++ b/cloudformation.json
@@ -94,61 +94,10 @@
             ],
             "Secrets": [
               {
-                "Name": "DISCORD__TOKEN",
+                "Name": "DISCORD__WEBHOOKURL",
                 "ValueFrom": {
                   "Fn::Sub": [
-                    "${SecretsManagerArn}:DISCORD_TOKEN::",
-                    {
-                      "SecretsManagerArn": {
-                        "Fn::FindInMap": [
-                          "Settings",
-                          "Values",
-                          "SecretsManagerArn"
-                        ]
-                      }
-                    }
-                  ]
-                }
-              },
-              {
-                "Name": "DISCORD__SERVER",
-                "ValueFrom": {
-                  "Fn::Sub": [
-                    "${SecretsManagerArn}:DISCORD_SERVER::",
-                    {
-                      "SecretsManagerArn": {
-                        "Fn::FindInMap": [
-                          "Settings",
-                          "Values",
-                          "SecretsManagerArn"
-                        ]
-                      }
-                    }
-                  ]
-                }
-              },
-              {
-                "Name": "DISCORD__CHANNEL",
-                "ValueFrom": {
-                  "Fn::Sub": [
-                    "${SecretsManagerArn}:DISCORD_CHANNEL::",
-                    {
-                      "SecretsManagerArn": {
-                        "Fn::FindInMap": [
-                          "Settings",
-                          "Values",
-                          "SecretsManagerArn"
-                        ]
-                      }
-                    }
-                  ]
-                }
-              },
-              {
-                "Name": "DISCORD__RELEASE_CHANNEL",
-                "ValueFrom": {
-                  "Fn::Sub": [
-                    "${SecretsManagerArn}:DISCORD_RELEASE_CHANNEL::",
+                    "${SecretsManagerArn}:DISCORD_WEBHOOK::",
                     {
                       "SecretsManagerArn": {
                         "Fn::FindInMap": [
diff --git a/src/BuildBot.CloudFormation.Tests/Publishers/CloudFormationMessageReceivedNotificationHandlerTests.cs b/src/BuildBot.CloudFormation.Tests/Publishers/CloudFormationMessageReceivedNotificationHandlerTests.cs
index bbc63b15e..fa6d71c64 100644
--- a/src/BuildBot.CloudFormation.Tests/Publishers/CloudFormationMessageReceivedNotificationHandlerTests.cs
+++ b/src/BuildBot.CloudFormation.Tests/Publishers/CloudFormationMessageReceivedNotificationHandlerTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using BuildBot.CloudFormation;
@@ -215,4 +216,97 @@ CloudFormationMessageReceivedNotificationHandler handler
 
         await mediator.Received(1).Publish(Arg.Any<BotMessage>(), Arg.Any<CancellationToken>());
     }
+
+    private static DiscordEmbed PublishedEmbed(IMediator mediator)
+    {
+        return mediator
+            .ReceivedCalls()
+            .Select(static call => call.GetArguments()[0])
+            .OfType<BotMessage>()
+            .Single()
+            .Message;
+    }
+
+    private async Task<DiscordEmbed> PublishAsync(Deployment deployment, StackDetails? stackDetails)
+    {
+        (
+            _,
+            ICloudFormationDeploymentExtractor extractor,
+            IAwsCloudFormation aws,
+            IMediator mediator,
+            CloudFormationMessageReceivedNotificationHandler handler
+        ) = this.CreateHandler();
+
+        extractor.ExtractDeploymentProperties(Arg.Any<CloudFormationMessageReceived>()).Returns(deployment);
+        aws.GetStackDetailsAsync(Arg.Any<Deployment>(), Arg.Any<CancellationToken>()).Returns(stackDetails);
+
+        await handler.Handle(notification: MakeNotification(VALID_ARN), cancellationToken: this.CancellationToken());
+
+        return PublishedEmbed(mediator);
+    }
+
+    [Fact]
+    public async Task Handle_WithoutStackDetails_PublishesExpectedEmbed()
+    {
+        DiscordEmbed embed = await this.PublishAsync(deployment: MakeDeployment(), stackDetails: null);
+
+        Assert.Equal(expected: "MyProject was deployed ", actual: embed.Title);
+        Assert.Equal(
+            expected: new Uri(
+                "https://eu-west-1.console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/stackinfo?stackId=arn:aws:cf:eu-west-1:123:stack/MyStack/x"
+            ),
+            actual: embed.Url
+        );
+        Assert.Null(embed.Description);
+        Assert.Equal(expected: 0x2ECC71u, actual: embed.Color?.Value);
+        Assert.Equal(
+            expected:
+            [
+                new DiscordEmbedField(Name: "ARN", Value: "arn:aws:cf:eu-west-1:123:stack/MyStack/x"),
+                new DiscordEmbedField(Name: "Status", Value: "UPDATE_COMPLETE"),
+            ],
+            actual: embed.Fields
+        );
+    }
+
+    [Fact]
+    public async Task Handle_WithFailedDeploymentAndStackDetails_PublishesExpectedEmbed()
+    {
+        Deployment deployment = MakeDeployment() with { Status = "UPDATE_FAILED", Success = false };
+
+        DiscordEmbed embed = await this.PublishAsync(
+            deployment: deployment,
+            stackDetails: new StackDetails(Description: "A deployment", Version: "2.0.0")
+        );
+
+        Assert.Equal(expected: "MyProject (2.0.0) failed to deploy", actual: embed.Title);
+        Assert.Equal(expected: "A deployment", actual: embed.Description);
+        Assert.Equal(expected: 0xE74C3Cu, actual: embed.Color?.Value);
+        Assert.Equal(
+            expected:
+            [
+                new DiscordEmbedField(Name: "ARN", Value: "arn:aws:cf:eu-west-1:123:stack/MyStack/x"),
+                new DiscordEmbedField(Name: "Status", Value: "UPDATE_FAILED"),
+                new DiscordEmbedField(Name: "Version", Value: "2.0.0"),
+            ],
+            actual: embed.Fields
+        );
+    }
+
+    [Fact]
+    public async Task Handle_WithStackDetailsButNoVersion_OmitsVersionField()
+    {
+        DiscordEmbed embed = await this.PublishAsync(
+            deployment: MakeDeployment(),
+            stackDetails: new StackDetails(Description: "A deployment", Version: null)
+        );
+
+        Assert.Equal(expected: "MyProject was deployed ", actual: embed.Title);
+        Assert.Equal(expected: "A deployment", actual: embed.Description);
+        Assert.Equal(
+            expected: ["ARN", "Status"],
+            actual: embed.Fields.Select(static f => f.Name),
+            comparer: StringComparer.Ordinal
+        );
+    }
 }
diff --git a/src/BuildBot.CloudFormation/Publishers/CloudFormationMessageReceivedNotificationHandler.cs b/src/BuildBot.CloudFormation/Publishers/CloudFormationMessageReceivedNotificationHandler.cs
index ec6a23d76..350eecee8 100644
--- a/src/BuildBot.CloudFormation/Publishers/CloudFormationMessageReceivedNotificationHandler.cs
+++ b/src/BuildBot.CloudFormation/Publishers/CloudFormationMessageReceivedNotificationHandler.cs
@@ -7,7 +7,6 @@
 using BuildBot.CloudFormation.Models;
 using BuildBot.CloudFormation.Publishers.LoggingExtensions;
 using BuildBot.Discord.Models;
-using Discord;
 using Mediator;
 using Microsoft.Extensions.Logging;
 
@@ -67,29 +66,22 @@ public async ValueTask Handle(CloudFormationMessageReceived notification, Cancel
         );
 
         this._logger.BuildingMessage(deployment.Value);
-        EmbedBuilder embed = BuildStatusMessage(deployment: deployment.Value, stackDetails: stackDetails);
+        DiscordEmbed embed = BuildStatusMessage(deployment: deployment.Value, stackDetails: stackDetails);
 
         this._logger.PublishingMessage(deployment.Value);
 
         await this._mediator.Publish(new BotMessage(embed), cancellationToken: cancellationToken);
     }
 
-    private static EmbedBuilder BuildStatusMessage(in Deployment deployment, StackDetails? stackDetails)
+    private static DiscordEmbed BuildStatusMessage(in Deployment deployment, StackDetails? stackDetails)
     {
-        EmbedBuilder builder = new EmbedBuilder()
-            .WithTitle(BuildTitle(deployment: deployment, stackDetails: stackDetails))
-            .WithUrl(BuildStackUrl(deployment).ToString())
-            .WithColor(deployment.Success ? Color.Green : Color.Red)
-            .WithFields(GetFields(deployment));
-
-        if (stackDetails is not null)
-        {
-            builder
-                .WithDescription(stackDetails.Value.Description)
-                .AddField(name: "Version", value: stackDetails.Value.Version);
-        }
-
-        return builder;
+        return new(
+            Title: BuildTitle(deployment: deployment, stackDetails: stackDetails),
+            Url: BuildStackUrl(deployment),
+            Description: stackDetails?.Description,
+            Color: deployment.Success ? DiscordColor.Green : DiscordColor.Red,
+            Fields: GetFields(deployment: deployment, stackDetails: stackDetails)
+        );
     }
 
     private static string BuildTitle(in Deployment deployment, StackDetails? stackDetails)
@@ -113,18 +105,26 @@ private static Uri BuildStackUrl(in Deployment deployment)
         );
     }
 
-    private static IReadOnlyList<EmbedFieldBuilder> GetFields(in Deployment deployment)
+    private static IReadOnlyList<DiscordEmbedField> GetFields(in Deployment deployment, StackDetails? stackDetails)
+    {
+        DiscordEmbedField[] fields = [AddArnEmbed(deployment), AddStatusEmbed(deployment)];
+        string? version = stackDetails?.Version;
+
+        return string.IsNullOrWhiteSpace(version) ? fields : [.. fields, AddVersionEmbed(version)];
+    }
+
+    private static DiscordEmbedField AddArnEmbed(in Deployment deployment)
     {
-        return [AddArnEmbed(deployment), AddStatusEmbed(deployment)];
+        return new(Name: "ARN", Value: deployment.Arn);
     }
 
-    private static EmbedFieldBuilder AddArnEmbed(in Deployment deployment)
+    private static DiscordEmbedField AddStatusEmbed(in Deployment deployment)
     {
-        return new EmbedFieldBuilder().WithName("ARN").WithValue(deployment.Arn);
+        return new(Name: "Status", Value: deployment.Status);
     }
 
-    private static EmbedFieldBuilder AddStatusEmbed(in Deployment deployment)
+    private static DiscordEmbedField AddVersionEmbed(string version)
     {
-        return new EmbedFieldBuilder().WithName("Status").WithValue(deployment.Status);
+        return new(Name: "Version", Value: version);
     }
 }
diff --git a/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs b/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs
index 8997602d1..1605e6745 100644
--- a/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs
+++ b/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs
@@ -1,8 +1,7 @@
-using BuildBot.Discord;
+using System;
 using BuildBot.Discord.Models;
 using BuildBot.Discord.Services;
 using BuildBot.ServiceModel.ComponentStatus;
-using Discord;
 using FunFair.Test.Common;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -12,11 +11,8 @@ namespace BuildBot.Discord.Tests;
 
 public sealed class DependencyInjectionTests : DependencyInjectionTestsBase
 {
-    private static readonly DiscordBotConfiguration TestConfig = new(
-        token: "test-token",
-        server: "test-server",
-        channel: "test-channel",
-        releaseChannel: "test-release-channel"
+    private static readonly DiscordBotConfiguration TestConfig = DiscordBotConfiguration.FromWebhookUrl(
+        "https://example.com/webhook"
     );
 
     public DependencyInjectionTests(ITestOutputHelper output)
@@ -40,44 +36,32 @@ public void DiscordBotMustBeRegisteredAsIComponentStatus()
     }
 
     [Fact]
-    public void BotMessageChannelMustBeRegistered()
-    {
-        this.RequireService<IMessageChannel<BotMessage>>();
-    }
-
-    [Fact]
-    public void BotReleaseMessageChannelMustBeRegistered()
+    public void DiscordWebhookClientMustBeRegistered()
     {
-        this.RequireService<IMessageChannel<BotReleaseMessage>>();
+        this.RequireService<IDiscordWebhookClient>();
     }
 
     [Fact]
-    public void BotServiceMustBeRegisteredAsIHostedService()
+    public void TimeProviderMustBeRegistered()
     {
-        this.RequireService<IHostedService>();
+        this.RequireService<TimeProvider>();
     }
 
     [Fact]
-    public void DiscordRawClientMustBeRegistered()
+    public void ConfigurationMustBeRegistered()
     {
-        this.RequireService<IDiscordRawClient>();
+        this.RequireService<DiscordBotConfiguration>();
     }
 
     [Fact]
-    public void DiscordRawClient_WhenDisconnected_LoginStateIsLoggedOut()
+    public void BotMessageChannelMustBeRegistered()
     {
-        IDiscordRawClient client = this.GetService<IDiscordRawClient>();
-        Assert.Equal(expected: LoginState.LoggedOut, actual: client.LoginState);
+        this.RequireService<IMessageChannel<BotMessage>>();
     }
 
     [Fact]
-    public void FindChannel_WhenClientIsDisconnected_ReturnsNull()
+    public void DiscordMessageSenderMustBeRegisteredAsIHostedService()
     {
-        IDiscordRawClient client = this.GetService<IDiscordRawClient>();
-        IDiscordChannel? channel = client.FindChannel(
-            serverName: "nonexistent-server",
-            channelName: "nonexistent-channel"
-        );
-        Assert.Null(channel);
+        this.RequireService<IHostedService>();
     }
 }
diff --git a/src/BuildBot.Discord.Tests/DiscordSetupTests.cs b/src/BuildBot.Discord.Tests/DiscordSetupTests.cs
new file mode 100644
index 000000000..4f3e8df5c
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/DiscordSetupTests.cs
@@ -0,0 +1,486 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services;
+using BuildBot.Discord.Services.Models;
+using BuildBot.Discord.Tests.Services;
+using FunFair.Test.Common;
+using FunFair.Test.Infrastructure.Mocks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Polly;
+using Polly.Timeout;
+using Xunit;
+
+namespace BuildBot.Discord.Tests;
+
+public sealed class DiscordSetupTests : TestBase
+{
+    private const string SECRET = "secret-token";
+    private const string CONTROL_CLIENT_NAME = "Control";
+    private static readonly DiscordBotConfiguration Config = DiscordBotConfiguration.FromWebhookUrl(
+        "https://example.com/webhook/" + SECRET
+    );
+    private static readonly Uri WebhookUrl = Config.WebhookUrl;
+    private static readonly DateTimeOffset Now = MockDateTimeSources.Past.GetUtcNow();
+
+    [Theory]
+    [InlineData(1, 2)]
+    [InlineData(2, 4)]
+    [InlineData(3, 8)]
+    public static void CalculateRetryDelay_IsExponential(int attempt, int expectedSeconds)
+    {
+        Assert.Equal(
+            expected: TimeSpan.FromSeconds(expectedSeconds),
+            actual: DiscordSetup.CalculateRetryDelay(attempt)
+        );
+    }
+
+    [Theory]
+    [InlineData(HttpStatusCode.TooManyRequests, 5, null, 5)]
+    [InlineData(HttpStatusCode.TooManyRequests, 0, null, 0)]
+    [InlineData(HttpStatusCode.TooManyRequests, -5, null, 0)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, 5, 5)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, -5, 0)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, null, 2)]
+    [InlineData(HttpStatusCode.ServiceUnavailable, 5, null, 5)]
+    [InlineData(HttpStatusCode.InternalServerError, null, 7, 7)]
+    [InlineData(HttpStatusCode.InternalServerError, null, null, 2)]
+    public static void CalculateRetryDelay_ForResponse_ReturnsExpectedDelay(
+        HttpStatusCode statusCode,
+        int? retryAfterDeltaSeconds,
+        int? retryAfterDateOffsetSeconds,
+        int expectedSeconds
+    )
+    {
+        using HttpResponseMessage response = new(statusCode);
+        response.Headers.RetryAfter = CreateRetryAfter(
+            deltaSeconds: retryAfterDeltaSeconds,
+            dateOffsetSeconds: retryAfterDateOffsetSeconds
+        );
+
+        TimeSpan actual = DiscordSetup.CalculateRetryDelay(attempt: 1, response: response, now: Now);
+
+        Assert.Equal(expected: TimeSpan.FromSeconds(expectedSeconds), actual: actual);
+    }
+
+    [Theory]
+    [InlineData(HttpStatusCode.TooManyRequests, null, null, true)]
+    [InlineData(HttpStatusCode.TooManyRequests, 60, null, true)]
+    [InlineData(HttpStatusCode.TooManyRequests, 61, null, false)]
+    [InlineData(HttpStatusCode.TooManyRequests, -5, null, true)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, 60, true)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, 61, false)]
+    [InlineData(HttpStatusCode.TooManyRequests, null, -5, true)]
+    [InlineData(HttpStatusCode.ServiceUnavailable, 5, null, true)]
+    [InlineData(HttpStatusCode.ServiceUnavailable, 3600, null, false)]
+    [InlineData(HttpStatusCode.InternalServerError, null, null, true)]
+    [InlineData(HttpStatusCode.RequestTimeout, null, null, true)]
+    [InlineData(HttpStatusCode.BadGateway, null, null, true)]
+    [InlineData(HttpStatusCode.ServiceUnavailable, null, null, true)]
+    [InlineData(HttpStatusCode.GatewayTimeout, null, null, true)]
+    [InlineData(HttpStatusCode.NotImplemented, null, null, false)]
+    [InlineData(HttpStatusCode.HttpVersionNotSupported, null, null, false)]
+    [InlineData(HttpStatusCode.InsufficientStorage, null, null, false)]
+    [InlineData(HttpStatusCode.OK, null, null, false)]
+    [InlineData(HttpStatusCode.NotFound, 5, null, false)]
+    public static void ShouldRetry_ReturnsExpectedDecision(
+        HttpStatusCode statusCode,
+        int? retryAfterDeltaSeconds,
+        int? retryAfterDateOffsetSeconds,
+        bool expected
+    )
+    {
+        using HttpResponseMessage response = new(statusCode);
+        response.Headers.RetryAfter = CreateRetryAfter(
+            deltaSeconds: retryAfterDeltaSeconds,
+            dateOffsetSeconds: retryAfterDateOffsetSeconds
+        );
+
+        Assert.Equal(expected: expected, actual: DiscordSetup.ShouldRetry(response: response, now: Now));
+    }
+
+    [Fact]
+    public static void CalculateRetryDelay_WithoutResponse_UsesBackoff()
+    {
+        TimeSpan actual = DiscordSetup.CalculateRetryDelay(attempt: 2, response: null, now: Now);
+
+        Assert.Equal(expected: TimeSpan.FromSeconds(4), actual: actual);
+    }
+
+    private static RetryConditionHeaderValue? CreateRetryAfter(int? deltaSeconds, int? dateOffsetSeconds)
+    {
+        if (deltaSeconds is not null)
+        {
+            return new(TimeSpan.FromSeconds(deltaSeconds.Value));
+        }
+
+        if (dateOffsetSeconds is not null)
+        {
+            return new(Now.AddSeconds(dateOffsetSeconds.Value));
+        }
+
+        return null;
+    }
+
+    [Fact]
+    public async Task WebhookHttpClient_DoesNotLogRequestUrl()
+    {
+        CapturingLogger<DiscordSetupTests> httpLogger = new();
+
+        ILoggerProvider loggerProvider = GetSubstitute<ILoggerProvider>();
+        loggerProvider.CreateLogger(Arg.Any<string>()).Returns(httpLogger);
+
+        ServiceCollection services = new();
+        services
+            .AddLogging(builder => builder.AddProvider(loggerProvider))
+            .AddDiscord(Config)
+            .AddHttpClient(DiscordWebhookClient.HttpClientName)
+            .ConfigurePrimaryHttpMessageHandler(CreateNoContentHandler);
+        services.AddHttpClient(CONTROL_CLIENT_NAME).ConfigurePrimaryHttpMessageHandler(CreateNoContentHandler);
+
+        await using ServiceProvider serviceProvider = services.BuildServiceProvider();
+        IHttpClientFactory factory = serviceProvider.GetRequiredService<IHttpClientFactory>();
+
+        using (HttpClient control = factory.CreateClient(CONTROL_CLIENT_NAME))
+        {
+            using HttpResponseMessage controlResponse = await control.GetAsync(
+                requestUri: WebhookUrl,
+                cancellationToken: this.CancellationToken()
+            );
+        }
+
+        Assert.Contains(collection: httpLogger.Entries, filter: static entry => ContainsSecret(entry));
+        int controlEntryCount = httpLogger.EntryCount;
+
+        using (HttpClient client = factory.CreateClient(DiscordWebhookClient.HttpClientName))
+        {
+            using HttpResponseMessage response = await client.GetAsync(
+                requestUri: WebhookUrl,
+                cancellationToken: this.CancellationToken()
+            );
+        }
+
+        Assert.DoesNotContain(
+            collection: httpLogger.Entries.Skip(controlEntryCount),
+            filter: static entry => ContainsSecret(entry)
+        );
+    }
+
+    private static bool ContainsSecret(in CapturedLogEntry entry)
+    {
+        return entry.Message.Contains(value: SECRET, comparisonType: StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task WebhookClient_RetriesRateLimitedRequestsWithSamePayload()
+    {
+        using TestHttpMessageHandler handler = new(
+            static () =>
+                new HttpResponseMessage(HttpStatusCode.TooManyRequests)
+                {
+                    Headers = { RetryAfter = new RetryConditionHeaderValue(TimeSpan.Zero) },
+                },
+            static () => new HttpResponseMessage(HttpStatusCode.NoContent)
+        );
+
+        CapturingLogger<DiscordSetupTests> logger = new();
+
+        WebhookSendResult result = await this.SendViaWebhookClientAsync(handler: handler, logger: logger);
+
+        Assert.Equal(
+            expected: new(Success: true, StatusCode: HttpStatusCode.NoContent, ResponseBody: string.Empty),
+            actual: result
+        );
+        Assert.Equal(expected: 2, actual: handler.Requests.Count);
+        AssertRetryWarningLoggedWithoutSecret(
+            logger: logger,
+            expectedMessage: "DISCORD: Webhook attempt 1 failed with HTTP TooManyRequests; retrying in 00:00:00"
+        );
+        Assert.All(
+            collection: handler.Requests,
+            action: static r =>
+                Assert.Equal(
+                    expected: """{"embeds":[{"title":"Title","author":{"name":"FunFair BuildBot","url":"https://funfair.io","icon_url":"https://s2.coinmarketcap.com/static/img/coins/32x32/1757.png"},"fields":[]}]}""",
+                    actual: r.Body
+                )
+        );
+    }
+
+    [Fact]
+    public async Task WebhookClient_RetriesServiceUnavailableHonouringRetryAfter()
+    {
+        using TestHttpMessageHandler handler = new(
+            static () =>
+                new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
+                {
+                    Headers = { RetryAfter = new RetryConditionHeaderValue(TimeSpan.Zero) },
+                },
+            static () => new HttpResponseMessage(HttpStatusCode.NoContent)
+        );
+
+        CapturingLogger<DiscordSetupTests> logger = new();
+
+        WebhookSendResult result = await this.SendViaWebhookClientAsync(handler: handler, logger: logger);
+
+        Assert.Equal(
+            expected: new(Success: true, StatusCode: HttpStatusCode.NoContent, ResponseBody: string.Empty),
+            actual: result
+        );
+        Assert.Equal(expected: 2, actual: handler.Requests.Count);
+        AssertRetryWarningLoggedWithoutSecret(
+            logger: logger,
+            expectedMessage: "DISCORD: Webhook attempt 1 failed with HTTP ServiceUnavailable; retrying in 00:00:00"
+        );
+    }
+
+    private static void AssertRetryWarningLoggedWithoutSecret(
+        CapturingLogger<DiscordSetupTests> logger,
+        string expectedMessage
+    )
+    {
+        CapturedLogEntry warning = Assert.Single(
+            collection: logger.Entries,
+            predicate: static entry => entry.Level == LogLevel.Warning
+        );
+        Assert.Equal(expected: expectedMessage, actual: warning.Message);
+        Assert.DoesNotContain(collection: logger.Entries, filter: static entry => ContainsSecret(entry));
+    }
+
+    [Fact]
+    public async Task WebhookClient_DoesNotRetryWhenRetryAfterExceedsMaximum()
+    {
+        using TestHttpMessageHandler handler = new(static () =>
+            new HttpResponseMessage(HttpStatusCode.TooManyRequests)
+            {
+                Headers = { RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromHours(1)) },
+            }
+        );
+
+        CapturingLogger<DiscordSetupTests> logger = new();
+
+        WebhookSendResult result = await this.SendViaWebhookClientAsync(handler: handler, logger: logger);
+
+        Assert.Equal(
+            expected: new(Success: false, StatusCode: HttpStatusCode.TooManyRequests, ResponseBody: string.Empty),
+            actual: result
+        );
+        Assert.Single(handler.Requests);
+        Assert.DoesNotContain(collection: logger.Entries, filter: static entry => entry.Level == LogLevel.Warning);
+    }
+
+    [Fact]
+    public async Task WebhookHttpClient_TimeoutCoversFullRetryBudget()
+    {
+        ServiceCollection services = new();
+        services.AddLogging().AddDiscord(Config);
+
+        await using ServiceProvider serviceProvider = services.BuildServiceProvider();
+        using HttpClient client = serviceProvider
+            .GetRequiredService<IHttpClientFactory>()
+            .CreateClient(DiscordWebhookClient.HttpClientName);
+
+        // 4 attempts of up to 30s each, plus 3 retries waiting up to the 60s maximum Retry-After each.
+        TimeSpan worstCaseRetryBudget = TimeSpan.FromSeconds(30) * 4 + TimeSpan.FromSeconds(60) * 3;
+
+        Assert.True(
+            client.Timeout > worstCaseRetryBudget,
+            userMessage: $"Timeout {client.Timeout} must exceed the worst-case retry budget {worstCaseRetryBudget}"
+        );
+        Assert.Equal(expected: DiscordSetup.WebhookTimeout, actual: client.Timeout);
+    }
+
+    [Fact]
+    public async Task WebhookPolicy_RetriesTimedOutAttempt()
+    {
+        CapturingLogger<DiscordWebhookClient> logger = new();
+        IAsyncPolicy<HttpResponseMessage> policy = CreateFastTimeoutPolicy(logger);
+        int attempts = 0;
+
+        using HttpResponseMessage response = await policy.ExecuteAsync(
+            action: async cancellationToken =>
+            {
+                if (Interlocked.Increment(ref attempts) == 1)
+                {
+                    return await StallAsync(cancellationToken);
+                }
+
+                return new(HttpStatusCode.NoContent);
+            },
+            cancellationToken: this.CancellationToken()
+        );
+
+        Assert.Equal(expected: HttpStatusCode.NoContent, actual: response.StatusCode);
+        Assert.Equal(expected: 2, actual: attempts);
+        AssertSingleRetryWarning(
+            logger: logger,
+            expectedMessage: "DISCORD: Webhook attempt 1 failed with TimeoutRejectedException; retrying in 00:00:00"
+        );
+    }
+
+    [Fact]
+    public async Task WebhookPolicy_RetriesFailedRequestWithoutLoggingItsMessage()
+    {
+        CapturingLogger<DiscordWebhookClient> logger = new();
+        IAsyncPolicy<HttpResponseMessage> policy = CreateFastTimeoutPolicy(logger);
+        int attempts = 0;
+
+        using HttpResponseMessage response = await policy.ExecuteAsync(
+            action: _ =>
+            {
+                if (Interlocked.Increment(ref attempts) == 1)
+                {
+                    throw new HttpRequestException("Failed to reach " + WebhookUrl);
+                }
+
+                return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NoContent));
+            },
+            cancellationToken: this.CancellationToken()
+        );
+
+        Assert.Equal(expected: HttpStatusCode.NoContent, actual: response.StatusCode);
+        AssertSingleRetryWarning(
+            logger: logger,
+            expectedMessage: "DISCORD: Webhook attempt 1 failed with HttpRequestException; retrying in 00:00:00"
+        );
+        Assert.DoesNotContain(collection: logger.Entries, filter: static entry => ContainsSecret(entry));
+    }
+
+    [Fact]
+    public async Task WebhookPolicy_WhenEveryAttemptTimesOut_ThrowsAfterAllRetries()
+    {
+        CapturingLogger<DiscordWebhookClient> logger = new();
+        IAsyncPolicy<HttpResponseMessage> policy = CreateFastTimeoutPolicy(logger);
+        int attempts = 0;
+
+        await Assert.ThrowsAsync<TimeoutRejectedException>(async () =>
+            await policy.ExecuteAsync(
+                action: cancellationToken =>
+                {
+                    Interlocked.Increment(ref attempts);
+
+                    return StallAsync(cancellationToken);
+                },
+                cancellationToken: this.CancellationToken()
+            )
+        );
+
+        Assert.Equal(expected: 4, actual: attempts);
+        string[] expectedMessages =
+        [
+            "DISCORD: Webhook attempt 1 failed with TimeoutRejectedException; retrying in 00:00:00",
+            "DISCORD: Webhook attempt 2 failed with TimeoutRejectedException; retrying in 00:00:00",
+            "DISCORD: Webhook attempt 3 failed with TimeoutRejectedException; retrying in 00:00:00",
+        ];
+        Assert.Equal(
+            expected: expectedMessages,
+            actual: logger.Entries.Select(static entry => entry.Message),
+            comparer: StringComparer.Ordinal
+        );
+    }
+
+    [Fact]
+    public async Task WebhookPolicy_WhenCallerCancels_DoesNotRetry()
+    {
+        CapturingLogger<DiscordWebhookClient> logger = new();
+        IAsyncPolicy<HttpResponseMessage> policy = DiscordSetup.CreateWebhookPolicy(
+            timeProvider: MockDateTimeSources.Past,
+            attemptTimeout: Timeout.InfiniteTimeSpan,
+            backoff: static _ => TimeSpan.Zero,
+            logger: logger
+        );
+        using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(this.CancellationToken());
+        TaskCompletionSource attemptStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        int attempts = 0;
+
+        ValueTask<HttpResponseMessage> executing = ExecutePolicyAsync(
+            policy: policy,
+            action: cancellationToken =>
+            {
+                Interlocked.Increment(ref attempts);
+                attemptStarted.TrySetResult();
+
+                return StallAsync(cancellationToken);
+            },
+            cancellationToken: cts.Token
+        );
+        await attemptStarted.Task.WaitAsync(this.CancellationToken());
+        await cts.CancelAsync();
+
+        // A TimeoutRejectedException is not an OperationCanceledException, so this also proves the caller's
+        // cancellation was not reported as an attempt timeout.
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await executing);
+
+        Assert.Equal(expected: 1, actual: attempts);
+        Assert.Empty(logger.Entries);
+    }
+
+    private static async ValueTask<HttpResponseMessage> ExecutePolicyAsync(
+        IAsyncPolicy<HttpResponseMessage> policy,
+        Func<CancellationToken, Task<HttpResponseMessage>> action,
+        CancellationToken cancellationToken
+    )
+    {
+        return await policy.ExecuteAsync(action: action, cancellationToken: cancellationToken);
+    }
+
+    private static IAsyncPolicy<HttpResponseMessage> CreateFastTimeoutPolicy(ILogger<DiscordWebhookClient> logger)
+    {
+        return DiscordSetup.CreateWebhookPolicy(
+            timeProvider: MockDateTimeSources.Past,
+            attemptTimeout: TimeSpan.FromMilliseconds(1),
+            backoff: static _ => TimeSpan.Zero,
+            logger: logger
+        );
+    }
+
+    private static void AssertSingleRetryWarning(CapturingLogger<DiscordWebhookClient> logger, string expectedMessage)
+    {
+        CapturedLogEntry entry = Assert.Single(logger.Entries);
+        Assert.Equal(expected: LogLevel.Warning, actual: entry.Level);
+        Assert.Equal(expected: expectedMessage, actual: entry.Message);
+    }
+
+    private static async Task<HttpResponseMessage> StallAsync(CancellationToken cancellationToken)
+    {
+        await Task.Delay(delay: Timeout.InfiniteTimeSpan, cancellationToken: cancellationToken);
+
+        throw new InvalidOperationException("A stalled attempt only ends by cancellation");
+    }
+
+    private async ValueTask<WebhookSendResult> SendViaWebhookClientAsync(
+        TestHttpMessageHandler handler,
+        CapturingLogger<DiscordSetupTests> logger
+    )
+    {
+        ILoggerProvider loggerProvider = GetSubstitute<ILoggerProvider>();
+        loggerProvider.CreateLogger(Arg.Any<string>()).Returns(logger);
+
+        ServiceCollection services = new();
+        services
+            .AddLogging(builder => builder.AddProvider(loggerProvider))
+            .AddDiscord(Config)
+            .AddHttpClient(DiscordWebhookClient.HttpClientName)
+            .ConfigurePrimaryHttpMessageHandler(() => handler);
+
+        await using ServiceProvider serviceProvider = services.BuildServiceProvider();
+        IDiscordWebhookClient client = serviceProvider.GetRequiredService<IDiscordWebhookClient>();
+
+        return await client.SendAsync(
+            webhookUrl: WebhookUrl,
+            payload: EmbedMapper.ToPayload(TestEmbeds.WithTitle("Title")),
+            cancellationToken: this.CancellationToken()
+        );
+    }
+
+    private static HttpMessageHandler CreateNoContentHandler()
+    {
+        return new TestHttpMessageHandler(static () => new HttpResponseMessage(HttpStatusCode.NoContent));
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs b/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs
index 1288c2ced..3a408475d 100644
--- a/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs
+++ b/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs
@@ -1,5 +1,4 @@
 using BuildBot.Discord.Models;
-using Discord;
 using FunFair.Test.Common;
 using Xunit;
 
@@ -8,29 +7,29 @@ namespace BuildBot.Discord.Tests.Models;
 public sealed class BotMessageTests : TestBase
 {
     [Fact]
-    public void MessageProperty_ReturnsSuppliedBuilder()
+    public void MessageProperty_ReturnsSuppliedEmbed()
     {
-        EmbedBuilder builder = new();
-        BotMessage msg = new(builder);
+        DiscordEmbed embed = TestEmbeds.WithTitle("Message");
+        BotMessage msg = new(embed);
 
-        Assert.Same(expected: builder, actual: msg.Message);
+        Assert.Same(expected: embed, actual: msg.Message);
     }
 
     [Fact]
-    public void TwoInstances_WithSameBuilder_AreEqual()
+    public void TwoInstances_WithSameEmbed_AreEqual()
     {
-        EmbedBuilder builder = new();
-        BotMessage msg1 = new(builder);
-        BotMessage msg2 = new(builder);
+        DiscordEmbed embed = TestEmbeds.WithTitle("Message");
+        BotMessage msg1 = new(embed);
+        BotMessage msg2 = new(embed);
 
         Assert.Equal(expected: msg1, actual: msg2);
     }
 
     [Fact]
-    public void TwoInstances_WithDifferentBuilders_AreNotEqual()
+    public void TwoInstances_WithDifferentEmbeds_AreNotEqual()
     {
-        BotMessage msg1 = new(new EmbedBuilder().WithTitle("First Message"));
-        BotMessage msg2 = new(new EmbedBuilder().WithTitle("Second Message"));
+        BotMessage msg1 = new(TestEmbeds.WithTitle("First Message"));
+        BotMessage msg2 = new(TestEmbeds.WithTitle("Second Message"));
 
         Assert.NotEqual(expected: msg1, actual: msg2);
     }
diff --git a/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs b/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs
deleted file mode 100644
index 152d977e0..000000000
--- a/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using BuildBot.Discord.Models;
-using Discord;
-using FunFair.Test.Common;
-using Xunit;
-
-namespace BuildBot.Discord.Tests.Models;
-
-public sealed class BotReleaseMessageTests : TestBase
-{
-    [Fact]
-    public void MessageProperty_ReturnsSuppliedBuilder()
-    {
-        EmbedBuilder builder = new();
-        BotReleaseMessage msg = new(builder);
-
-        Assert.Same(expected: builder, actual: msg.Message);
-    }
-
-    [Fact]
-    public void TwoInstances_WithSameBuilder_AreEqual()
-    {
-        EmbedBuilder builder = new();
-        BotReleaseMessage msg1 = new(builder);
-        BotReleaseMessage msg2 = new(builder);
-
-        Assert.Equal(expected: msg1, actual: msg2);
-    }
-
-    [Fact]
-    public void TwoInstances_WithDifferentBuilders_AreNotEqual()
-    {
-        BotReleaseMessage msg1 = new(new EmbedBuilder().WithTitle("First Release"));
-        BotReleaseMessage msg2 = new(new EmbedBuilder().WithTitle("Second Release"));
-
-        Assert.NotEqual(expected: msg1, actual: msg2);
-    }
-}
diff --git a/src/BuildBot.Discord.Tests/Models/DiscordColorTests.cs b/src/BuildBot.Discord.Tests/Models/DiscordColorTests.cs
new file mode 100644
index 000000000..84dc8f598
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Models/DiscordColorTests.cs
@@ -0,0 +1,20 @@
+using BuildBot.Discord.Models;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Models;
+
+public sealed class DiscordColorTests : TestBase
+{
+    [Fact]
+    public void Green_MatchesDiscordGreen()
+    {
+        Assert.Equal(expected: 0x2ECC71u, actual: DiscordColor.Green.Value);
+    }
+
+    [Fact]
+    public void Red_MatchesDiscordRed()
+    {
+        Assert.Equal(expected: 0xE74C3Cu, actual: DiscordColor.Red.Value);
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Models/EmbedUrlTests.cs b/src/BuildBot.Discord.Tests/Models/EmbedUrlTests.cs
new file mode 100644
index 000000000..398f9d077
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Models/EmbedUrlTests.cs
@@ -0,0 +1,28 @@
+using System;
+using BuildBot.Discord.Models;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Models;
+
+public sealed class EmbedUrlTests : TestBase
+{
+    [Theory]
+    [InlineData("https://example.com/build/1")]
+    [InlineData("ftp://example.com/build/1")]
+    public static void FromString_WithAbsoluteUrl_ReturnsUri(string value)
+    {
+        Uri? uri = EmbedUrl.FromString(value);
+
+        Assert.Equal(expected: new Uri(value), actual: uri);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("not a url")]
+    public static void FromString_WithMissingOrInvalidUrl_ReturnsNull(string? value)
+    {
+        Assert.Null(EmbedUrl.FromString(value));
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs b/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs
index f09458664..b8ea612f0 100644
--- a/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs
+++ b/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs
@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using BuildBot.Discord.Models;
 using BuildBot.Discord.Publishers;
-using Discord;
 using FunFair.Test.Common;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
@@ -23,14 +22,11 @@ public async Task Handle_LogsAndPublishesToChannel()
 
         DiscordBotMessageNotificationHandler handler = new(messageChannel: channel, logger: logger);
 
-        EmbedBuilder builder = new EmbedBuilder().WithTitle("Test Notification");
-        BotMessage notification = new(builder);
+        BotMessage notification = new(TestEmbeds.WithTitle("Test Notification"));
 
         await handler.Handle(notification: notification, cancellationToken: this.CancellationToken());
 
         logger.Received(1).IsEnabled(LogLevel.Information);
-        await channel
-            .Received(1)
-            .PublishAsync(message: Arg.Any<BotMessage>(), cancellationToken: Arg.Any<CancellationToken>());
+        await channel.Received(1).PublishAsync(message: notification, cancellationToken: Arg.Any<CancellationToken>());
     }
 }
diff --git a/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs b/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs
deleted file mode 100644
index c938fef64..000000000
--- a/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using BuildBot.Discord.Models;
-using BuildBot.Discord.Publishers;
-using Discord;
-using FunFair.Test.Common;
-using NSubstitute;
-using Xunit;
-
-namespace BuildBot.Discord.Tests.Publishers;
-
-public sealed class DiscordBotReleaseMessageNotificationHandlerTests : TestBase
-{
-    [Fact]
-    public async Task Handle_PublishesToChannel()
-    {
-        IMessageChannel<BotReleaseMessage> channel = GetSubstitute<IMessageChannel<BotReleaseMessage>>();
-
-        DiscordBotReleaseMessageNotificationHandler handler = new(channel);
-
-        EmbedBuilder builder = new EmbedBuilder().WithTitle("Release Notification");
-        BotReleaseMessage notification = new(builder);
-
-        await handler.Handle(notification: notification, cancellationToken: this.CancellationToken());
-
-        await channel
-            .Received(1)
-            .PublishAsync(message: Arg.Any<BotReleaseMessage>(), cancellationToken: Arg.Any<CancellationToken>());
-    }
-}
diff --git a/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs b/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs
deleted file mode 100644
index 15e4291c6..000000000
--- a/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs
+++ /dev/null
@@ -1,144 +0,0 @@
-using System;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
-using BuildBot.Discord.Models;
-using BuildBot.Discord.Services;
-using Discord;
-using FunFair.Test.Common;
-using NSubstitute;
-using Xunit;
-
-namespace BuildBot.Discord.Tests.Services;
-
-public sealed class BotServiceTests : TestBase
-{
-    private static (
-        BotService Service,
-        IDiscordBot Bot,
-        MessageChannel<BotMessage> MessageChannel,
-        MessageChannel<BotReleaseMessage> ReleaseChannel
-    ) CreateService()
-    {
-        IDiscordBot bot = GetSubstitute<IDiscordBot>();
-        bot.StartAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
-        bot.StopAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
-
-        MessageChannel<BotMessage> messageChannel = new();
-        MessageChannel<BotReleaseMessage> releaseChannel = new();
-
-        BotService service = new(bot: bot, botMessageChannel: messageChannel, botReleaseMessageChannel: releaseChannel);
-
-        return (service, bot, messageChannel, releaseChannel);
-    }
-
-    [Fact]
-    public async Task StartAsync_DelegatesToBot()
-    {
-        (BotService service, IDiscordBot bot, _, _) = CreateService();
-
-        using (service)
-        {
-            await service.StartAsync(this.CancellationToken());
-
-            await bot.Received(1).StartAsync(Arg.Any<CancellationToken>());
-        }
-    }
-
-    [Fact]
-    public async Task StopAsync_DelegatesToBot()
-    {
-        (BotService service, IDiscordBot bot, _, _) = CreateService();
-
-        using (service)
-        {
-            await service.StopAsync(this.CancellationToken());
-
-            await bot.Received(1).StopAsync(Arg.Any<CancellationToken>());
-        }
-    }
-
-    [Fact]
-    public void Dispose_DisposesSubscriptions()
-    {
-        (BotService service, _, _, _) = CreateService();
-
-        service.Dispose();
-    }
-
-    [Fact]
-    public async Task BotMessage_IsForwardedToBot_AfterDelay()
-    {
-        (BotService service, IDiscordBot bot, MessageChannel<BotMessage> messageChannel, _) = CreateService();
-
-        using (service)
-        {
-            EmbedBuilder builder = new EmbedBuilder().WithTitle("Test");
-            BotMessage message = new(builder);
-
-            await messageChannel.PublishAsync(message: message, cancellationToken: this.CancellationToken());
-
-            await Task.Delay(TimeSpan.FromSeconds(2), this.CancellationToken());
-
-            await bot.Received(1)
-                .PublishAsync(builder: Arg.Any<EmbedBuilder>(), cancellationToken: Arg.Any<CancellationToken>());
-        }
-    }
-
-    [Fact]
-    public async Task BotReleaseMessage_IsForwardedToBot_AfterDelay()
-    {
-        (BotService service, IDiscordBot bot, _, MessageChannel<BotReleaseMessage> releaseChannel) = CreateService();
-
-        using (service)
-        {
-            EmbedBuilder builder = new EmbedBuilder().WithTitle("Release");
-            BotReleaseMessage message = new(builder);
-
-            await releaseChannel.PublishAsync(message: message, cancellationToken: this.CancellationToken());
-
-            await Task.Delay(TimeSpan.FromSeconds(2), this.CancellationToken());
-
-            await bot.Received(1)
-                .PublishToReleaseChannelAsync(
-                    builder: Arg.Any<EmbedBuilder>(),
-                    cancellationToken: Arg.Any<CancellationToken>()
-                );
-        }
-    }
-
-    public static TheoryData<int, string> NullConstructorArguments =>
-        new()
-        {
-            { 0, "bot" },
-            { 1, "botMessageChannel" },
-            { 2, "botReleaseMessageChannel" },
-        };
-
-    [Theory]
-    [MemberData(nameof(NullConstructorArguments))]
-    public static void Constructor_ThrowsArgumentNullException_WhenParameterIsNull(
-        int nullParameterIndex,
-        string expectedParamName
-    )
-    {
-        ConstructorInfo? ctor = typeof(BotService).GetConstructor([
-            typeof(IDiscordBot),
-            typeof(IMessageChannel<BotMessage>),
-            typeof(IMessageChannel<BotReleaseMessage>),
-        ]);
-        Assert.NotNull(ctor);
-
-        object?[] args =
-        [
-            GetSubstitute<IDiscordBot>(),
-            GetSubstitute<IMessageChannel<BotMessage>>(),
-            GetSubstitute<IMessageChannel<BotReleaseMessage>>(),
-        ];
-        args[nullParameterIndex] = null;
-
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => ctor.Invoke(args));
-        ArgumentNullException ane = Assert.IsType<ArgumentNullException>(ex.InnerException);
-        Assert.Equal(expected: expectedParamName, actual: ane.ParamName);
-    }
-}
diff --git a/src/BuildBot.Discord.Tests/Services/CountingReadStream.cs b/src/BuildBot.Discord.Tests/Services/CountingReadStream.cs
new file mode 100644
index 000000000..dccd148ff
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/CountingReadStream.cs
@@ -0,0 +1,68 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BuildBot.Discord.Tests.Services;
+
+internal sealed class CountingReadStream : Stream
+{
+    private readonly long _length;
+
+    public CountingReadStream(long length)
+    {
+        this._length = length;
+    }
+
+    public long BytesRead { get; private set; }
+
+    public override bool CanRead => true;
+
+    public override bool CanSeek => false;
+
+    public override bool CanWrite => false;
+
+    public override long Length => throw new NotSupportedException();
+
+    public override long Position
+    {
+        get => throw new NotSupportedException();
+        set => throw new NotSupportedException();
+    }
+
+    public override void Flush() { }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        return this.Fill(buffer.AsSpan(start: offset, length: count));
+    }
+
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        return ValueTask.FromResult(this.Fill(buffer.Span));
+    }
+
+    private int Fill(Span<byte> buffer)
+    {
+        int count = (int)Math.Min(val1: buffer.Length, val2: this._length - this.BytesRead);
+        buffer[..count].Fill((byte)'a');
+        this.BytesRead += count;
+
+        return count;
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void SetLength(long value)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs
index cd7bfd17b..6b8e8d02c 100644
--- a/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs
+++ b/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs
@@ -1,4 +1,6 @@
-using BuildBot.Discord;
+using System;
+using System.Diagnostics;
+using System.Reflection;
 using FunFair.Test.Common;
 using Xunit;
 
@@ -6,55 +8,62 @@ namespace BuildBot.Discord.Tests.Services;
 
 public sealed class DiscordBotConfigurationTests : TestBase
 {
+    private const string WEBHOOK_URL = "https://example.com/webhook/secret-token";
+
     [Fact]
-    public void Token_ReturnsConstructorValue()
+    public void FromWebhookUrl_WithHttpsUrl_ReturnsConfiguredConfiguration()
     {
-        DiscordBotConfiguration config = new(
-            token: "my-token",
-            server: "server",
-            channel: "channel",
-            releaseChannel: "releases"
-        );
+        DiscordBotConfiguration config = DiscordBotConfiguration.FromWebhookUrl(WEBHOOK_URL);
 
-        Assert.Equal(expected: "my-token", actual: config.Token);
+        Assert.Equal(expected: new Uri(WEBHOOK_URL), actual: config.WebhookUrl);
     }
 
-    [Fact]
-    public void Server_ReturnsConstructorValue()
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData("/webhook/secret-token")]
+    [InlineData("webhook/secret-token")]
+    [InlineData("http://example.com/webhook/secret-token")]
+    [InlineData("ftp://example.com/webhook/secret-token")]
+    public static void FromWebhookUrl_WithMissingOrInvalidUrl_ThrowsWithoutRevealingValue(string? webhookUrl)
     {
-        DiscordBotConfiguration config = new(
-            token: "token",
-            server: "my-server",
-            channel: "channel",
-            releaseChannel: "releases"
+        InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
+            DiscordBotConfiguration.FromWebhookUrl(webhookUrl)
         );
 
-        Assert.Equal(expected: "my-server", actual: config.Server);
+        Assert.Equal(
+            expected: "Discord:WebhookUrl must be configured as an absolute https URL",
+            actual: exception.Message
+        );
+        Assert.DoesNotContain(
+            expectedSubstring: "secret-token",
+            actualString: exception.ToString(),
+            comparisonType: StringComparison.Ordinal
+        );
     }
 
     [Fact]
-    public void Channel_ReturnsConstructorValue()
+    public void ToString_DoesNotRevealWebhookUrl()
     {
-        DiscordBotConfiguration config = new(
-            token: "token",
-            server: "server",
-            channel: "my-channel",
-            releaseChannel: "releases"
-        );
+        DiscordBotConfiguration config = DiscordBotConfiguration.FromWebhookUrl(WEBHOOK_URL);
 
-        Assert.Equal(expected: "my-channel", actual: config.Channel);
+        string text = config.ToString();
+
+        Assert.Equal(expected: "DiscordBotConfiguration { Webhook = <redacted> }", actual: text);
     }
 
     [Fact]
-    public void ReleaseChannel_ReturnsConstructorValue()
+    public void DebuggerDisplay_DoesNotReferenceWebhookUrl()
     {
-        DiscordBotConfiguration config = new(
-            token: "token",
-            server: "server",
-            channel: "channel",
-            releaseChannel: "my-releases"
+        DebuggerDisplayAttribute attribute = Assert.Single(
+            typeof(DiscordBotConfiguration).GetCustomAttributes<DebuggerDisplayAttribute>()
         );
 
-        Assert.Equal(expected: "my-releases", actual: config.ReleaseChannel);
+        Assert.DoesNotContain(
+            expectedSubstring: nameof(DiscordBotConfiguration.WebhookUrl),
+            actualString: attribute.Value,
+            comparisonType: StringComparison.Ordinal
+        );
     }
 }
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs
index 4a3b22b02..48fd23038 100644
--- a/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs
+++ b/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs
@@ -1,429 +1,160 @@
 using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
+using BuildBot.Discord.Models;
 using BuildBot.Discord.Services;
+using BuildBot.Discord.Services.Models;
 using BuildBot.ServiceModel.ComponentStatus;
-using Discord;
 using FunFair.Test.Common;
+using FunFair.Test.Infrastructure.Mocks;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
+using NSubstitute.ExceptionExtensions;
 using Xunit;
 
 namespace BuildBot.Discord.Tests.Services;
 
 public sealed class DiscordBotTests : TestBase
 {
-    private static readonly DiscordBotConfiguration Config = new(
-        token: "test-token",
-        server: "test-server",
-        channel: "test-channel",
-        releaseChannel: "test-release-channel"
+    private const string SECRET = "secret-token";
+    private const string REJECTION_BODY = """{"embeds":["0"]}""";
+    private static readonly DiscordBotConfiguration Config = DiscordBotConfiguration.FromWebhookUrl(
+        "https://example.com/webhook/" + SECRET
     );
 
-    private (IDiscordRawClient Client, ILogger<DiscordBot> Logger, DiscordBot Bot) CreateBot()
+    private static readonly DiscordEmbed Embed = new(
+        Title: "Test Message",
+        Url: new("https://example.com/build"),
+        Description: "Description",
+        Color: DiscordColor.Green,
+        Fields: [new(Name: "Name", Value: "Value")]
+    );
+
+    private static (IDiscordWebhookClient Client, CapturingLogger<DiscordBot> Logger, DiscordBot Bot) CreateBot()
     {
-        IDiscordRawClient client = GetSubstitute<IDiscordRawClient>();
-        ILogger<DiscordBot> logger = this.GetTypedLogger<DiscordBot>();
-        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
+        IDiscordWebhookClient client = GetSubstitute<IDiscordWebhookClient>();
+        CapturingLogger<DiscordBot> logger = new();
 
         DiscordBot bot = new(client: client, botConfiguration: Config, logger: logger);
 
         return (client, logger, bot);
     }
 
-    private (ILogger<DiscordBot> Logger, Func<LogMessage, Task> Handler) CreateBotForLogTests()
+    private static void MockDiscordWebhookClientSend(IDiscordWebhookClient client, in WebhookSendResult result)
     {
-        IDiscordRawClient client = GetSubstitute<IDiscordRawClient>();
-        ILogger<DiscordBot> logger = this.GetTypedLogger<DiscordBot>();
-        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
-
-        Func<LogMessage, Task>? capturedHandler = null;
         client
-            .When(x => x.RegisterLogHandler(Arg.Any<Func<LogMessage, Task>>()))
-            .Do(callInfo => capturedHandler = callInfo.Arg<Func<LogMessage, Task>>());
-
-        _ = new DiscordBot(client: client, botConfiguration: Config, logger: logger);
-
-        return (
-            logger,
-            capturedHandler
-                ?? throw new InvalidOperationException("DiscordBot constructor did not call RegisterLogHandler")
-        );
-    }
-
-    [Fact]
-    public void GetStatus_WhenLoggedOut_ReturnsDisconnectedStatus()
-    {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        client.LoginState.Returns(LoginState.LoggedOut);
-
-        ServiceStatus status = bot.GetStatus();
-
-        Assert.Equal(expected: "Discord", actual: status.Name);
-        Assert.False(condition: status.Ok, userMessage: "Discord should not be connected when logged out");
-    }
-
-    [Fact]
-    public void GetStatus_WhenLoggedIn_ReturnsConnectedStatus()
-    {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        client.LoginState.Returns(LoginState.LoggedIn);
-
-        ServiceStatus status = bot.GetStatus();
-
-        Assert.Equal(expected: "Discord", actual: status.Name);
-        Assert.True(condition: status.Ok, userMessage: "Discord should be connected when logged in");
+            .SendAsync(
+                webhookUrl: Arg.Any<Uri>(),
+                payload: Arg.Any<WebhookPayload>(),
+                cancellationToken: Arg.Any<CancellationToken>()
+            )
+            .Returns(result);
     }
 
-    [Fact]
-    public async Task PublishAsync_WhenChannelNotFound_LogsErrorAndReturns()
+    private static void MockDiscordWebhookClientSendThrows(IDiscordWebhookClient client, Exception exception)
     {
-        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
-
         client
-            .FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>())
-            .Returns((IDiscordChannel?)null);
-
-        await bot.PublishAsync(
-            builder: new EmbedBuilder().WithTitle("Test"),
-            cancellationToken: this.CancellationToken()
-        );
-
-        client.Received(1).FindChannel(serverName: Config.Server, channelName: Config.Channel);
-        logger.Received(1).IsEnabled(LogLevel.Error);
+            .SendAsync(
+                webhookUrl: Arg.Any<Uri>(),
+                payload: Arg.Any<WebhookPayload>(),
+                cancellationToken: Arg.Any<CancellationToken>()
+            )
+            .ThrowsAsync(exception);
     }
 
-    [Fact]
-    public async Task PublishToReleaseChannelAsync_WhenChannelNotFound_LogsErrorAndReturns()
+    private static void AssertSecretNeverLogged(CapturingLogger<DiscordBot> logger)
     {
-        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
-
-        client
-            .FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>())
-            .Returns((IDiscordChannel?)null);
-
-        await bot.PublishToReleaseChannelAsync(
-            builder: new EmbedBuilder().WithTitle("Test"),
-            cancellationToken: this.CancellationToken()
+        Assert.DoesNotContain(
+            collection: logger.Entries,
+            filter: static entry => entry.Message.Contains(value: SECRET, comparisonType: StringComparison.Ordinal)
         );
-
-        client.Received(1).FindChannel(serverName: Config.Server, channelName: Config.ReleaseChannel);
-        logger.Received(1).IsEnabled(LogLevel.Error);
     }
 
-    [Fact]
-    public async Task PublishAsync_WhenChannelFound_SendsMessageAndLogsSuccess()
+    private static int LogCallsAt(LogLevel level, CapturingLogger<DiscordBot> logger)
     {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(Task.FromResult<(string SentToChannel, string MessageContent)>(("test-channel", string.Empty)));
-
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-
-        await bot.PublishAsync(
-            builder: new EmbedBuilder().WithTitle("Test Message"),
-            cancellationToken: this.CancellationToken()
-        );
-
-        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
+        return logger.Entries.Count(entry => entry.Level == level);
     }
 
     [Fact]
-    public async Task PublishToReleaseChannelAsync_WhenChannelFound_SendsMessage()
+    public static void GetStatus_IsOk()
     {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-release-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(
-                Task.FromResult<(string SentToChannel, string MessageContent)>(("test-release-channel", string.Empty))
-            );
-
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+        (_, _, DiscordBot bot) = CreateBot();
 
-        await bot.PublishToReleaseChannelAsync(
-            builder: new EmbedBuilder().WithTitle("Release Test"),
-            cancellationToken: this.CancellationToken()
-        );
+        ServiceStatus status = bot.GetStatus();
 
-        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
+        Assert.Equal(expected: new ServiceStatus(Name: "Discord", Ok: true), actual: status);
     }
 
     [Fact]
-    public async Task PublishAsync_WhenSendFails_WhileLoggedIn_ReconnectsAfterLogout()
+    public async Task PublishAsync_SendsMappedEmbedToWebhookAndLogsSuccess()
     {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
+        (IDiscordWebhookClient client, CapturingLogger<DiscordBot> logger, DiscordBot bot) = CreateBot();
+        WebhookPayload? captured = null;
+        client
+            .SendAsync(
+                webhookUrl: Config.WebhookUrl,
+                payload: Arg.Do<WebhookPayload>(p => captured = p),
+                cancellationToken: Arg.Any<CancellationToken>()
+            )
             .Returns(
-                Task.FromException<(string SentToChannel, string MessageContent)>(
-                    new InvalidOperationException("send failed")
-                )
+                new WebhookSendResult(Success: true, StatusCode: HttpStatusCode.NoContent, ResponseBody: string.Empty)
             );
 
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-        client.LoginState.Returns(LoginState.LoggedIn);
-
-        await bot.PublishAsync(
-            builder: new EmbedBuilder().WithTitle("Test"),
-            cancellationToken: this.CancellationToken()
-        );
+        await bot.PublishAsync(embed: Embed, cancellationToken: this.CancellationToken());
 
-        await client.Received(1).LogoutAsync();
-        await client.Received(1).StopAsync();
-        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
+        WebhookPayload payload = AssertReallyNotNull(captured);
+        WebhookEmbed sent = Assert.Single(payload.Embeds);
+        WebhookEmbed expected = EmbedMapper.ToWebhookEmbed(Embed);
+        Assert.Equal(expected: expected with { Fields = sent.Fields }, actual: sent);
+        Assert.Equal(expected: expected.Fields, actual: sent.Fields);
+        Assert.Equal(expected: 2, actual: LogCallsAt(level: LogLevel.Information, logger: logger));
+        Assert.Equal(expected: 0, actual: LogCallsAt(level: LogLevel.Error, logger: logger));
+        AssertSecretNeverLogged(logger);
     }
 
     [Fact]
-    public async Task PublishAsync_WhenSendFails_WhileNotLoggedIn_ReconnectsWithoutLogout()
+    public async Task PublishAsync_WhenWebhookRejectsMessage_LogsError()
     {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(
-                Task.FromException<(string SentToChannel, string MessageContent)>(
-                    new InvalidOperationException("send failed")
-                )
-            );
-
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-        client.LoginState.Returns(LoginState.LoggedOut);
-
-        await bot.PublishAsync(
-            builder: new EmbedBuilder().WithTitle("Test"),
-            cancellationToken: this.CancellationToken()
+        (IDiscordWebhookClient client, CapturingLogger<DiscordBot> logger, DiscordBot bot) = CreateBot();
+        MockDiscordWebhookClientSend(
+            client: client,
+            result: new(Success: false, StatusCode: HttpStatusCode.BadRequest, ResponseBody: REJECTION_BODY)
         );
 
-        await client.DidNotReceive().LogoutAsync();
-        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
-    }
-
-    [Fact]
-    public async Task PublishAsync_WhenReconnectFails_LogsError()
-    {
-        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(
-                Task.FromException<(string SentToChannel, string MessageContent)>(
-                    new InvalidOperationException("send failed")
-                )
-            );
+        await bot.PublishAsync(embed: Embed, cancellationToken: this.CancellationToken());
 
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-        client.LoginState.Returns(LoginState.LoggedIn);
-        client.LogoutAsync().Returns(Task.FromException(new InvalidOperationException("logout failed")));
-
-        await bot.PublishAsync(
-            builder: new EmbedBuilder().WithTitle("Test"),
-            cancellationToken: this.CancellationToken()
+        CapturedLogEntry error = Assert.Single(
+            collection: logger.Entries,
+            predicate: static entry => entry.Level == LogLevel.Error
         );
-
-        logger.Received(2).IsEnabled(LogLevel.Error);
-    }
-
-    [Fact]
-    public async Task StartAsync_CallsLoginStartAndSetGame()
-    {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        await bot.StartAsync(this.CancellationToken());
-
-        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
-        await client.Received(1).StartAsync();
-        await client.Received(1).SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
-    }
-
-    [Fact]
-    public async Task StopAsync_CallsLogout()
-    {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        await bot.StopAsync(this.CancellationToken());
-
-        await client.Received(1).LogoutAsync();
-    }
-
-    [Fact]
-    public async Task LogAsync_Debug_LogsAtDebugLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Debug, source: "Test", message: "Debug message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Debug);
-    }
-
-    [Fact]
-    public async Task LogAsync_Verbose_LogsAtInformationLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Verbose, source: "Test", message: "Verbose message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Information);
-    }
-
-    [Fact]
-    public async Task LogAsync_Info_LogsAtInformationLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Info, source: "Test", message: "Info message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Information);
-    }
-
-    [Fact]
-    public async Task LogAsync_Warning_LogsAtWarningLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Warning, source: "Test", message: "Warning message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Warning);
-    }
-
-    [Fact]
-    public async Task LogAsync_ErrorWithoutException_LogsAtErrorLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Error, source: "Test", message: "Error message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Error);
-    }
-
-    [Fact]
-    public async Task LogAsync_ErrorWithException_LogsAtErrorLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(
-            new LogMessage(
-                LogSeverity.Error,
-                source: "Test",
-                message: "Error message",
-                exception: new InvalidOperationException("test error")
-            )
+        Assert.Contains(
+            expectedSubstring: REJECTION_BODY,
+            actualString: error.Message,
+            comparisonType: StringComparison.Ordinal
         );
-
-        logger.Received(1).IsEnabled(LogLevel.Error);
-    }
-
-    [Fact]
-    public async Task LogAsync_CriticalWithoutException_LogsAtCriticalLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage(LogSeverity.Critical, source: "Test", message: "Critical message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Critical);
-    }
-
-    [Fact]
-    public async Task LogAsync_CriticalWithException_LogsAtCriticalLevel()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(
-            new LogMessage(
-                LogSeverity.Critical,
-                source: "Test",
-                message: "Critical message",
-                exception: new InvalidOperationException("critical error")
-            )
+        Assert.Contains(
+            expectedSubstring: "BadRequest",
+            actualString: error.Message,
+            comparisonType: StringComparison.Ordinal
         );
-
-        logger.Received(1).IsEnabled(LogLevel.Critical);
-    }
-
-    [Fact]
-    public async Task LogAsync_UnknownSeverity_LogsAsCritical()
-    {
-        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
-
-        await handler(new LogMessage((LogSeverity)99, source: "Test", message: "Unknown severity message"));
-
-        logger.Received(1).IsEnabled(LogLevel.Critical);
+        AssertSecretNeverLogged(logger);
     }
 
     [Fact]
-    public async Task PublishAsync_WhenChannelFound_WithNullTitle_SendsMessage()
+    public async Task PublishAsync_WhenClientThrows_PropagatesTheException()
     {
-        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(Task.FromResult<(string SentToChannel, string MessageContent)>(("test-channel", string.Empty)));
-
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-
-        await bot.PublishAsync(builder: new EmbedBuilder(), cancellationToken: this.CancellationToken());
-
-        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
-    }
+        (IDiscordWebhookClient client, CapturingLogger<DiscordBot> logger, DiscordBot bot) = CreateBot();
+        HttpRequestException exception = new("connection failed");
+        MockDiscordWebhookClientSendThrows(client: client, exception: exception);
 
-    [Fact]
-    public async Task PublishAsync_WhenSendFails_WithNullTitle_LogsErrorAndReconnects()
-    {
-        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
-
-        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
-        IDisposable mockTypingState = GetSubstitute<IDisposable>();
-
-        mockChannel.Name.Returns("test-channel");
-        mockChannel.EnterTypingState().Returns(mockTypingState);
-        mockChannel
-            .SendMessageAsync(Arg.Any<Embed>())
-            .Returns(
-                Task.FromException<(string SentToChannel, string MessageContent)>(
-                    new InvalidOperationException("send failed")
-                )
-            );
-
-        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
-        client.LoginState.Returns(LoginState.LoggedOut);
-
-        await bot.PublishAsync(builder: new EmbedBuilder(), cancellationToken: this.CancellationToken());
+        HttpRequestException thrown = await Assert.ThrowsAsync<HttpRequestException>(async () =>
+            await bot.PublishAsync(embed: Embed, cancellationToken: this.CancellationToken())
+        );
 
-        logger.Received(1).IsEnabled(LogLevel.Error);
-        await client.DidNotReceive().LogoutAsync();
+        Assert.Same(expected: exception, actual: thrown);
+        AssertSecretNeverLogged(logger);
     }
 }
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordChannelAdapterTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordChannelAdapterTests.cs
deleted file mode 100644
index 34ed239fa..000000000
--- a/src/BuildBot.Discord.Tests/Services/DiscordChannelAdapterTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using BuildBot.Discord.Services;
-using Discord;
-using FunFair.Test.Common;
-using NSubstitute;
-using Xunit;
-
-namespace BuildBot.Discord.Tests.Services;
-
-public sealed class DiscordChannelAdapterTests : TestBase
-{
-    [Fact]
-    public void Name_ReturnsChannelName()
-    {
-        ITextChannel channel = GetSubstitute<ITextChannel>();
-        channel.Name.Returns("test-channel");
-
-        DiscordChannelAdapter adapter = new(channel);
-
-        Assert.Equal(expected: "test-channel", actual: adapter.Name);
-    }
-
-    [Fact]
-    public void EnterTypingState_ReturnsTypingStateFromChannel()
-    {
-        ITextChannel channel = GetSubstitute<ITextChannel>();
-        IDisposable typingState = GetSubstitute<IDisposable>();
-        channel.EnterTypingState(Arg.Any<RequestOptions>()).Returns(typingState);
-
-        DiscordChannelAdapter adapter = new(channel);
-
-        IDisposable result = adapter.EnterTypingState();
-
-        Assert.Same(expected: typingState, actual: result);
-    }
-
-    [Fact]
-    public async Task SendMessageAsync_ReturnsChannelNameAndCleanContent()
-    {
-        ITextChannel channel = GetSubstitute<ITextChannel>();
-        IUserMessage message = GetSubstitute<IUserMessage>();
-
-        channel.Name.Returns("sent-channel");
-
-        // In production CleanContent is always "" because the adapter sends text: string.Empty (embed-only).
-        message.CleanContent.Returns("clean content");
-
-        channel.SendMessageAsync(text: string.Empty, embed: default).ReturnsForAnyArgs(Task.FromResult(message));
-
-        DiscordChannelAdapter adapter = new(channel);
-
-        Embed embed = new EmbedBuilder().Build();
-        (string sentToChannel, string messageContent) = await adapter.SendMessageAsync(embed);
-
-        Assert.Equal(expected: "sent-channel", actual: sentToChannel);
-        Assert.Equal(expected: "clean content", actual: messageContent);
-
-        await channel
-            .Received(1)
-            .SendMessageAsync(
-                text: string.Empty,
-                isTTS: Arg.Any<bool>(),
-                embed: embed,
-                options: Arg.Any<RequestOptions>(),
-                allowedMentions: Arg.Any<AllowedMentions>(),
-                messageReference: Arg.Any<MessageReference>(),
-                components: Arg.Any<MessageComponent>(),
-                stickers: Arg.Any<ISticker[]>(),
-                embeds: Arg.Any<Embed[]>(),
-                flags: Arg.Any<MessageFlags>(),
-                poll: Arg.Any<PollProperties>()
-            );
-    }
-}
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordMessageSenderTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordMessageSenderTests.cs
new file mode 100644
index 000000000..8d54d40d9
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/DiscordMessageSenderTests.cs
@@ -0,0 +1,284 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services;
+using FunFair.Test.Common;
+using FunFair.Test.Infrastructure.Mocks;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using NSubstitute.Core;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class DiscordMessageSenderTests : TestBase
+{
+    private const int PUBLISH_FAILED_EVENT_ID = 7;
+    private const string SECRET = "secret-token";
+    private const string FAILURE_MESSAGE = "Failed to reach https://example.com/webhook/" + SECRET;
+    private static readonly TimeSpan CompletionWait = TimeSpan.FromSeconds(10);
+
+    private static (
+        DiscordMessageSender Service,
+        IDiscordBot Bot,
+        MessageChannel<BotMessage> MessageChannel,
+        CapturingLogger<DiscordMessageSender> Logger
+    ) CreateService()
+    {
+        IDiscordBot bot = GetSubstitute<IDiscordBot>();
+        MessageChannel<BotMessage> messageChannel = new();
+        CapturingLogger<DiscordMessageSender> logger = new();
+
+        DiscordMessageSender service = new(bot: bot, botMessageChannel: messageChannel, logger: logger);
+
+        return (service, bot, messageChannel, logger);
+    }
+
+    [Fact]
+    public async Task StartAsync_DoesNotPublishWithoutMessages()
+    {
+        (DiscordMessageSender service, IDiscordBot bot, _, _) = CreateService();
+
+        using (service)
+        {
+            await service.StartAsync(this.CancellationToken());
+            await service.StopAsync(this.CancellationToken());
+
+            Assert.Empty(bot.ReceivedCalls());
+        }
+    }
+
+    [Fact]
+    public async Task StopAsync_EndsTheLoopAndStopsForwardingMessages()
+    {
+        (DiscordMessageSender service, IDiscordBot bot, MessageChannel<BotMessage> messageChannel, _) = CreateService();
+
+        using (service)
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+            await service.StopAsync(cancellationToken);
+
+            Assert.NotNull(service.ExecuteTask);
+            Assert.True(service.ExecuteTask.IsCompleted, userMessage: "The send loop should have ended");
+
+            BotMessage message = new(TestEmbeds.WithTitle("Test"));
+            await messageChannel.PublishAsync(message: message, cancellationToken: cancellationToken);
+
+            // The stopped service no longer reads the channel, so the message is still there for us to read.
+            await using IAsyncEnumerator<BotMessage> reader = messageChannel
+                .ReadAllAsync(cancellationToken)
+                .GetAsyncEnumerator(cancellationToken);
+            Assert.True(
+                await reader
+                    .MoveNextAsync()
+                    .AsTask()
+                    .WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken),
+                userMessage: "Message should remain unread in the channel"
+            );
+            Assert.Same(expected: message, actual: reader.Current);
+
+            await bot.DidNotReceive()
+                .PublishAsync(embed: Arg.Any<DiscordEmbed>(), cancellationToken: Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public async Task BotMessage_IsForwardedToBot()
+    {
+        (DiscordMessageSender service, IDiscordBot bot, MessageChannel<BotMessage> messageChannel, _) = CreateService();
+        TaskCompletionSource published = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        bot.When(async x =>
+                await x.PublishAsync(embed: Arg.Any<DiscordEmbed>(), cancellationToken: Arg.Any<CancellationToken>())
+            )
+            .Do(_ => published.TrySetResult());
+
+        using (service)
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+
+            DiscordEmbed embed = TestEmbeds.WithTitle("Test");
+
+            await messageChannel.PublishAsync(message: new(embed), cancellationToken: cancellationToken);
+
+            await published.Task.WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken);
+
+            await service.StopAsync(cancellationToken);
+
+            await bot.Received(1).PublishAsync(embed: embed, cancellationToken: Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public async Task ChannelCompletion_EndsTheLoopAfterSendingEveryMessage()
+    {
+        IDiscordBot bot = GetSubstitute<IDiscordBot>();
+        IMessageChannel<BotMessage> messageChannel = GetSubstitute<IMessageChannel<BotMessage>>();
+        DiscordEmbed embed = TestEmbeds.WithTitle("Test");
+        messageChannel
+            .ReadAllAsync(Arg.Any<CancellationToken>())
+            .Returns(new BotMessage[] { new(embed) }.ToAsyncEnumerable());
+
+        using (
+            DiscordMessageSender service = new(
+                bot: bot,
+                botMessageChannel: messageChannel,
+                logger: new CapturingLogger<DiscordMessageSender>()
+            )
+        )
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+
+            Assert.NotNull(service.ExecuteTask);
+            await service.ExecuteTask.WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken);
+
+            await service.StopAsync(cancellationToken);
+
+            await bot.Received(1).PublishAsync(embed: embed, cancellationToken: Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public async Task StopAsync_DuringSend_EndsTheLoopWithoutLoggingAFailure()
+    {
+        (
+            DiscordMessageSender service,
+            IDiscordBot bot,
+            MessageChannel<BotMessage> messageChannel,
+            CapturingLogger<DiscordMessageSender> logger
+        ) = CreateService();
+        TaskCompletionSource sendStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        bot.When(async x =>
+                await x.PublishAsync(embed: Arg.Any<DiscordEmbed>(), cancellationToken: Arg.Any<CancellationToken>())
+            )
+            .Do(call =>
+                BlockUntilCancelled(sendStarted: sendStarted, cancellationToken: call.Arg<CancellationToken>())
+            );
+
+        using (service)
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+
+            await messageChannel.PublishAsync(
+                message: new(TestEmbeds.WithTitle("Test")),
+                cancellationToken: cancellationToken
+            );
+            await sendStarted.Task.WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken);
+
+            await service.StopAsync(cancellationToken);
+
+            Assert.NotNull(service.ExecuteTask);
+            Assert.True(service.ExecuteTask.IsCanceled, userMessage: "The send loop should have ended by cancellation");
+            Assert.Empty(logger.Entries);
+        }
+    }
+
+    private static void BlockUntilCancelled(TaskCompletionSource sendStarted, in CancellationToken cancellationToken)
+    {
+        sendStarted.TrySetResult();
+
+        // Bounded so a broken stop fails the IsCanceled assertion rather than hanging the run.
+        cancellationToken.WaitHandle.WaitOne(CompletionWait);
+        cancellationToken.ThrowIfCancellationRequested();
+    }
+
+    [Fact]
+    public async Task FailedPublish_IsLoggedAndLaterMessagesAreStillSent()
+    {
+        (
+            DiscordMessageSender service,
+            IDiscordBot bot,
+            MessageChannel<BotMessage> messageChannel,
+            CapturingLogger<DiscordMessageSender> logger
+        ) = CreateService();
+        TaskCompletionSource secondPublishAttempted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        bot.When(async x =>
+                await x.PublishAsync(embed: Arg.Any<DiscordEmbed>(), cancellationToken: Arg.Any<CancellationToken>())
+            )
+            .Do(
+                Callback
+                    .First(_ => throw new HttpRequestException(FAILURE_MESSAGE))
+                    .Then(_ => secondPublishAttempted.TrySetResult())
+            );
+
+        using (service)
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+
+            DiscordEmbed second = TestEmbeds.WithTitle("Second");
+            await messageChannel.PublishAsync(
+                message: new(TestEmbeds.WithTitle("First")),
+                cancellationToken: cancellationToken
+            );
+            await messageChannel.PublishAsync(message: new(second), cancellationToken: cancellationToken);
+
+            await secondPublishAttempted.Task.WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken);
+
+            await service.StopAsync(cancellationToken);
+
+            await bot.Received(1).PublishAsync(embed: second, cancellationToken: Arg.Any<CancellationToken>());
+
+            // Messages are sent one at a time, so the first failure was logged before the second send began.
+            CapturedLogEntry failure = Assert.Single(
+                collection: logger.Entries,
+                predicate: static entry => entry.Level == LogLevel.Error
+            );
+            Assert.Equal(expected: PUBLISH_FAILED_EVENT_ID, actual: failure.EventId.Id);
+
+            // Only the exception type is logged; its message carries the webhook URL and so the token.
+            Assert.Equal(
+                expected: "DISCORD: Failed to publish message First with HttpRequestException",
+                actual: failure.Message
+            );
+            Assert.DoesNotContain(
+                expectedSubstring: SECRET,
+                actualString: failure.Message,
+                comparisonType: StringComparison.Ordinal
+            );
+        }
+    }
+
+    [Fact]
+    public async Task FailedPublish_DoesNotAttachTheExceptionToTheLog()
+    {
+        IDiscordBot bot = GetSubstitute<IDiscordBot>();
+        bot.When(async x =>
+                await x.PublishAsync(embed: Arg.Any<DiscordEmbed>(), cancellationToken: Arg.Any<CancellationToken>())
+            )
+            .Do(_ => throw new HttpRequestException(FAILURE_MESSAGE));
+        IMessageChannel<BotMessage> messageChannel = GetSubstitute<IMessageChannel<BotMessage>>();
+        messageChannel
+            .ReadAllAsync(Arg.Any<CancellationToken>())
+            .Returns(new BotMessage[] { new(TestEmbeds.WithTitle("First")) }.ToAsyncEnumerable());
+        ILogger<DiscordMessageSender> logger = GetSubstitute<ILogger<DiscordMessageSender>>();
+        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
+
+        using (DiscordMessageSender service = new(bot: bot, botMessageChannel: messageChannel, logger: logger))
+        {
+            CancellationToken cancellationToken = this.CancellationToken();
+            await service.StartAsync(cancellationToken);
+
+            Assert.NotNull(service.ExecuteTask);
+            await service.ExecuteTask.WaitAsync(timeout: CompletionWait, cancellationToken: cancellationToken);
+
+            await service.StopAsync(cancellationToken);
+        }
+
+        // The exception object would be written by any sink that renders it, message and all.
+        ICall logCall = Assert.Single(collection: logger.ReceivedCalls(), predicate: static call => IsLogCall(call));
+        Assert.Null(logCall.GetArguments()[3]);
+    }
+
+    private static bool IsLogCall(ICall call)
+    {
+        return StringComparer.Ordinal.Equals(x: call.GetMethodInfo().Name, y: nameof(ILogger.Log));
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordWebhookClientTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordWebhookClientTests.cs
new file mode 100644
index 000000000..58a179600
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/DiscordWebhookClientTests.cs
@@ -0,0 +1,275 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Services;
+using BuildBot.Discord.Services.Models;
+using FunFair.Test.Common;
+using FunFair.Test.Infrastructure.Mocks;
+using Microsoft.Extensions.Time.Testing;
+using NSubstitute;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class DiscordWebhookClientTests : TestBase
+{
+    private static readonly Uri WebhookUrl = new("https://example.com/webhook/secret-token");
+
+    private static readonly WebhookPayload Payload = new([
+        new WebhookEmbed(
+            Title: "Title",
+            Url: new("https://example.com/build"),
+            Description: null,
+            Color: 0x2ECC71,
+            Author: new(Name: "Author", Url: new("https://example.com/"), IconUrl: new("https://example.com/icon.png")),
+            Fields: [new(Name: "Name", Value: "Value", Inline: true)]
+        ),
+    ]);
+
+    private const string EXPECTED_JSON =
+        """{"embeds":[{"title":"Title","url":"https://example.com/build","color":3066993,"author":{"name":"Author","url":"https://example.com/","icon_url":"https://example.com/icon.png"},"fields":[{"name":"Name","value":"Value","inline":true}]}]}""";
+
+    private static DiscordWebhookClient CreateClient(TestHttpMessageHandler handler)
+    {
+        return CreateClient(handler: handler, timeProvider: MockDateTimeSources.Past);
+    }
+
+    private static DiscordWebhookClient CreateClient(TestHttpMessageHandler handler, TimeProvider timeProvider)
+    {
+        IHttpClientFactory factory = GetSubstitute<IHttpClientFactory>();
+        factory
+            .CreateClient(DiscordWebhookClient.HttpClientName)
+            .Returns(_ => new HttpClient(handler: handler, disposeHandler: false));
+
+        return new(httpClientFactory: factory, timeProvider: timeProvider);
+    }
+
+    private static Func<HttpResponseMessage> Respond(HttpStatusCode statusCode)
+    {
+        return () => new(statusCode);
+    }
+
+    [Fact]
+    public async Task SendAsync_PostsPayloadAsJsonToWebhookUrl()
+    {
+        using TestHttpMessageHandler handler = new(Respond(HttpStatusCode.NoContent));
+        DiscordWebhookClient client = CreateClient(handler);
+
+        WebhookSendResult result = await client.SendAsync(
+            webhookUrl: WebhookUrl,
+            payload: Payload,
+            cancellationToken: this.CancellationToken()
+        );
+
+        Assert.Equal(
+            expected: new(Success: true, StatusCode: HttpStatusCode.NoContent, ResponseBody: string.Empty),
+            actual: result
+        );
+
+        TestHttpMessageHandler.RecordedRequest request = Assert.Single(handler.Requests);
+        Assert.Equal(expected: HttpMethod.Post, actual: request.Method);
+        Assert.Equal(expected: WebhookUrl, actual: request.RequestUri);
+        Assert.Equal(expected: "application/json", actual: request.ContentType);
+        Assert.Equal(expected: EXPECTED_JSON, actual: request.Body);
+    }
+
+    [Theory]
+    [InlineData(HttpStatusCode.OK, true)]
+    [InlineData(HttpStatusCode.NoContent, true)]
+    [InlineData(HttpStatusCode.BadRequest, false)]
+    [InlineData(HttpStatusCode.NotFound, false)]
+    [InlineData(HttpStatusCode.TooManyRequests, false)]
+    [InlineData(HttpStatusCode.InternalServerError, false)]
+    public async Task SendAsync_ReturnsResultForStatusWithoutThrowingAsync(
+        HttpStatusCode statusCode,
+        bool expectedSuccess
+    )
+    {
+        using TestHttpMessageHandler handler = new(Respond(statusCode));
+        DiscordWebhookClient client = CreateClient(handler);
+
+        WebhookSendResult result = await client.SendAsync(
+            webhookUrl: WebhookUrl,
+            payload: Payload,
+            cancellationToken: this.CancellationToken()
+        );
+
+        Assert.Equal(
+            expected: new(Success: expectedSuccess, StatusCode: statusCode, ResponseBody: string.Empty),
+            actual: result
+        );
+        Assert.Single(handler.Requests);
+    }
+
+    private static Func<HttpResponseMessage> Respond(HttpStatusCode statusCode, HttpContent content)
+    {
+        return () => new(statusCode) { Content = content };
+    }
+
+    private ValueTask<WebhookSendResult> SendAsync(TestHttpMessageHandler handler)
+    {
+        DiscordWebhookClient client = CreateClient(handler);
+
+        return client.SendAsync(webhookUrl: WebhookUrl, payload: Payload, cancellationToken: this.CancellationToken());
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenRejected_ReturnsResponseBody()
+    {
+        const string body =
+            """{"message":"Invalid Form Body","errors":{"embeds":{"0":{"title":"Must be 256 or fewer"}}}}""";
+        using StringContent content = new(body);
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+
+        WebhookSendResult result = await this.SendAsync(handler);
+
+        Assert.Equal(
+            expected: new(Success: false, StatusCode: HttpStatusCode.BadRequest, ResponseBody: body),
+            actual: result
+        );
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenRejectedWithLongBody_TruncatesResponseBody()
+    {
+        string body = new string(c: 'a', count: DiscordWebhookClient.MaximumResponseBodyLength) + "TRUNCATED";
+        using StringContent content = new(body);
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+
+        WebhookSendResult result = await this.SendAsync(handler);
+
+        Assert.Equal(
+            expected: new(
+                Success: false,
+                StatusCode: HttpStatusCode.BadRequest,
+                ResponseBody: body[..DiscordWebhookClient.MaximumResponseBodyLength]
+            ),
+            actual: result
+        );
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenRejectedWithHugeBody_DoesNotBufferTheWholeBody()
+    {
+        const long bodyLength = 16 * 1024 * 1024;
+        CountingReadStream stream = new(bodyLength);
+        using StreamContent content = new(stream);
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+
+        WebhookSendResult result = await this.SendAsync(handler);
+
+        Assert.Equal(expected: DiscordWebhookClient.MaximumResponseBodyLength, actual: result.ResponseBody.Length);
+        Assert.InRange(actual: stream.BytesRead, low: DiscordWebhookClient.MaximumResponseBodyLength, high: 64 * 1024);
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenSuccessful_DoesNotReadResponseBody()
+    {
+        using StreamContent content = new(new ThrowingReadStream(new InvalidOperationException("Body read")));
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.OK, content: content));
+
+        WebhookSendResult result = await this.SendAsync(handler);
+
+        Assert.Equal(
+            expected: new(Success: true, StatusCode: HttpStatusCode.OK, ResponseBody: string.Empty),
+            actual: result
+        );
+    }
+
+    public static TheoryData<Exception> UnreadableBodyExceptions =>
+        [new IOException("Connection reset"), new HttpRequestException("Response ended prematurely")];
+
+    [Theory]
+    [MemberData(nameof(UnreadableBodyExceptions))]
+    public async Task SendAsync_WhenRejectedBodyCannotBeRead_StillReturnsStatusAsync(Exception exception)
+    {
+        using StreamContent content = new(new ThrowingReadStream(exception));
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+
+        WebhookSendResult result = await this.SendAsync(handler);
+
+        Assert.Equal(
+            expected: new(
+                Success: false,
+                StatusCode: HttpStatusCode.BadRequest,
+                ResponseBody: DiscordWebhookClient.ResponseBodyUnavailable
+            ),
+            actual: result
+        );
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenRejectedBodyReadIsCancelled_Throws()
+    {
+        using StreamContent content = new(new ThrowingReadStream(new OperationCanceledException()));
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await this.SendAsync(handler));
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenRejectedBodyReadTimesOut_StillReturnsStatus()
+    {
+        FakeTimeProvider timeProvider = MockDateTimeSources.Past;
+        StalledReadStream stream = new();
+        using StreamContent content = new(stream);
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+        DiscordWebhookClient client = CreateClient(handler: handler, timeProvider: timeProvider);
+
+        ValueTask<WebhookSendResult> sending = client.SendAsync(
+            webhookUrl: WebhookUrl,
+            payload: Payload,
+            cancellationToken: this.CancellationToken()
+        );
+        await stream.ReadStarted.WaitAsync(this.CancellationToken());
+        timeProvider.Advance(DiscordWebhookClient.ResponseBodyReadTimeout);
+
+        WebhookSendResult result = await sending;
+
+        Assert.Equal(
+            expected: new(
+                Success: false,
+                StatusCode: HttpStatusCode.BadRequest,
+                ResponseBody: DiscordWebhookClient.ResponseBodyUnavailable
+            ),
+            actual: result
+        );
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenCancelledWhileReadingRejectedBody_Throws()
+    {
+        StalledReadStream stream = new();
+        using StreamContent content = new(stream);
+        using TestHttpMessageHandler handler = new(Respond(statusCode: HttpStatusCode.BadRequest, content: content));
+        DiscordWebhookClient client = CreateClient(handler);
+        using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(this.CancellationToken());
+
+        ValueTask<WebhookSendResult> sending = client.SendAsync(
+            webhookUrl: WebhookUrl,
+            payload: Payload,
+            cancellationToken: cts.Token
+        );
+        await stream.ReadStarted.WaitAsync(this.CancellationToken());
+        await cts.CancelAsync();
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await sending);
+    }
+
+    [Fact]
+    public async Task SendAsync_WhenCancelled_Throws()
+    {
+        using TestHttpMessageHandler handler = new(Respond(HttpStatusCode.NoContent));
+        DiscordWebhookClient client = CreateClient(handler);
+
+        using CancellationTokenSource cts = new();
+        await cts.CancelAsync();
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () =>
+            await client.SendAsync(webhookUrl: WebhookUrl, payload: Payload, cancellationToken: cts.Token)
+        );
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/EmbedMapperTests.cs b/src/BuildBot.Discord.Tests/Services/EmbedMapperTests.cs
new file mode 100644
index 000000000..306155b2f
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/EmbedMapperTests.cs
@@ -0,0 +1,377 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services;
+using BuildBot.Discord.Services.Models;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class EmbedMapperTests : TestBase
+{
+    private const int MAX_TOTAL_LENGTH = 6000;
+
+    [Fact]
+    public void ToWebhookEmbed_MapsAllPropertiesAndAddsStandardAuthor()
+    {
+        DiscordEmbed embed = new(
+            Title: "Title",
+            Url: new("https://example.com/build"),
+            Description: "Description",
+            Color: DiscordColor.Red,
+            Fields: [new(Name: "First", Value: "One"), new(Name: "Second", Value: "Two", Inline: true)]
+        );
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: "Title", actual: result.Title);
+        Assert.Equal(expected: new Uri("https://example.com/build"), actual: result.Url);
+        Assert.Equal(expected: "Description", actual: result.Description);
+        Assert.Equal(expected: 0xE74C3Cu, actual: result.Color);
+        Assert.Same(expected: EmbedMapper.StandardAuthor, actual: result.Author);
+        Assert.Equal(
+            expected:
+            [
+                new WebhookEmbedField(Name: "First", Value: "One", Inline: false),
+                new WebhookEmbedField(Name: "Second", Value: "Two", Inline: true),
+            ],
+            actual: result.Fields
+        );
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_WithoutOptionalValues_LeavesThemNull()
+    {
+        DiscordEmbed embed = new(Title: string.Empty, Url: null, Description: string.Empty, Color: null, Fields: []);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Null(result.Title);
+        Assert.Null(result.Url);
+        Assert.Null(result.Description);
+        Assert.Null(result.Color);
+        Assert.Empty(result.Fields);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData("\t\r\n")]
+    public static void ToWebhookEmbed_WithBlankTitleAndDescription_OmitsThem(string value)
+    {
+        DiscordEmbed embed = new(Title: value, Url: null, Description: value, Color: null, Fields: []);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Null(result.Title);
+        Assert.Null(result.Description);
+    }
+
+    [Theory]
+    [InlineData("", "Value", "-", "Value")]
+    [InlineData(" ", "Value", "-", "Value")]
+    [InlineData("Name", "", "Name", "-")]
+    [InlineData("Name", " \t", "Name", "-")]
+    [InlineData("", "", "-", "-")]
+    [InlineData(" Name ", " Value ", " Name ", " Value ")]
+    public static void ToWebhookEmbed_WithBlankFieldNameOrValue_SubstitutesPlaceholder(
+        string name,
+        string value,
+        string expectedName,
+        string expectedValue
+    )
+    {
+        DiscordEmbedField field = new(Name: name, Value: value, Inline: true);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithFields([field]));
+
+        Assert.Equal(
+            expected: new WebhookEmbedField(Name: expectedName, Value: expectedValue, Inline: true),
+            actual: Assert.Single(result.Fields)
+        );
+    }
+
+    [Theory]
+    [InlineData("https://example.com/build/1")]
+    [InlineData("http://example.com/build/1")]
+    public static void ToWebhookEmbed_WithWebUrl_KeepsUrl(string value)
+    {
+        Uri url = new(value);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithUrl(url));
+
+        Assert.Equal(expected: url, actual: result.Url);
+    }
+
+    [Theory]
+    [InlineData("/builds/123")]
+    [InlineData("builds/123")]
+    [InlineData("ftp://example.com/build/1")]
+    [InlineData("file:///builds/123")]
+    public static void ToWebhookEmbed_WithRelativeOrNonWebUrl_DropsUrl(string value)
+    {
+        Uri url = new(uriString: value, uriKind: UriKind.RelativeOrAbsolute);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithUrl(url));
+
+        Assert.Null(result.Url);
+    }
+
+    [Fact]
+    public void ToPayload_ContainsSingleMappedEmbed()
+    {
+        DiscordEmbed embed = new(Title: "Title", Url: null, Description: null, Color: DiscordColor.Green, Fields: []);
+
+        WebhookPayload payload = EmbedMapper.ToPayload(embed);
+
+        WebhookEmbed result = Assert.Single(payload.Embeds);
+        Assert.Equal(expected: "Title", actual: result.Title);
+        Assert.Equal(expected: 0x2ECC71u, actual: result.Color);
+    }
+
+    [Fact]
+    public void StandardAuthor_IsFunFairBuildBot()
+    {
+        WebhookEmbedAuthor author = EmbedMapper.StandardAuthor;
+
+        Assert.Equal(expected: "FunFair BuildBot", actual: author.Name);
+        Assert.Equal(expected: new Uri("https://funfair.io"), actual: author.Url);
+        Assert.Equal(
+            expected: new Uri("https://s2.coinmarketcap.com/static/img/coins/32x32/1757.png"),
+            actual: author.IconUrl
+        );
+    }
+
+    [Theory]
+    [InlineData(256, 256)]
+    [InlineData(257, 256)]
+    [InlineData(1000, 256)]
+    public static void ToWebhookEmbed_LimitsTitleLength(int length, int expectedLength)
+    {
+        DiscordEmbed embed = new(Title: Text(length), Url: null, Description: null, Color: null, Fields: []);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        AssertTruncatedTo(original: embed.Title, actual: result.Title, expectedLength: expectedLength);
+    }
+
+    [Theory]
+    [InlineData(4096, 4096)]
+    [InlineData(4097, 4096)]
+    public static void ToWebhookEmbed_LimitsDescriptionLength(int length, int expectedLength)
+    {
+        DiscordEmbed embed = new(Title: string.Empty, Url: null, Description: Text(length), Color: null, Fields: []);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        AssertTruncatedTo(original: embed.Description, actual: result.Description, expectedLength: expectedLength);
+    }
+
+    [Theory]
+    [InlineData(256, 256)]
+    [InlineData(257, 256)]
+    public static void ToWebhookEmbed_LimitsFieldNameLength(int length, int expectedLength)
+    {
+        DiscordEmbedField field = new(Name: Text(length), Value: "Value");
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithFields([field]));
+
+        WebhookEmbedField mapped = Assert.Single(result.Fields);
+        AssertTruncatedTo(original: field.Name, actual: mapped.Name, expectedLength: expectedLength);
+        Assert.Equal(expected: "Value", actual: mapped.Value);
+    }
+
+    [Theory]
+    [InlineData(1024, 1024)]
+    [InlineData(1025, 1024)]
+    public static void ToWebhookEmbed_LimitsFieldValueLength(int length, int expectedLength)
+    {
+        DiscordEmbedField field = new(Name: "Name", Value: Text(length), Inline: true);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithFields([field]));
+
+        WebhookEmbedField mapped = Assert.Single(result.Fields);
+        Assert.Equal(expected: "Name", actual: mapped.Name);
+        AssertTruncatedTo(original: field.Value, actual: mapped.Value, expectedLength: expectedLength);
+        Assert.True(mapped.Inline, userMessage: "Inline should be preserved");
+    }
+
+    [Theory]
+    [InlineData(25, 25)]
+    [InlineData(26, 25)]
+    public static void ToWebhookEmbed_LimitsFieldCount(int count, int expectedCount)
+    {
+        DiscordEmbedField[] fields =
+        [
+            .. Enumerable
+                .Range(start: 0, count: count)
+                .Select(static index => new DiscordEmbedField(Name: $"Name{index}", Value: "Value")),
+        ];
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(CreateEmbedWithFields(fields));
+
+        Assert.Equal(expected: expectedCount, actual: result.Fields.Count);
+        Assert.Equal(expected: "Name0", actual: result.Fields[0].Name);
+        Assert.Equal(expected: "Name24", actual: result.Fields[^1].Name);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_TruncationDoesNotSplitSurrogatePair()
+    {
+        string title = new string(c: 'a', count: 252) + "\U0001F600" + "bbb";
+        DiscordEmbed embed = new(Title: title, Url: null, Description: null, Color: null, Fields: []);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: new string(c: 'a', count: 252) + "...", actual: result.Title);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_AtTotalLimit_IsUnchanged()
+    {
+        DiscordEmbed embed = CreateEmbedAtTotalLength(lastValueLength: 252);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: MAX_TOTAL_LENGTH, actual: TotalLength(result));
+        Assert.Equal(expected: embed.Description, actual: result.Description);
+        Assert.Equal(expected: embed.Fields[^1].Value, actual: result.Fields[^1].Value);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_OverTotalLimit_ShrinksDescriptionFirst()
+    {
+        DiscordEmbed embed = CreateEmbedAtTotalLength(lastValueLength: 253);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: MAX_TOTAL_LENGTH, actual: TotalLength(result));
+        AssertTruncatedTo(original: embed.Description, actual: result.Description, expectedLength: 4095);
+        Assert.Equal(expected: embed.Fields[^1].Value, actual: result.Fields[^1].Value);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_OverTotalLimitWithoutDescription_ShrinksLastFieldValue()
+    {
+        // Title 256 + author 16 + 6 fields of (10 + 1024) = 6476, so the last value must lose 476 characters.
+        DiscordEmbed embed = CreateEmbedWithFullValues(fieldCount: 6);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: MAX_TOTAL_LENGTH, actual: TotalLength(result));
+        Assert.Equal(expected: 6, actual: result.Fields.Count);
+        Assert.Equal(expected: embed.Fields[4].Value, actual: result.Fields[4].Value);
+        AssertTruncatedTo(original: embed.Fields[5].Value, actual: result.Fields[5].Value, expectedLength: 548);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_OverTotalLimitByMoreThanOneValue_ShrinksValuesFromTheLastFieldBack()
+    {
+        // Title 256 + author 16 + 7 fields of (10 + 1024) = 7510; the last value shrinks to 4 (-1020), the one before by 490.
+        DiscordEmbed embed = CreateEmbedWithFullValues(fieldCount: 7);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.Equal(expected: MAX_TOTAL_LENGTH, actual: TotalLength(result));
+        Assert.Equal(expected: 7, actual: result.Fields.Count);
+        Assert.Equal(expected: embed.Fields[4].Value, actual: result.Fields[4].Value);
+        AssertTruncatedTo(original: embed.Fields[5].Value, actual: result.Fields[5].Value, expectedLength: 534);
+        AssertTruncatedTo(original: embed.Fields[6].Value, actual: result.Fields[6].Value, expectedLength: 4);
+    }
+
+    [Fact]
+    public void ToWebhookEmbed_FieldNamesAloneOverTotalLimit_DropsTrailingFields()
+    {
+        // Author 16 + description 2 + 25 fields of (256 + 10) = 6668; shrinking every value to 4 still leaves 6518, so only
+        // the first 23 fields (23 x 260 = 5980 of the 5982 left) are kept.
+        DiscordEmbedField[] fields =
+        [
+            .. Enumerable
+                .Range(start: 0, count: 25)
+                .Select(static _ => new DiscordEmbedField(Name: Text(256), Value: Text(10))),
+        ];
+        DiscordEmbed embed = new(Title: string.Empty, Url: null, Description: Text(2), Color: null, Fields: fields);
+
+        WebhookEmbed result = EmbedMapper.ToWebhookEmbed(embed);
+
+        Assert.True(
+            TotalLength(result) <= MAX_TOTAL_LENGTH,
+            userMessage: "Total length should be within Discord's limit"
+        );
+        Assert.Equal(expected: 23, actual: result.Fields.Count);
+        Assert.All(
+            collection: result.Fields,
+            action: static field => Assert.Equal(expected: "a...", actual: field.Value)
+        );
+    }
+
+    private static DiscordEmbed CreateEmbedWithUrl(Uri url)
+    {
+        return new(Title: "Title", Url: url, Description: null, Color: null, Fields: []);
+    }
+
+    private static DiscordEmbed CreateEmbedWithFields(IReadOnlyList<DiscordEmbedField> fields)
+    {
+        return new(Title: "Title", Url: null, Description: null, Color: null, Fields: fields);
+    }
+
+    // Title 256 + author 16 + description 4096 + (256 + 1024) + (100 + lastValueLength) = 5748 + lastValueLength.
+    private static DiscordEmbed CreateEmbedAtTotalLength(int lastValueLength)
+    {
+        return new(
+            Title: Text(256),
+            Url: null,
+            Description: Text(4096),
+            Color: null,
+            Fields: [new(Name: Text(256), Value: Text(1024)), new(Name: Text(100), Value: Text(lastValueLength))]
+        );
+    }
+
+    private static DiscordEmbed CreateEmbedWithFullValues(int fieldCount)
+    {
+        DiscordEmbedField[] fields =
+        [
+            .. Enumerable
+                .Range(start: 0, count: fieldCount)
+                .Select(static _ => new DiscordEmbedField(Name: Text(10), Value: Text(1024))),
+        ];
+
+        return new(Title: Text(256), Url: null, Description: null, Color: null, Fields: fields);
+    }
+
+    private static string Text(int length)
+    {
+        return new(c: 'a', count: length);
+    }
+
+    private static int TotalLength(WebhookEmbed embed)
+    {
+        return (embed.Title?.Length ?? 0)
+            + (embed.Description?.Length ?? 0)
+            + embed.Author.Name.Length
+            + embed.Fields.Sum(static field => field.Name.Length + field.Value.Length);
+    }
+
+    private static void AssertTruncatedTo(string? original, string? actual, int expectedLength)
+    {
+        Assert.NotNull(original);
+        Assert.NotNull(actual);
+        Assert.Equal(expected: expectedLength, actual: actual.Length);
+
+        if (original.Length <= expectedLength)
+        {
+            Assert.Equal(expected: original, actual: actual);
+
+            return;
+        }
+
+        Assert.EndsWith(expectedEndString: "...", actualString: actual, comparisonType: StringComparison.Ordinal);
+        Assert.StartsWith(
+            expectedStartString: original[..(expectedLength - 3)],
+            actualString: actual,
+            comparisonType: StringComparison.Ordinal
+        );
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/StalledReadStream.cs b/src/BuildBot.Discord.Tests/Services/StalledReadStream.cs
new file mode 100644
index 000000000..ff6406586
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/StalledReadStream.cs
@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BuildBot.Discord.Tests.Services;
+
+internal sealed class StalledReadStream : Stream
+{
+    private readonly TaskCompletionSource _readStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    public Task ReadStarted => this._readStarted.Task;
+
+    public override bool CanRead => true;
+
+    public override bool CanSeek => false;
+
+    public override bool CanWrite => false;
+
+    public override long Length => throw new NotSupportedException();
+
+    public override long Position
+    {
+        get => throw new NotSupportedException();
+        set => throw new NotSupportedException();
+    }
+
+    public override void Flush() { }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        this._readStarted.TrySetResult();
+
+        // Only cancellation ends the read, as with a server that sent headers and then stopped sending.
+        await Task.Delay(millisecondsDelay: Timeout.Infinite, cancellationToken: cancellationToken);
+
+        return 0;
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void SetLength(long value)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/TestHttpMessageHandler.cs b/src/BuildBot.Discord.Tests/Services/TestHttpMessageHandler.cs
new file mode 100644
index 000000000..96ab8e1a7
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/TestHttpMessageHandler.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BuildBot.Discord.Tests.Services;
+
+internal sealed class TestHttpMessageHandler : HttpMessageHandler
+{
+    private readonly ConcurrentQueue<Func<HttpResponseMessage>> _responses;
+    private readonly ConcurrentQueue<RecordedRequest> _requests = new();
+
+    public TestHttpMessageHandler(params IEnumerable<Func<HttpResponseMessage>> responses)
+    {
+        this._responses = new(responses);
+    }
+
+    public IReadOnlyList<RecordedRequest> Requests => [.. this._requests];
+
+    protected override async Task<HttpResponseMessage> SendAsync(
+        HttpRequestMessage request,
+        CancellationToken cancellationToken
+    )
+    {
+        string body = request.Content is null
+            ? string.Empty
+            : await request.Content.ReadAsStringAsync(cancellationToken);
+
+        this._requests.Enqueue(
+            new(
+                Method: request.Method,
+                RequestUri: request.RequestUri,
+                Body: body,
+                ContentType: request.Content?.Headers.ContentType?.MediaType
+            )
+        );
+
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (!this._responses.TryDequeue(out Func<HttpResponseMessage>? response))
+        {
+            throw new InvalidOperationException("No more responses configured");
+        }
+
+        return response();
+    }
+
+    [DebuggerDisplay("{Method} {RequestUri}")]
+    internal sealed record RecordedRequest(HttpMethod Method, Uri? RequestUri, string Body, string? ContentType);
+}
diff --git a/src/BuildBot.Discord.Tests/Services/ThrowingReadStream.cs b/src/BuildBot.Discord.Tests/Services/ThrowingReadStream.cs
new file mode 100644
index 000000000..582a5cba7
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/ThrowingReadStream.cs
@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BuildBot.Discord.Tests.Services;
+
+internal sealed class ThrowingReadStream : Stream
+{
+    private readonly Exception _exception;
+
+    public ThrowingReadStream(Exception exception)
+    {
+        this._exception = exception;
+    }
+
+    public override bool CanRead => true;
+
+    public override bool CanSeek => false;
+
+    public override bool CanWrite => false;
+
+    public override long Length => throw new NotSupportedException();
+
+    public override long Position
+    {
+        get => throw new NotSupportedException();
+        set => throw new NotSupportedException();
+    }
+
+    public override void Flush() { }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        throw this._exception;
+    }
+
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        return ValueTask.FromException<int>(this._exception);
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void SetLength(long value)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/TestEmbeds.cs b/src/BuildBot.Discord.Tests/TestEmbeds.cs
new file mode 100644
index 000000000..3aa2bf34b
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/TestEmbeds.cs
@@ -0,0 +1,11 @@
+using BuildBot.Discord.Models;
+
+namespace BuildBot.Discord.Tests;
+
+internal static class TestEmbeds
+{
+    public static DiscordEmbed WithTitle(string title)
+    {
+        return new(Title: title, Url: null, Description: null, Color: null, Fields: []);
+    }
+}
diff --git a/src/BuildBot.Discord/BuildBot.Discord.csproj b/src/BuildBot.Discord/BuildBot.Discord.csproj
index bf5ef84b7..34c4f2eca 100644
--- a/src/BuildBot.Discord/BuildBot.Discord.csproj
+++ b/src/BuildBot.Discord/BuildBot.Discord.csproj
@@ -41,8 +41,8 @@
     <ProjectReference Include="../BuildBot.ServiceModel/BuildBot.ServiceModel.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.20.2" IncludeAssets="compile;runtime" />
     <PackageReference Include="Mediator.Abstractions" Version="3.0.2" IncludeAssets="compile;runtime" />
+    <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="10.0.12" IncludeAssets="compile;runtime" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="AsyncFixer" Version="2.1.0" PrivateAssets="All" ExcludeAssets="runtime" />
diff --git a/src/BuildBot.Discord/DiscordBotConfiguration.cs b/src/BuildBot.Discord/DiscordBotConfiguration.cs
index 08355927f..1737c76e2 100644
--- a/src/BuildBot.Discord/DiscordBotConfiguration.cs
+++ b/src/BuildBot.Discord/DiscordBotConfiguration.cs
@@ -1,23 +1,33 @@
+using System;
 using System.Diagnostics;
 
 namespace BuildBot.Discord;
 
-[DebuggerDisplay("Server: {Server}, Channel: {Channel}, Release Channel: {ReleaseChannel}")]
-public sealed class DiscordBotConfiguration
+[DebuggerDisplay("Webhook: <redacted>")]
+public sealed record DiscordBotConfiguration
 {
-    public DiscordBotConfiguration(string token, string server, string channel, string releaseChannel)
+    private DiscordBotConfiguration(Uri webhookUrl)
     {
-        this.Token = token;
-        this.Server = server;
-        this.Channel = channel;
-        this.ReleaseChannel = releaseChannel;
+        this.WebhookUrl = webhookUrl;
     }
 
-    public string Token { get; }
+    public Uri WebhookUrl { get; }
 
-    public string Server { get; }
+    public static DiscordBotConfiguration FromWebhookUrl(string? webhookUrl)
+    {
+        if (
+            Uri.TryCreate(uriString: webhookUrl, uriKind: UriKind.Absolute, out Uri? uri)
+            && StringComparer.Ordinal.Equals(x: uri.Scheme, y: Uri.UriSchemeHttps)
+        )
+        {
+            return new(uri);
+        }
 
-    public string Channel { get; }
+        throw new InvalidOperationException("Discord:WebhookUrl must be configured as an absolute https URL");
+    }
 
-    public string ReleaseChannel { get; }
+    public override string ToString()
+    {
+        return $"{nameof(DiscordBotConfiguration)} {{ Webhook = <redacted> }}";
+    }
 }
diff --git a/src/BuildBot.Discord/DiscordSetup.cs b/src/BuildBot.Discord/DiscordSetup.cs
index 1eee85b41..77477673d 100644
--- a/src/BuildBot.Discord/DiscordSetup.cs
+++ b/src/BuildBot.Discord/DiscordSetup.cs
@@ -1,20 +1,187 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
 using BuildBot.Discord.Services;
+using BuildBot.Discord.Services.LoggingExtensions;
 using BuildBot.ServiceModel.ComponentStatus;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Polly;
+using Polly.Timeout;
 
 namespace BuildBot.Discord;
 
 public static class DiscordSetup
 {
+    private const int MAX_RETRIES = 3;
+    private static readonly TimeSpan MaximumRetryAfterDelay = TimeSpan.FromSeconds(60);
+    private static readonly TimeSpan AttemptAllowance = TimeSpan.FromSeconds(30);
+
+    // Held as a field so the delegate is created once, rather than via a lazily-cached method-group conversion.
+    private static readonly Func<int, TimeSpan> ExponentialBackoff = CalculateRetryDelay;
+
+    // Scheduling and logging overhead between attempts is not counted in the retry budget below.
+    private static readonly TimeSpan WebhookTimeoutSlack = TimeSpan.FromSeconds(30);
+
+    // HttpClient.Timeout wraps the whole policy pipeline, so it must cover every attempt and every wait between them,
+    // with slack so it cannot cancel the final attempt when every earlier attempt and wait used its full allowance.
+    public static readonly TimeSpan WebhookTimeout =
+        MaximumRetryAfterDelay * MAX_RETRIES + AttemptAllowance * (MAX_RETRIES + 1) + WebhookTimeoutSlack;
+
     public static IServiceCollection AddDiscord(this IServiceCollection services, DiscordBotConfiguration discordConfig)
     {
+        services.TryAddSingleton(TimeProvider.System);
+
         return services
             .AddSingleton(discordConfig)
-            .AddSingleton<IDiscordRawClient>(_ => new DiscordSocketClientAdapter())
+            .AddSingleton<IDiscordWebhookClient, DiscordWebhookClient>()
             .AddSingleton<DiscordBot>()
             .AddSingleton<IDiscordBot>(s => s.GetRequiredService<DiscordBot>())
             .AddSingleton<IComponentStatus>(s => s.GetRequiredService<DiscordBot>())
-            .AddHostedService<BotService>()
-            .AddSingleton(typeof(IMessageChannel<>), typeof(MessageChannel<>));
+            .AddHostedService<DiscordMessageSender>()
+            .AddSingleton(typeof(IMessageChannel<>), typeof(MessageChannel<>))
+            .AddDiscordWebhookHttpClient();
+    }
+
+    public static TimeSpan CalculateRetryDelay(int attempt)
+    {
+        return TimeSpan.FromSeconds(Math.Pow(x: 2, y: attempt));
+    }
+
+    public static TimeSpan CalculateRetryDelay(int attempt, HttpResponseMessage? response, in DateTimeOffset now)
+    {
+        return CalculateRetryDelay(attempt: attempt, response: response, now: now, backoff: ExponentialBackoff);
+    }
+
+    private static TimeSpan CalculateRetryDelay(
+        int attempt,
+        HttpResponseMessage? response,
+        in DateTimeOffset now,
+        Func<int, TimeSpan> backoff
+    )
+    {
+        TimeSpan? retryAfter = GetRetryAfter(retryAfter: response?.Headers.RetryAfter, now: now);
+
+        if (retryAfter is null)
+        {
+            return backoff(attempt);
+        }
+
+        return retryAfter.Value < TimeSpan.Zero ? TimeSpan.Zero : retryAfter.Value;
+    }
+
+    public static bool ShouldRetry(HttpResponseMessage response, in DateTimeOffset now)
+    {
+        if (!IsTransientFailure(response.StatusCode))
+        {
+            return false;
+        }
+
+        // A server asking for a longer wait than we are prepared to give is not retried; the response is returned as-is.
+        TimeSpan? retryAfter = GetRetryAfter(retryAfter: response.Headers.RetryAfter, now: now);
+
+        return retryAfter is null || retryAfter.Value <= MaximumRetryAfterDelay;
+    }
+
+    // Only codes that can succeed on a later attempt; permanent server failures such as 501 or 505 fail immediately
+    // rather than holding up the queue through every backoff wait.
+    private static bool IsTransientFailure(HttpStatusCode statusCode)
+    {
+        return statusCode
+            is HttpStatusCode.RequestTimeout
+                or HttpStatusCode.TooManyRequests
+                or HttpStatusCode.InternalServerError
+                or HttpStatusCode.BadGateway
+                or HttpStatusCode.ServiceUnavailable
+                or HttpStatusCode.GatewayTimeout;
+    }
+
+    private static TimeSpan? GetRetryAfter(RetryConditionHeaderValue? retryAfter, in DateTimeOffset now)
+    {
+        if (retryAfter is null)
+        {
+            return null;
+        }
+
+        // The header always carries exactly one of a delta or a date.
+        return retryAfter.Delta ?? retryAfter.Date.GetValueOrDefault(now) - now;
+    }
+
+    public static IAsyncPolicy<HttpResponseMessage> CreateWebhookPolicy(
+        TimeProvider timeProvider,
+        in TimeSpan attemptTimeout,
+        Func<int, TimeSpan> backoff,
+        ILogger<DiscordWebhookClient> logger
+    )
+    {
+        IAsyncPolicy<HttpResponseMessage> retry = Policy<HttpResponseMessage>
+            .Handle<HttpRequestException>()
+            .Or<TimeoutRejectedException>()
+            .OrResult(response => ShouldRetry(response: response, now: timeProvider.GetUtcNow()))
+            .WaitAndRetryAsync(
+                retryCount: MAX_RETRIES,
+                sleepDurationProvider: (attempt, outcome, _) =>
+                    CalculateRetryDelay(
+                        attempt: attempt,
+                        response: outcome.Result,
+                        now: timeProvider.GetUtcNow(),
+                        backoff: backoff
+                    ),
+                onRetryAsync: (outcome, delay, attempt, _) =>
+                    LogRetryAsync(outcome: outcome, attempt: attempt, delay: delay, logger: logger)
+            );
+
+        // Each attempt gets its own allowance inside the retry, so one stalled attempt is retried rather than
+        // consuming the whole HttpClient.Timeout; the caller's own cancellation still surfaces as cancellation.
+        IAsyncPolicy<HttpResponseMessage> attemptTimeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(
+            attemptTimeout
+        );
+
+        return Policy.WrapAsync(retry, attemptTimeoutPolicy);
+    }
+
+    private static Task LogRetryAsync(
+        DelegateResult<HttpResponseMessage> outcome,
+        int attempt,
+        in TimeSpan delay,
+        ILogger<DiscordWebhookClient> logger
+    )
+    {
+        if (outcome.Result is null)
+        {
+            logger.LogRetryingAfterException(
+                attempt: attempt,
+                exceptionType: outcome.Exception.GetType().Name,
+                delay: delay
+            );
+
+            return Task.CompletedTask;
+        }
+
+        logger.LogRetryingAfterStatusCode(attempt: attempt, statusCode: outcome.Result.StatusCode, delay: delay);
+
+        return Task.CompletedTask;
+    }
+
+    private static IServiceCollection AddDiscordWebhookHttpClient(this IServiceCollection services)
+    {
+        // The webhook URL embeds its token, so the default request logging (which writes the URL) is removed.
+        return services
+            .AddHttpClient(DiscordWebhookClient.HttpClientName)
+            .RemoveAllLoggers()
+            .ConfigureHttpClient(static client => client.Timeout = WebhookTimeout)
+            .AddPolicyHandler(
+                (serviceProvider, _) =>
+                    CreateWebhookPolicy(
+                        timeProvider: serviceProvider.GetRequiredService<TimeProvider>(),
+                        attemptTimeout: AttemptAllowance,
+                        backoff: ExponentialBackoff,
+                        logger: serviceProvider.GetRequiredService<ILogger<DiscordWebhookClient>>()
+                    )
+            )
+            .Services;
     }
 }
diff --git a/src/BuildBot.Discord/IDiscordBot.cs b/src/BuildBot.Discord/IDiscordBot.cs
index a2883eca6..17a103d22 100644
--- a/src/BuildBot.Discord/IDiscordBot.cs
+++ b/src/BuildBot.Discord/IDiscordBot.cs
@@ -1,16 +1,10 @@
 using System.Threading;
 using System.Threading.Tasks;
-using Discord;
+using BuildBot.Discord.Models;
 
 namespace BuildBot.Discord;
 
 public interface IDiscordBot
 {
-    Task StartAsync(CancellationToken cancellationToken);
-
-    Task StopAsync(CancellationToken cancellationToken);
-
-    ValueTask PublishAsync(EmbedBuilder builder, CancellationToken cancellationToken);
-
-    ValueTask PublishToReleaseChannelAsync(EmbedBuilder builder, CancellationToken cancellationToken);
+    ValueTask PublishAsync(DiscordEmbed embed, CancellationToken cancellationToken);
 }
diff --git a/src/BuildBot.Discord/Models/BotMessage.cs b/src/BuildBot.Discord/Models/BotMessage.cs
index cd4de0234..3c4c40fdc 100644
--- a/src/BuildBot.Discord/Models/BotMessage.cs
+++ b/src/BuildBot.Discord/Models/BotMessage.cs
@@ -1,8 +1,7 @@
 using System.Diagnostics;
-using Discord;
 using Mediator;
 
 namespace BuildBot.Discord.Models;
 
 [DebuggerDisplay("{Message.Title}")]
-public sealed record BotMessage(EmbedBuilder Message) : INotification;
+public sealed record BotMessage(DiscordEmbed Message) : INotification;
diff --git a/src/BuildBot.Discord/Models/BotReleaseMessage.cs b/src/BuildBot.Discord/Models/BotReleaseMessage.cs
deleted file mode 100644
index d95072b40..000000000
--- a/src/BuildBot.Discord/Models/BotReleaseMessage.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-using System.Diagnostics;
-using Discord;
-using Mediator;
-
-namespace BuildBot.Discord.Models;
-
-[DebuggerDisplay("{Message.Title}")]
-public sealed record BotReleaseMessage(EmbedBuilder Message) : INotification;
diff --git a/src/BuildBot.Discord/Models/DiscordColor.cs b/src/BuildBot.Discord/Models/DiscordColor.cs
new file mode 100644
index 000000000..34f0d9e21
--- /dev/null
+++ b/src/BuildBot.Discord/Models/DiscordColor.cs
@@ -0,0 +1,11 @@
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Models;
+
+[DebuggerDisplay("{Value}")]
+public readonly record struct DiscordColor(uint Value)
+{
+    public static DiscordColor Green { get; } = new(0x2ECC71);
+
+    public static DiscordColor Red { get; } = new(0xE74C3C);
+}
diff --git a/src/BuildBot.Discord/Models/DiscordEmbed.cs b/src/BuildBot.Discord/Models/DiscordEmbed.cs
new file mode 100644
index 000000000..040ff2273
--- /dev/null
+++ b/src/BuildBot.Discord/Models/DiscordEmbed.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Models;
+
+[DebuggerDisplay("{Title}: {Url} {Description} {Color}")]
+public sealed record DiscordEmbed(
+    string Title,
+    Uri? Url,
+    string? Description,
+    DiscordColor? Color,
+    IReadOnlyList<DiscordEmbedField> Fields
+);
diff --git a/src/BuildBot.Discord/Models/DiscordEmbedField.cs b/src/BuildBot.Discord/Models/DiscordEmbedField.cs
new file mode 100644
index 000000000..0d363c98e
--- /dev/null
+++ b/src/BuildBot.Discord/Models/DiscordEmbedField.cs
@@ -0,0 +1,6 @@
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Models;
+
+[DebuggerDisplay("{Name}: {Value} (Inline: {Inline})")]
+public readonly record struct DiscordEmbedField(string Name, string Value, bool Inline = false);
diff --git a/src/BuildBot.Discord/Models/EmbedUrl.cs b/src/BuildBot.Discord/Models/EmbedUrl.cs
new file mode 100644
index 000000000..918a94f9c
--- /dev/null
+++ b/src/BuildBot.Discord/Models/EmbedUrl.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace BuildBot.Discord.Models;
+
+public static class EmbedUrl
+{
+    public static Uri? FromString(string? value)
+    {
+        return Uri.TryCreate(uriString: value, uriKind: UriKind.Absolute, out Uri? uri) ? uri : null;
+    }
+}
diff --git a/src/BuildBot.Discord/Publishers/DiscordBotReleaseMessageNotificationHandler.cs b/src/BuildBot.Discord/Publishers/DiscordBotReleaseMessageNotificationHandler.cs
deleted file mode 100644
index b9f93c584..000000000
--- a/src/BuildBot.Discord/Publishers/DiscordBotReleaseMessageNotificationHandler.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using BuildBot.Discord.Models;
-using Mediator;
-
-namespace BuildBot.Discord.Publishers;
-
-public sealed class DiscordBotReleaseMessageNotificationHandler : INotificationHandler<BotReleaseMessage>
-{
-    private readonly IMessageChannel<BotReleaseMessage> _messageChannel;
-
-    public DiscordBotReleaseMessageNotificationHandler(IMessageChannel<BotReleaseMessage> messageChannel)
-    {
-        this._messageChannel = messageChannel;
-    }
-
-    public ValueTask Handle(BotReleaseMessage notification, CancellationToken cancellationToken)
-    {
-        return this._messageChannel.PublishAsync(message: notification, cancellationToken: cancellationToken);
-    }
-}
diff --git a/src/BuildBot.Discord/Services/BotService.cs b/src/BuildBot.Discord/Services/BotService.cs
deleted file mode 100644
index 62e3d4a58..000000000
--- a/src/BuildBot.Discord/Services/BotService.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using System;
-using System.Linq;
-using System.Reactive.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using BuildBot.Discord.Models;
-using Microsoft.Extensions.Hosting;
-
-namespace BuildBot.Discord.Services;
-
-public sealed class BotService : IHostedService, IDisposable
-{
-    private static readonly TimeSpan InterMessageDelay = TimeSpan.FromSeconds(1);
-    private readonly IDiscordBot _bot;
-    private readonly IMessageChannel<BotMessage> _botMessageChannel;
-    private readonly IMessageChannel<BotReleaseMessage> _botReleaseMessageChannel;
-    private readonly CancellationTokenSource _cancellationTokenSource = new();
-
-    public BotService(
-        IDiscordBot bot,
-        IMessageChannel<BotMessage> botMessageChannel,
-        IMessageChannel<BotReleaseMessage> botReleaseMessageChannel
-    )
-    {
-        this._bot = bot ?? throw new ArgumentNullException(nameof(bot));
-        this._botMessageChannel = botMessageChannel ?? throw new ArgumentNullException(nameof(botMessageChannel));
-        this._botReleaseMessageChannel =
-            botReleaseMessageChannel ?? throw new ArgumentNullException(nameof(botReleaseMessageChannel));
-
-        this._botMessageChannel.ReadAllAsync(this._cancellationTokenSource.Token)
-            .ToObservable()
-            .Delay(InterMessageDelay)
-            .Select(message =>
-                Observable.FromAsync(ct => this.PublishMessageAsync(message: message, cancellationToken: ct).AsTask())
-            )
-            .Concat()
-            .Subscribe(this._cancellationTokenSource.Token);
-
-        this._botReleaseMessageChannel.ReadAllAsync(this._cancellationTokenSource.Token)
-            .ToObservable()
-            .Delay(InterMessageDelay)
-            .Select(message =>
-                Observable.FromAsync(ct => this.PublishMessageAsync(message: message, cancellationToken: ct).AsTask())
-            )
-            .Concat()
-            .Subscribe(this._cancellationTokenSource.Token);
-    }
-
-    public void Dispose()
-    {
-        this._cancellationTokenSource.Cancel();
-        this._cancellationTokenSource.Dispose();
-    }
-
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        return this._bot.StartAsync(cancellationToken);
-    }
-
-    public async Task StopAsync(CancellationToken cancellationToken)
-    {
-        await this._cancellationTokenSource.CancelAsync();
-        await this._bot.StopAsync(cancellationToken);
-    }
-
-    private ValueTask PublishMessageAsync(BotMessage message, in CancellationToken cancellationToken)
-    {
-        return this._bot.PublishAsync(builder: message.Message, cancellationToken: cancellationToken);
-    }
-
-    private ValueTask PublishMessageAsync(BotReleaseMessage message, in CancellationToken cancellationToken)
-    {
-        return this._bot.PublishToReleaseChannelAsync(builder: message.Message, cancellationToken: cancellationToken);
-    }
-}
diff --git a/src/BuildBot.Discord/Services/DiscordBot.cs b/src/BuildBot.Discord/Services/DiscordBot.cs
index 3da7918db..458f35a93 100644
--- a/src/BuildBot.Discord/Services/DiscordBot.cs
+++ b/src/BuildBot.Discord/Services/DiscordBot.cs
@@ -1,219 +1,61 @@
-using System;
 using System.Threading;
 using System.Threading.Tasks;
+using BuildBot.Discord.Models;
 using BuildBot.Discord.Services.LoggingExtensions;
+using BuildBot.Discord.Services.Models;
 using BuildBot.ServiceModel.ComponentStatus;
-using Discord;
 using Microsoft.Extensions.Logging;
 
 namespace BuildBot.Discord.Services;
 
 public sealed class DiscordBot : IDiscordBot, IComponentStatus
 {
-    private static readonly TimeSpan TypingDelay = TimeSpan.FromSeconds(2);
     private readonly DiscordBotConfiguration _botConfiguration;
-    private readonly IDiscordRawClient _client;
+    private readonly IDiscordWebhookClient _client;
     private readonly ILogger<DiscordBot> _logger;
-    private readonly SemaphoreSlim _semaphore = new(1);
 
-    public DiscordBot(IDiscordRawClient client, DiscordBotConfiguration botConfiguration, ILogger<DiscordBot> logger)
+    public DiscordBot(
+        IDiscordWebhookClient client,
+        DiscordBotConfiguration botConfiguration,
+        ILogger<DiscordBot> logger
+    )
     {
         this._client = client;
         this._botConfiguration = botConfiguration;
         this._logger = logger;
-        this._client.RegisterLogHandler(this.LogAsync);
     }
 
-    private static EmbedAuthorBuilder Author { get; } =
-        new EmbedAuthorBuilder()
-            .WithName("FunFair BuildBot")
-            .WithUrl("https://funfair.io")
-            .WithIconUrl("https://s2.coinmarketcap.com/static/img/coins/32x32/1757.png");
-
     public ServiceStatus GetStatus()
     {
-        return new(Name: "Discord", this._client.LoginState == LoginState.LoggedIn);
-    }
-
-    public async ValueTask PublishAsync(EmbedBuilder builder, CancellationToken cancellationToken)
-    {
-        IDiscordChannel? channel = this.GetChannel(this._botConfiguration.Channel);
-
-        if (channel is null)
-        {
-            this._logger.LogDiscordChannelNotFound(
-                channelName: this._botConfiguration.Channel,
-                serverName: this._botConfiguration.Server
-            );
-
-            return;
-        }
-
-        await this.PublishCommonAsync(builder: builder, channel: channel, cancellationToken: cancellationToken);
-    }
-
-    public async ValueTask PublishToReleaseChannelAsync(EmbedBuilder builder, CancellationToken cancellationToken)
-    {
-        IDiscordChannel? channel = this.GetChannel(this._botConfiguration.ReleaseChannel);
-
-        if (channel is null)
-        {
-            this._logger.LogDiscordChannelNotFound(
-                channelName: this._botConfiguration.Channel,
-                serverName: this._botConfiguration.Server
-            );
-
-            return;
-        }
-
-        await this.PublishCommonAsync(builder: builder, channel: channel, cancellationToken: cancellationToken);
-    }
-
-    private async ValueTask PublishCommonAsync(
-        EmbedBuilder builder,
-        IDiscordChannel channel,
-        CancellationToken cancellationToken
-    )
-    {
-        try
-        {
-            this._logger.LogSendingMessage(channelName: channel.Name, message: builder.Title ?? string.Empty);
-
-            using (channel.EnterTypingState())
-            {
-                Embed embed = IncludeStandardParameters(builder);
-
-                (string sentToChannel, string messageContent) = await channel.SendMessageAsync(embed);
-                this.LogSent(channelName: sentToChannel, content: messageContent);
-                await Task.Delay(delay: TypingDelay, cancellationToken: cancellationToken);
-            }
-        }
-        catch (Exception exception)
-        {
-            this._logger.FailedToPublishMessage(
-                channelName: this._botConfiguration.Channel,
-                title: builder.Title ?? string.Empty,
-                message: exception.Message,
-                exception: exception
-            );
-
-            await this.ReconnectAsync(CancellationToken.None);
-        }
-    }
-
-    private void LogSent(string channelName, string content)
-    {
-        this._logger.LogSentMessage(channelName: channelName, message: content);
-    }
-
-    private static Embed IncludeStandardParameters(EmbedBuilder builder)
-    {
-        return builder.WithAuthor(Author).Build();
-    }
-
-    private IDiscordChannel? GetChannel(string channelName)
-    {
-        return this._client.FindChannel(serverName: this._botConfiguration.Server, channelName: channelName);
+        return new(Name: "Discord", Ok: true);
     }
 
-    private Task LogAsync(LogMessage arg)
+    public async ValueTask PublishAsync(DiscordEmbed embed, CancellationToken cancellationToken)
     {
-        return arg.Severity switch
-        {
-            LogSeverity.Debug => this.LogDebugAsync(arg),
-            LogSeverity.Verbose => this.LogInformationAsync(arg),
-            LogSeverity.Info => this.LogInformationAsync(arg),
-            LogSeverity.Warning => this.LogWarningAsync(arg),
-            LogSeverity.Error => this.LogErrorAsync(arg),
-            LogSeverity.Critical => this.LogCriticalAsync(arg),
-            _ => this.LogCriticalAsync(arg),
-        };
-    }
+        this._logger.LogSendingMessage(embed.Title);
 
-    private Task LogCriticalAsync(LogMessage arg)
-    {
-        if (arg.Exception is not null)
-        {
-            this._logger.DiscordCriticalError(message: arg.Message, exception: arg.Exception);
-        }
-        else
-        {
-            this._logger.DiscordCriticalError(arg.Message);
-        }
+        WebhookSendResult result = await this._client.SendAsync(
+            webhookUrl: this._botConfiguration.WebhookUrl,
+            payload: EmbedMapper.ToPayload(embed),
+            cancellationToken: cancellationToken
+        );
 
-        return Task.CompletedTask;
+        this.LogResult(embed: embed, result: result);
     }
 
-    private Task LogErrorAsync(LogMessage arg)
+    private void LogResult(DiscordEmbed embed, in WebhookSendResult result)
     {
-        if (arg.Exception is not null)
+        if (result.Success)
         {
-            this._logger.DiscordError(message: arg.Message, exception: arg.Exception);
+            this._logger.LogSentMessage(embed.Title);
         }
         else
         {
-            this._logger.DiscordError(arg.Message);
-        }
-
-        return Task.CompletedTask;
-    }
-
-    private Task LogWarningAsync(LogMessage arg)
-    {
-        this._logger.DiscordWarning(arg.Message);
-
-        return Task.CompletedTask;
-    }
-
-    private Task LogInformationAsync(LogMessage arg)
-    {
-        this._logger.DiscordInfo(arg.Message);
-
-        return Task.CompletedTask;
-    }
-
-    private Task LogDebugAsync(LogMessage arg)
-    {
-        this._logger.DiscordDebug(arg.Message);
-
-        return Task.CompletedTask;
-    }
-
-    public async Task StartAsync(CancellationToken cancellationToken)
-    {
-        await this._client.LoginAsync(tokenType: TokenType.Bot, token: this._botConfiguration.Token);
-        await this._client.StartAsync();
-        await this._client.SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
-    }
-
-    public Task StopAsync(CancellationToken cancellationToken)
-    {
-        return this._client.LogoutAsync();
-    }
-
-    private async ValueTask ReconnectAsync(CancellationToken cancellationToken)
-    {
-        await this._semaphore.WaitAsync(cancellationToken);
-
-        try
-        {
-            if (this._client.LoginState == LoginState.LoggedIn)
-            {
-                await this._client.LogoutAsync();
-                await this._client.StopAsync();
-            }
-
-            await this._client.LoginAsync(tokenType: TokenType.Bot, token: this._botConfiguration.Token);
-            await this._client.StartAsync();
-            await this._client.SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
-        }
-        catch (Exception exception)
-        {
-            this._logger.DiscordError(message: "Failed to reconnect", exception: exception);
-        }
-        finally
-        {
-            this._semaphore.Release();
+            this._logger.LogSendRejected(
+                title: embed.Title,
+                statusCode: result.StatusCode,
+                responseBody: result.ResponseBody
+            );
         }
     }
 }
diff --git a/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs b/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs
deleted file mode 100644
index a9e0fd996..000000000
--- a/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using Discord;
-
-namespace BuildBot.Discord.Services;
-
-public sealed class DiscordChannelAdapter : IDiscordChannel
-{
-    private readonly ITextChannel _channel;
-
-    public DiscordChannelAdapter(ITextChannel channel)
-    {
-        this._channel = channel ?? throw new ArgumentNullException(nameof(channel));
-    }
-
-    public string Name => this._channel.Name;
-
-    public IDisposable EnterTypingState()
-    {
-        return this._channel.EnterTypingState();
-    }
-
-    public async Task<(string SentToChannel, string MessageContent)> SendMessageAsync(Embed embed)
-    {
-        IUserMessage msg = await this._channel.SendMessageAsync(text: string.Empty, embed: embed);
-
-        return (this._channel.Name, msg.CleanContent);
-    }
-}
diff --git a/src/BuildBot.Discord/Services/DiscordMessageSender.cs b/src/BuildBot.Discord/Services/DiscordMessageSender.cs
new file mode 100644
index 000000000..a9dd05d1e
--- /dev/null
+++ b/src/BuildBot.Discord/Services/DiscordMessageSender.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services.LoggingExtensions;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace BuildBot.Discord.Services;
+
+public sealed class DiscordMessageSender : BackgroundService
+{
+    private readonly IDiscordBot _bot;
+    private readonly IMessageChannel<BotMessage> _botMessageChannel;
+    private readonly ILogger<DiscordMessageSender> _logger;
+
+    public DiscordMessageSender(
+        IDiscordBot bot,
+        IMessageChannel<BotMessage> botMessageChannel,
+        ILogger<DiscordMessageSender> logger
+    )
+    {
+        this._bot = bot;
+        this._botMessageChannel = botMessageChannel;
+        this._logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        await foreach (BotMessage message in this._botMessageChannel.ReadAllAsync(stoppingToken))
+        {
+            await this.PublishMessageAsync(message: message, stoppingToken: stoppingToken);
+        }
+    }
+
+    private async ValueTask PublishMessageAsync(BotMessage message, CancellationToken stoppingToken)
+    {
+        // One failed message must not end the loop; only shutting down may.
+        try
+        {
+            await this._bot.PublishAsync(embed: message.Message, cancellationToken: stoppingToken);
+        }
+        catch (Exception exception)
+            when (exception is not OperationCanceledException || !stoppingToken.IsCancellationRequested)
+        {
+            this._logger.LogPublishFailed(title: message.Message.Title, exceptionType: exception.GetType().Name);
+        }
+    }
+}
diff --git a/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs b/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs
deleted file mode 100644
index bc7c47ad8..000000000
--- a/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using Discord;
-using Discord.WebSocket;
-
-namespace BuildBot.Discord.Services;
-
-internal sealed class DiscordSocketClientAdapter : IDiscordRawClient
-{
-    private readonly DiscordSocketClient _client;
-
-    public DiscordSocketClientAdapter()
-    {
-        this._client = new(
-            new()
-            {
-                GatewayIntents =
-                    GatewayIntents.Guilds | GatewayIntents.GuildMessageTyping | GatewayIntents.GuildMessages,
-            }
-        );
-    }
-
-    public LoginState LoginState => this._client.LoginState;
-
-    public IDiscordChannel? FindChannel(string serverName, string channelName)
-    {
-        SocketGuild? guild = this._client.Guilds.FirstOrDefault(predicate: g =>
-            StringComparer.Ordinal.Equals(x: g.Name, y: serverName)
-        );
-
-        SocketTextChannel? textChannel = guild?.TextChannels.FirstOrDefault(predicate: c =>
-            StringComparer.OrdinalIgnoreCase.Equals(x: c.Name, y: channelName)
-        );
-
-        return textChannel is null ? null : new DiscordChannelAdapter(textChannel);
-    }
-
-    public Task LoginAsync(TokenType tokenType, string token)
-    {
-        return this._client.LoginAsync(tokenType: tokenType, token: token);
-    }
-
-    public Task StartAsync()
-    {
-        return this._client.StartAsync();
-    }
-
-    public Task StopAsync()
-    {
-        return this._client.StopAsync();
-    }
-
-    public Task LogoutAsync()
-    {
-        return this._client.LogoutAsync();
-    }
-
-    public Task SetGameAsync(string name, string? streamUrl, ActivityType type)
-    {
-        return this._client.SetGameAsync(name: name, streamUrl: streamUrl, type: type);
-    }
-
-    public void RegisterLogHandler(Func<LogMessage, Task> handler)
-    {
-        this._client.Log += handler;
-    }
-}
diff --git a/src/BuildBot.Discord/Services/DiscordWebhookClient.cs b/src/BuildBot.Discord/Services/DiscordWebhookClient.cs
new file mode 100644
index 000000000..8bdcdf5d6
--- /dev/null
+++ b/src/BuildBot.Discord/Services/DiscordWebhookClient.cs
@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Services.Models;
+
+namespace BuildBot.Discord.Services;
+
+public sealed class DiscordWebhookClient : IDiscordWebhookClient
+{
+    public const string HttpClientName = "DiscordWebhook";
+
+    public const int MaximumResponseBodyLength = 1024;
+
+    public const string ResponseBodyUnavailable = "(response body unavailable)";
+
+    // HttpClient.Timeout stops applying once headers arrive, so a stalled error body needs its own limit.
+    public static readonly TimeSpan ResponseBodyReadTimeout = TimeSpan.FromSeconds(10);
+
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly TimeProvider _timeProvider;
+
+    public DiscordWebhookClient(IHttpClientFactory httpClientFactory, TimeProvider timeProvider)
+    {
+        this._httpClientFactory = httpClientFactory;
+        this._timeProvider = timeProvider;
+    }
+
+    public async ValueTask<WebhookSendResult> SendAsync(
+        Uri webhookUrl,
+        WebhookPayload payload,
+        CancellationToken cancellationToken
+    )
+    {
+        HttpClient client = this._httpClientFactory.CreateClient(HttpClientName);
+
+        using HttpRequestMessage request = new(method: HttpMethod.Post, requestUri: webhookUrl)
+        {
+            Content = JsonContent.Create(
+                inputValue: payload,
+                jsonTypeInfo: DiscordWebhookSerializationContext.Default.WebhookPayload
+            ),
+        };
+
+        // Headers only, so an error body is never buffered in full; only a bounded prefix of it is read below.
+        using HttpResponseMessage response = await client.SendAsync(
+            request: request,
+            completionOption: HttpCompletionOption.ResponseHeadersRead,
+            cancellationToken: cancellationToken
+        );
+
+        if (response.IsSuccessStatusCode)
+        {
+            return new(Success: true, StatusCode: response.StatusCode, ResponseBody: string.Empty);
+        }
+
+        string responseBody = await this.ReadBoundedResponseBodyAsync(
+            content: response.Content,
+            cancellationToken: cancellationToken
+        );
+
+        return new(Success: false, StatusCode: response.StatusCode, ResponseBody: responseBody);
+    }
+
+    private async ValueTask<string> ReadBoundedResponseBodyAsync(
+        HttpContent content,
+        CancellationToken cancellationToken
+    )
+    {
+        using CancellationTokenSource timeout = new(delay: ResponseBodyReadTimeout, timeProvider: this._timeProvider);
+        using CancellationTokenSource readCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+            token1: cancellationToken,
+            token2: timeout.Token
+        );
+
+        // The status code is the primary diagnostic, so failing to read the body must not lose it.
+        try
+        {
+            return await ReadResponseBodyPrefixAsync(content: content, cancellationToken: readCancellation.Token);
+        }
+        catch (OperationCanceledException)
+            when (!cancellationToken.IsCancellationRequested && timeout.IsCancellationRequested)
+        {
+            return ResponseBodyUnavailable;
+        }
+        catch (HttpRequestException)
+        {
+            return ResponseBodyUnavailable;
+        }
+        catch (IOException)
+        {
+            return ResponseBodyUnavailable;
+        }
+    }
+
+    private static async ValueTask<string> ReadResponseBodyPrefixAsync(
+        HttpContent content,
+        CancellationToken cancellationToken
+    )
+    {
+        await using Stream stream = await content.ReadAsStreamAsync(cancellationToken);
+        using StreamReader reader = new(stream);
+
+        char[] buffer = new char[MaximumResponseBodyLength];
+        int length = await reader.ReadBlockAsync(buffer: buffer.AsMemory(), cancellationToken: cancellationToken);
+
+        return new(value: buffer, startIndex: 0, length: length);
+    }
+}
diff --git a/src/BuildBot.Discord/Services/DiscordWebhookSerializationContext.cs b/src/BuildBot.Discord/Services/DiscordWebhookSerializationContext.cs
new file mode 100644
index 000000000..430406870
--- /dev/null
+++ b/src/BuildBot.Discord/Services/DiscordWebhookSerializationContext.cs
@@ -0,0 +1,14 @@
+using System.Text.Json.Serialization;
+using BuildBot.Discord.Services.Models;
+
+namespace BuildBot.Discord.Services;
+
+[JsonSourceGenerationOptions(
+    GenerationMode = JsonSourceGenerationMode.Serialization | JsonSourceGenerationMode.Metadata,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.SnakeCaseLower,
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    WriteIndented = false,
+    IncludeFields = false
+)]
+[JsonSerializable(typeof(WebhookPayload))]
+internal sealed partial class DiscordWebhookSerializationContext : JsonSerializerContext;
diff --git a/src/BuildBot.Discord/Services/EmbedLimiter.cs b/src/BuildBot.Discord/Services/EmbedLimiter.cs
new file mode 100644
index 000000000..d0104abfc
--- /dev/null
+++ b/src/BuildBot.Discord/Services/EmbedLimiter.cs
@@ -0,0 +1,154 @@
+using System;
+using System.Linq;
+using BuildBot.Discord.Services.Models;
+
+namespace BuildBot.Discord.Services;
+
+// Discord rejects the whole message when any embed limit is exceeded, so oversized text is cut down rather than lost entirely.
+internal static class EmbedLimiter
+{
+    public const int MAX_TITLE_LENGTH = 256;
+    public const int MAX_DESCRIPTION_LENGTH = 4096;
+    public const int MAX_FIELD_NAME_LENGTH = 256;
+    public const int MAX_FIELD_VALUE_LENGTH = 1024;
+    public const int MAX_FIELDS = 25;
+    public const int MAX_TOTAL_LENGTH = 6000;
+
+    public const string TRUNCATION_MARKER = "...";
+
+    // Room for one character of the original text in front of the three-character marker when shrinking to fit the total.
+    private const int MIN_SHRUNK_LENGTH = 4;
+
+    public static WebhookEmbed Apply(WebhookEmbed embed)
+    {
+        WebhookEmbed limited = embed with
+        {
+            Title = TruncateOrNull(value: embed.Title, maxLength: MAX_TITLE_LENGTH),
+            Description = TruncateOrNull(value: embed.Description, maxLength: MAX_DESCRIPTION_LENGTH),
+            Fields = [.. embed.Fields.Take(MAX_FIELDS).Select(LimitField)],
+        };
+
+        return FitTotalLength(limited);
+    }
+
+    private static int TotalLength(WebhookEmbed embed)
+    {
+        return FixedLength(embed) + embed.Fields.Sum(FieldLength);
+    }
+
+    private static WebhookEmbedField LimitField(WebhookEmbedField field)
+    {
+        return field with
+        {
+            Name = Truncate(value: field.Name, maxLength: MAX_FIELD_NAME_LENGTH),
+            Value = Truncate(value: field.Value, maxLength: MAX_FIELD_VALUE_LENGTH),
+        };
+    }
+
+    // Shrinks the least important text first: the description, then field values from the last field back, and only drops
+    // trailing fields when the field names alone are still too long.
+    private static WebhookEmbed FitTotalLength(WebhookEmbed embed)
+    {
+        if (TotalLength(embed) <= MAX_TOTAL_LENGTH)
+        {
+            return embed;
+        }
+
+        WebhookEmbed shrunkDescription = ShrinkDescription(embed: embed, excess: TotalLength(embed) - MAX_TOTAL_LENGTH);
+
+        if (TotalLength(shrunkDescription) <= MAX_TOTAL_LENGTH)
+        {
+            return shrunkDescription;
+        }
+
+        WebhookEmbed shrunkValues = ShrinkFieldValues(
+            embed: shrunkDescription,
+            excess: TotalLength(shrunkDescription) - MAX_TOTAL_LENGTH
+        );
+
+        return TotalLength(shrunkValues) <= MAX_TOTAL_LENGTH ? shrunkValues : DropTrailingFields(shrunkValues);
+    }
+
+    private static WebhookEmbed ShrinkDescription(WebhookEmbed embed, int excess)
+    {
+        return embed.Description is null
+            ? embed
+            : embed with
+            {
+                Description = Shrink(value: embed.Description, excess: excess),
+            };
+    }
+
+    private static WebhookEmbed ShrinkFieldValues(WebhookEmbed embed, int excess)
+    {
+        WebhookEmbedField[] fields = [.. embed.Fields];
+        int remainingExcess = excess;
+
+        for (int index = fields.Length - 1; index >= 0 && remainingExcess > 0; index--)
+        {
+            string shrunk = Shrink(value: fields[index].Value, excess: remainingExcess);
+            remainingExcess -= fields[index].Value.Length - shrunk.Length;
+            fields[index] = fields[index] with { Value = shrunk };
+        }
+
+        return embed with
+        {
+            Fields = fields,
+        };
+    }
+
+    private static WebhookEmbed DropTrailingFields(WebhookEmbed embed)
+    {
+        int remaining = MAX_TOTAL_LENGTH - FixedLength(embed);
+        int kept = 0;
+
+        while (kept < embed.Fields.Count && FieldLength(embed.Fields[kept]) <= remaining)
+        {
+            remaining -= FieldLength(embed.Fields[kept]);
+            kept++;
+        }
+
+        return embed with
+        {
+            Fields = [.. embed.Fields.Take(kept)],
+        };
+    }
+
+    private static int FixedLength(WebhookEmbed embed)
+    {
+        return (embed.Title?.Length ?? 0) + (embed.Description?.Length ?? 0) + embed.Author.Name.Length;
+    }
+
+    private static int FieldLength(WebhookEmbedField field)
+    {
+        return field.Name.Length + field.Value.Length;
+    }
+
+    private static string Shrink(string value, int excess)
+    {
+        return Truncate(value: value, maxLength: Math.Max(val1: value.Length - excess, val2: MIN_SHRUNK_LENGTH));
+    }
+
+    private static string? TruncateOrNull(string? value, int maxLength)
+    {
+        return value is null ? null : Truncate(value: value, maxLength: maxLength);
+    }
+
+    private static string Truncate(string value, int maxLength)
+    {
+        if (value.Length <= maxLength)
+        {
+            return value;
+        }
+
+        int kept = maxLength - TRUNCATION_MARKER.Length;
+
+        // Cutting between the halves of a surrogate pair would leave an unpaired surrogate, which is not valid UTF-16.
+        if (char.IsHighSurrogate(value[kept - 1]))
+        {
+            kept--;
+        }
+
+        return string.Concat(str0: value.AsSpan(start: 0, length: kept), str1: TRUNCATION_MARKER);
+    }
+}
diff --git a/src/BuildBot.Discord/Services/EmbedMapper.cs b/src/BuildBot.Discord/Services/EmbedMapper.cs
new file mode 100644
index 000000000..0a2cef9e6
--- /dev/null
+++ b/src/BuildBot.Discord/Services/EmbedMapper.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services.Models;
+
+namespace BuildBot.Discord.Services;
+
+public static class EmbedMapper
+{
+    // Discord trims field names and values and rejects the whole message when either ends up empty, so a blank one is
+    // replaced with a visible placeholder to keep the field and the rest of the notification.
+    public const string BLANK_FIELD_PLACEHOLDER = "-";
+
+    public static WebhookEmbedAuthor StandardAuthor { get; } =
+        new(
+            Name: "FunFair BuildBot",
+            Url: new("https://funfair.io"),
+            IconUrl: new("https://s2.coinmarketcap.com/static/img/coins/32x32/1757.png")
+        );
+
+    public static WebhookPayload ToPayload(DiscordEmbed embed)
+    {
+        return new([ToWebhookEmbed(embed)]);
+    }
+
+    public static WebhookEmbed ToWebhookEmbed(DiscordEmbed embed)
+    {
+        return EmbedLimiter.Apply(
+            new(
+                Title: NullIfBlank(embed.Title),
+                Url: WebUrlOrNull(embed.Url),
+                Description: NullIfBlank(embed.Description),
+                Color: embed.Color?.Value,
+                Author: StandardAuthor,
+                Fields: [.. embed.Fields.Select(ToWebhookEmbedField)]
+            )
+        );
+    }
+
+    private static WebhookEmbedField ToWebhookEmbedField(DiscordEmbedField field)
+    {
+        return new(Name: PlaceholderIfBlank(field.Name), Value: PlaceholderIfBlank(field.Value), Inline: field.Inline);
+    }
+
+    // Discord rejects the whole message when an embed URL is not http(s); on Linux "/path" parses as a file URI.
+    private static Uri? WebUrlOrNull(Uri? url)
+    {
+        return url is { IsAbsoluteUri: true } && IsWebScheme(url.Scheme) ? url : null;
+    }
+
+    private static bool IsWebScheme(string scheme)
+    {
+        return StringComparer.Ordinal.Equals(x: scheme, y: Uri.UriSchemeHttps)
+            || StringComparer.Ordinal.Equals(x: scheme, y: Uri.UriSchemeHttp);
+    }
+
+    // Title and description are optional, so a blank one is omitted rather than sent as an empty string Discord may reject.
+    private static string? NullIfBlank(string? value)
+    {
+        return string.IsNullOrWhiteSpace(value) ? null : value;
+    }
+
+    private static string PlaceholderIfBlank(string value)
+    {
+        return string.IsNullOrWhiteSpace(value) ? BLANK_FIELD_PLACEHOLDER : value;
+    }
+}
diff --git a/src/BuildBot.Discord/Services/IDiscordChannel.cs b/src/BuildBot.Discord/Services/IDiscordChannel.cs
deleted file mode 100644
index 210ea45b2..000000000
--- a/src/BuildBot.Discord/Services/IDiscordChannel.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using Discord;
-
-namespace BuildBot.Discord.Services;
-
-public interface IDiscordChannel
-{
-    string Name { get; }
-
-    IDisposable EnterTypingState();
-
-    Task<(string SentToChannel, string MessageContent)> SendMessageAsync(Embed embed);
-}
diff --git a/src/BuildBot.Discord/Services/IDiscordRawClient.cs b/src/BuildBot.Discord/Services/IDiscordRawClient.cs
deleted file mode 100644
index c32136598..000000000
--- a/src/BuildBot.Discord/Services/IDiscordRawClient.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using Discord;
-
-namespace BuildBot.Discord.Services;
-
-public interface IDiscordRawClient
-{
-    LoginState LoginState { get; }
-
-    IDiscordChannel? FindChannel(string serverName, string channelName);
-
-    Task LoginAsync(TokenType tokenType, string token);
-
-    Task StartAsync();
-
-    Task StopAsync();
-
-    Task LogoutAsync();
-
-    Task SetGameAsync(string name, string? streamUrl, ActivityType type);
-
-    void RegisterLogHandler(Func<LogMessage, Task> handler);
-}
diff --git a/src/BuildBot.Discord/Services/IDiscordWebhookClient.cs b/src/BuildBot.Discord/Services/IDiscordWebhookClient.cs
new file mode 100644
index 000000000..59580fdf8
--- /dev/null
+++ b/src/BuildBot.Discord/Services/IDiscordWebhookClient.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Services.Models;
+
+namespace BuildBot.Discord.Services;
+
+public interface IDiscordWebhookClient
+{
+    ValueTask<WebhookSendResult> SendAsync(Uri webhookUrl, WebhookPayload payload, CancellationToken cancellationToken);
+}
diff --git a/src/BuildBot.Discord/Services/LoggingExtensions/DiscordBotLoggingExtensions.cs b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordBotLoggingExtensions.cs
index c7cd70dd2..0a635879e 100644
--- a/src/BuildBot.Discord/Services/LoggingExtensions/DiscordBotLoggingExtensions.cs
+++ b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordBotLoggingExtensions.cs
@@ -1,66 +1,25 @@
-using System;
+using System.Net;
 using Microsoft.Extensions.Logging;
 
 namespace BuildBot.Discord.Services.LoggingExtensions;
 
 internal static partial class DiscordBotLoggingExtensions
 {
-    [LoggerMessage(
-        EventId = 1,
-        Level = LogLevel.Error,
-        Message = "DISCORD: {channelName}: Could not find channel on server {serverName}"
-    )]
-    public static partial void LogDiscordChannelNotFound(
-        this ILogger<DiscordBot> logger,
-        string channelName,
-        string serverName
-    );
+    [LoggerMessage(EventId = 2, Level = LogLevel.Information, Message = "DISCORD: Sending message {title}")]
+    public static partial void LogSendingMessage(this ILogger<DiscordBot> logger, string title);
 
-    [LoggerMessage(
-        EventId = 2,
-        Level = LogLevel.Warning,
-        Message = "DISCORD: {channelName}: Sending message {message}"
-    )]
-    public static partial void LogSendingMessage(this ILogger<DiscordBot> logger, string channelName, string message);
-
-    [LoggerMessage(EventId = 3, Level = LogLevel.Warning, Message = "DISCORD: {channelName}: Sent message {message}")]
-    public static partial void LogSentMessage(this ILogger<DiscordBot> logger, string channelName, string message);
+    [LoggerMessage(EventId = 3, Level = LogLevel.Information, Message = "DISCORD: Sent message {title}")]
+    public static partial void LogSentMessage(this ILogger<DiscordBot> logger, string title);
 
     [LoggerMessage(
         EventId = 4,
         Level = LogLevel.Error,
-        Message = "DISCORD: {channelName}: Failed to send message {title}: {message}"
+        Message = "DISCORD: Failed to send message {title}: HTTP {statusCode}: {responseBody}"
     )]
-    public static partial void FailedToPublishMessage(
+    public static partial void LogSendRejected(
         this ILogger<DiscordBot> logger,
-        string channelName,
         string title,
-        string message,
-        Exception exception
-    );
-
-    [LoggerMessage(EventId = 6, Level = LogLevel.Debug, Message = "DISCORD: DEBUG: {message}")]
-    public static partial void DiscordDebug(this ILogger<DiscordBot> logger, string message);
-
-    [LoggerMessage(EventId = 7, Level = LogLevel.Information, Message = "DISCORD: INFO: {message}")]
-    public static partial void DiscordInfo(this ILogger<DiscordBot> logger, string message);
-
-    [LoggerMessage(EventId = 8, Level = LogLevel.Warning, Message = "DISCORD: WARNING: {message}")]
-    public static partial void DiscordWarning(this ILogger<DiscordBot> logger, string message);
-
-    [LoggerMessage(EventId = 9, Level = LogLevel.Error, Message = "DISCORD: ERROR: {message}")]
-    public static partial void DiscordError(this ILogger<DiscordBot> logger, string message);
-
-    [LoggerMessage(EventId = 9, Level = LogLevel.Error, Message = "DISCORD: ERROR: {message}")]
-    public static partial void DiscordError(this ILogger<DiscordBot> logger, string message, Exception exception);
-
-    [LoggerMessage(EventId = 10, Level = LogLevel.Critical, Message = "DISCORD: CRITICAL ERROR: {message}")]
-    public static partial void DiscordCriticalError(this ILogger<DiscordBot> logger, string message);
-
-    [LoggerMessage(EventId = 10, Level = LogLevel.Critical, Message = "DISCORD: CRITICAL ERROR: {message}")]
-    public static partial void DiscordCriticalError(
-        this ILogger<DiscordBot> logger,
-        string message,
-        Exception exception
+        HttpStatusCode statusCode,
+        string responseBody
     );
 }
diff --git a/src/BuildBot.Discord/Services/LoggingExtensions/DiscordMessageSenderLoggingExtensions.cs b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordMessageSenderLoggingExtensions.cs
new file mode 100644
index 000000000..251cf562b
--- /dev/null
+++ b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordMessageSenderLoggingExtensions.cs
@@ -0,0 +1,18 @@
+using Microsoft.Extensions.Logging;
+
+namespace BuildBot.Discord.Services.LoggingExtensions;
+
+internal static partial class DiscordMessageSenderLoggingExtensions
+{
+    // Only the exception type is logged: an exception message can carry the request URL, which embeds the webhook token.
+    [LoggerMessage(
+        EventId = 7,
+        Level = LogLevel.Error,
+        Message = "DISCORD: Failed to publish message {title} with {exceptionType}"
+    )]
+    public static partial void LogPublishFailed(
+        this ILogger<DiscordMessageSender> logger,
+        string title,
+        string exceptionType
+    );
+}
diff --git a/src/BuildBot.Discord/Services/LoggingExtensions/DiscordWebhookClientLoggingExtensions.cs b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordWebhookClientLoggingExtensions.cs
new file mode 100644
index 000000000..56ed4839f
--- /dev/null
+++ b/src/BuildBot.Discord/Services/LoggingExtensions/DiscordWebhookClientLoggingExtensions.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Net;
+using Microsoft.Extensions.Logging;
+
+namespace BuildBot.Discord.Services.LoggingExtensions;
+
+internal static partial class DiscordWebhookClientLoggingExtensions
+{
+    [LoggerMessage(
+        EventId = 8,
+        Level = LogLevel.Warning,
+        Message = "DISCORD: Webhook attempt {attempt} failed with HTTP {statusCode}; retrying in {delay}"
+    )]
+    public static partial void LogRetryingAfterStatusCode(
+        this ILogger<DiscordWebhookClient> logger,
+        int attempt,
+        HttpStatusCode statusCode,
+        TimeSpan delay
+    );
+
+    // Only the exception type is logged: an exception message can carry the request URL, which embeds the webhook token.
+    [LoggerMessage(
+        EventId = 9,
+        Level = LogLevel.Warning,
+        Message = "DISCORD: Webhook attempt {attempt} failed with {exceptionType}; retrying in {delay}"
+    )]
+    public static partial void LogRetryingAfterException(
+        this ILogger<DiscordWebhookClient> logger,
+        int attempt,
+        string exceptionType,
+        TimeSpan delay
+    );
+}
diff --git a/src/BuildBot.Discord/Services/Models/WebhookEmbed.cs b/src/BuildBot.Discord/Services/Models/WebhookEmbed.cs
new file mode 100644
index 000000000..cb528cac6
--- /dev/null
+++ b/src/BuildBot.Discord/Services/Models/WebhookEmbed.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Services.Models;
+
+[DebuggerDisplay("{Title}: {Url} {Description} {Color}")]
+public sealed record WebhookEmbed(
+    string? Title,
+    Uri? Url,
+    string? Description,
+    uint? Color,
+    WebhookEmbedAuthor Author,
+    IReadOnlyList<WebhookEmbedField> Fields
+);
diff --git a/src/BuildBot.Discord/Services/Models/WebhookEmbedAuthor.cs b/src/BuildBot.Discord/Services/Models/WebhookEmbedAuthor.cs
new file mode 100644
index 000000000..544c9edc2
--- /dev/null
+++ b/src/BuildBot.Discord/Services/Models/WebhookEmbedAuthor.cs
@@ -0,0 +1,7 @@
+using System;
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Services.Models;
+
+[DebuggerDisplay("{Name}: {Url} {IconUrl}")]
+public sealed record WebhookEmbedAuthor(string Name, Uri Url, Uri IconUrl);
diff --git a/src/BuildBot.Discord/Services/Models/WebhookEmbedField.cs b/src/BuildBot.Discord/Services/Models/WebhookEmbedField.cs
new file mode 100644
index 000000000..4abf3d4cf
--- /dev/null
+++ b/src/BuildBot.Discord/Services/Models/WebhookEmbedField.cs
@@ -0,0 +1,6 @@
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Services.Models;
+
+[DebuggerDisplay("{Name}: {Value} (Inline: {Inline})")]
+public readonly record struct WebhookEmbedField(string Name, string Value, bool Inline);
diff --git a/src/BuildBot.Discord/Services/Models/WebhookPayload.cs b/src/BuildBot.Discord/Services/Models/WebhookPayload.cs
new file mode 100644
index 000000000..03750e29a
--- /dev/null
+++ b/src/BuildBot.Discord/Services/Models/WebhookPayload.cs
@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace BuildBot.Discord.Services.Models;
+
+[DebuggerDisplay("Embeds: {Embeds.Count}")]
+public sealed record WebhookPayload(IReadOnlyList<WebhookEmbed> Embeds);
diff --git a/src/BuildBot.Discord/Services/Models/WebhookSendResult.cs b/src/BuildBot.Discord/Services/Models/WebhookSendResult.cs
new file mode 100644
index 000000000..3ca22e29b
--- /dev/null
+++ b/src/BuildBot.Discord/Services/Models/WebhookSendResult.cs
@@ -0,0 +1,7 @@
+using System.Diagnostics;
+using System.Net;
+
+namespace BuildBot.Discord.Services.Models;
+
+[DebuggerDisplay("Success: {Success}, Status: {StatusCode}, Response: {ResponseBody}")]
+public readonly record struct WebhookSendResult(bool Success, HttpStatusCode StatusCode, string ResponseBody);
diff --git a/src/BuildBot.GitHub.Tests/Publishers/GithubPushNotificationHandlerTests.cs b/src/BuildBot.GitHub.Tests/Publishers/GithubPushNotificationHandlerTests.cs
index 2a269e8cc..2fe0af172 100644
--- a/src/BuildBot.GitHub.Tests/Publishers/GithubPushNotificationHandlerTests.cs
+++ b/src/BuildBot.GitHub.Tests/Publishers/GithubPushNotificationHandlerTests.cs
@@ -185,4 +185,64 @@ public async Task SingleCommitWithNullUsernameShouldPublishAsync()
 
         await mediator.Received(1).Publish(Arg.Any<BotMessage>(), Arg.Any<CancellationToken>());
     }
+
+    [Fact]
+    public async Task PublishedEmbedHasExpectedContentAsync()
+    {
+        (IMediator mediator, GithubPushNotificationHandler handler) = this.CreateHandler();
+
+        Commit commit1 = MakeCommit(message: "First commit", username: "devuser");
+        Commit commit2 = MakeCommit(message: "Second commit", username: null);
+        Push push = MakePush(repoName: NORMAL_REPO, gitRef: NORMAL_REF, commits: [commit1, commit2]);
+
+        await handler.Handle(notification: new(push), cancellationToken: this.CancellationToken());
+
+        DiscordEmbed embed = mediator.PublishedEmbed();
+        Assert.Equal(expected: "testpusher pushed 2 commits to BuildBot (feature/my-feature)", actual: embed.Title);
+        Assert.Equal(expected: new Uri("https://github.com/example/repo/compare/before...after"), actual: embed.Url);
+        Assert.Null(embed.Description);
+        Assert.Null(embed.Color);
+        Assert.Equal(
+            expected:
+            [
+                new DiscordEmbedField(Name: "**devuser** - First commit", Value: "0 added, 0 modified, 0 removed"),
+                new DiscordEmbedField(Name: "**Test User** - Second commit", Value: "0 added, 0 modified, 0 removed"),
+            ],
+            actual: embed.Fields
+        );
+    }
+
+    [Theory]
+    [InlineData("Subject line\n\nBody text")]
+    [InlineData("Subject line\r\n\r\nBody text")]
+    public async Task PublishedEmbedFieldNameUsesFirstLineOfCommitMessageAsync(string message)
+    {
+        (IMediator mediator, GithubPushNotificationHandler handler) = this.CreateHandler();
+
+        Push push = MakePush(
+            repoName: NORMAL_REPO,
+            gitRef: NORMAL_REF,
+            commits: [MakeCommit(message: message, username: "devuser")]
+        );
+
+        await handler.Handle(notification: new(push), cancellationToken: this.CancellationToken());
+
+        DiscordEmbedField field = Assert.Single(mediator.PublishedEmbed().Fields);
+        Assert.Equal(expected: "**devuser** - Subject line", actual: field.Name);
+    }
+
+    [Fact]
+    public async Task PublishedEmbedForSingleCommitUsesSingularTitleAsync()
+    {
+        (IMediator mediator, GithubPushNotificationHandler handler) = this.CreateHandler();
+
+        Push push = MakePush(repoName: NORMAL_REPO, gitRef: NORMAL_REF, commits: [MakeCommit("Only commit")]);
+
+        await handler.Handle(notification: new(push), cancellationToken: this.CancellationToken());
+
+        Assert.Equal(
+            expected: "testpusher pushed 1 commit to BuildBot (feature/my-feature)",
+            actual: mediator.PublishedEmbed().Title
+        );
+    }
 }
diff --git a/src/BuildBot.GitHub.Tests/Publishers/GithubStatusNotificationHandlerTests.cs b/src/BuildBot.GitHub.Tests/Publishers/GithubStatusNotificationHandlerTests.cs
index c77067951..a78e00f9c 100644
--- a/src/BuildBot.GitHub.Tests/Publishers/GithubStatusNotificationHandlerTests.cs
+++ b/src/BuildBot.GitHub.Tests/Publishers/GithubStatusNotificationHandlerTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using BuildBot.Discord.Models;
 using BuildBot.GitHub.Models;
 using BuildBot.GitHub.Publishers;
 using BuildBot.ServiceModel.GitHub;
@@ -118,4 +119,51 @@ public async Task NonPendingStateWithNoBranchesShouldPublishAsync(string state)
 
         await mediator.Received(1).Publish(Arg.Any<INotification>(), Arg.Any<CancellationToken>());
     }
+
+    public static TheoryData<string, uint?> StateColors =>
+        new()
+        {
+            { "success", 0x2ECC71 },
+            { "SUCCESS", 0x2ECC71 },
+            { "failure", 0xE74C3C },
+            { "error", null },
+        };
+
+    [Theory]
+    [MemberData(nameof(StateColors))]
+    public async Task PublishedEmbedHasExpectedContentAsync(string state, uint? expectedColor)
+    {
+        (IMediator mediator, GithubStatusNotificationHandler handler) = this.CreateHandler();
+
+        await handler.Handle(notification: new(MakeStatus(state: state)), cancellationToken: this.CancellationToken());
+
+        DiscordEmbed embed = mediator.PublishedEmbed();
+        Assert.Equal(expected: "Build finished for ci/build from BuildBot (main)", actual: embed.Title);
+        Assert.Equal(expected: new Uri("https://ci.example.com/builds/123"), actual: embed.Url);
+        Assert.Equal(expected: "Built at abc123", actual: embed.Description);
+        Assert.Equal(expected: expectedColor, actual: embed.Color?.Value);
+        Assert.Equal(
+            expected:
+            [
+                new DiscordEmbedField(Name: "Head commit", Value: "testuser - Fix something"),
+                new DiscordEmbedField(Name: "Branch", Value: "main"),
+            ],
+            actual: embed.Fields
+        );
+    }
+
+    [Fact]
+    public async Task PublishedEmbedWithNoBranchesUsesUnknownAsync()
+    {
+        (IMediator mediator, GithubStatusNotificationHandler handler) = this.CreateHandler();
+
+        await handler.Handle(
+            notification: new(MakeStatusWithNoBranches(state: "success")),
+            cancellationToken: this.CancellationToken()
+        );
+
+        DiscordEmbed embed = mediator.PublishedEmbed();
+        Assert.Equal(expected: "Build finished for ci/build from BuildBot ((unknown))", actual: embed.Title);
+        Assert.Equal(expected: new DiscordEmbedField(Name: "Branch", Value: "(unknown)"), actual: embed.Fields[1]);
+    }
 }
diff --git a/src/BuildBot.GitHub.Tests/Publishers/MediatorTestExtensions.cs b/src/BuildBot.GitHub.Tests/Publishers/MediatorTestExtensions.cs
new file mode 100644
index 000000000..0ffb086d6
--- /dev/null
+++ b/src/BuildBot.GitHub.Tests/Publishers/MediatorTestExtensions.cs
@@ -0,0 +1,19 @@
+using System.Linq;
+using BuildBot.Discord.Models;
+using Mediator;
+using NSubstitute;
+
+namespace BuildBot.GitHub.Tests.Publishers;
+
+internal static class MediatorTestExtensions
+{
+    public static DiscordEmbed PublishedEmbed(this IMediator mediator)
+    {
+        return mediator
+            .ReceivedCalls()
+            .Select(static call => call.GetArguments()[0])
+            .OfType<BotMessage>()
+            .Single()
+            .Message;
+    }
+}
diff --git a/src/BuildBot.GitHub/Publishers/GithubPushNotificationHandler.cs b/src/BuildBot.GitHub/Publishers/GithubPushNotificationHandler.cs
index df50bee82..c8089f4b1 100644
--- a/src/BuildBot.GitHub/Publishers/GithubPushNotificationHandler.cs
+++ b/src/BuildBot.GitHub/Publishers/GithubPushNotificationHandler.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -7,7 +8,6 @@
 using BuildBot.GitHub.Models;
 using BuildBot.GitHub.Publishers.LoggingExtensions;
 using BuildBot.ServiceModel.GitHub;
-using Discord;
 using Mediator;
 using Microsoft.Extensions.Logging;
 
@@ -52,9 +52,9 @@ private async ValueTask PublishAsync(Push message, CancellationToken cancellatio
             return;
         }
 
-        EmbedBuilder builder = BuildPushEmbed(message);
+        DiscordEmbed embed = BuildPushEmbed(message);
 
-        await this._mediator.Publish(new BotMessage(builder), cancellationToken: cancellationToken);
+        await this._mediator.Publish(new BotMessage(embed), cancellationToken: cancellationToken);
     }
 
     private static bool IsIgnoredRepo(in Push message)
@@ -82,29 +82,39 @@ static bool IsPackageUpdate(Commit commit)
         }
     }
 
-    private static EmbedBuilder BuildPushEmbed(in Push message)
-    {
-        return message.Commits.Aggregate(CreateBasicEmbed(message), func: AddCommit);
-    }
-
-    private static EmbedBuilder CreateBasicEmbed(in Push message)
+    private static DiscordEmbed BuildPushEmbed(in Push message)
     {
         string commitString = GetCommitString(message);
         string title = GetCommitTitle(message: message, commitString: commitString);
 
-        return new EmbedBuilder().WithTitle(title).WithUrl(message.CompareUrl);
+        return new(
+            Title: title,
+            Url: EmbedUrl.FromString(message.CompareUrl),
+            Description: null,
+            Color: null,
+            Fields: CreateCommitFields(message.Commits)
+        );
     }
 
-    private static EmbedBuilder AddCommit(EmbedBuilder current, Commit commit)
+    private static IReadOnlyList<DiscordEmbedField> CreateCommitFields(IReadOnlyList<Commit> commits)
     {
-        return current.AddField(CreateCommitEmbed(commit));
+        return [.. commits.Select(CreateCommitEmbed)];
     }
 
-    private static EmbedFieldBuilder CreateCommitEmbed(in Commit commit)
+    private static DiscordEmbedField CreateCommitEmbed(Commit commit)
     {
-        return new EmbedFieldBuilder()
-            .WithName($"**{commit.Author.Username ?? commit.Author.Name}** - {commit.Message}")
-            .WithValue($"{commit.Added.Count} added, {commit.Modified.Count} modified, {commit.Removed.Count} removed");
+        return new(
+            Name: $"**{commit.Author.Username ?? commit.Author.Name}** - {FirstLine(commit.Message)}",
+            Value: $"{commit.Added.Count} added, {commit.Modified.Count} modified, {commit.Removed.Count} removed"
+        );
+    }
+
+    // The commit subject is the summary; the body would make the field name multi-line and hit Discord's name limit.
+    private static string FirstLine(string message)
+    {
+        int lineEnd = message.AsSpan().IndexOfAny('\r', '\n');
+
+        return lineEnd < 0 ? message : message[..lineEnd];
     }
 
     private static string GetCommitTitle(in Push message, string commitString)
diff --git a/src/BuildBot.GitHub/Publishers/GithubStatusNotificationHandler.cs b/src/BuildBot.GitHub/Publishers/GithubStatusNotificationHandler.cs
index ccf038b8f..a3dd2f998 100644
--- a/src/BuildBot.GitHub/Publishers/GithubStatusNotificationHandler.cs
+++ b/src/BuildBot.GitHub/Publishers/GithubStatusNotificationHandler.cs
@@ -8,7 +8,6 @@
 using BuildBot.GitHub.Models;
 using BuildBot.GitHub.Publishers.LoggingExtensions;
 using BuildBot.ServiceModel.GitHub;
-using Discord;
 using Mediator;
 using Microsoft.Extensions.Logging;
 
@@ -16,10 +15,10 @@ namespace BuildBot.GitHub.Publishers;
 
 public sealed class GithubStatusNotificationHandler : INotificationHandler<GithubStatus>
 {
-    private static readonly IReadOnlyList<ColourMapping> ColourMappings =
+    private static readonly IReadOnlyList<ColorMapping> ColorMappings =
     [
-        new(State: "success", Colour: Color.Green),
-        new(State: "failure", Colour: Color.Red),
+        new(State: "success", Color: DiscordColor.Green),
+        new(State: "failure", Color: DiscordColor.Red),
     ];
 
     private readonly ILogger<GithubStatusNotificationHandler> _logger;
@@ -51,49 +50,45 @@ private static bool IsPendingBuild(in Status message)
         return StringComparer.OrdinalIgnoreCase.Equals(x: message.State, y: "pending");
     }
 
-    private static EmbedBuilder BuildStatusMessage(in Status message)
+    private static DiscordEmbed BuildStatusMessage(in Status message)
     {
         Branch? lastBranch = message.Branches.Count > 0 ? message.Branches[^1] : null;
+        string branchName = lastBranch?.Name ?? "(unknown)";
 
-        return new EmbedBuilder()
-            .WithTitle(
-                $"{message.Description} for {message.Context} from {message.Repository.Name} ({lastBranch?.Name ?? "(unknown)"})"
-            )
-            .WithUrl(message.TargetUrl)
-            .WithDescription($"Built at {message.StatusCommit.Sha}")
-            .WithColor(GetEmbedColor(message))
-            .WithFields(GetFields(message));
+        return new(
+            Title: $"{message.Description} for {message.Context} from {message.Repository.Name} ({branchName})",
+            Url: EmbedUrl.FromString(message.TargetUrl),
+            Description: $"Built at {message.StatusCommit.Sha}",
+            Color: GetEmbedColor(message),
+            Fields: GetFields(message)
+        );
     }
 
-    private static IReadOnlyList<EmbedFieldBuilder> GetFields(in Status message)
+    private static IReadOnlyList<DiscordEmbedField> GetFields(in Status message)
     {
         return [AddHeadCommitEmbed(message.StatusCommit), AddBranchEmbed(message)];
     }
 
-    private static EmbedFieldBuilder AddBranchEmbed(in Status message)
+    private static DiscordEmbedField AddBranchEmbed(in Status message)
     {
-        return new EmbedFieldBuilder()
-            .WithName("Branch")
-            .WithValue(message.Branches.Select(static b => b.Name).FirstOrDefault() ?? "(unknown)");
+        return new(Name: "Branch", Value: message.Branches.Select(static b => b.Name).FirstOrDefault() ?? "(unknown)");
     }
 
-    private static EmbedFieldBuilder AddHeadCommitEmbed(in StatusCommit statusCommit)
+    private static DiscordEmbedField AddHeadCommitEmbed(in StatusCommit statusCommit)
     {
-        return new EmbedFieldBuilder()
-            .WithName("Head commit")
-            .WithValue($"{statusCommit.Author.Login} - {statusCommit.Commit.Message}");
+        return new(Name: "Head commit", Value: $"{statusCommit.Author.Login} - {statusCommit.Commit.Message}");
     }
 
-    private static Color GetEmbedColor(Status message)
+    private static DiscordColor? GetEmbedColor(Status message)
     {
-        return ColourMappings
+        return ColorMappings
             .Where(mapping => mapping.IsMatch(message))
-            .Select(mapping => mapping.Colour)
-            .FirstOrDefault(Color.Default);
+            .Select(static DiscordColor? (mapping) => mapping.Color)
+            .FirstOrDefault();
     }
 
-    [DebuggerDisplay("{State} => {Colour}")]
-    private readonly record struct ColourMapping(string State, Color Colour)
+    [DebuggerDisplay("{State} => {Color}")]
+    private readonly record struct ColorMapping(string State, DiscordColor Color)
     {
         public bool IsMatch(in Status message)
         {
diff --git a/src/BuildBot.Watchtower.Tests/Publishers/WatchTowerPublishMessageNotificationHandlerTests.cs b/src/BuildBot.Watchtower.Tests/Publishers/WatchTowerPublishMessageNotificationHandlerTests.cs
index 94e3925ae..9e7ff83f8 100644
--- a/src/BuildBot.Watchtower.Tests/Publishers/WatchTowerPublishMessageNotificationHandlerTests.cs
+++ b/src/BuildBot.Watchtower.Tests/Publishers/WatchTowerPublishMessageNotificationHandlerTests.cs
@@ -1,3 +1,4 @@
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using BuildBot.Discord.Models;
@@ -26,4 +27,28 @@ public async Task HandlePublishesBotMessageViaMediatorAsync()
 
         await mediator.Received(1).Publish(Arg.Any<BotMessage>(), Arg.Any<CancellationToken>());
     }
+
+    [Fact]
+    public async Task PublishedEmbedHasExpectedContentAsync()
+    {
+        IMediator mediator = GetSubstitute<IMediator>();
+        WatchTowerPublishMessageNotificationHandler handler = new(mediator);
+
+        await handler.Handle(
+            notification: new(new WatchTowerMessage(Message: "Service deployed", Title: "Deployment")),
+            cancellationToken: this.CancellationToken()
+        );
+
+        DiscordEmbed embed = mediator
+            .ReceivedCalls()
+            .Select(static call => call.GetArguments()[0])
+            .OfType<BotMessage>()
+            .Single()
+            .Message;
+        Assert.Equal(expected: "Deployment", actual: embed.Title);
+        Assert.Equal(expected: "Service deployed", actual: embed.Description);
+        Assert.Null(embed.Url);
+        Assert.Null(embed.Color);
+        Assert.Empty(embed.Fields);
+    }
 }
diff --git a/src/BuildBot.Watchtower/Publishers/WatchTowerPublishMessageNotificationHandler.cs b/src/BuildBot.Watchtower/Publishers/WatchTowerPublishMessageNotificationHandler.cs
index 8110b731b..acea8277b 100644
--- a/src/BuildBot.Watchtower/Publishers/WatchTowerPublishMessageNotificationHandler.cs
+++ b/src/BuildBot.Watchtower/Publishers/WatchTowerPublishMessageNotificationHandler.cs
@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using BuildBot.Discord.Models;
 using BuildBot.Watchtower.Models;
-using Discord;
 using Mediator;
 
 namespace BuildBot.Watchtower.Publishers;
@@ -21,8 +20,14 @@ public ValueTask Handle(WatchTowerPublishMessage notification, CancellationToken
         return this._mediator.Publish(new BotMessage(BuildMessage(notification)), cancellationToken: cancellationToken);
     }
 
-    private static EmbedBuilder BuildMessage(WatchTowerPublishMessage notification)
+    private static DiscordEmbed BuildMessage(WatchTowerPublishMessage notification)
     {
-        return new EmbedBuilder().WithTitle(notification.Model.Title).WithDescription(notification.Model.Message);
+        return new(
+            Title: notification.Model.Title,
+            Url: null,
+            Description: notification.Model.Message,
+            Color: null,
+            Fields: []
+        );
     }
 }
diff --git a/src/BuildBot/.gitignore b/src/BuildBot/.gitignore
new file mode 100644
index 000000000..95914b980
--- /dev/null
+++ b/src/BuildBot/.gitignore
@@ -0,0 +1 @@
+http-client.private.env.json
diff --git a/src/BuildBot/DiscordWebhook.http b/src/BuildBot/DiscordWebhook.http
new file mode 100644
index 000000000..a0f48e93b
--- /dev/null
+++ b/src/BuildBot/DiscordWebhook.http
@@ -0,0 +1,29 @@
+# Discord webhook (consumed API).
+# The webhook URL contains its token, so it is a credential: supply DiscordWebhookUrl from an
+# uncommitted http-client.private.env.json, e.g. { "dev": { "DiscordWebhookUrl": "https://..." } }
+
+### Discord webhook - execute (expects 204 No Content)
+POST {{DiscordWebhookUrl}}
+Content-Type: application/json
+
+{
+  "embeds": [
+    {
+      "title": "BuildBot webhook test",
+      "description": "Test message from DiscordWebhook.http",
+      "color": 3066993,
+      "author": {
+        "name": "FunFair BuildBot",
+        "url": "https://funfair.io",
+        "icon_url": "https://s2.coinmarketcap.com/static/img/coins/32x32/1757.png"
+      },
+      "fields": [
+        {
+          "name": "Field",
+          "value": "Value",
+          "inline": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/BuildBot/Helpers/ServerStartup.cs b/src/BuildBot/Helpers/ServerStartup.cs
index 0217e0323..bd6bdc34f 100644
--- a/src/BuildBot/Helpers/ServerStartup.cs
+++ b/src/BuildBot/Helpers/ServerStartup.cs
@@ -68,9 +68,6 @@ public static WebApplication CreateApp(string[] args)
         IConfigurationRoot config = LoadConfiguration(configPath);
 
         DiscordBotConfiguration discordConfig = LoadDiscordConfig(config);
-        Console.WriteLine($"Discord Server: {discordConfig.Server}");
-        Console.WriteLine($"Discord Channel: {discordConfig.Channel}");
-        Console.WriteLine($"Discord Release Channel: {discordConfig.ReleaseChannel}");
 
         SnsNotificationOptions snsConfiguration = LoadSnsNotificationConfig(config);
 
@@ -157,12 +154,7 @@ private static IConfigurationRoot LoadConfiguration(string configPath)
 
     private static DiscordBotConfiguration LoadDiscordConfig(IConfigurationRoot configuration)
     {
-        return new(
-            configuration["Discord:Token"] ?? string.Empty,
-            configuration["Discord:Server"] ?? string.Empty,
-            configuration["Discord:Channel"] ?? string.Empty,
-            configuration["Discord:ReleaseChannel"] ?? string.Empty
-        );
+        return DiscordBotConfiguration.FromWebhookUrl(configuration["Discord:WebhookUrl"]);
     }
 
     private static GitHubConfiguration LoadGitHubConfig(IConfigurationRoot configuration)
diff --git a/src/BuildBot/appsettings.json b/src/BuildBot/appsettings.json
index 96c600e7c..139f00adc 100644
--- a/src/BuildBot/appsettings.json
+++ b/src/BuildBot/appsettings.json
@@ -7,10 +7,7 @@
   },
   "AllowedHosts": "*",
   "Discord": {
-    "Token": "",
-    "Server": "",
-    "Channel": "",
-    "ReleaseChannel": ""
+    "WebhookUrl": ""
   },
   "CloudFormation": {
     "TopicArn": "",
diff --git a/src/publish b/src/publish
index e41e7368c..fea1ca922 100755
--- a/src/publish
+++ b/src/publish
@@ -8,7 +8,7 @@ die() {
 PLATFORM=linux-x64
 OUTFOLDER="$HOME/work/funfair/BuildBot/src/server-dist/$PLATFORM"
 
-[ -z "$DISCORDTOKEN" ] && die "DISCORDTOKEN not set"
+[ -z "$DISCORDWEBHOOKURL" ] && die "DISCORDWEBHOOKURL not set"
 
 echo "Clear $OUTFOLDER" \
   && rm -fr "$HOME/work/funfair/BuildBot/src/server-dist" \
@@ -50,9 +50,6 @@ echo "Clear $OUTFOLDER" \
   && sudo docker run \
       --name buildbot \
       -p 8080:8080 \
-      -e "DISCORD__TOKEN=$DISCORDTOKEN" \
-      -e "DISCORD__SERVER=FunFair Internal" \
-      -e "DISCORD__CHANNEL=build" \
-      -e "DISCORD__RELEASE_CHANNEL=release-notification" \
+      -e "DISCORD__WEBHOOKURL=$DISCORDWEBHOOKURL" \
       -it \
       --rm "funfair/buildbot:latest"