diff --git a/README.md b/README.md
index 2674519..47711bd 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,33 @@
 
 `Nalu.Maui` provides a set of classes to help you with everyday challenges encountered while working with .NET MAUI.
 
+### Core [![Nalu.Maui.Core NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Core.svg)](https://www.nuget.org/packages/Nalu.Maui.Core/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Core)](https://www.nuget.org/packages/Nalu.Maui.Core/)
+
+The core library is intended to provide a set of common use utilities.
+
+Have you ever noticed that when the user backgrounds the app on iOS, the app is suspended, and the network requests will fail due to `The network connection was lost`?
+
+This is really annoying: it forces us to implement complex retry logic, especially considering that the request may have already hit the server.
+
+To solve this issue, we provide a `NSUrlBackgroundSessionHttpMessageHandler` to be used in your `HttpClient` to allow http request to continue even when the app is in the background.
+
+```csharp
+#if IOS
+    var client = new HttpClient(new NSUrlBackgroundSessionHttpMessageHandler());
+#else
+    var client = new HttpClient();
+#endif
+```
+
+To make this work, you need to change your `AppDelegate` as follows:
+```csharp
+[Export("application:handleEventsForBackgroundURLSession:completionHandler:")]
+public virtual void HandleEventsForBackgroundUrl(UIApplication application, string sessionIdentifier, Action completionHandler)
+    => NSUrlBackgroundSessionHttpMessageHandler.HandleEventsForBackgroundUrl(application, sessionIdentifier, completionHandler);
+```
+
+**Check out the [Core Wiki](core.html) for more information**.
+
 ### Navigation [![Nalu.Maui.Navigation NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Navigation.svg)](https://www.nuget.org/packages/Nalu.Maui.Navigation/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Navigation)](https://www.nuget.org/packages/Nalu.Maui.Navigation/)
 
 The MVVM navigation service offers a straightforward and robust method for navigating between pages and passing parameters.
diff --git a/Samples/Nalu.Maui.Sample/MauiProgram.cs b/Samples/Nalu.Maui.Sample/MauiProgram.cs
index 8b63e43..a615f8e 100644
--- a/Samples/Nalu.Maui.Sample/MauiProgram.cs
+++ b/Samples/Nalu.Maui.Sample/MauiProgram.cs
@@ -64,10 +64,24 @@ public static MauiApp CreateMauiApp()
 
 #if DEBUG
         builder.Logging.AddDebug();
+        builder.Logging.SetMinimumLevel(LogLevel.Debug);
 #endif
 
         builder.Services.AddTransientPopup<CanLeavePopup, CanLeavePopupModel>();
 
+        builder.Services.AddKeyedSingleton<HttpClient>("dummyjson", (_, _) =>
+        {
+#if IOS
+            var client = new HttpClient(new NSUrlBackgroundSessionHttpMessageHandler())
+#else
+            var client = new HttpClient()
+#endif
+            {
+                BaseAddress = new Uri("https://dummyjson.com/")
+            };
+            return client;
+        });
+
         return builder.Build();
     }
 }
diff --git a/Samples/Nalu.Maui.Sample/PageModels/OnePageModel.cs b/Samples/Nalu.Maui.Sample/PageModels/OnePageModel.cs
index 022084a..74bbb30 100644
--- a/Samples/Nalu.Maui.Sample/PageModels/OnePageModel.cs
+++ b/Samples/Nalu.Maui.Sample/PageModels/OnePageModel.cs
@@ -1,5 +1,6 @@
 namespace Nalu.Maui.Sample.PageModels;
 
+using System.Net.Http.Json;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 
@@ -8,14 +9,81 @@ public class AnimalModel
     public string Name { get; set; } = null!;
 }
 
-public partial class OnePageModel(INavigationService navigationService) : ObservableObject
+public partial class OnePageModel(
+    INavigationService navigationService,
+    [FromKeyedServices("dummyjson")] HttpClient httpClient) : ObservableObject
 {
     private static int _instanceCount;
 
-    public AnimalModel Animal { get; } = new AnimalModel { Name = "Dog" };
+    [ObservableProperty]
+    private string? _result1;
+
+    [ObservableProperty]
+    private string? _result2;
+
+    [ObservableProperty]
+    private string? _result3;
+
+    [ObservableProperty]
+    private string? _result4;
+
+    public AnimalModel Animal { get; } = new() { Name = "Dog" };
 
     public int InstanceCount { get; } = Interlocked.Increment(ref _instanceCount);
 
     [RelayCommand(AllowConcurrentExecutions = false)]
     private Task PushThreeAsync() => navigationService.GoToAsync(Navigation.Relative().Push<ThreePageModel>());
+
+    [RelayCommand]
+    private async Task SendRequestAsync()
+    {
+        Result1 = null;
+        Result2 = null;
+        Result3 = null;
+        Result4 = null;
+
+        var parallelRequestTask1 = SendRequestAsync(CreateTestLongRequest(5000));
+        Result1 = "waiting...";
+        var parallelRequestTask2 = SendRequestAsync(CreateTestLongRequest(4000));
+        Result2 = "waiting...";
+
+        Result1 = await parallelRequestTask1;
+        Result2 = await parallelRequestTask2;
+
+        var followUpRequest = SendRequestAsync(CreateTestLongRequest(5000));
+        Result3 = "waiting...";
+        Result3 = await followUpRequest;
+
+        var followUpRequest2 = SendRequestAsync(CreateTestLongRequest(999999));
+        Result4 = "waiting...";
+        Result4 = await followUpRequest2;
+    }
+
+    private async Task<string> SendRequestAsync(HttpRequestMessage requestMessage)
+    {
+        string result;
+        try
+        {
+            var responseMessage = await httpClient.SendAsync(requestMessage);
+            result = await responseMessage.Content.ReadAsStringAsync();
+        }
+        catch (Exception e)
+        {
+            result = e.Message;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Creates a request to an endpoint that will delay the response.
+    /// See https://dummyjson.com/docs#intro-test for more information.
+    /// </summary>
+    private HttpRequestMessage CreateTestLongRequest(int delayMs = 5000) =>
+        new()
+        {
+            RequestUri = new Uri($"test?delay={delayMs}", UriKind.Relative),
+            Method = HttpMethod.Post,
+            Content = JsonContent.Create(Animal),
+        };
 }
diff --git a/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml b/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
index 8441e78..362c3c2 100644
--- a/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
+++ b/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
@@ -17,6 +17,46 @@
                    Aspect="AspectFit"
                    Margin="0,16,0,24"/>
 
+            <Button Command="{Binding SendRequestCommand}"
+                    Text="Send requests"
+                    HorizontalOptions="Center" />
+
+            <Label>
+                <Label.FormattedText>
+                    <FormattedString>
+                        <Span Text="Parallel Request 1: " />
+                        <Span Text="{Binding Result1}" />
+                    </FormattedString>
+                </Label.FormattedText>
+            </Label>
+
+            <Label>
+                <Label.FormattedText>
+                    <FormattedString>
+                        <Span Text="Parallel Request 2: " />
+                        <Span Text="{Binding Result2}" />
+                    </FormattedString>
+                </Label.FormattedText>
+            </Label>
+
+            <Label>
+                <Label.FormattedText>
+                    <FormattedString>
+                        <Span Text="Follow-up Request 3: " />
+                        <Span Text="{Binding Result3}" />
+                    </FormattedString>
+                </Label.FormattedText>
+            </Label>
+
+            <Label>
+                <Label.FormattedText>
+                    <FormattedString>
+                        <Span Text="Erroring Request 4: " />
+                        <Span Text="{Binding Result4}" />
+                    </FormattedString>
+                </Label.FormattedText>
+            </Label>
+
             <Label>
                 <Label.FormattedText>
                     <FormattedString>
diff --git a/Samples/Nalu.Maui.Sample/Platforms/iOS/AppDelegate.cs b/Samples/Nalu.Maui.Sample/Platforms/iOS/AppDelegate.cs
index 002047f..ae91755 100644
--- a/Samples/Nalu.Maui.Sample/Platforms/iOS/AppDelegate.cs
+++ b/Samples/Nalu.Maui.Sample/Platforms/iOS/AppDelegate.cs
@@ -1,9 +1,14 @@
 namespace Nalu.Maui.Sample;
 
 using Foundation;
+using UIKit;
 
 [Register("AppDelegate")]
 public class AppDelegate : MauiUIApplicationDelegate
 {
     protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+
+    [Export("application:handleEventsForBackgroundURLSession:completionHandler:")]
+    public virtual void HandleEventsForBackgroundUrl(UIApplication application, string sessionIdentifier, Action completionHandler)
+        => NSUrlBackgroundSessionHttpMessageHandler.HandleEventsForBackgroundUrl(application, sessionIdentifier, completionHandler);
 }
diff --git a/Source/Nalu.Maui.Core/Nalu.Maui.Core.csproj b/Source/Nalu.Maui.Core/Nalu.Maui.Core.csproj
index e629764..a630fdb 100644
--- a/Source/Nalu.Maui.Core/Nalu.Maui.Core.csproj
+++ b/Source/Nalu.Maui.Core/Nalu.Maui.Core.csproj
@@ -40,7 +40,6 @@
 
   <ItemGroup>
     <Folder Include="Platforms\Android\" />
-    <Folder Include="Platforms\iOS\" />
     <Folder Include="Platforms\MacCatalyst\" />
   </ItemGroup>
 </Project>
diff --git a/Source/Nalu.Maui.Core/Platforms/iOS/MessageHandlerNSUrlSessionDownloadDelegate.cs b/Source/Nalu.Maui.Core/Platforms/iOS/MessageHandlerNSUrlSessionDownloadDelegate.cs
new file mode 100644
index 0000000..fc7ae09
--- /dev/null
+++ b/Source/Nalu.Maui.Core/Platforms/iOS/MessageHandlerNSUrlSessionDownloadDelegate.cs
@@ -0,0 +1,312 @@
+namespace Nalu;
+
+using System.Collections.Concurrent;
+using Foundation;
+using Microsoft.Extensions.Logging;
+using UIKit;
+
+#pragma warning disable VSTHRD103, VSTHRD100, VSTHRD003, IDE0290, CA1848
+
+/// <summary>
+/// iOS processor for background HTTP requests.
+/// </summary>
+internal class MessageHandlerNSUrlSessionDownloadDelegate : NSUrlSessionDownloadDelegate
+{
+    /// <summary>
+    /// Gets the singleton instance of the <see cref="MessageHandlerNSUrlSessionDownloadDelegate"/>.
+    /// </summary>
+    public static MessageHandlerNSUrlSessionDownloadDelegate Current => _instance ??= new MessageHandlerNSUrlSessionDownloadDelegate();
+
+    private static MessageHandlerNSUrlSessionDownloadDelegate? _instance;
+    private NSUrlSession? _nsUrlSession;
+    private ILogger? _logger;
+    private ILogger Logger => _logger ??= GetLoggerFromApplicationServiceProvider() ?? CreateEmptyLogger();
+    private readonly ConcurrentDictionary<string, RequestHandle> _pendingRequests = new();
+
+    private NSUrlSession Session
+    {
+        get
+        {
+            if (_nsUrlSession == null)
+            {
+                var sessionName = $"{NSBundle.MainBundle.BundleIdentifier}.NSUrlBackgroundSessionHttpMessageHandler";
+                var cfg = NSUrlSessionConfiguration.CreateBackgroundSessionConfiguration(sessionName);
+                cfg.SessionSendsLaunchEvents = true;
+                _nsUrlSession = NSUrlSession.FromConfiguration(cfg, this, new NSOperationQueue());
+            }
+
+            return _nsUrlSession!;
+        }
+    }
+
+    private MessageHandlerNSUrlSessionDownloadDelegate()
+    {
+    }
+
+    public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+    {
+        var requestUrl = new NSUrl(request.RequestUri?.ToString() ?? throw new ArgumentException("RequestUri cannot be null."));
+        var requestIdentifier = Guid.NewGuid().ToString("N");
+        var nativeHttpRequest = new NSMutableUrlRequest(requestUrl)
+        {
+            HttpMethod = request.Method.Method,
+            Headers = GetPlatformHeaders(request),
+        };
+
+        string? contentPath = null;
+        if (request.Content is { } content)
+        {
+            if (content is MultipartContent or StreamContent)
+            {
+                contentPath = GetRequestBodyPath(requestIdentifier);
+                await using var fileStream = File.Create(contentPath);
+                await content.CopyToAsync(fileStream, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                await using var memoryStream = new MemoryStream();
+                await content.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
+                var body = memoryStream.ToArray();
+                nativeHttpRequest.Body = NSData.FromArray(body);
+            }
+        }
+
+        NSUrlSessionTask task;
+        if (contentPath != null)
+        {
+            var fileUrl = NSUrl.CreateFileUrl(contentPath, null);
+            task = Session.CreateUploadTask(nativeHttpRequest, fileUrl);
+            Logger.LogDebug("Created upload task for {RequestName} with content stored in {BodyPath}", requestIdentifier, contentPath);
+        }
+        else
+        {
+            task = Session.CreateDownloadTask(nativeHttpRequest);
+            Logger.LogDebug("Created download task for {RequestName}", requestIdentifier);
+        }
+
+        var cancellationTokenRegistration = cancellationToken.Register(() =>
+        {
+            if (task.State is NSUrlSessionTaskState.Running or NSUrlSessionTaskState.Suspended)
+            {
+                task.Cancel();
+            }
+        });
+        var requestHandle = new RequestHandle(requestIdentifier, contentPath, cancellationTokenRegistration);
+        _pendingRequests[requestIdentifier] = requestHandle;
+
+        task.TaskDescription = requestIdentifier;
+        task.Resume();
+
+        await Task.Yield();
+        return await requestHandle.ResponseCompletionSource.Task.ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public override void DidBecomeInvalid(NSUrlSession session, NSError? error)
+    {
+        Logger.LogDebug("DidBecomeInvalid");
+        _nsUrlSession = null;
+
+        if (error != null)
+        {
+            Logger.LogError(new InvalidOperationException(error.ToString()), "Exception in DidBecomeInvalid");
+        }
+    }
+
+    /// <inheritdoc/>
+    public override void DidCompleteWithError(NSUrlSession session, NSUrlSessionTask task, NSError? error)
+    {
+        Logger.LogDebug("DidComplete {TaskDescription} with {State}", task.State, task.TaskDescription);
+
+        if (task.TaskDescription is not { } requestIdentifier ||
+            !_pendingRequests.TryGetValue(requestIdentifier, out var handle))
+        {
+            Logger.LogError("No handle found for {RequestName}", task.TaskDescription);
+            return;
+        }
+
+        switch (task.State)
+        {
+            case NSUrlSessionTaskState.Running:
+                Logger.LogError("Task {RequestIdentifier} completed callback invoked with running state: {Error}", requestIdentifier, error?.ToString());
+                handle.ResponseCompletionSource.TrySetException(new InvalidOperationException("Task completed callback invoked with running state"));
+                CompleteAndRemoveHandle(handle);
+                break;
+            case NSUrlSessionTaskState.Suspended:
+                Logger.LogError("Task {RequestIdentifier} completed callback invoked with suspended state: {Error}", requestIdentifier, error?.ToString());
+                handle.ResponseCompletionSource.TrySetException(new InvalidOperationException("Task completed callback invoked with suspended state"));
+                CompleteAndRemoveHandle(handle);
+                break;
+            case NSUrlSessionTaskState.Canceling:
+                Logger.LogDebug("Task {RequestIdentifier} completed with canceling state", requestIdentifier);
+                handle.ResponseCompletionSource.TrySetCanceled();
+                CompleteAndRemoveHandle(handle);
+                break;
+            case NSUrlSessionTaskState.Completed:
+                if (task.Error != null)
+                {
+                    if (task.IsCanceled())
+                    {
+                        Logger.LogDebug("Task completed with canceled state");
+                        handle.ResponseCompletionSource.TrySetCanceled();
+                    }
+                    else
+                    {
+                        var e = task.Error;
+                        var msg = e?.ToString();
+                        Logger.LogDebug("Task completed with error: {Error}", msg);
+                        handle.ResponseCompletionSource.TrySetException(new HttpRequestException(msg));
+                    }
+
+                    CompleteAndRemoveHandle(handle);
+                }
+
+                break;
+            default:
+                Logger.LogError("Unknown task state {TaskState}", task.State);
+                handle.ResponseCompletionSource.TrySetException(new HttpRequestException($"Unknown task state: {task.State}"));
+                CompleteAndRemoveHandle(handle);
+                break;
+        }
+    }
+
+    /// <inheritdoc/>
+    public override void DidFinishDownloading(NSUrlSession session, NSUrlSessionDownloadTask downloadTask, NSUrl location)
+    {
+        Logger.LogDebug("DidComplete {TaskDescription} with {Location}", downloadTask.TaskDescription, location);
+
+        if (downloadTask.TaskDescription is not { } requestIdentifier ||
+            !_pendingRequests.TryGetValue(requestIdentifier, out var handle))
+        {
+            Logger.LogError("No handle found for {RequestName}", downloadTask.TaskDescription);
+            return;
+        }
+
+        if (downloadTask.Response is not NSHttpUrlResponse response)
+        {
+            Logger.LogError("Response is not NSHttpUrlResponse");
+            handle.ResponseCompletionSource.TrySetException(new HttpRequestException("Response is not NSHttpUrlResponse"));
+            CompleteAndRemoveHandle(handle);
+            return;
+        }
+
+        var httpResponseMessage = new HttpResponseMessage(downloadTask.GetHttpStatusCode());
+        var fileStream = new FileStream(location.Path!, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.Asynchronous | FileOptions.SequentialScan | FileOptions.DeleteOnClose);
+        httpResponseMessage.Content = new StreamContent(fileStream);
+        ApplyResponseHeaders(httpResponseMessage, response);
+        handle.ResponseCompletionSource.TrySetResult(httpResponseMessage);
+        CompleteAndRemoveHandle(handle);
+    }
+
+#pragma warning disable IDE0060, VSTHRD110
+    public bool HandleEventsForBackgroundUrl(UIApplication application, string sessionIdentifier, Action completionHandler)
+    {
+        if (!ReferenceEquals(this, _nsUrlSession?.Delegate))
+        {
+            return false;
+        }
+
+        Logger.LogDebug("HandleEventsForBackgroundUrl");
+        NotifyCompletion(completionHandler);
+        return true;
+    }
+
+    private void CompleteAndRemoveHandle(RequestHandle handle)
+    {
+        handle.Complete();
+        _pendingRequests.TryRemove(handle.Identifier, out _);
+    }
+
+    private async void NotifyCompletion(Action completionHandler)
+    {
+        var acknowledgeTasks = _pendingRequests.Values.Select(handle => handle.CompletedTask).ToArray();
+        await Task.WhenAll(acknowledgeTasks).ConfigureAwait(false);
+
+        // Give it a small amount of time to eventually enqueue other requests
+        await Task.Delay(250).ConfigureAwait(false);
+
+        Logger.LogDebug("HandleEventsForBackgroundUrl: Completed");
+        completionHandler();
+    }
+#pragma warning restore IDE0060, VSTHRD110
+
+    private void ApplyResponseHeaders(HttpResponseMessage httpResponseMessage, NSHttpUrlResponse response)
+    {
+        foreach (var header in response.AllHeaderFields)
+        {
+            var key = header.Key.ToString();
+            var value = header.Value.ToString();
+
+            var added =
+                httpResponseMessage.Headers.TryAddWithoutValidation(key, value) ||
+                httpResponseMessage.Content.Headers.TryAddWithoutValidation(key, value);
+
+            if (!added)
+            {
+                Logger.LogWarning("Failed to add response header {HeaderKey}: {HeaderValue}", key, value);
+            }
+        }
+    }
+
+    private static string GetRequestBodyPath(string requestIdentifier)
+        => Path.Combine(Path.GetTempPath(), $"{requestIdentifier}.nsrequest");
+
+    private static NSDictionary GetPlatformHeaders(HttpRequestMessage request)
+    {
+        var requestHeaders = request.Headers
+            .Select(header => (HeaderName: header.Key, HeaderValue: string.Join(';', header.Value)))
+            .Where(header => !string.IsNullOrEmpty(header.HeaderValue))
+            .ToDictionary();
+
+        if (request.Content is { } content)
+        {
+            foreach (var contentHeader in content.Headers)
+            {
+                requestHeaders[contentHeader.Key] = string.Join(';', contentHeader.Value);
+            }
+        }
+
+        var headers = requestHeaders
+            .Select(header => (HeaderName: header.Key, HeaderValue: string.Join(';', header.Value)))
+            .Where(header => !string.IsNullOrEmpty(header.HeaderValue))
+            .ToArray();
+
+        var nativeHeaders = NSDictionary.FromObjectsAndKeys(
+            headers.Select(object (h) => h.HeaderValue).ToArray(),
+            headers.Select(object (h) => h.HeaderName).ToArray());
+        return nativeHeaders;
+    }
+
+    private static ILogger<MessageHandlerNSUrlSessionDownloadDelegate> CreateEmptyLogger() => LoggerFactory.Create(_ => { }).CreateLogger<MessageHandlerNSUrlSessionDownloadDelegate>();
+
+    private static ILogger<MessageHandlerNSUrlSessionDownloadDelegate>? GetLoggerFromApplicationServiceProvider() => IPlatformApplication.Current?.Services.GetService<ILogger<MessageHandlerNSUrlSessionDownloadDelegate>>();
+
+    private struct RequestHandle(
+        string identifier,
+        string? contentFile,
+        CancellationTokenRegistration cancellationTokenRegistration)
+    {
+        private readonly TaskCompletionSource _completedCompletionSource = new();
+        private bool _completed;
+        public TaskCompletionSource<HttpResponseMessage> ResponseCompletionSource { get; } = new();
+        public readonly Task CompletedTask => _completedCompletionSource.Task;
+        public readonly string Identifier => identifier;
+
+        public void Complete()
+        {
+            if (_completed)
+            {
+                return;
+            }
+
+            _completed = true;
+            cancellationTokenRegistration.Dispose();
+            _completedCompletionSource.SetResult();
+
+            if (File.Exists(contentFile))
+            {
+                File.Delete(contentFile);
+            }
+        }
+    }
+}
diff --git a/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlBackgroundSessionHttpMessageHandler.cs b/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlBackgroundSessionHttpMessageHandler.cs
new file mode 100644
index 0000000..cfe94ff
--- /dev/null
+++ b/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlBackgroundSessionHttpMessageHandler.cs
@@ -0,0 +1,24 @@
+namespace Nalu;
+
+using Foundation;
+using UIKit;
+
+/// <summary>
+/// An <see cref="HttpMessageHandler"/> that uses a background <see cref="NSUrlSession"/> to send requests over the network.
+/// </summary>
+public class NSUrlBackgroundSessionHttpMessageHandler : HttpMessageHandler
+{
+    private static MessageHandlerNSUrlSessionDownloadDelegate MessageHandler
+        => MessageHandlerNSUrlSessionDownloadDelegate.Current;
+
+    /// <inheritdoc cref="UIApplicationDelegate.HandleEventsForBackgroundUrl"/>
+    public static void HandleEventsForBackgroundUrl(
+        UIApplication application,
+        string sessionIdentifier,
+        Action completionHandler)
+        => MessageHandler.HandleEventsForBackgroundUrl(application, sessionIdentifier, completionHandler);
+
+    /// <inheritdoc />
+    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        => MessageHandler.SendAsync(request, cancellationToken);
+}
diff --git a/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlSessionTaskExtensions.cs b/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlSessionTaskExtensions.cs
new file mode 100644
index 0000000..026b5b7
--- /dev/null
+++ b/Source/Nalu.Maui.Core/Platforms/iOS/NSUrlSessionTaskExtensions.cs
@@ -0,0 +1,13 @@
+namespace Nalu;
+
+using System.Net;
+using Foundation;
+
+internal static class NSUrlSessionTaskExtensions
+{
+    public static bool IsCanceled(this NSUrlSessionTask task)
+        => task.State == NSUrlSessionTaskState.Canceling || (task.Error?.Code ?? 0) == -999;
+
+    public static HttpStatusCode GetHttpStatusCode(this NSUrlSessionTask task)
+        => (HttpStatusCode)((task.Response as NSHttpUrlResponse)?.StatusCode ?? 0);
+}
diff --git a/docs/core.md b/docs/core.md
new file mode 100644
index 0000000..d1a1afd
--- /dev/null
+++ b/docs/core.md
@@ -0,0 +1,42 @@
+## Core [![Nalu.Maui.Core NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Core.svg)](https://www.nuget.org/packages/Nalu.Maui.Core/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Core)](https://www.nuget.org/packages/Nalu.Maui.Core/)
+
+The core library is intended to provide a set of common use utilities.
+
+### Background iOS HttpClient requests
+
+Have you ever noticed that when the user backgrounds the app on iOS, the app is suspended, and the network requests fails due to `The network connection was lost` exception?
+
+```csharp
+var client = new HttpClient();
+var responseTask = client.GetAsync("https://myservice.foo/my-endpoint");
+// --> i.e. App goes to background because user receives a phone call
+// ...
+// --> After a while the user comes back to the app
+var response = await responseTask; // <-- Exception: The network connection was lost
+```
+
+This is really annoying: it forces us to implement complex retry logic, especially considering that **the request may have already hit the server** and potentially made changes there.
+
+To solve this issue, we provide a `NSUrlBackgroundSessionHttpMessageHandler` to be used in your `HttpClient` to allow http request to continue even when the app is in the background.
+
+```csharp
+#if IOS
+    var client = new HttpClient(new NSUrlBackgroundSessionHttpMessageHandler());
+#else
+    var client = new HttpClient();
+#endif
+```
+
+To make this work, you need to change your `AppDelegate` as follows:
+```csharp
+[Export("application:handleEventsForBackgroundURLSession:completionHandler:")]
+public virtual void HandleEventsForBackgroundUrl(UIApplication application, string sessionIdentifier, Action completionHandler)
+    => NSUrlBackgroundSessionHttpMessageHandler.HandleEventsForBackgroundUrl(application, sessionIdentifier, completionHandler);
+```
+
+Right after receiving the response `await responseTask` you have a small timeframe of 250ms to eventually start a new request.
+This can happen even if the app is in the background, making it possible to process a queue of requests with your custom queue logic.
+
+Please note that if this occurs while the app is in the background, iOS will process new requests after some time, which is beyond our control.
+
+Foregrounding the app will immediately process the pending requests.
diff --git a/docs/index.md b/docs/index.md
index b31d7fd..74601e8 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -2,6 +2,33 @@
 
 `Nalu.Maui` provides a set of classes to help you with everyday challenges encountered while working with .NET MAUI.
 
+### Core [![Nalu.Maui.Core NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Core.svg)](https://www.nuget.org/packages/Nalu.Maui.Core/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Core)](https://www.nuget.org/packages/Nalu.Maui.Core/)
+
+The core library is intended to provide a set of common use utilities.
+
+Have you ever noticed that when the user backgrounds the app on iOS, the app is suspended, and the network requests will fail due to `The network connection was lost`?
+
+This is really annoying: it forces us to implement complex retry logic, especially considering that the request may have already hit the server.
+
+To solve this issue, we provide a `NSUrlBackgroundSessionHttpMessageHandler` to be used in your `HttpClient` to allow http request to continue even when the app is in the background.
+
+```csharp
+#if IOS
+    var client = new HttpClient(new NSUrlBackgroundSessionHttpMessageHandler());
+#else
+    var client = new HttpClient();
+#endif
+```
+
+To make this work, you need to change your `AppDelegate` as follows:
+```csharp
+[Export("application:handleEventsForBackgroundURLSession:completionHandler:")]
+public virtual void HandleEventsForBackgroundUrl(UIApplication application, string sessionIdentifier, Action completionHandler)
+    => NSUrlBackgroundSessionHttpMessageHandler.HandleEventsForBackgroundUrl(application, sessionIdentifier, completionHandler);
+```
+
+**Check out the [Core Wiki](core.html) for more information**.
+
 ### Navigation [![Nalu.Maui.Navigation NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Navigation.svg)](https://www.nuget.org/packages/Nalu.Maui.Navigation/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Navigation)](https://www.nuget.org/packages/Nalu.Maui.Navigation/)
 
 The MVVM navigation service offers a straightforward and robust method for navigating between pages and passing parameters.