diff --git a/EventsHandler/Api/EventsHandler/Behaviors/Mapping/Models/POCOs/NotifyNL/DeliveryReceipt.cs b/EventsHandler/Api/EventsHandler/Behaviors/Mapping/Models/POCOs/NotifyNL/DeliveryReceipt.cs
index 5da8b228..5ad3ba1c 100644
--- a/EventsHandler/Api/EventsHandler/Behaviors/Mapping/Models/POCOs/NotifyNL/DeliveryReceipt.cs
+++ b/EventsHandler/Api/EventsHandler/Behaviors/Mapping/Models/POCOs/NotifyNL/DeliveryReceipt.cs
@@ -21,6 +21,8 @@ namespace EventsHandler.Behaviors.Mapping.Models.POCOs.NotifyNL
     /// </summary>
     internal struct DeliveryReceipt : IJsonSerializable
     {
+        internal static DeliveryReceipt Default { get; } = new();
+
         /// <summary>
         /// Notify’s id for the status receipts.
         /// </summary>
diff --git a/EventsHandler/Api/EventsHandler/Configuration/WebApiConfiguration.cs b/EventsHandler/Api/EventsHandler/Configuration/WebApiConfiguration.cs
index 35fe6391..d8e961dd 100644
--- a/EventsHandler/Api/EventsHandler/Configuration/WebApiConfiguration.cs
+++ b/EventsHandler/Api/EventsHandler/Configuration/WebApiConfiguration.cs
@@ -3,7 +3,6 @@
 using EventsHandler.Extensions;
 using EventsHandler.Services.DataLoading.Interfaces;
 using EventsHandler.Services.DataLoading.Strategy.Interfaces;
-using System.Collections.Concurrent;
 
 namespace EventsHandler.Configuration
 {
@@ -39,25 +38,6 @@ public WebApiConfiguration(ILoadersContext loaderContext)  // NOTE: The only con
         /// </summary>
         internal abstract record BaseComponent
         {
-            /// <summary>
-            /// A thread-safe dictionary, storing cached configuration <see langword="string"/> values.
-            /// <para>
-            ///   The reasons to use such solution are:
-            ///   <para>
-            ///     - Some values are validated during retrieval time, whether they have correct format or range.
-            ///     After being loaded for the first time and then validated, there is no reason to check them again.
-            ///   </para>
-            ///   <para>
-            ///     - The methods used to map specific configurations (like in fluent builder design pattern) is very handy
-            ///     in terms of OOP approach, but might introduce some minimal overhead. Thanks to caching values by their
-            ///     configuration nodes, both - flexibility and convenience as well as better performance can be achieved.
-            ///   </para>
-            /// </para>
-            /// </summary>
-            private protected static readonly ConcurrentDictionary<
-                string /* Config path */,
-                string /* Config value */> s_cachedValues = new();
-
             /// <inheritdoc cref="AuthorizationComponent"/>
             internal AuthorizationComponent Authorization { get; }
 
@@ -106,27 +86,27 @@ internal JwtComponent(ILoadersContext loadersContext, string parentPath)
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string Secret()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(Secret));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(Secret));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string Issuer()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(Issuer));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(Issuer));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string Audience()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(Audience));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(Audience));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal ushort ExpiresInMin()
-                        => GetCachedValue<ushort>(this._loadersContext, this._currentPath, nameof(ExpiresInMin));
+                        => GetValue<ushort>(this._loadersContext, this._currentPath, nameof(ExpiresInMin));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string UserId()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(UserId));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(UserId));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string UserName()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(UserName));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(UserName));
                 }
             }
         }
@@ -167,7 +147,7 @@ internal ApiComponent(ILoadersContext loadersContext, string parentPath)
 
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string BaseUrl()
-                    => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(BaseUrl));
+                    => GetValue(this._loadersContext, this._currentPath, nameof(BaseUrl));
             }
         }
 
@@ -233,11 +213,11 @@ internal KeyComponent(ILoadersContext loadersContext, string parentPath)
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string NotifyNL()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(NotifyNL));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(NotifyNL));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string Objecten()
-                        => GetCachedValue(this._loadersContext, s_cachedValues, this._currentPath, nameof(Objecten));
+                        => GetValue(this._loadersContext, this._currentPath, nameof(Objecten));
                 }
             }
 
@@ -246,10 +226,6 @@ internal string Objecten()
             /// </summary>
             internal sealed record DomainComponent
             {
-                private static readonly ConcurrentDictionary<
-                    string /* Config path */,
-                    string /* Config value */> s_cachedDomainValues = new();
-                
                 private readonly ILoadersContext _loadersContext;
                 private readonly string _currentPath;
 
@@ -264,23 +240,23 @@ internal DomainComponent(ILoadersContext loadersContext, string parentPath)
 
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string OpenNotificaties()
-                    => GetCachedDomainValue(this._loadersContext, s_cachedDomainValues, this._currentPath, nameof(OpenNotificaties));
+                    => GetDomainValue(this._loadersContext, this._currentPath, nameof(OpenNotificaties));
                 
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string OpenZaak()
-                    => GetCachedDomainValue(this._loadersContext, s_cachedDomainValues, this._currentPath, nameof(OpenZaak));
+                    => GetDomainValue(this._loadersContext, this._currentPath, nameof(OpenZaak));
                     
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string OpenKlant()
-                    => GetCachedDomainValue(this._loadersContext, s_cachedDomainValues, this._currentPath, nameof(OpenKlant));
+                    => GetDomainValue(this._loadersContext, this._currentPath, nameof(OpenKlant));
 
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string Objecten()
-                    => GetCachedDomainValue(this._loadersContext, s_cachedDomainValues, this._currentPath, nameof(Objecten));
+                    => GetDomainValue(this._loadersContext, this._currentPath, nameof(Objecten));
 
                 /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                 internal string ObjectTypen()
-                    => GetCachedDomainValue(this._loadersContext, s_cachedDomainValues, this._currentPath, nameof(ObjectTypen));
+                    => GetDomainValue(this._loadersContext, this._currentPath, nameof(ObjectTypen));
             }
 
             /// <summary>
@@ -310,10 +286,6 @@ internal TemplateIdsComponent(ILoadersContext loadersContext, string parentPath)
                 /// </summary>
                 internal sealed record SmsComponent
                 {
-                    private static readonly ConcurrentDictionary<
-                        string /* Config path */,
-                        string /* Config value */> s_cachedSmsTemplateValues = new();
-                    
                     private readonly ILoadersContext _loadersContext;
                     private readonly string _currentPath;
 
@@ -328,15 +300,15 @@ internal SmsComponent(ILoadersContext loadersContext, string parentPath)
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakCreate()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedSmsTemplateValues, this._currentPath, nameof(ZaakCreate));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakCreate));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakUpdate()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedSmsTemplateValues, this._currentPath, nameof(ZaakUpdate));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakUpdate));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakClose()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedSmsTemplateValues, this._currentPath, nameof(ZaakClose));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakClose));
                 }
 
                 /// <summary>
@@ -344,10 +316,6 @@ internal string ZaakClose()
                 /// </summary>
                 internal sealed record EmailComponent
                 {
-                    private static readonly ConcurrentDictionary<
-                        string /* Config path */,
-                        string /* Config value */> s_cachedEmailTemplateValues = new();
-
                     private readonly ILoadersContext _loadersContext;
                     private readonly string _currentPath;
 
@@ -362,15 +330,15 @@ internal EmailComponent(ILoadersContext loadersContext, string parentPath)
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakCreate()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedEmailTemplateValues, this._currentPath, nameof(ZaakCreate));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakCreate));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakUpdate()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedEmailTemplateValues, this._currentPath, nameof(ZaakUpdate));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakUpdate));
 
                     /// <inheritdoc cref="ILoadingService.GetData{TData}(string)"/>
                     internal string ZaakClose()
-                        => GetCachedTemplateIdValue(this._loadersContext, s_cachedEmailTemplateValues, this._currentPath, nameof(ZaakClose));
+                        => GetTemplateIdValue(this._loadersContext, this._currentPath, nameof(ZaakClose));
                 }
             }
         }
@@ -379,26 +347,17 @@ internal string ZaakClose()
         /// <summary>
         /// Retrieves cached configuration value.
         /// </summary>
-        private static string GetCachedValue(
-            ILoadingService loadersContext,
-            ConcurrentDictionary<string, string> cachedValues,
-            string currentPath,
-            string nodeName)
+        private static string GetValue(ILoadingService loadersContext, string currentPath, string nodeName)
         {
             string finalPath = loadersContext.GetPathWithNode(currentPath, nodeName);
 
-            return cachedValues.GetOrAdd(
-                nodeName,
-                loadersContext.GetData<string>(finalPath));
+            return loadersContext.GetData<string>(finalPath);
         }
 
         /// <summary>
         /// Retrieves cached configuration value.
         /// </summary>
-        private static TData GetCachedValue<TData>(
-            ILoadingService loadersContext,
-            string currentPath,
-            string nodeName)
+        private static TData GetValue<TData>(ILoadingService loadersContext, string currentPath, string nodeName)
         {
             string finalPath = loadersContext.GetPathWithNode(currentPath, nodeName);
 
@@ -408,34 +367,22 @@ private static TData GetCachedValue<TData>(
         /// <summary>
         /// Retrieves cached configuration value, ensuring it will be a domain (without http/s and API endpoint).
         /// </summary>
-        private static string GetCachedDomainValue(
-            ILoadingService loadersContext,
-            ConcurrentDictionary<string, string> cachedValues,
-            string currentPath,
-            string nodeName)
+        private static string GetDomainValue(ILoadingService loadersContext, string currentPath, string nodeName)
         {
-            return cachedValues.GetOrAdd(
-                nodeName,
-                GetCachedValue(loadersContext, cachedValues, currentPath, nodeName)
+            return GetValue<string>(loadersContext, currentPath, nodeName)
                 // NOTE: Validate only once when the value is cached
                 .WithoutHttp()
-                .WithoutEndpoint());
+                .WithoutEndpoint();
         }
 
         /// <summary>
         /// Retrieves cached configuration value, ensuring it will be a valid Template Id.
         /// </summary>
-        private static string GetCachedTemplateIdValue(
-            ILoadingService loadersContext,
-            ConcurrentDictionary<string, string> cachedValues,
-            string currentPath,
-            string nodeName)
+        private static string GetTemplateIdValue(ILoadingService loadersContext, string currentPath, string nodeName)
         {
-            return cachedValues.GetOrAdd(
-                nodeName,
-                GetCachedValue(loadersContext, cachedValues, currentPath, nodeName)
+            return GetValue<string>(loadersContext, currentPath, nodeName)
                 // NOTE: Validate only once when the value is cached
-                .ValidTemplateId());
+                .ValidTemplateId();
         }
         #endregion
     }
diff --git a/EventsHandler/Api/EventsHandler/Controllers/EventsController.cs b/EventsHandler/Api/EventsHandler/Controllers/EventsController.cs
index bd247389..720cf968 100644
--- a/EventsHandler/Api/EventsHandler/Controllers/EventsController.cs
+++ b/EventsHandler/Api/EventsHandler/Controllers/EventsController.cs
@@ -43,7 +43,7 @@ public sealed class EventsController : OmcController
         /// <param name="validator">The input validating service.</param>
         /// <param name="processor">The input processing service (business logic).</param>
         /// <param name="responder">The output standardization service (UX/UI).</param>
-        /// <param name="logger">The logging service.</param>
+        /// <param name="logger">The logging service registering API events.</param>
         public EventsController(
             ISerializationService serializer,
             IValidationService<NotificationEvent> validator,
diff --git a/EventsHandler/Api/EventsHandler/Controllers/NotifyController.cs b/EventsHandler/Api/EventsHandler/Controllers/NotifyController.cs
index b72a7bd7..05a7c740 100644
--- a/EventsHandler/Api/EventsHandler/Controllers/NotifyController.cs
+++ b/EventsHandler/Api/EventsHandler/Controllers/NotifyController.cs
@@ -9,6 +9,7 @@
 using EventsHandler.Constants;
 using EventsHandler.Controllers.Base;
 using EventsHandler.Services.Serialization.Interfaces;
+using EventsHandler.Services.Telemetry.Interfaces;
 using EventsHandler.Services.UserCommunication.Interfaces;
 using EventsHandler.Utilities.Swagger.Examples;
 using Microsoft.AspNetCore.Mvc;
@@ -30,21 +31,25 @@ public sealed class NotifyController : OmcController
     {
         private readonly ISerializationService _serializer;
         private readonly IRespondingService<ProcessingResult, string> _responder;
-
+        private readonly ITelemetryService _telemetry;
+        
         /// <summary>
         /// Initializes a new instance of the <see cref="EventsController"/> class.
         /// </summary>
         /// <param name="serializer">The input de(serializing) service.</param>
         /// <param name="responder">The output standardization service (UX/UI).</param>
-        /// <param name="logger">The logging service.</param>
+        /// <param name="telemetry">The telemetry service registering API events.</param>
+        /// <param name="logger">The logging service registering API events.</param>
         public NotifyController(
             ISerializationService serializer,
             IRespondingService<ProcessingResult, string> responder,
+            ITelemetryService telemetry,
             ILogger<NotifyController> logger)
             : base(logger)
         {
             this._serializer = serializer;
             this._responder = responder;
+            this._telemetry = telemetry;
         }
 
         /// <summary>
@@ -60,34 +65,49 @@ public NotifyController(
         [ProducesResponseType(StatusCodes.Status400BadRequest,   Type = typeof(ProcessingFailed.Detailed))]  // REASON: The delivery receipt with failure status
         [ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(string))]                     // REASON: JWT Token is invalid or expired
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]                                     // REASON: Internal server error (if-else / try-catch-finally handle)
-        public IActionResult Confirm([Required, FromBody] object json)
+        public async Task<IActionResult> ConfirmAsync([Required, FromBody] object json)
         {
+            DeliveryReceipt callback = DeliveryReceipt.Default;
+            string callbackDetails = string.Empty;
+
             try
             {
                 // Deserialize received JSON payload
-                DeliveryReceipt callback = this._serializer.Deserialize<DeliveryReceipt>(json);
+                callback = this._serializer.Deserialize<DeliveryReceipt>(json);
 
                 if (callback.Status is not (DeliveryStatus.PermanentFailure or
                                             DeliveryStatus.TemporaryFailure or
                                             DeliveryStatus.TechnicalFailure))
                 {
                     return LogAndReturnApiResponse(LogLevel.Information,
-                        this._responder.GetStandardized_Processing_ActionResult(ProcessingResult.Success, GetCallbackDetails(callback)));
+                        this._responder.GetStandardized_Processing_ActionResult(ProcessingResult.Success, callbackDetails = GetCallbackDetails(callback)));
                 }
 
                 return LogAndReturnApiResponse(LogLevel.Error,
-                    this._responder.GetStandardized_Processing_ActionResult(ProcessingResult.Failure, GetCallbackDetails(callback)));
+                    this._responder.GetStandardized_Processing_ActionResult(ProcessingResult.Failure, callbackDetails = GetCallbackDetails(callback)));
             }
             catch (Exception exception)
             {
+                // NOTE: If callback.Id == Guid.Empty then to be suspected is exception during DeliveryReceipt deserialization
+                callbackDetails = GetErrorDetails(callback, exception);
+
                 return LogAndReturnApiResponse(LogLevel.Critical,
                     this._responder.GetStandardized_Exception_ActionResult(exception));
             }
+            finally
+            {
+                _ = await this._telemetry.ReportCompletionAsync(default, default, callbackDetails);
+            }
         }
 
         private static string GetCallbackDetails(DeliveryReceipt callback)
         {
             return $"The status of notification with ID {callback.Id} is: {callback.Status}.";
         }
+
+        private static string GetErrorDetails(DeliveryReceipt callback, Exception exception)
+        {
+            return $"An unexpected error occurred during processing the notification with ID {callback.Id}: {exception.Message}.";
+        }
     }
 }
\ No newline at end of file
diff --git a/EventsHandler/Api/EventsHandler/Program.cs b/EventsHandler/Api/EventsHandler/Program.cs
index e34c6ad7..c17cac2f 100644
--- a/EventsHandler/Api/EventsHandler/Program.cs
+++ b/EventsHandler/Api/EventsHandler/Program.cs
@@ -202,7 +202,7 @@ private static WebApplicationBuilder AddCustomServices(this WebApplicationBuilde
             builder.Services.RegisterClientFactories();
             builder.Services.AddSingleton<ITemplatesService<TemplateResponse, NotificationEvent>, NotifyTemplatesAnalyzer>();
             builder.Services.AddSingleton<ISendingService<NotificationEvent, NotifyData>, NotifySender>();
-            builder.Services.AddSingleton<IFeedbackService, ContactRegistration>();
+            builder.Services.AddSingleton<ITelemetryService, ContactRegistration>();
             builder.Services.RegisterResponders();
 
             return builder;
diff --git a/EventsHandler/Api/EventsHandler/Properties/Resources.Designer.cs b/EventsHandler/Api/EventsHandler/Properties/Resources.Designer.cs
index 9e3fb01d..5886b2f8 100644
--- a/EventsHandler/Api/EventsHandler/Properties/Resources.Designer.cs
+++ b/EventsHandler/Api/EventsHandler/Properties/Resources.Designer.cs
@@ -555,6 +555,15 @@ internal static string Processing_SUCCESS_Scenario_NotificationSent {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to The notification was passed to NotifyNL API..
+        /// </summary>
+        internal static string Register_NotifyNL_SUCCESS_NotificationSent {
+            get {
+                return ResourceManager.GetString("Register_NotifyNL_SUCCESS_NotificationSent", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Insert received JWT token here.
         /// </summary>
diff --git a/EventsHandler/Api/EventsHandler/Properties/Resources.resx b/EventsHandler/Api/EventsHandler/Properties/Resources.resx
index d0f790f0..49d784a3 100644
--- a/EventsHandler/Api/EventsHandler/Properties/Resources.resx
+++ b/EventsHandler/Api/EventsHandler/Properties/Resources.resx
@@ -314,4 +314,7 @@
     <value>was successfully send to NotifyNL.</value>
     <comment>API Endpoint: TestController/Notify/</comment>
   </data>
+  <data name="Register_NotifyNL_SUCCESS_NotificationSent" xml:space="preserve">
+    <value>The notification was passed to NotifyNL API.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/EventsHandler/Api/EventsHandler/Services/DataSending/NotifySender.cs b/EventsHandler/Api/EventsHandler/Services/DataSending/NotifySender.cs
index 951af203..12e0d3f6 100644
--- a/EventsHandler/Api/EventsHandler/Services/DataSending/NotifySender.cs
+++ b/EventsHandler/Api/EventsHandler/Services/DataSending/NotifySender.cs
@@ -3,6 +3,7 @@
 using EventsHandler.Behaviors.Communication.Strategy.Models.DTOs;
 using EventsHandler.Behaviors.Mapping.Models.POCOs.NotificatieApi;
 using EventsHandler.Extensions;
+using EventsHandler.Properties;
 using EventsHandler.Services.DataReceiving.Factories.Interfaces;
 using EventsHandler.Services.DataSending.Clients.Interfaces;
 using EventsHandler.Services.DataSending.Interfaces;
@@ -20,14 +21,14 @@ internal sealed class NotifySender : ISendingService<NotificationEvent, NotifyDa
         #endregion
 
         private readonly IHttpClientFactory<INotifyClient, string> _clientFactory;
-        private readonly IFeedbackService _telemetry;
+        private readonly ITelemetryService _telemetry;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="NotifySender"/> class.
         /// </summary>
         public NotifySender(
             IHttpClientFactory<INotifyClient, string> clientFactory,
-            IFeedbackService telemetry)
+            ITelemetryService telemetry)
         {
             this._clientFactory = clientFactory;
             this._telemetry = telemetry;
@@ -39,8 +40,9 @@ async Task ISendingService<NotificationEvent, NotifyData>.SendSmsAsync(Notificat
             _ = await ResolveNotifyClient(notification).SendSmsAsync(mobileNumber:    package.ContactDetails,
                                                                      templateId:      package.TemplateId,
                                                                      personalisation: package.Personalization);
-            // TODO: Extract some data from Notify NL here
-            _ = await this._telemetry.ReportCompletionAsync(notification, package.NotificationMethod);
+
+            _ = await this._telemetry.ReportCompletionAsync(notification, package.NotificationMethod,
+                $"SMS: {Resources.Register_NotifyNL_SUCCESS_NotificationSent}");
         }
 
         /// <inheritdoc cref="ISendingService{TModel, TPackage}.SendEmailAsync(TModel, TPackage)"/>
@@ -49,8 +51,9 @@ async Task ISendingService<NotificationEvent, NotifyData>.SendEmailAsync(Notific
             _ = await ResolveNotifyClient(notification).SendEmailAsync(emailAddress:    package.ContactDetails,
                                                                        templateId:      package.TemplateId,
                                                                        personalisation: package.Personalization);
-            // TODO: Extract some data from Notify NL here
-            _ = await this._telemetry.ReportCompletionAsync(notification, package.NotificationMethod);
+
+            _ = await this._telemetry.ReportCompletionAsync(notification, package.NotificationMethod,
+                $"Email: {Resources.Register_NotifyNL_SUCCESS_NotificationSent}");
         }
 
         #region IDisposable
diff --git a/EventsHandler/Api/EventsHandler/Services/Telemetry/ContactRegistration.cs b/EventsHandler/Api/EventsHandler/Services/Telemetry/ContactRegistration.cs
index 48b9f842..6642c5aa 100644
--- a/EventsHandler/Api/EventsHandler/Services/Telemetry/ContactRegistration.cs
+++ b/EventsHandler/Api/EventsHandler/Services/Telemetry/ContactRegistration.cs
@@ -17,13 +17,13 @@
 namespace EventsHandler.Services.Telemetry
 {
     /// <summary>
-    /// <inheritdoc cref="IFeedbackService" />
+    /// <inheritdoc cref="ITelemetryService" />
     /// <para>
     ///   Informs external "Contactmomenten" API web service about completion of sending notifications to "NotifyNL" API web service.
     /// </para>
     /// </summary>
-    /// <seealso cref="IFeedbackService" />
-    internal sealed class ContactRegistration : IFeedbackService
+    /// <seealso cref="ITelemetryService" />
+    internal sealed class ContactRegistration : ITelemetryService
     {
         private readonly IDataQueryService<NotificationEvent> _dataQuery;
 
@@ -35,20 +35,20 @@ public ContactRegistration(IDataQueryService<NotificationEvent> dataQuery)
             this._dataQuery = dataQuery;
         }
 
-        /// <inheritdoc cref="IFeedbackService.ReportCompletionAsync(NotificationEvent, NotifyMethods)"/>
-        async Task<string> IFeedbackService.ReportCompletionAsync(NotificationEvent notification, NotifyMethods notificationMethod)
+        /// <inheritdoc cref="ITelemetryService.ReportCompletionAsync(NotificationEvent, NotifyMethods, string)"/>
+        async Task<string> ITelemetryService.ReportCompletionAsync(NotificationEvent notification, NotifyMethods notificationMethod, string message)
         {
             // NOTE: Feedback from "OpenKlant" will be passed to "OpenZaak"
             return await SendFeedbackToOpenZaakAsync(
                 notification,
-                await SendFeedbackToOpenKlantAsync(notification, notificationMethod));
+                await SendFeedbackToOpenKlantAsync(notification, notificationMethod, message));
         }
 
         #region Helper methods
         /// <summary>
         /// Sends the completion feedback to "OpenKlant" Web service.
         /// </summary>
-        private async Task<ContactMoment> SendFeedbackToOpenKlantAsync(NotificationEvent notification, NotifyMethods notificationMethod)
+        private async Task<ContactMoment> SendFeedbackToOpenKlantAsync(NotificationEvent notification, NotifyMethods notificationMethod, string message)
         {
             // Prepare the body
             CaseStatus caseStatus = (await this._dataQuery.From(notification).GetCaseStatusesAsync()).LastStatus();  // TODO: Regarding performance, think whether we can store such data in a kind of register
@@ -58,7 +58,7 @@ private async Task<ContactMoment> SendFeedbackToOpenKlantAsync(NotificationEvent
                 { "bronorganisatie", notification.GetOrganizationId() },
                 { "registratiedatum", caseStatus.Created },
                 { "kanaal", $"{notificationMethod}" },
-                { "tekst", string.Empty },  // TODO: To be filled
+                { "tekst", message },
                 { "initiatief", "gemeente" }
             });
             HttpContent body = new StringContent(serialized, Encoding.UTF8, DefaultValues.Request.ContentType);
diff --git a/EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/IFeedbackService.cs b/EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/ITelemetryService.cs
similarity index 83%
rename from EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/IFeedbackService.cs
rename to EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/ITelemetryService.cs
index ba78c5ba..07868533 100644
--- a/EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/IFeedbackService.cs
+++ b/EventsHandler/Api/EventsHandler/Services/Telemetry/Interfaces/ITelemetryService.cs
@@ -9,17 +9,18 @@ namespace EventsHandler.Services.Telemetry.Interfaces
     /// <summary>
     /// The service to collect and send feedback about the current business activities to the dedicated external API endpoint.
     /// </summary>
-    public interface IFeedbackService
+    public interface ITelemetryService
     {
         /// <summary>
         /// Reports to external API service that notification of type <see cref="NotifyMethods"/> was sent to "Notify NL" service.
         /// </summary>
         /// <param name="notification">The notification from "Notificatie API" Web service.</param>
         /// <param name="notificationMethod">The notification method.</param>
+        /// <param name="message">The message to be passed along with the completion report.</param>
         /// <returns>
         ///   The callback URL prepared in response by "OpenKlant" web service.
         /// </returns>
         /// <exception cref="TelemetryException">The completion status could not be sent.</exception>
-        internal Task<string> ReportCompletionAsync(NotificationEvent notification, NotifyMethods notificationMethod);
+        internal Task<string> ReportCompletionAsync(NotificationEvent notification, NotifyMethods notificationMethod, string message);
     }
 }
\ No newline at end of file
diff --git a/EventsHandler/Tests/IntegrationTests/EventsHandler.IntegrationTests/Services/DataSending/NotifySenderTests.cs b/EventsHandler/Tests/IntegrationTests/EventsHandler.IntegrationTests/Services/DataSending/NotifySenderTests.cs
index c8aefe09..4aef37d5 100644
--- a/EventsHandler/Tests/IntegrationTests/EventsHandler.IntegrationTests/Services/DataSending/NotifySenderTests.cs
+++ b/EventsHandler/Tests/IntegrationTests/EventsHandler.IntegrationTests/Services/DataSending/NotifySenderTests.cs
@@ -91,7 +91,7 @@ public async Task SendEmailAsync_Calls_NotificationClientMethod_SendEmailAsync()
         public async Task SendSmsAsync_Calls_IFeedbackServiceMethod_ReportCompletionAsync()
         {
             // Arrange
-            Mock<IFeedbackService> mockedTelemetry = GetMockedTelemetry();
+            Mock<ITelemetryService> mockedTelemetry = GetMockedTelemetry();
             this._testNotifySender = GetTestSendingService(mockedTelemetry: mockedTelemetry);
             NotificationEvent testNotification = GetTestNotification();
 
@@ -102,14 +102,15 @@ public async Task SendSmsAsync_Calls_IFeedbackServiceMethod_ReportCompletionAsyn
             mockedTelemetry.Verify(mock =>
                 mock.ReportCompletionAsync(
                     It.IsAny<NotificationEvent>(),
-                    It.IsAny<NotifyMethods>()), Times.Once);
+                    It.IsAny<NotifyMethods>(),
+                    It.IsAny<string>()), Times.Once);
         }
 
         [Test]
         public async Task SendEmailAsync_Calls_IFeedbackServiceMethod_ReportCompletionAsync()
         {
             // Arrange
-            Mock<IFeedbackService> mockedTelemetry = GetMockedTelemetry();
+            Mock<ITelemetryService> mockedTelemetry = GetMockedTelemetry();
             this._testNotifySender = GetTestSendingService(mockedTelemetry: mockedTelemetry);
             NotificationEvent testNotification = GetTestNotification();
 
@@ -119,7 +120,8 @@ public async Task SendEmailAsync_Calls_IFeedbackServiceMethod_ReportCompletionAs
             // Assert
             mockedTelemetry.Verify(mock => mock.ReportCompletionAsync(
                 It.IsAny<NotificationEvent>(),
-                It.IsAny<NotifyMethods>()), Times.Once);
+                It.IsAny<NotifyMethods>(),
+                It.IsAny<string>()), Times.Once);
         }
 
         [Test]
@@ -127,7 +129,7 @@ public async Task HttpClient_IsCached_AsExpected()
         {
             #region First phase of the test (HttpClient will be just created)
             // Arrange
-            Mock<IFeedbackService> mockedTelemetry = GetMockedTelemetry();
+            Mock<ITelemetryService> mockedTelemetry = GetMockedTelemetry();
             Mock<INotifyClient> firstMockedNotifyClient = GetMockedNotifyClient();
             var firstMockedClientFactory = new Mock<IHttpClientFactory<INotifyClient, string>>(MockBehavior.Strict);
             firstMockedClientFactory
@@ -178,7 +180,7 @@ public async Task HttpClient_IsCached_AsExpected()
         #region Helper methods
         private static ISendingService<NotificationEvent, NotifyData> GetTestSendingService(
             Mock<INotifyClient>? mockedClient = null,
-            Mock<IFeedbackService>? mockedTelemetry = null)
+            Mock<ITelemetryService>? mockedTelemetry = null)
         {
             var mockedClientFactory = new Mock<IHttpClientFactory<INotifyClient, string>>(MockBehavior.Strict);
             mockedClientFactory.Setup(mock => mock.GetHttpClient(It.IsAny<string>()))
@@ -208,12 +210,13 @@ private static Mock<INotifyClient> GetMockedNotifyClient()
             return notificationClientMock;
         }
 
-        private static Mock<IFeedbackService> GetMockedTelemetry()
+        private static Mock<ITelemetryService> GetMockedTelemetry()
         {
-            var mockedTelemetry = new Mock<IFeedbackService>(MockBehavior.Strict);
+            var mockedTelemetry = new Mock<ITelemetryService>(MockBehavior.Strict);
             mockedTelemetry.Setup(mock => mock.ReportCompletionAsync(
                     It.IsAny<NotificationEvent>(),
-                    It.IsAny<NotifyMethods>()))
+                    It.IsAny<NotifyMethods>(),
+                    It.IsAny<string>()))
                 .ReturnsAsync(string.Empty);
 
             return mockedTelemetry;