diff --git a/src/plugin/CMakeLists.txt b/src/plugin/CMakeLists.txt
index 4ec9e1d4..11a5d3d9 100644
--- a/src/plugin/CMakeLists.txt
+++ b/src/plugin/CMakeLists.txt
@@ -814,7 +814,7 @@ set(src__releases
     releases/EnrouteRelease.cpp releases/EnrouteReleaseType.cpp
     releases/RejectDepartureReleaseDialog.cpp releases/RejectDepartureReleaseDialog.h
     releases/ReleaseApprovalRemarksUserMessage.cpp releases/ReleaseApprovalRemarksUserMessage.h
-    releases/ReleaseRejectionRemarksUserMessage.cpp releases/ReleaseRejectionRemarksUserMessage.h)
+    releases/ReleaseRejectionRemarksUserMessage.cpp releases/ReleaseRejectionRemarksUserMessage.h releases/DepartureReleaseRequestedEvent.h releases/SendReleaseRequestedChatAreaMessage.cpp releases/SendReleaseRequestedChatAreaMessage.h releases/DepartureReleaseRelevanceChecker.h releases/ReleaseIsTargetedAtUser.cpp releases/ReleaseIsTargetedAtUser.h)
 source_group("src\\releases" FILES ${src__releases})
 
 set(src__runway
diff --git a/src/plugin/euroscope/GeneralSettingsEntries.cpp b/src/plugin/euroscope/GeneralSettingsEntries.cpp
index 0e5c902f..c3be2292 100644
--- a/src/plugin/euroscope/GeneralSettingsEntries.cpp
+++ b/src/plugin/euroscope/GeneralSettingsEntries.cpp
@@ -10,6 +10,9 @@ namespace UKControllerPlugin {
         const std::string GeneralSettingsEntries::prenoteChatAreaMessagesSettingsKey = "sendPrenotesToChat";
         const std::string GeneralSettingsEntries::prenoteChatAreaMessagesSettingsDescription =
             "Show prenote activity in chat area";
+        const std::string GeneralSettingsEntries::releaseChatAreaMessagesSettingsKey = "sendReleasesToChat";
+        const std::string GeneralSettingsEntries::releaseChatAreaMessagesSettingsDescription =
+            "Show release activity in chat area";
 
         // SQUAWKS
         const std::string GeneralSettingsEntries::squawkToggleSettingsKey = "autoAssignSquawks";
diff --git a/src/plugin/euroscope/GeneralSettingsEntries.h b/src/plugin/euroscope/GeneralSettingsEntries.h
index 60197c35..3b44d6d9 100644
--- a/src/plugin/euroscope/GeneralSettingsEntries.h
+++ b/src/plugin/euroscope/GeneralSettingsEntries.h
@@ -13,6 +13,8 @@ namespace UKControllerPlugin {
             static const std::string usePrenoteSettingsDescription;
             static const std::string prenoteChatAreaMessagesSettingsKey;
             static const std::string prenoteChatAreaMessagesSettingsDescription;
+            static const std::string releaseChatAreaMessagesSettingsKey;
+            static const std::string releaseChatAreaMessagesSettingsDescription;
 
             // SQUAWKS
             static const std::string squawkToggleSettingsKey;
diff --git a/src/plugin/releases/DepartureReleaseEventHandler.cpp b/src/plugin/releases/DepartureReleaseEventHandler.cpp
index 155a84a8..29426349 100644
--- a/src/plugin/releases/DepartureReleaseEventHandler.cpp
+++ b/src/plugin/releases/DepartureReleaseEventHandler.cpp
@@ -2,6 +2,7 @@
 #include "DepartureReleaseCountdownColours.h"
 #include "DepartureReleaseEventHandler.h"
 #include "DepartureReleaseRequest.h"
+#include "DepartureReleaseRequestedEvent.h"
 #include "DepartureReleaseRequestView.h"
 #include "ReleaseApprovalRemarksUserMessage.h"
 #include "ReleaseRejectionRemarksUserMessage.h"
@@ -15,6 +16,7 @@
 #include "dialog/DialogManager.h"
 #include "euroscope/EuroScopeCFlightPlanInterface.h"
 #include "euroscope/EuroscopePluginLoopbackInterface.h"
+#include "eventhandler/EventBus.h"
 #include "message/UserMessager.h"
 #include "tag/TagData.h"
 #include "task/TaskRunnerInterface.h"
@@ -524,12 +526,13 @@ namespace UKControllerPlugin::Releases {
         int releaseRequestId = data.at("id").get<int>();
         int targetController = data.at("target_controller").get<int>();
         auto callsign = data.at("callsign").get<std::string>();
-        this->releaseRequests->Add(std::make_shared<DepartureReleaseRequest>(
+        auto request = std::make_shared<DepartureReleaseRequest>(
             releaseRequestId,
             callsign,
             data.at("requesting_controller").get<int>(),
             targetController,
-            Time::ParseTimeString(data.at("expires_at").get<std::string>())));
+            Time::ParseTimeString(data.at("expires_at").get<std::string>()));
+        this->releaseRequests->Add(request);
 
         // Remove any others for the same callsign and controller
         this->releaseRequests->RemoveWhere([callsign, targetController, releaseRequestId](const auto& releaseRequest) {
@@ -537,6 +540,10 @@ namespace UKControllerPlugin::Releases {
                    releaseRequest->Id() != releaseRequestId;
         });
 
+        // Trigger an event
+        LogDebug("Triggering departure release requested event");
+        UKControllerPluginUtils::EventHandler::EventBus::Bus().OnEvent(DepartureReleaseRequestedEvent{request});
+
         // Play a sound to alert the controller if we are the target
         if (this->activeCallsigns.UserHasCallsign() &&
             this->activeCallsigns.GetUserCallsign().GetNormalisedPosition().GetId() == targetController) {
diff --git a/src/plugin/releases/DepartureReleaseRelevanceChecker.h b/src/plugin/releases/DepartureReleaseRelevanceChecker.h
new file mode 100644
index 00000000..bc053fe5
--- /dev/null
+++ b/src/plugin/releases/DepartureReleaseRelevanceChecker.h
@@ -0,0 +1,16 @@
+#pragma once
+
+namespace UKControllerPlugin::Releases {
+
+    class DepartureReleaseRequest;
+
+    /**
+     * Checks if a release request is relevant to the current user.
+     */
+    class DepartureReleaseRelevanceChecker
+    {
+        public:
+        virtual ~DepartureReleaseRelevanceChecker() = default;
+        [[nodiscard]] virtual bool IsRelevant(const DepartureReleaseRequest& releaseRequest) const = 0;
+    };
+} // namespace UKControllerPlugin::Releases
diff --git a/src/plugin/releases/DepartureReleaseRequestedEvent.h b/src/plugin/releases/DepartureReleaseRequestedEvent.h
new file mode 100644
index 00000000..2cb92307
--- /dev/null
+++ b/src/plugin/releases/DepartureReleaseRequestedEvent.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace UKControllerPlugin::Releases {
+
+    class DepartureReleaseRequest;
+
+    using DepartureReleaseRequestedEvent = struct DepartureReleaseRequestedEvent
+    {
+        std::shared_ptr<DepartureReleaseRequest> releaseRequest;
+    };
+} // namespace UKControllerPlugin::Releases
diff --git a/src/plugin/releases/ReleaseIsTargetedAtUser.cpp b/src/plugin/releases/ReleaseIsTargetedAtUser.cpp
new file mode 100644
index 00000000..f737d8c8
--- /dev/null
+++ b/src/plugin/releases/ReleaseIsTargetedAtUser.cpp
@@ -0,0 +1,25 @@
+#include "ReleaseIsTargetedAtUser.h"
+#include "controller/ActiveCallsignCollection.h"
+#include "controller/ActiveCallsign.h"
+#include "controller/ControllerPosition.h"
+#include "releases/DepartureReleaseRequest.h"
+
+namespace UKControllerPlugin::Releases {
+
+    ReleaseIsTargetedAtUser::ReleaseIsTargetedAtUser(
+        std::shared_ptr<const Controller::ActiveCallsignCollection> activeCallsigns)
+        : activeCallsigns(std::move(activeCallsigns))
+    {
+        assert(this->activeCallsigns && "activeCallsigns must not be null");
+    }
+
+    /**
+     * Check that the user has a callsign, and that the callsign has the same normalised controller position
+     * as the target of the release request.
+     */
+    bool ReleaseIsTargetedAtUser::IsRelevant(const DepartureReleaseRequest& releaseRequest) const
+    {
+        return activeCallsigns->UserHasCallsign() &&
+               activeCallsigns->GetUserCallsign().GetNormalisedPosition().GetId() == releaseRequest.TargetController();
+    }
+} // namespace UKControllerPlugin::Releases
diff --git a/src/plugin/releases/ReleaseIsTargetedAtUser.h b/src/plugin/releases/ReleaseIsTargetedAtUser.h
new file mode 100644
index 00000000..5c48b501
--- /dev/null
+++ b/src/plugin/releases/ReleaseIsTargetedAtUser.h
@@ -0,0 +1,21 @@
+#pragma once
+#include "releases/DepartureReleaseRelevanceChecker.h"
+
+namespace UKControllerPlugin::Controller {
+    class ActiveCallsignCollection;
+} // namespace UKControllerPlugin::Controller
+
+namespace UKControllerPlugin::Releases {
+
+    class ReleaseIsTargetedAtUser : public DepartureReleaseRelevanceChecker
+    {
+        public:
+        explicit ReleaseIsTargetedAtUser(std::shared_ptr<const Controller::ActiveCallsignCollection> activeCallsigns);
+        [[nodiscard]] bool IsRelevant(const DepartureReleaseRequest& releaseRequest) const override;
+
+        private:
+        // The active callsigns
+        const std::shared_ptr<const Controller::ActiveCallsignCollection> activeCallsigns;
+    };
+
+} // namespace UKControllerPlugin::Releases
diff --git a/src/plugin/releases/ReleaseModule.cpp b/src/plugin/releases/ReleaseModule.cpp
index ca9fa3f2..894824d6 100644
--- a/src/plugin/releases/ReleaseModule.cpp
+++ b/src/plugin/releases/ReleaseModule.cpp
@@ -2,11 +2,14 @@
 #include "CompareEnrouteReleaseTypes.h"
 #include "DepartureReleaseEventHandler.h"
 #include "DepartureReleaseRequestView.h"
+#include "DepartureReleaseRequestedEvent.h"
 #include "EnrouteReleaseEventHandler.h"
 #include "EnrouteReleaseTypesSerializer.h"
 #include "RejectDepartureReleaseDialog.h"
+#include "ReleaseIsTargetedAtUser.h"
 #include "ReleaseModule.h"
 #include "RequestDepartureReleaseDialog.h"
+#include "SendReleaseRequestedChatAreaMessage.h"
 #include "bootstrap/PersistenceContainer.h"
 #include "collection/Collection.h"
 #include "controller/HandoffEventHandlerCollection.h"
@@ -14,6 +17,8 @@
 #include "dialog/DialogManager.h"
 #include "euroscope/CallbackFunction.h"
 #include "euroscope/EuroscopePluginLoopbackInterface.h"
+#include "eventhandler/EventBus.h"
+#include "eventhandler/EventHandlerFlags.h"
 #include "plugin/FunctionCallEventHandler.h"
 #include "plugin/UKPlugin.h"
 #include "push/PushEventProcessorCollection.h"
@@ -229,6 +234,13 @@ namespace UKControllerPlugin::Releases {
 
         // Add to handlers
         container.timedHandler->RegisterEvent(departureHandler, departureReleaseEventFrequency);
+
+        // Event handlers for displaying chat area messages
+        auto releaseIsTargetedAtUser = std::make_shared<ReleaseIsTargetedAtUser>(container.activeCallsigns);
+        UKControllerPluginUtils::EventHandler::EventBus::Bus().AddHandler<DepartureReleaseRequestedEvent>(
+            std::make_shared<SendReleaseRequestedChatAreaMessage>(
+                releaseIsTargetedAtUser, *container.plugin, *container.pluginUserSettingHandler),
+            UKControllerPluginUtils::EventHandler::EventHandlerFlags::Sync);
     }
 
     void
diff --git a/src/plugin/releases/SendReleaseRequestedChatAreaMessage.cpp b/src/plugin/releases/SendReleaseRequestedChatAreaMessage.cpp
new file mode 100644
index 00000000..a1f59a25
--- /dev/null
+++ b/src/plugin/releases/SendReleaseRequestedChatAreaMessage.cpp
@@ -0,0 +1,42 @@
+#include "DepartureReleaseRelevanceChecker.h"
+#include "DepartureReleaseRequest.h"
+#include "DepartureReleaseRequestedEvent.h"
+#include "SendReleaseRequestedChatAreaMessage.h"
+#include "euroscope/EuroscopePluginLoopbackInterface.h"
+#include "euroscope/GeneralSettingsEntries.h"
+#include "euroscope/UserSetting.h"
+
+namespace UKControllerPlugin::Releases {
+
+    SendReleaseRequestedChatAreaMessage::SendReleaseRequestedChatAreaMessage(
+        std::shared_ptr<const DepartureReleaseRelevanceChecker> relevanceChecker,
+        Euroscope::EuroscopePluginLoopbackInterface& plugin,
+        Euroscope::UserSetting& userSettings)
+        : relevanceChecker(std::move(relevanceChecker)), plugin(plugin), userSettings(userSettings)
+    {
+        assert(this->relevanceChecker && "relevanceChecker must not be null");
+    }
+
+    void SendReleaseRequestedChatAreaMessage::OnEvent(const DepartureReleaseRequestedEvent& event)
+    {
+        if (!this->relevanceChecker->IsRelevant(*event.releaseRequest)) {
+            LogDebug("Not sending release requested chat area message because it is not relevant");
+            return;
+        }
+
+        if (!userSettings.GetBooleanEntry(Euroscope::GeneralSettingsEntries::releaseChatAreaMessagesSettingsKey)) {
+            LogDebug("Not sending release requested chat area message because user does not want chat area messages");
+            return;
+        }
+
+        plugin.ChatAreaMessage(
+            "UKCP_COORDINATION",
+            "UKCP",
+            "Departure release requested for " + event.releaseRequest->Callsign() + ".",
+            true,
+            true,
+            true,
+            true,
+            true);
+    }
+} // namespace UKControllerPlugin::Releases
diff --git a/src/plugin/releases/SendReleaseRequestedChatAreaMessage.h b/src/plugin/releases/SendReleaseRequestedChatAreaMessage.h
new file mode 100644
index 00000000..42af3c00
--- /dev/null
+++ b/src/plugin/releases/SendReleaseRequestedChatAreaMessage.h
@@ -0,0 +1,35 @@
+#pragma once
+#include "eventhandler/EventHandler.h"
+
+namespace UKControllerPlugin::Euroscope {
+    class EuroscopePluginLoopbackInterface;
+    class UserSetting;
+} // namespace UKControllerPlugin::Euroscope
+
+namespace UKControllerPlugin::Releases {
+
+    class DepartureReleaseRelevanceChecker;
+    struct DepartureReleaseRequestedEvent;
+
+    class SendReleaseRequestedChatAreaMessage
+        : public UKControllerPluginUtils::EventHandler::EventHandler<DepartureReleaseRequestedEvent>
+    {
+        public:
+        SendReleaseRequestedChatAreaMessage(
+            std::shared_ptr<const DepartureReleaseRelevanceChecker> relevanceChecker,
+            Euroscope::EuroscopePluginLoopbackInterface& plugin,
+            Euroscope::UserSetting& userSettings);
+        void OnEvent(const DepartureReleaseRequestedEvent& event) override;
+
+        private:
+        // Checks prenote relevance
+        const std::shared_ptr<const DepartureReleaseRelevanceChecker> relevanceChecker;
+
+        // For sending messages
+        Euroscope::EuroscopePluginLoopbackInterface& plugin;
+
+        // For checking user settings
+        Euroscope::UserSetting& userSettings;
+    };
+
+} // namespace UKControllerPlugin::Releases
diff --git a/test/plugin/CMakeLists.txt b/test/plugin/CMakeLists.txt
index d68bdd3f..c213d263 100644
--- a/test/plugin/CMakeLists.txt
+++ b/test/plugin/CMakeLists.txt
@@ -508,7 +508,7 @@ set(test__releases
     "releases/EnrouteReleaseTypesSerializerTest.cpp"
     "releases/ReleaseModuleTest.cpp"
     releases/ReleaseApprovalRemarksUserMessageTest.cpp
-    releases/ReleaseRejectionRemarksUserMessageTest.cpp)
+    releases/ReleaseRejectionRemarksUserMessageTest.cpp releases/ReleaseIsTargetedAtUserTest.cpp releases/SendReleaseRequestedChatAreaMessageTest.cpp)
 source_group("test\\releases" FILES ${test__releases})
 
 set(test__runway
diff --git a/test/plugin/releases/DepartureReleaseEventHandlerTest.cpp b/test/plugin/releases/DepartureReleaseEventHandlerTest.cpp
index fd8f7991..dbb7bff3 100644
--- a/test/plugin/releases/DepartureReleaseEventHandlerTest.cpp
+++ b/test/plugin/releases/DepartureReleaseEventHandlerTest.cpp
@@ -8,10 +8,12 @@
 #include "releases/DepartureReleaseColours.h"
 #include "releases/DepartureReleaseEventHandler.h"
 #include "releases/DepartureReleaseRequest.h"
+#include "releases/DepartureReleaseRequestedEvent.h"
 #include "releases/DepartureReleaseRequestView.h"
 #include "time/ParseTimeStrings.h"
 #include "time/SystemClock.h"
 #include "tag/TagData.h"
+#include "test/EventBusTestCase.h"
 
 using testing::_;
 using testing::NiceMock;
@@ -30,7 +32,7 @@ using UKControllerPlugin::Time::TimeNow;
 
 namespace UKControllerPluginTest::Releases {
 
-    class DepartureReleaseEventHandlerTest : public Test
+    class DepartureReleaseEventHandlerTest : public UKControllerPluginUtilsTest::EventBusTestCase
     {
         public:
         DepartureReleaseEventHandlerTest()
@@ -778,6 +780,10 @@ namespace UKControllerPluginTest::Releases {
         EXPECT_EQ(2, release->RequestingController());
         EXPECT_EQ(3, release->TargetController());
         EXPECT_EQ(ParseTimeString("2021-05-12 19:55:00"), release->RequestExpiryTime());
+
+        AssertSingleEventDispatched();
+        AssertFirstEventDispatched<UKControllerPlugin::Releases::DepartureReleaseRequestedEvent>(
+            [release](const auto& event) { EXPECT_EQ(release, event.releaseRequest); });
     }
 
     TEST_F(DepartureReleaseEventHandlerTest, ItDoesntPlaySoundOnRequestIfUserNotActive)
diff --git a/test/plugin/releases/ReleaseIsTargetedAtUserTest.cpp b/test/plugin/releases/ReleaseIsTargetedAtUserTest.cpp
new file mode 100644
index 00000000..aefeb703
--- /dev/null
+++ b/test/plugin/releases/ReleaseIsTargetedAtUserTest.cpp
@@ -0,0 +1,54 @@
+#include "controller/ActiveCallsign.h"
+#include "controller/ActiveCallsignCollection.h"
+#include "controller/ControllerPosition.h"
+#include "releases/DepartureReleaseRequest.h"
+#include "releases/ReleaseIsTargetedAtUser.h"
+
+namespace UKControllerPluginTest::Releases {
+    class ReleaseIsTargetedAtUserTest : public ::testing::Test
+    {
+        protected:
+        ReleaseIsTargetedAtUserTest()
+            : position1(std::make_shared<UKControllerPlugin::Controller::ControllerPosition>(
+                  1, "EGGD_APP", 125.650, std::vector<std::string>{}, true, true)),
+              position2(std::make_shared<UKControllerPlugin::Controller::ControllerPosition>(
+                  2, "EGGD_TWR", 133.850, std::vector<std::string>{}, true, true)),
+              userCallsign("EGGD_APP", "EGGD_APP", *position1, true),
+              nonUserCallsign("EGGD_TWR", "EGGD_TWR", *position2, false),
+              callsignCollection(std::make_shared<UKControllerPlugin::Controller::ActiveCallsignCollection>()),
+              releaseIsTargetedAtUser(callsignCollection)
+        {
+            callsignCollection->AddCallsign(nonUserCallsign);
+        }
+
+        std::shared_ptr<UKControllerPlugin::Controller::ControllerPosition> position1;
+        std::shared_ptr<UKControllerPlugin::Controller::ControllerPosition> position2;
+        UKControllerPlugin::Controller::ActiveCallsign userCallsign;
+        UKControllerPlugin::Controller::ActiveCallsign nonUserCallsign;
+        std::shared_ptr<UKControllerPlugin::Controller::ActiveCallsignCollection> callsignCollection;
+        UKControllerPlugin::Releases::ReleaseIsTargetedAtUser releaseIsTargetedAtUser;
+    };
+
+    TEST_F(ReleaseIsTargetedAtUserTest, IsRelevantReturnsTrueWhenCallsignIsUser)
+    {
+        callsignCollection->AddUserCallsign(userCallsign);
+        UKControllerPlugin::Releases::DepartureReleaseRequest releaseRequest(
+            1, "BAW555", 99, 1, std::chrono::system_clock::now());
+        EXPECT_TRUE(releaseIsTargetedAtUser.IsRelevant(releaseRequest));
+    }
+
+    TEST_F(ReleaseIsTargetedAtUserTest, IsRelevantReturnsFalseWhenCallsignIsNotUser)
+    {
+        callsignCollection->AddUserCallsign(userCallsign);
+        UKControllerPlugin::Releases::DepartureReleaseRequest releaseRequest(
+            1, "BAW555", 99, 2, std::chrono::system_clock::now());
+        EXPECT_FALSE(releaseIsTargetedAtUser.IsRelevant(releaseRequest));
+    }
+
+    TEST_F(ReleaseIsTargetedAtUserTest, IsRelevantReturnsFalseWhenUserCallsignIsNotInCollection)
+    {
+        UKControllerPlugin::Releases::DepartureReleaseRequest releaseRequest(
+            1, "BAW555", 99, 1, std::chrono::system_clock::now());
+        EXPECT_FALSE(releaseIsTargetedAtUser.IsRelevant(releaseRequest));
+    }
+} // namespace UKControllerPluginTest::Releases
diff --git a/test/plugin/releases/ReleaseModuleTest.cpp b/test/plugin/releases/ReleaseModuleTest.cpp
index e29812ab..44510155 100644
--- a/test/plugin/releases/ReleaseModuleTest.cpp
+++ b/test/plugin/releases/ReleaseModuleTest.cpp
@@ -1,5 +1,10 @@
+#include "controller/ActiveCallsignCollection.h"
 #include "releases/ReleaseModule.h"
 #include "bootstrap/PersistenceContainer.h"
+#include "releases/DepartureReleaseRequestedEvent.h"
+#include "releases/DepartureReleaseRequestedEvent.h"
+#include "releases/SendReleaseRequestedChatAreaMessage.h"
+#include "test/EventBusTestCase.h"
 #include "push/PushEventProcessorCollection.h"
 #include "tag/TagItemCollection.h"
 #include "timedevent/TimedEventCollection.h"
@@ -28,7 +33,7 @@ using UKControllerPluginTest::Euroscope::MockEuroscopePluginLoopbackInterface;
 namespace UKControllerPluginTest {
     namespace Releases {
 
-        class ReleaseModuleTest : public Test
+        class ReleaseModuleTest : public UKControllerPluginUtilsTest::EventBusTestCase
         {
             public:
             ReleaseModuleTest()
@@ -39,6 +44,8 @@ namespace UKControllerPluginTest {
                 container.pluginFunctionHandlers.reset(new FunctionCallEventHandler);
                 container.controllerHandoffHandlers.reset(new HandoffEventHandlerCollection);
                 container.dialogManager.reset(new DialogManager(this->dialogProvider));
+                container.activeCallsigns =
+                    std::make_shared<UKControllerPlugin::Controller::ActiveCallsignCollection>();
 
                 nlohmann::json dependency = nlohmann::json::array();
                 dependency.push_back({{"id", 1}, {"tag_string", "RFC"}, {"description", "Released For Climb"}});
@@ -178,5 +185,16 @@ namespace UKControllerPluginTest {
             BootstrapPlugin(this->container, this->plugin, this->dependencyLoader);
             EXPECT_EQ(1, this->container.tagHandler->HasHandlerForItemId(126));
         }
+
+        TEST_F(ReleaseModuleTest, ItRegistersReleaseRequestedChatAreaHandler)
+        {
+            BootstrapPlugin(this->container, this->plugin, this->dependencyLoader);
+            AssertSingleEventHandlerRegistrationForEvent<
+                UKControllerPlugin::Releases::DepartureReleaseRequestedEvent>();
+            AssertHandlerRegisteredForEvent<
+                UKControllerPlugin::Releases::SendReleaseRequestedChatAreaMessage,
+                UKControllerPlugin::Releases::DepartureReleaseRequestedEvent>(
+                UKControllerPluginUtils::EventHandler::EventHandlerFlags::Sync);
+        }
     } // namespace Releases
 } // namespace UKControllerPluginTest
diff --git a/test/plugin/releases/SendReleaseRequestedChatAreaMessageTest.cpp b/test/plugin/releases/SendReleaseRequestedChatAreaMessageTest.cpp
new file mode 100644
index 00000000..29794897
--- /dev/null
+++ b/test/plugin/releases/SendReleaseRequestedChatAreaMessageTest.cpp
@@ -0,0 +1,88 @@
+#include "mock/MockEuroscopePluginLoopbackInterface.h"
+#include "mock/MockPluginSettingsProvider.h"
+#include "mock/MockUserSettingProviderInterface.h"
+#include "releases/DepartureReleaseRequestedEvent.h"
+#include "releases/DepartureReleaseRequest.h"
+#include "releases/DepartureReleaseRelevanceChecker.h"
+#include "releases/SendReleaseRequestedChatAreaMessage.h"
+#include "euroscope/UserSetting.h"
+
+namespace UKControllerPluginTest::Releases {
+
+    class MockUserRelevanceChecker : public UKControllerPlugin::Releases::DepartureReleaseRelevanceChecker
+    {
+        public:
+        MOCK_METHOD(
+            bool, IsRelevant, (const UKControllerPlugin::Releases::DepartureReleaseRequest&), (const, override));
+    };
+
+    class SendReleaseRequestedChatAreaMessageTest : public ::testing::Test
+    {
+        public:
+        SendReleaseRequestedChatAreaMessageTest()
+            : releaseRequest(std::make_shared<UKControllerPlugin::Releases::DepartureReleaseRequest>(
+                  1, "BAW555", 99, 1, std::chrono::system_clock::now())),
+              userSettings(userSettingProvider), sendMessage(relevanceChecker, plugin, userSettings)
+        {
+        }
+
+        std::shared_ptr<UKControllerPlugin::Releases::DepartureReleaseRequest> releaseRequest;
+        testing::NiceMock<Euroscope::MockEuroscopePluginLoopbackInterface> plugin;
+        testing::NiceMock<Euroscope::MockUserSettingProviderInterface> userSettingProvider;
+        std::shared_ptr<testing::NiceMock<MockUserRelevanceChecker>> relevanceChecker =
+            std::make_shared<testing::NiceMock<MockUserRelevanceChecker>>();
+        UKControllerPlugin::Euroscope::UserSetting userSettings;
+        UKControllerPlugin::Releases::SendReleaseRequestedChatAreaMessage sendMessage;
+    };
+
+    TEST_F(SendReleaseRequestedChatAreaMessageTest, DoesNotSendMessageIfNotRelevant)
+    {
+        UKControllerPlugin::Releases::DepartureReleaseRequestedEvent event{releaseRequest};
+
+        ON_CALL(userSettingProvider, KeyExists("sendReleasesToChat")).WillByDefault(testing::Return(true));
+        ON_CALL(userSettingProvider, GetKey("sendReleasesToChat")).WillByDefault(testing::Return("1"));
+        EXPECT_CALL(*relevanceChecker, IsRelevant(testing::Ref(*releaseRequest))).WillOnce(testing::Return(false));
+        EXPECT_CALL(plugin, ChatAreaMessage).Times(0);
+
+        sendMessage.OnEvent(event);
+    }
+
+    TEST_F(SendReleaseRequestedChatAreaMessageTest, DoesNotSendMessageIfSettingNotEnabled)
+    {
+        UKControllerPlugin::Releases::DepartureReleaseRequestedEvent event{releaseRequest};
+
+        ON_CALL(userSettingProvider, KeyExists("sendReleasesToChat")).WillByDefault(testing::Return(false));
+        EXPECT_CALL(*relevanceChecker, IsRelevant(testing::Ref(*releaseRequest))).WillOnce(testing::Return(true));
+        EXPECT_CALL(plugin, ChatAreaMessage).Times(0);
+
+        sendMessage.OnEvent(event);
+    }
+
+    TEST_F(SendReleaseRequestedChatAreaMessageTest, DoesNotSendMessageIfSettingDisabled)
+    {
+        UKControllerPlugin::Releases::DepartureReleaseRequestedEvent event{releaseRequest};
+
+        ON_CALL(userSettingProvider, KeyExists("sendReleasesToChat")).WillByDefault(testing::Return(true));
+        ON_CALL(userSettingProvider, GetKey("sendReleasesToChat")).WillByDefault(testing::Return("0"));
+        EXPECT_CALL(*relevanceChecker, IsRelevant(testing::Ref(*releaseRequest))).WillOnce(testing::Return(true));
+        EXPECT_CALL(plugin, ChatAreaMessage).Times(0);
+
+        sendMessage.OnEvent(event);
+    }
+
+    TEST_F(SendReleaseRequestedChatAreaMessageTest, SendsMessageIfRelevantAndSettingEnabled)
+    {
+        UKControllerPlugin::Releases::DepartureReleaseRequestedEvent event{releaseRequest};
+
+        ON_CALL(userSettingProvider, KeyExists("sendReleasesToChat")).WillByDefault(testing::Return(true));
+        ON_CALL(userSettingProvider, GetKey("sendReleasesToChat")).WillByDefault(testing::Return("1"));
+        EXPECT_CALL(*relevanceChecker, IsRelevant(testing::Ref(*releaseRequest))).WillOnce(testing::Return(true));
+        EXPECT_CALL(
+            plugin,
+            ChatAreaMessage(
+                "UKCP_COORDINATION", "UKCP", "Departure release requested for BAW555.", true, true, true, true, true))
+            .Times(1);
+
+        sendMessage.OnEvent(event);
+    }
+} // namespace UKControllerPluginTest::Releases