diff --git a/Maybe.Toolkit.Demo/Maybe.Toolkit.Demo.csproj b/Maybe.Toolkit.Demo/Maybe.Toolkit.Demo.csproj
new file mode 100644
index 0000000..99de62d
--- /dev/null
+++ b/Maybe.Toolkit.Demo/Maybe.Toolkit.Demo.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Maybe.Toolkit\Maybe.Toolkit.csproj" />
+    <ProjectReference Include="..\Maybe\Maybe.csproj" />
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/Maybe.Toolkit.Demo/Program.cs b/Maybe.Toolkit.Demo/Program.cs
new file mode 100644
index 0000000..475c3fa
--- /dev/null
+++ b/Maybe.Toolkit.Demo/Program.cs
@@ -0,0 +1,261 @@
+using System.Text.Json;
+using Maybe;
+using Maybe.Toolkit;
+
+namespace Maybe.Toolkit.Demo;
+
+public static class Program
+{
+    public static async Task Main()
+    {
+        Console.WriteLine("=== Maybe Toolkit Demo ===\n");
+
+        await DemoJsonToolkit();
+        Console.WriteLine();
+
+        await DemoFileToolkit();
+        Console.WriteLine();
+
+        DemoParseToolkit();
+        Console.WriteLine();
+
+        await DemoHttpToolkit();
+        Console.WriteLine();
+
+        DemoCollectionToolkit();
+        Console.WriteLine();
+
+        Console.WriteLine("=== Demo Complete ===");
+    }
+
+    private static async Task DemoJsonToolkit()
+    {
+        Console.WriteLine("--- JSON Toolkit Demo ---");
+
+        // Success case
+        var person = new { Name = "John Doe", Age = 30, City = "New York" };
+        var serializeResult = JsonToolkit.TrySerialize(person);
+        
+        serializeResult
+            .IfSome(json => Console.WriteLine($"✓ Serialized: {json}"))
+            .ElseDo(error => Console.WriteLine($"✗ Serialization failed: {error.Message}"));
+
+        if (serializeResult.IsSuccess)
+        {
+            var json = serializeResult.ValueOrThrow();
+            var deserializeResult = JsonToolkit.TryDeserialize<dynamic>(json);
+            
+            deserializeResult
+                .IfSome(obj => Console.WriteLine($"✓ Deserialized successfully"))
+                .ElseDo(error => Console.WriteLine($"✗ Deserialization failed: {error.Message}"));
+        }
+
+        // Error case
+        var invalidJson = "{\"Name\":\"John\",\"Age\":}";
+        JsonToolkit.TryDeserialize<object>(invalidJson)
+            .IfSome(_ => Console.WriteLine("✓ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: {error.Message}"));
+    }
+
+    private static async Task DemoFileToolkit()
+    {
+        Console.WriteLine("--- File Toolkit Demo ---");
+
+        var tempFile = Path.GetTempFileName();
+        var content = "Hello, Maybe Toolkit!";
+
+        try
+        {
+            // Write file
+            var writeResult = FileToolkit.TryWriteAllText(tempFile, content);
+            writeResult
+                .IfSome(_ => Console.WriteLine($"✓ File written to: {tempFile}"))
+                .ElseDo(error => Console.WriteLine($"✗ Write failed: {error.Message}"));
+
+            // Read file
+            var readResult = FileToolkit.TryReadAllText(tempFile);
+            readResult
+                .IfSome(text => Console.WriteLine($"✓ File content: {text}"))
+                .ElseDo(error => Console.WriteLine($"✗ Read failed: {error.Message}"));
+
+            // Read non-existent file
+            FileToolkit.TryReadAllText("/path/to/nonexistent/file.txt")
+                .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+                .ElseDo(error => Console.WriteLine($"✓ Expected error: File not found"));
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    private static void DemoParseToolkit()
+    {
+        Console.WriteLine("--- Parse Toolkit Demo ---");
+
+        // Success cases
+        ParseToolkit.TryParseInt("42")
+            .IfSome(value => Console.WriteLine($"✓ Parsed int: {value}"))
+            .ElseDo(error => Console.WriteLine($"✗ Parse failed: {error.Message}"));
+
+        ParseToolkit.TryParseDouble("3.14159")
+            .IfSome(value => Console.WriteLine($"✓ Parsed double: {value}"))
+            .ElseDo(error => Console.WriteLine($"✗ Parse failed: {error.Message}"));
+
+        ParseToolkit.TryParseGuid(Guid.NewGuid().ToString())
+            .IfSome(value => Console.WriteLine($"✓ Parsed GUID: {value}"))
+            .ElseDo(error => Console.WriteLine($"✗ Parse failed: {error.Message}"));
+
+        // Error cases
+        ParseToolkit.TryParseInt("not-a-number")
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: {error.Message}"));
+
+        ParseToolkit.TryParseDouble("invalid-double")
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: {error.Message}"));
+    }
+
+    private static async Task DemoHttpToolkit()
+    {
+        Console.WriteLine("--- HTTP Toolkit Demo ---");
+
+        using var client = new HttpClient();
+
+        // Demo basic HTTP verbs with error handling
+        Console.WriteLine("Basic HTTP Methods:");
+        
+        // GET Demo with invalid URL to show error handling
+        var getResult = await client.TryGetAsync("invalid-url");
+        getResult
+            .IfSome(response => Console.WriteLine($"✓ GET Response received: {response.StatusCode}"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected GET error: HTTP request failed"));
+
+        // POST Demo with null content
+        var postResult = await client.TryPostAsync("invalid-url", null);
+        postResult
+            .IfSome(response => Console.WriteLine($"✓ POST Response received: {response.StatusCode}"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected POST error: HTTP request failed"));
+
+        // PUT Demo
+        var putResult = await client.TryPutAsync("invalid-url", null);
+        putResult
+            .IfSome(response => Console.WriteLine($"✓ PUT Response received: {response.StatusCode}"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected PUT error: HTTP request failed"));
+
+        // PATCH Demo
+        var patchResult = await client.TryPatchAsync("invalid-url", null);
+        patchResult
+            .IfSome(response => Console.WriteLine($"✓ PATCH Response received: {response.StatusCode}"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected PATCH error: HTTP request failed"));
+
+        // DELETE Demo
+        var deleteResult = await client.TryDeleteAsync("invalid-url");
+        deleteResult
+            .IfSome(response => Console.WriteLine($"✓ DELETE Response received: {response.StatusCode}"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected DELETE error: HTTP request failed"));
+
+        Console.WriteLine("\nJSON Integration:");
+
+        // JSON GET Demo
+        var jsonGetResult = await client.TryGetJsonAsync<PersonDto>("invalid-url");
+        jsonGetResult
+            .IfSome(person => Console.WriteLine($"✓ Received person: {person.Name}"))
+            .ElseDo(error => 
+            {
+                if (error.IsHttpError)
+                    Console.WriteLine($"✓ Expected HTTP error in JSON GET: {error.HttpError?.Message}");
+                else if (error.IsJsonError)
+                    Console.WriteLine($"✓ Expected JSON error in JSON GET: {error.JsonError?.Message}");
+            });
+
+        // JSON POST Demo
+        var samplePerson = new PersonDto { Name = "John Doe", Age = 30, Email = "john@example.com" };
+        var jsonPostResult = await client.TryPostJsonAsync("invalid-url", samplePerson);
+        jsonPostResult
+            .IfSome(response => Console.WriteLine($"✓ JSON POST Response: {response.StatusCode}"))
+            .ElseDo(error => 
+            {
+                if (error.IsHttpError)
+                    Console.WriteLine($"✓ Expected HTTP error in JSON POST: Request failed");
+                else if (error.IsJsonError)
+                    Console.WriteLine($"✓ Expected JSON error in JSON POST: {error.JsonError?.Message}");
+            });
+
+        // JSON POST with response Demo
+        var jsonPostWithResponseResult = await client.TryPostJsonAsync<PersonDto, PersonDto>("invalid-url", samplePerson);
+        jsonPostWithResponseResult
+            .IfSome(person => Console.WriteLine($"✓ Received response person: {person.Name}"))
+            .ElseDo(error => 
+            {
+                if (error.IsHttpError)
+                    Console.WriteLine($"✓ Expected HTTP error in JSON POST with response");
+                else if (error.IsJsonError)
+                    Console.WriteLine($"✓ Expected JSON error in JSON POST with response");
+            });
+
+        Console.WriteLine("\nNull Client Demo:");
+        // Demo with null client
+        HttpClient? nullClient = null;
+        var nullResult = await nullClient!.TryGetJsonAsync<PersonDto>("http://example.com");
+        nullResult
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: HttpClient cannot be null"));
+    }
+
+    // Sample DTO for JSON demos
+    public class PersonDto
+    {
+        public string Name { get; set; } = string.Empty;
+        public int Age { get; set; }
+        public string Email { get; set; } = string.Empty;
+    }
+
+    private static void DemoCollectionToolkit()
+    {
+        Console.WriteLine("--- Collection Toolkit Demo ---");
+
+        // Dictionary demo
+        IDictionary<string, int> dictionary = new Dictionary<string, int>
+        {
+            { "apple", 5 },
+            { "banana", 3 },
+            { "orange", 8 }
+        };
+
+        dictionary.TryGetValue("apple")
+            .IfSome(value => Console.WriteLine($"✓ Found apple: {value}"))
+            .ElseDo(error => Console.WriteLine($"✗ Failed: {error.Message}"));
+
+        dictionary.TryGetValue("grape")
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: Key 'grape' was not found"));
+
+        // List demo
+        IList<string> fruits = new List<string> { "apple", "banana", "orange" };
+
+        fruits.TryGetAt(1)
+            .IfSome(fruit => Console.WriteLine($"✓ Fruit at index 1: {fruit}"))
+            .ElseDo(error => Console.WriteLine($"✗ Failed: {error.Message}"));
+
+        fruits.TryGetAt(10)
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: Index out of range"));
+
+        // First/Last demo
+        fruits.TryFirst()
+            .IfSome(first => Console.WriteLine($"✓ First fruit: {first}"))
+            .ElseDo(error => Console.WriteLine($"✗ Failed: {error.Message}"));
+
+        fruits.TryLast()
+            .IfSome(last => Console.WriteLine($"✓ Last fruit: {last}"))
+            .ElseDo(error => Console.WriteLine($"✗ Failed: {error.Message}"));
+
+        // Empty collection demo
+        var emptyList = new List<string>();
+        emptyList.TryFirst()
+            .IfSome(_ => Console.WriteLine("✗ This shouldn't happen"))
+            .ElseDo(error => Console.WriteLine($"✓ Expected error: Sequence contains no elements"));
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/CollectionToolkitTests.cs b/Maybe.Toolkit.Tests/CollectionToolkitTests.cs
new file mode 100644
index 0000000..b4428fe
--- /dev/null
+++ b/Maybe.Toolkit.Tests/CollectionToolkitTests.cs
@@ -0,0 +1,415 @@
+using FluentAssertions;
+using Maybe;
+using Maybe.Toolkit;
+
+namespace Maybe.Toolkit.Tests;
+
+public class CollectionToolkitTests
+{
+    [Fact]
+    public void TryGetValue_WithExistingKey_ReturnsSuccess()
+    {
+        // Arrange
+        IDictionary<string, int> dictionary = new Dictionary<string, int>
+        {
+            { "key1", 100 },
+            { "key2", 200 }
+        };
+
+        // Act
+        var result = dictionary.TryGetValue("key1");
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(100);
+    }
+
+    [Fact]
+    public void TryGetValue_WithNonExistingKey_ReturnsCollectionError()
+    {
+        // Arrange
+        IDictionary<string, int> dictionary = new Dictionary<string, int>
+        {
+            { "key1", 100 }
+        };
+
+        // Act
+        var result = dictionary.TryGetValue("nonexistent");
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Code.Should().Be("Collection.AccessError");
+        error.Key.Should().Be("nonexistent");
+    }
+
+    [Fact]
+    public void TryGetValue_WithNullDictionary_ReturnsCollectionError()
+    {
+        // Arrange
+        IDictionary<string, int>? dictionary = null;
+
+        // Act
+        var result = dictionary!.TryGetValue("key1");
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryGetAt_WithValidIndex_ReturnsSuccess()
+    {
+        // Arrange
+        IList<string> list = new List<string> { "first", "second", "third" };
+
+        // Act
+        var result = list.TryGetAt(1);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("second");
+    }
+
+    [Fact]
+    public void TryGetAt_WithInvalidIndex_ReturnsCollectionError()
+    {
+        // Arrange
+        IList<string> list = new List<string> { "first", "second" };
+
+        // Act
+        var result = list.TryGetAt(5);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be(5);
+    }
+
+    [Fact]
+    public void TryGetAt_WithNegativeIndex_ReturnsCollectionError()
+    {
+        // Arrange
+        IList<string> list = new List<string> { "first", "second" };
+
+        // Act
+        var result = list.TryGetAt(-1);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be(-1);
+    }
+
+    [Fact]
+    public void TryGetAt_WithArray_ReturnsSuccess()
+    {
+        // Arrange
+        var array = new[] { "first", "second", "third" };
+
+        // Act
+        var result = array.TryGetAt(2);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("third");
+    }
+
+    [Fact]
+    public void TryFirst_WithNonEmptySequence_ReturnsSuccess()
+    {
+        // Arrange
+        var sequence = new[] { "first", "second", "third" };
+
+        // Act
+        var result = sequence.TryFirst();
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("first");
+    }
+
+    [Fact]
+    public void TryFirst_WithEmptySequence_ReturnsCollectionError()
+    {
+        // Arrange
+        var sequence = Array.Empty<string>();
+
+        // Act
+        var result = sequence.TryFirst();
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be("first");
+    }
+
+    [Fact]
+    public void TryLast_WithNonEmptySequence_ReturnsSuccess()
+    {
+        // Arrange
+        var sequence = new[] { "first", "second", "third" };
+
+        // Act
+        var result = sequence.TryLast();
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("third");
+    }
+
+    [Fact]
+    public void TryLast_WithEmptySequence_ReturnsCollectionError()
+    {
+        // Arrange
+        var sequence = Array.Empty<string>();
+
+        // Act
+        var result = sequence.TryLast();
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be("last");
+    }
+
+    [Fact]
+    public void TryGetValue_WithReadOnlyDictionary_ReturnsSuccess()
+    {
+        // Arrange
+        var dictionary = new Dictionary<string, int> { { "key1", 100 } };
+        IReadOnlyDictionary<string, int> readOnlyDict = dictionary;
+
+        // Act
+        var result = readOnlyDict.TryGetValue("key1");
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(100);
+    }
+
+    [Fact]
+    public void TryGetAt_WithReadOnlyList_ReturnsSuccess()
+    {
+        // Arrange
+        var list = new List<string> { "first", "second" };
+        IReadOnlyList<string> readOnlyList = list;
+
+        // Act
+        var result = readOnlyList.TryGetAt(0);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("first");
+    }
+
+    [Fact]
+    public void TryGetValue_WithReadOnlyDictionary_AndNonExistingKey_ReturnsCollectionError()
+    {
+        // Arrange
+        var dictionary = new Dictionary<string, int> { { "key1", 100 } };
+        IReadOnlyDictionary<string, int> readOnlyDict = dictionary;
+
+        // Act
+        var result = readOnlyDict.TryGetValue("nonexistent");
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Code.Should().Be("Collection.AccessError");
+        error.Key.Should().Be("nonexistent");
+    }
+
+    [Fact]
+    public void TryGetValue_WithNullReadOnlyDictionary_ReturnsCollectionError()
+    {
+        // Arrange
+        IReadOnlyDictionary<string, int>? dictionary = null;
+
+        // Act
+        var result = dictionary!.TryGetValue("key1");
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryGetAt_WithReadOnlyList_AndInvalidIndex_ReturnsCollectionError()
+    {
+        // Arrange
+        var list = new List<string> { "first", "second" };
+        IReadOnlyList<string> readOnlyList = list;
+
+        // Act
+        var result = readOnlyList.TryGetAt(10);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be(10);
+    }
+
+    [Fact]
+    public void TryGetAt_WithNullReadOnlyList_ReturnsCollectionError()
+    {
+        // Arrange
+        IReadOnlyList<string>? list = null;
+
+        // Act
+        var result = list!.TryGetAt(0);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryGetAt_WithNullList_ReturnsCollectionError()
+    {
+        // Arrange
+        IList<string>? list = null;
+
+        // Act
+        var result = list!.TryGetAt(0);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryGetAt_WithNullArray_ReturnsCollectionError()
+    {
+        // Arrange
+        string[]? array = null;
+
+        // Act
+        var result = array!.TryGetAt(0);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryGetAt_WithArray_AndInvalidIndex_ReturnsCollectionError()
+    {
+        // Arrange
+        var array = new[] { "first", "second" };
+
+        // Act
+        var result = array.TryGetAt(10);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+        error.Key.Should().Be(10);
+    }
+
+    [Fact]
+    public void TryFirst_WithNullSequence_ReturnsCollectionError()
+    {
+        // Arrange
+        IEnumerable<string>? sequence = null;
+
+        // Act
+        var result = sequence!.TryFirst();
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryLast_WithNullSequence_ReturnsCollectionError()
+    {
+        // Arrange
+        IEnumerable<string>? sequence = null;
+
+        // Act
+        var result = sequence!.TryLast();
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<CollectionError>();
+    }
+
+    [Fact]
+    public void TryFirst_WithSingleElement_ReturnsSuccess()
+    {
+        // Arrange
+        var sequence = new[] { "only" };
+
+        // Act
+        var result = sequence.TryFirst();
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("only");
+    }
+
+    [Fact]
+    public void TryLast_WithSingleElement_ReturnsSuccess()
+    {
+        // Arrange
+        var sequence = new[] { "only" };
+
+        // Act
+        var result = sequence.TryLast();
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("only");
+    }
+
+    [Fact]
+    public void TryGetValue_WithNullKey_HandlesGracefully()
+    {
+        // Arrange
+        IDictionary<string, int> dictionary = new Dictionary<string, int>
+        {
+            { "key1", 100 }
+        };
+
+        // Act & Assert - just verify the method doesn't crash with null
+        // The behavior may vary depending on the dictionary implementation
+        try
+        {
+            var result = dictionary.TryGetValue(null!);
+            result.Should().NotBeNull(); // Just ensure no exception
+        }
+        catch
+        {
+            // It's ok if some dictionary implementations don't support null keys
+        }
+    }
+
+    [Fact]
+    public void CollectionError_Properties_AreSetCorrectly()
+    {
+        // Test the error class properties for better coverage
+        var originalException = new InvalidOperationException("test");
+        var error = new CollectionError("testKey", originalException, "Test message");
+        
+        error.OriginalException.Should().Be(originalException);
+        error.Key.Should().Be("testKey");
+        error.Message.Should().NotBeNullOrEmpty(); // The message behavior depends on CollectionError implementation
+        error.Code.Should().Be("Collection.AccessError");
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/FileToolkitTests.cs b/Maybe.Toolkit.Tests/FileToolkitTests.cs
new file mode 100644
index 0000000..6ad9df3
--- /dev/null
+++ b/Maybe.Toolkit.Tests/FileToolkitTests.cs
@@ -0,0 +1,350 @@
+using FluentAssertions;
+using Maybe;
+using Maybe.Toolkit;
+
+namespace Maybe.Toolkit.Tests;
+
+public class FileToolkitTests
+{
+    private readonly string _tempDirectory;
+
+    public FileToolkitTests()
+    {
+        _tempDirectory = Path.GetTempPath();
+    }
+
+    [Fact]
+    public void TryReadAllText_WithExistingFile_ReturnsSuccess()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.txt");
+        var expectedContent = "Hello, World!";
+        File.WriteAllText(tempFile, expectedContent);
+
+        try
+        {
+            // Act
+            var result = FileToolkit.TryReadAllText(tempFile);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.ValueOrThrow().Should().Be(expectedContent);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TryReadAllText_WithNonExistentFile_ReturnsFileError()
+    {
+        // Arrange
+        var nonExistentFile = Path.Combine(_tempDirectory, $"nonexistent_{Guid.NewGuid()}.txt");
+
+        // Act
+        var result = FileToolkit.TryReadAllText(nonExistentFile);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.Code.Should().Be("File.IOError");
+        error.FilePath.Should().Be(nonExistentFile);
+        error.OriginalException.Should().BeOfType<FileNotFoundException>();
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryReadAllText_WithInvalidPath_ReturnsFileError(string invalidPath)
+    {
+        // Act
+        var result = FileToolkit.TryReadAllText(invalidPath);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.FilePath.Should().Be(invalidPath);
+    }
+
+    [Fact]
+    public void TryReadAllBytes_WithExistingFile_ReturnsSuccess()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.bin");
+        var expectedBytes = new byte[] { 1, 2, 3, 4, 5 };
+        File.WriteAllBytes(tempFile, expectedBytes);
+
+        try
+        {
+            // Act
+            var result = FileToolkit.TryReadAllBytes(tempFile);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.ValueOrThrow().Should().BeEquivalentTo(expectedBytes);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TryWriteAllText_WithValidPath_ReturnsSuccess()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.txt");
+        var content = "Test content";
+
+        try
+        {
+            // Act
+            var result = FileToolkit.TryWriteAllText(tempFile, content);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            File.Exists(tempFile).Should().BeTrue();
+            File.ReadAllText(tempFile).Should().Be(content);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TryWriteAllText_WithNullContent_ReturnsFileError()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.txt");
+
+        // Act
+        var result = FileToolkit.TryWriteAllText(tempFile, null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryWriteAllBytes_WithValidPath_ReturnsSuccess()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.bin");
+        var bytes = new byte[] { 1, 2, 3, 4, 5 };
+
+        try
+        {
+            // Act
+            var result = FileToolkit.TryWriteAllBytes(tempFile, bytes);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            File.Exists(tempFile).Should().BeTrue();
+            File.ReadAllBytes(tempFile).Should().BeEquivalentTo(bytes);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TryReadAllText_WithEncoding_ReturnsSuccess()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.txt");
+        var expectedContent = "Hello, UTF-8!";
+        var encoding = System.Text.Encoding.UTF8;
+        File.WriteAllText(tempFile, expectedContent, encoding);
+
+        try
+        {
+            // Act
+            var result = FileToolkit.TryReadAllText(tempFile, encoding);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.ValueOrThrow().Should().Be(expectedContent);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TryReadAllText_WithNullEncoding_ReturnsFileError()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.txt");
+
+        // Act
+        var result = FileToolkit.TryReadAllText(tempFile, null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryReadAllBytes_WithNonExistentFile_ReturnsFileError()
+    {
+        // Arrange
+        var nonExistentFile = Path.Combine(_tempDirectory, $"nonexistent_{Guid.NewGuid()}.bin");
+
+        // Act
+        var result = FileToolkit.TryReadAllBytes(nonExistentFile);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.Code.Should().Be("File.IOError");
+        error.FilePath.Should().Be(nonExistentFile);
+        error.OriginalException.Should().BeOfType<FileNotFoundException>();
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData(null)]
+    public void TryReadAllBytes_WithInvalidPath_ReturnsFileError(string? invalidPath)
+    {
+        // Act
+        var result = FileToolkit.TryReadAllBytes(invalidPath!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.FilePath.Should().Be(invalidPath);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData(null)]
+    public void TryWriteAllText_WithInvalidPath_ReturnsFileError(string? invalidPath)
+    {
+        // Act
+        var result = FileToolkit.TryWriteAllText(invalidPath!, "content");
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.FilePath.Should().Be(invalidPath);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData(null)]
+    public void TryWriteAllBytes_WithInvalidPath_ReturnsFileError(string? invalidPath)
+    {
+        // Act
+        var result = FileToolkit.TryWriteAllBytes(invalidPath!, new byte[] { 1, 2, 3 });
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.FilePath.Should().Be(invalidPath);
+    }
+
+    [Fact]
+    public void TryWriteAllBytes_WithNullBytes_ReturnsFileError()
+    {
+        // Arrange
+        var tempFile = Path.Combine(_tempDirectory, $"test_{Guid.NewGuid()}.bin");
+
+        // Act
+        var result = FileToolkit.TryWriteAllBytes(tempFile, null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryWriteAllText_WithReadOnlyFile_ReturnsFileError()
+    {
+        // This test checks unauthorized access scenarios
+        var tempFile = Path.Combine(_tempDirectory, $"readonly_{Guid.NewGuid()}.txt");
+        
+        try
+        {
+            File.WriteAllText(tempFile, "initial content");
+            File.SetAttributes(tempFile, FileAttributes.ReadOnly);
+
+            // Act
+            var result = FileToolkit.TryWriteAllText(tempFile, "new content");
+
+            // Assert
+            result.IsError.Should().BeTrue();
+            var error = result.ErrorOrThrow();
+            error.Should().BeOfType<FileError>();
+            error.OriginalException.Should().BeOfType<UnauthorizedAccessException>();
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+            {
+                File.SetAttributes(tempFile, FileAttributes.Normal);
+                File.Delete(tempFile);
+            }
+        }
+    }
+
+    [Fact]
+    public void TryReadAllText_WithDirectoryPath_ReturnsFileError()
+    {
+        // Arrange - use a directory path instead of file path
+        var directoryPath = _tempDirectory;
+
+        // Act
+        var result = FileToolkit.TryReadAllText(directoryPath);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<FileError>();
+        error.FilePath.Should().Be(directoryPath);
+    }
+
+    [Fact]
+    public void Unit_Value_IsNotNull()
+    {
+        // Test the Unit struct that's used in write operations
+        var unit = Unit.Value;
+        unit.Should().NotBeNull();
+        
+        // Test that two Unit values are equal
+        var unit2 = Unit.Value;
+        unit.Should().Be(unit2);
+    }
+
+    [Fact]
+    public void Unit_ToString_ReturnsExpectedValue()
+    {
+        // Test Unit.ToString() method
+        var unit = Unit.Value;
+        var stringValue = unit.ToString();
+        stringValue.Should().NotBeNull();
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/HttpToolkitTests.cs b/Maybe.Toolkit.Tests/HttpToolkitTests.cs
new file mode 100644
index 0000000..26c25cc
--- /dev/null
+++ b/Maybe.Toolkit.Tests/HttpToolkitTests.cs
@@ -0,0 +1,765 @@
+using FluentAssertions;
+using Maybe;
+using Maybe.Toolkit;
+using System.Net;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Maybe.Toolkit.Tests;
+
+public class HttpToolkitTests
+{
+    [Fact]
+    public void TryGetAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act & Assert
+        var result = client!.TryGetAsync("http://example.com");
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryGetAsync_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act & Assert
+        var result = client.TryGetAsync((string?)null);
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public void TryGetAsync_WithEmptyUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act & Assert
+        var result = client.TryGetAsync("");
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public void TryGetAsync_WithUriObject_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act & Assert
+        var result = client.TryGetAsync((Uri?)null);
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryPostAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act & Assert
+        var result = client!.TryPostAsync("http://example.com", null);
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void TryGetStringAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act & Assert
+        var result = client!.TryGetStringAsync("http://example.com");
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public void TryGetByteArrayAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act & Assert
+        var result = client!.TryGetByteArrayAsync("http://example.com");
+        result.Should().NotBeNull();
+        result.Result.IsError.Should().BeTrue();
+        var error = result.Result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public async Task TryPutAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act
+        var result = await client!.TryPutAsync("http://example.com", null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryPutAsync_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryPutAsync((string?)null, null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public async Task TryPutAsync_WithUriObject_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryPutAsync((Uri?)null, null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryPatchAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act
+        var result = await client!.TryPatchAsync("http://example.com", null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryPatchAsync_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryPatchAsync((string?)null, null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public async Task TryPatchAsync_WithUriObject_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryPatchAsync((Uri?)null, null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryDeleteAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act
+        var result = await client!.TryDeleteAsync("http://example.com");
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryDeleteAsync_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryDeleteAsync((string?)null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+    }
+
+    [Fact]
+    public async Task TryDeleteAsync_WithUriObject_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryDeleteAsync((Uri?)null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryPostAsync_WithUriObject_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act
+        var result = await client!.TryPostAsync(new Uri("http://example.com"), null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task TryPostAsync_WithUriObject_WithNullUri_ReturnsHttpError()
+    {
+        // Arrange
+        using var client = new HttpClient();
+
+        // Act
+        var result = await client.TryPostAsync((Uri?)null, null);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpError>();
+        error.OriginalException.Should().BeOfType<ArgumentNullException>();
+    }
+
+    #region JSON integration tests
+
+    [Fact]
+    public async Task TryGetJsonAsync_WithNullClient_ReturnsHttpError()
+    {
+        // Arrange
+        HttpClient? client = null;
+
+        // Act
+        var result = await client!.TryGetJsonAsync<TestObject>("http://example.com");
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpJsonError>();
+        error.IsHttpError.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task TryPostJsonAsync_WithNullClient_ReturnsJsonError()
+    {
+        // Arrange
+        HttpClient? client = null;
+        var testObject = new TestObject { Name = "Test", Value = 42 };
+
+        // Act
+        var result = await client!.TryPostJsonAsync("http://example.com", testObject);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpJsonError>();
+        error.IsHttpError.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task TryPutJsonAsync_WithNullClient_ReturnsJsonError()
+    {
+        // Arrange
+        HttpClient? client = null;
+        var testObject = new TestObject { Name = "Test", Value = 42 };
+
+        // Act
+        var result = await client!.TryPutJsonAsync("http://example.com", testObject);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpJsonError>();
+        error.IsHttpError.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task TryPatchJsonAsync_WithNullClient_ReturnsJsonError()
+    {
+        // Arrange
+        HttpClient? client = null;
+        var testObject = new TestObject { Name = "Test", Value = 42 };
+
+        // Act
+        var result = await client!.TryPatchJsonAsync("http://example.com", testObject);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpJsonError>();
+        error.IsHttpError.Should().BeTrue();
+    }
+
+    #endregion
+
+    #region Integration tests with DummyJSON service
+
+    private static bool IsNetworkAvailable()
+    {
+        try
+        {
+            using var client = new HttpClient();
+            client.Timeout = TimeSpan.FromSeconds(5);
+            var response = client.GetAsync("https://dummyjson.com/test").Result;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryGetAsync_WithDummyJsonService_ReturnsSuccessResponse()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos";
+
+        // Act
+        var result = await client.TryGetAsync(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var response = result.ValueOrThrow();
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        response.Content.Should().NotBeNull();
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryGetStringAsync_WithDummyJsonService_ReturnsJsonString()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos";
+
+        // Act
+        var result = await client.TryGetStringAsync(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var jsonString = result.ValueOrThrow();
+        jsonString.Should().NotBeNullOrWhiteSpace();
+        jsonString.Should().Contain("todos");
+        jsonString.Should().Contain("total");
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryGetJsonAsync_WithDummyJsonService_ReturnsTodosResponse()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos";
+
+        // Act
+        var result = await client.TryGetJsonAsync<TodosResponse>(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var todosResponse = result.ValueOrThrow();
+        todosResponse.Should().NotBeNull();
+        todosResponse.Todos.Should().NotBeNull();
+        todosResponse.Todos.Should().NotBeEmpty();
+        todosResponse.Total.Should().BeGreaterThan(0);
+        todosResponse.Limit.Should().BeGreaterThan(0);
+        
+        // Verify first todo structure
+        var firstTodo = todosResponse.Todos.First();
+        firstTodo.Id.Should().BeGreaterThan(0);
+        firstTodo.Task.Should().NotBeNullOrWhiteSpace();
+        firstTodo.UserId.Should().BeGreaterThan(0);
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryGetJsonAsync_WithDummyJsonSingleTodo_ReturnsTodo()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos/1";
+
+        // Act
+        var result = await client.TryGetJsonAsync<Todo>(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var todo = result.ValueOrThrow();
+        todo.Should().NotBeNull();
+        todo.Id.Should().Be(1);
+        todo.Task.Should().NotBeNullOrWhiteSpace();
+        todo.UserId.Should().BeGreaterThan(0);
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryPostJsonAsync_WithDummyJsonService_ReturnsCreatedTodo()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos/add";
+        var newTodo = new TodoCreate 
+        { 
+            Todo = "Use Maybe.Toolkit for HTTP requests", 
+            Completed = false, 
+            UserId = 1 
+        };
+
+        // Act
+        var result = await client.TryPostJsonAsync<TodoCreate, Todo>(url, newTodo);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var createdTodo = result.ValueOrThrow();
+        createdTodo.Should().NotBeNull();
+        createdTodo.Id.Should().BeGreaterThan(0);
+        createdTodo.Task.Should().Be(newTodo.Todo);
+        createdTodo.Completed.Should().Be(newTodo.Completed);
+        createdTodo.UserId.Should().Be(newTodo.UserId);
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryPutJsonAsync_WithDummyJsonService_ReturnsUpdatedTodo()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos/1";
+        var updateTodo = new TodoUpdate 
+        { 
+            Todo = "Updated todo using Maybe.Toolkit", 
+            Completed = true 
+        };
+
+        // Act
+        var result = await client.TryPutJsonAsync<TodoUpdate, Todo>(url, updateTodo);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var updatedTodo = result.ValueOrThrow();
+        updatedTodo.Should().NotBeNull();
+        updatedTodo.Id.Should().Be(1);
+        updatedTodo.Task.Should().Be(updateTodo.Todo);
+        updatedTodo.Completed.Should().Be(updateTodo.Completed);
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryPatchJsonAsync_WithDummyJsonService_ReturnsUpdatedTodo()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos/1";
+        var patchTodo = new TodoPatch 
+        { 
+            Completed = true
+        };
+
+        // Act
+        var result = await client.TryPatchJsonAsync<TodoPatch, Todo>(url, patchTodo);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var updatedTodo = result.ValueOrThrow();
+        updatedTodo.Should().NotBeNull();
+        updatedTodo.Id.Should().Be(1);
+        updatedTodo.Completed.Should().Be(patchTodo.Completed);
+    }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task TryDeleteAsync_WithDummyJsonService_ReturnsSuccessResponse()
+    {
+        // Skip if network is not available
+        if (!IsNetworkAvailable())
+        {
+            return; // Skip the test
+        }
+
+        // Arrange
+        using var client = new HttpClient();
+        const string url = "https://dummyjson.com/todos/1";
+
+        // Act
+        var result = await client.TryDeleteAsync(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsSuccess.Should().BeTrue();
+        var response = result.ValueOrThrow();
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+    }
+
+    [Fact]
+    [Trait("Category", "Unit")]
+    public async Task TryGetJsonAsync_WithInvalidJsonUrl_VerifiesErrorHandling()
+    {
+        // This test uses a local mock approach instead of external service
+        // to verify that JSON parsing errors are properly handled
+        
+        // Arrange
+        using var client = new HttpClient();
+        
+        // Use an invalid URL that will definitely cause an HTTP error
+        // This tests our error handling without depending on external services
+        const string url = "http://localhost:99999/invalid"; 
+
+        // Act
+        var result = await client.TryGetJsonAsync<TodosResponse>(url);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<HttpJsonError>();
+        error.IsHttpError.Should().BeTrue();
+        error.HttpError.Should().NotBeNull();
+    }
+
+    #endregion
+
+    // DTOs for DummyJSON service
+    private class TodosResponse
+    {
+        [JsonPropertyName("todos")]
+        public List<Todo> Todos { get; set; } = new();
+
+        [JsonPropertyName("total")]
+        public int Total { get; set; }
+
+        [JsonPropertyName("skip")]
+        public int Skip { get; set; }
+
+        [JsonPropertyName("limit")]
+        public int Limit { get; set; }
+    }
+
+    private class Todo
+    {
+        [JsonPropertyName("id")]
+        public int Id { get; set; }
+
+        [JsonPropertyName("todo")]
+        public string Task { get; set; } = string.Empty;
+
+        [JsonPropertyName("completed")]
+        public bool Completed { get; set; }
+
+        [JsonPropertyName("userId")]
+        public int UserId { get; set; }
+    }
+
+    private class TodoCreate
+    {
+        [JsonPropertyName("todo")]
+        public string Todo { get; set; } = string.Empty;
+
+        [JsonPropertyName("completed")]
+        public bool Completed { get; set; }
+
+        [JsonPropertyName("userId")]
+        public int UserId { get; set; }
+    }
+
+    private class TodoUpdate
+    {
+        [JsonPropertyName("todo")]
+        public string Todo { get; set; } = string.Empty;
+
+        [JsonPropertyName("completed")]
+        public bool Completed { get; set; }
+    }
+
+    private class TodoPatch
+    {
+        [JsonPropertyName("completed")]
+        public bool Completed { get; set; }
+    }
+
+    private class TestObject
+    {
+        public string Name { get; set; } = string.Empty;
+        public int Value { get; set; }
+    }
+
+    #region HttpJsonError tests
+
+    [Fact]
+    public void HttpJsonError_DefaultConstructor_SetsDefaults()
+    {
+        // Act
+        var error = new HttpJsonError();
+
+        // Assert
+        error.Should().NotBeNull();
+        error.IsHttpError.Should().BeFalse();
+        error.IsJsonError.Should().BeFalse();
+        error.HttpError.Should().BeNull();
+        error.JsonError.Should().BeNull();
+        error.UnderlyingError.Should().BeNull();
+    }
+
+    [Fact]
+    public void HttpJsonError_WithHttpError_SetsPropertiesCorrectly()
+    {
+        // Arrange
+        var httpError = new HttpError(new HttpRequestException("test"), "http://test.com", null, "Test HTTP error");
+
+        // Act
+        var error = new HttpJsonError(httpError);
+
+        // Assert
+        error.IsHttpError.Should().BeTrue();
+        error.IsJsonError.Should().BeFalse();
+        error.HttpError.Should().Be(httpError);
+        error.JsonError.Should().BeNull();
+        error.UnderlyingError.Should().Be(httpError);
+    }
+
+    [Fact]
+    public void HttpJsonError_WithJsonError_SetsPropertiesCorrectly()
+    {
+        // Arrange
+        var jsonError = new JsonError(new System.Text.Json.JsonException("test"), "Test JSON error");
+
+        // Act
+        var error = new HttpJsonError(jsonError);
+
+        // Assert
+        error.IsHttpError.Should().BeFalse();
+        error.IsJsonError.Should().BeTrue();
+        error.HttpError.Should().BeNull();
+        error.JsonError.Should().Be(jsonError);
+        error.UnderlyingError.Should().Be(jsonError);
+    }
+
+    #endregion
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/JsonToolkitTests.cs b/Maybe.Toolkit.Tests/JsonToolkitTests.cs
new file mode 100644
index 0000000..a251178
--- /dev/null
+++ b/Maybe.Toolkit.Tests/JsonToolkitTests.cs
@@ -0,0 +1,277 @@
+using FluentAssertions;
+using Maybe;
+using Maybe.Toolkit;
+
+namespace Maybe.Toolkit.Tests;
+
+public class JsonToolkitTests
+{
+    [Fact]
+    public void TryDeserialize_WithValidJson_ReturnsSuccess()
+    {
+        // Arrange
+        var json = "{\"Name\":\"John\",\"Age\":30}";
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(json);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var person = result.ValueOrThrow();
+        person.Name.Should().Be("John");
+        person.Age.Should().Be(30);
+    }
+
+    [Fact]
+    public void TryDeserialize_WithInvalidJson_ReturnsJsonError()
+    {
+        // Arrange
+        var invalidJson = "{\"Name\":\"John\",\"Age\":}"; // Missing value
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(invalidJson);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+        error.Code.Should().Be("Json.SerializationError");
+    }
+
+    [Fact]
+    public void TryDeserialize_WithNullOrEmptyJson_ReturnsJsonError()
+    {
+        // Act & Assert
+        JsonToolkit.TryDeserialize<Person>("").IsError.Should().BeTrue();
+        JsonToolkit.TryDeserialize<Person>("   ").IsError.Should().BeTrue();
+    }
+
+    [Fact]
+    public void TrySerialize_WithValidObject_ReturnsSuccess()
+    {
+        // Arrange
+        var person = new Person { Name = "John", Age = 30 };
+
+        // Act
+        var result = JsonToolkit.TrySerialize(person);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var json = result.ValueOrThrow();
+        json.Should().Contain("John");
+        json.Should().Contain("30");
+    }
+
+    [Fact]
+    public void TryDeserialize_WithUtf8Bytes_ReturnsSuccess()
+    {
+        // Arrange
+        var json = "{\"Name\":\"John\",\"Age\":30}";
+        var utf8Bytes = System.Text.Encoding.UTF8.GetBytes(json);
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(utf8Bytes);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var person = result.ValueOrThrow();
+        person.Name.Should().Be("John");
+        person.Age.Should().Be(30);
+    }
+
+    [Fact]
+    public void TryDeserialize_WithEmptyUtf8Bytes_ReturnsJsonError()
+    {
+        // Arrange
+        var emptyBytes = new byte[0];
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(emptyBytes);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+    }
+
+    [Fact]
+    public void TryDeserialize_WithInvalidUtf8Json_ReturnsJsonError()
+    {
+        // Arrange
+        var invalidJson = "{\"Name\":\"John\",\"Age\":}";
+        var utf8Bytes = System.Text.Encoding.UTF8.GetBytes(invalidJson);
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(utf8Bytes);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+        error.Code.Should().Be("Json.SerializationError");
+    }
+
+    [Fact]
+    public void TryDeserialize_WithNullJson_ReturnsJsonError()
+    {
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>((string)null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+    }
+
+    [Fact]
+    public void TrySerialize_WithCustomOptions_ReturnsSuccess()
+    {
+        // Arrange
+        var person = new Person { Name = "John", Age = 30 };
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase
+        };
+
+        // Act
+        var result = JsonToolkit.TrySerialize(person, options);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var json = result.ValueOrThrow();
+        json.Should().Contain("name"); // camelCase
+        json.Should().Contain("age");  // camelCase
+    }
+
+    [Fact]
+    public void TryDeserialize_WithCustomOptions_ReturnsSuccess()
+    {
+        // Arrange
+        var json = "{\"name\":\"John\",\"age\":30}"; // camelCase
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase
+        };
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(json, options);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var person = result.ValueOrThrow();
+        person.Name.Should().Be("John");
+        person.Age.Should().Be(30);
+    }
+
+    [Fact]
+    public void TryDeserialize_WithUtf8Bytes_AndCustomOptions_ReturnsSuccess()
+    {
+        // Arrange
+        var json = "{\"name\":\"John\",\"age\":30}"; // camelCase
+        var utf8Bytes = System.Text.Encoding.UTF8.GetBytes(json);
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase
+        };
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(utf8Bytes, options);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var person = result.ValueOrThrow();
+        person.Name.Should().Be("John");
+        person.Age.Should().Be(30);
+    }
+
+    [Fact]
+    public void TrySerialize_WithNullValue_ReturnsSuccess()
+    {
+        // Act
+        var result = JsonToolkit.TrySerialize<Person?>(null);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var json = result.ValueOrThrow();
+        json.Should().Be("null");
+    }
+
+    [Fact]
+    public void TryDeserialize_ReturningNull_ReturnsJsonError()
+    {
+        // This tests the case where JsonSerializer.Deserialize returns null
+        // but we expect a non-nullable type
+        var json = "null";
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(json);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+        // The actual error message depends on the JsonError implementation
+        error.Message.Should().NotBeNullOrEmpty();
+    }
+
+    [Fact]
+    public void TryDeserialize_WithUtf8Bytes_ReturningNull_ReturnsJsonError()
+    {
+        // This tests the case where JsonSerializer.Deserialize returns null
+        // but we expect a non-nullable type
+        var json = "null";
+        var utf8Bytes = System.Text.Encoding.UTF8.GetBytes(json);
+
+        // Act
+        var result = JsonToolkit.TryDeserialize<Person>(utf8Bytes);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+        // The actual error message depends on the JsonError implementation
+        error.Message.Should().NotBeNullOrEmpty();
+    }
+
+    [Fact]
+    public void JsonError_Properties_AreSetCorrectly()
+    {
+        // Test the error class properties for better coverage
+        var originalException = new System.Text.Json.JsonException("test json error");
+        var error = new JsonError(originalException, "Test message");
+        
+        error.OriginalException.Should().Be(originalException);
+        error.Message.Should().NotBeNullOrEmpty(); // The message behavior depends on JsonError implementation
+        error.Code.Should().Be("Json.SerializationError");
+    }
+
+    [Fact]
+    public void TrySerialize_WithCircularReference_ReturnsJsonError()
+    {
+        // Create an object with circular reference to test error handling
+        var obj1 = new CircularObject { Name = "obj1" };
+        var obj2 = new CircularObject { Name = "obj2", Reference = obj1 };
+        obj1.Reference = obj2; // Create circular reference
+
+        // Act
+        var result = JsonToolkit.TrySerialize(obj1);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<JsonError>();
+        error.Code.Should().Be("Json.SerializationError");
+    }
+
+    private class Person
+    {
+        public string Name { get; set; } = "";
+        public int Age { get; set; }
+    }
+
+    private class CircularObject
+    {
+        public string Name { get; set; } = "";
+        public CircularObject? Reference { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/Maybe.Toolkit.Tests.csproj b/Maybe.Toolkit.Tests/Maybe.Toolkit.Tests.csproj
new file mode 100644
index 0000000..7d4de21
--- /dev/null
+++ b/Maybe.Toolkit.Tests/Maybe.Toolkit.Tests.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2" />
+    <PackageReference Include="FluentAssertions" Version="8.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Maybe.Toolkit\Maybe.Toolkit.csproj" />
+    <ProjectReference Include="..\Maybe\Maybe.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/Maybe.Toolkit.Tests/ParseToolkitTests.cs b/Maybe.Toolkit.Tests/ParseToolkitTests.cs
new file mode 100644
index 0000000..61bdd6e
--- /dev/null
+++ b/Maybe.Toolkit.Tests/ParseToolkitTests.cs
@@ -0,0 +1,423 @@
+using FluentAssertions;
+using Maybe;
+using Maybe.Toolkit;
+
+namespace Maybe.Toolkit.Tests;
+
+public class ParseToolkitTests
+{
+    [Theory]
+    [InlineData("123", 123)]
+    [InlineData("-456", -456)]
+    [InlineData("0", 0)]
+    public void TryParseInt_WithValidInput_ReturnsSuccess(string input, int expected)
+    {
+        // Act
+        var result = ParseToolkit.TryParseInt(input);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("abc")]
+    [InlineData("12.34")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseInt_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseInt(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.Code.Should().Be("Parse.FormatError");
+        error.TargetType.Should().Be(typeof(int));
+        error.InputValue.Should().Be(input);
+    }
+
+    [Theory]
+    [InlineData("123.45", 123.45)]
+    [InlineData("-456.78", -456.78)]
+    [InlineData("0.0", 0.0)]
+    public void TryParseDouble_WithValidInput_ReturnsSuccess(string input, double expected)
+    {
+        // Act
+        var result = ParseToolkit.TryParseDouble(input);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("abc")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseDouble_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseDouble(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(double));
+    }
+
+    [Fact]
+    public void TryParseGuid_WithValidGuid_ReturnsSuccess()
+    {
+        // Arrange
+        var expectedGuid = Guid.NewGuid();
+        var guidString = expectedGuid.ToString();
+
+        // Act
+        var result = ParseToolkit.TryParseGuid(guidString);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expectedGuid);
+    }
+
+    [Theory]
+    [InlineData("invalid-guid")]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData("12345678")]
+    public void TryParseGuid_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseGuid(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(Guid));
+    }
+
+    [Theory]
+    [InlineData("true", true)]
+    [InlineData("false", false)]
+    [InlineData("True", true)]
+    [InlineData("False", false)]
+    public void TryParseBool_WithValidInput_ReturnsSuccess(string input, bool expected)
+    {
+        // Act
+        var result = ParseToolkit.TryParseBool(input);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("yes")]
+    [InlineData("no")]
+    [InlineData("1")]
+    [InlineData("0")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseBool_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseBool(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(bool));
+    }
+
+    [Fact]
+    public void TryParseDateTime_WithValidInput_ReturnsSuccess()
+    {
+        // Arrange
+        var dateString = "2023-12-25T10:30:00";
+        var expected = new DateTime(2023, 12, 25, 10, 30, 0);
+
+        // Act
+        var result = ParseToolkit.TryParseDateTime(dateString);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("invalid-date")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseDateTime_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseDateTime(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(DateTime));
+    }
+
+    [Theory]
+    [InlineData("1234567890", 1234567890L)]
+    [InlineData("-987654321", -987654321L)]
+    [InlineData("0", 0L)]
+    public void TryParseLong_WithValidInput_ReturnsSuccess(string input, long expected)
+    {
+        // Act
+        var result = ParseToolkit.TryParseLong(input);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("abc")]
+    [InlineData("12.34")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseLong_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseLong(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(long));
+    }
+
+    [Theory]
+    [InlineData("123.45", 123.45)]
+    [InlineData("-456.78", -456.78)]
+    [InlineData("0.0", 0.0)]
+    public void TryParseDecimal_WithValidInput_ReturnsSuccess(string input, decimal expected)
+    {
+        // Act
+        var result = ParseToolkit.TryParseDecimal(input);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(expected);
+    }
+
+    [Theory]
+    [InlineData("abc")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void TryParseDecimal_WithInvalidInput_ReturnsParseError(string input)
+    {
+        // Act
+        var result = ParseToolkit.TryParseDecimal(input);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+        error.TargetType.Should().Be(typeof(decimal));
+    }
+
+    [Fact]
+    public void TryParseInt_WithCustomNumberStyles_ReturnsSuccess()
+    {
+        // Act
+        var result = ParseToolkit.TryParseInt("FF", System.Globalization.NumberStyles.HexNumber);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(255);
+    }
+
+    [Fact]
+    public void TryParseInt_WithCustomFormatProvider_ReturnsSuccess()
+    {
+        // Arrange
+        var culture = new System.Globalization.CultureInfo("en-US");
+
+        // Act
+        var result = ParseToolkit.TryParseInt("1,234", System.Globalization.NumberStyles.Number, culture);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(1234);
+    }
+
+    [Fact]
+    public void TryParseLong_WithCustomNumberStyles_ReturnsSuccess()
+    {
+        // Act
+        var result = ParseToolkit.TryParseLong("FF", System.Globalization.NumberStyles.HexNumber);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(255L);
+    }
+
+    [Fact]
+    public void TryParseDouble_WithCustomNumberStyles_ReturnsSuccess()
+    {
+        // Arrange
+        var culture = new System.Globalization.CultureInfo("en-US");
+
+        // Act
+        var result = ParseToolkit.TryParseDouble("1,234.56", System.Globalization.NumberStyles.Number, culture);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(1234.56);
+    }
+
+    [Fact]
+    public void TryParseDecimal_WithCustomNumberStyles_ReturnsSuccess()
+    {
+        // Arrange
+        var culture = new System.Globalization.CultureInfo("en-US");
+
+        // Act
+        var result = ParseToolkit.TryParseDecimal("1,234.56", System.Globalization.NumberStyles.Number, culture);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(1234.56m);
+    }
+
+    [Fact]
+    public void TryParseDateTime_WithCustomFormatProvider_ReturnsSuccess()
+    {
+        // Arrange
+        var culture = new System.Globalization.CultureInfo("en-US");
+        var dateString = "12/25/2023 10:30:00 AM";
+
+        // Act
+        var result = ParseToolkit.TryParseDateTime(dateString, culture);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        var parsed = result.ValueOrThrow();
+        parsed.Year.Should().Be(2023);
+        parsed.Month.Should().Be(12);
+        parsed.Day.Should().Be(25);
+    }
+
+    [Fact]
+    public void TryParseDateTime_WithCustomDateTimeStyles_ReturnsSuccess()
+    {
+        // Arrange
+        var dateString = "2023-12-25T10:30:00Z";
+
+        // Act
+        var result = ParseToolkit.TryParseDateTime(dateString, null, System.Globalization.DateTimeStyles.AdjustToUniversal);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Kind.Should().Be(DateTimeKind.Utc);
+    }
+
+    [Fact]
+    public void TryParseInt_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseInt(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseLong_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseLong(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseDouble_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseDouble(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseDecimal_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseDecimal(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseGuid_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseGuid(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseDateTime_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseDateTime(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void TryParseBool_WithNull_ReturnsParseError()
+    {
+        // Act
+        var result = ParseToolkit.TryParseBool(null!);
+
+        // Assert
+        result.IsError.Should().BeTrue();
+        var error = result.ErrorOrThrow();
+        error.Should().BeOfType<ParseError>();
+    }
+
+    [Fact]
+    public void ParseError_Properties_AreSetCorrectly()
+    {
+        // Test the error class properties for better coverage
+        var originalException = new FormatException("test format error");
+        var error = new ParseError("test input", typeof(int), originalException, "Test message");
+        
+        error.OriginalException.Should().Be(originalException);
+        error.InputValue.Should().Be("test input");
+        error.TargetType.Should().Be(typeof(int));
+        error.Message.Should().NotBeNullOrEmpty(); // The message behavior depends on ParseError implementation
+        error.Code.Should().Be("Parse.FormatError");
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/CollectionError.cs b/Maybe.Toolkit/CollectionError.cs
new file mode 100644
index 0000000..0fc14c4
--- /dev/null
+++ b/Maybe.Toolkit/CollectionError.cs
@@ -0,0 +1,35 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Error for collection access operations.
+/// </summary>
+public class CollectionError : FailureError
+{
+    public override OutcomeType Type => OutcomeType.Failure;
+    public override string Code => "Collection.AccessError";
+    public override string Message => "Collection access failed.";
+
+    /// <summary>
+    /// The key or index that was being accessed when the error occurred.
+    /// </summary>
+    public object? Key { get; private set; }
+
+    /// <summary>
+    /// The original exception that caused the collection error.
+    /// </summary>
+    public Exception? OriginalException { get; private set; }
+
+    public CollectionError() { }
+
+    public CollectionError(object key, Exception? originalException = null, string? customMessage = null)
+    {
+        Key = key;
+        OriginalException = originalException;
+        if (customMessage != null)
+        {
+            Message = customMessage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/CollectionToolkit.cs b/Maybe.Toolkit/CollectionToolkit.cs
new file mode 100644
index 0000000..a365703
--- /dev/null
+++ b/Maybe.Toolkit/CollectionToolkit.cs
@@ -0,0 +1,279 @@
+using System.Collections.Generic;
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Provides Maybe-based wrapper methods for safe collection access operations.
+/// </summary>
+public static class CollectionToolkit
+{
+    /// <summary>
+    /// Attempts to get a value from a dictionary by key, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary key.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary value.</typeparam>
+    /// <param name="dictionary">The dictionary to access.</param>
+    /// <param name="key">The key to look up.</param>
+    /// <returns>A Maybe containing the value if found or a CollectionError.</returns>
+    public static Maybe<TValue, CollectionError> TryGetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
+    {
+        if (dictionary == null)
+        {
+            return new CollectionError(key!, new ArgumentNullException(nameof(dictionary)), "Dictionary cannot be null");
+        }
+
+        if (key == null)
+        {
+            return new CollectionError(key!, new ArgumentNullException(nameof(key)), "Key cannot be null");
+        }
+
+        try
+        {
+            if (dictionary.TryGetValue(key, out var value))
+            {
+                return Maybe<TValue, CollectionError>.Some(value);
+            }
+            else
+            {
+                return new CollectionError(key, new KeyNotFoundException($"Key '{key}' was not found in the dictionary"), $"Key '{key}' was not found in the dictionary");
+            }
+        }
+        catch (ArgumentException ex)
+        {
+            return new CollectionError(key, ex, $"Invalid key type for dictionary: {key}");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError(key, ex, $"Unexpected error accessing dictionary with key: {key}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get a value from a read-only dictionary by key, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary key.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary value.</typeparam>
+    /// <param name="dictionary">The read-only dictionary to access.</param>
+    /// <param name="key">The key to look up.</param>
+    /// <returns>A Maybe containing the value if found or a CollectionError.</returns>
+    public static Maybe<TValue, CollectionError> TryGetValue<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
+    {
+        if (dictionary == null)
+        {
+            return new CollectionError(key!, new ArgumentNullException(nameof(dictionary)), "Dictionary cannot be null");
+        }
+
+        if (key == null)
+        {
+            return new CollectionError(key!, new ArgumentNullException(nameof(key)), "Key cannot be null");
+        }
+
+        try
+        {
+            if (dictionary.TryGetValue(key, out var value))
+            {
+                return Maybe<TValue, CollectionError>.Some(value);
+            }
+            else
+            {
+                return new CollectionError(key, new KeyNotFoundException($"Key '{key}' was not found in the dictionary"), $"Key '{key}' was not found in the dictionary");
+            }
+        }
+        catch (ArgumentException ex)
+        {
+            return new CollectionError(key, ex, $"Invalid key type for dictionary: {key}");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError(key, ex, $"Unexpected error accessing dictionary with key: {key}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get an element from a list by index, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the list elements.</typeparam>
+    /// <param name="list">The list to access.</param>
+    /// <param name="index">The index to access.</param>
+    /// <returns>A Maybe containing the element if found or a CollectionError.</returns>
+    public static Maybe<T, CollectionError> TryGetAt<T>(this IList<T> list, int index)
+    {
+        if (list == null)
+        {
+            return new CollectionError(index, new ArgumentNullException(nameof(list)), "List cannot be null");
+        }
+
+        try
+        {
+            if (index < 0 || index >= list.Count)
+            {
+                return new CollectionError(index, new ArgumentOutOfRangeException(nameof(index)), $"Index {index} is out of range for list of length {list.Count}");
+            }
+
+            var element = list[index];
+            return Maybe<T, CollectionError>.Some(element);
+        }
+        catch (ArgumentOutOfRangeException ex)
+        {
+            return new CollectionError(index, ex, $"Index {index} is out of range for list of length {list.Count}");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError(index, ex, $"Unexpected error accessing list at index: {index}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get an element from a read-only list by index, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the list elements.</typeparam>
+    /// <param name="list">The read-only list to access.</param>
+    /// <param name="index">The index to access.</param>
+    /// <returns>A Maybe containing the element if found or a CollectionError.</returns>
+    public static Maybe<T, CollectionError> TryGetAt<T>(this IReadOnlyList<T> list, int index)
+    {
+        if (list == null)
+        {
+            return new CollectionError(index, new ArgumentNullException(nameof(list)), "List cannot be null");
+        }
+
+        try
+        {
+            if (index < 0 || index >= list.Count)
+            {
+                return new CollectionError(index, new ArgumentOutOfRangeException(nameof(index)), $"Index {index} is out of range for list of length {list.Count}");
+            }
+
+            var element = list[index];
+            return Maybe<T, CollectionError>.Some(element);
+        }
+        catch (ArgumentOutOfRangeException ex)
+        {
+            return new CollectionError(index, ex, $"Index {index} is out of range for list of length {list.Count}");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError(index, ex, $"Unexpected error accessing list at index: {index}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get an element from an array by index, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the array elements.</typeparam>
+    /// <param name="array">The array to access.</param>
+    /// <param name="index">The index to access.</param>
+    /// <returns>A Maybe containing the element if found or a CollectionError.</returns>
+    public static Maybe<T, CollectionError> TryGetAt<T>(this T[] array, int index)
+    {
+        if (array == null)
+        {
+            return new CollectionError(index, new ArgumentNullException(nameof(array)), "Array cannot be null");
+        }
+
+        try
+        {
+            if (index < 0 || index >= array.Length)
+            {
+                return new CollectionError(index, new ArgumentOutOfRangeException(nameof(index)), $"Index {index} is out of range for array of length {array.Length}");
+            }
+
+            var element = array[index];
+            return Maybe<T, CollectionError>.Some(element);
+        }
+        catch (IndexOutOfRangeException ex)
+        {
+            return new CollectionError(index, ex, $"Index {index} is out of range for array of length {array.Length}");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError(index, ex, $"Unexpected error accessing array at index: {index}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get the first element from a sequence, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the sequence elements.</typeparam>
+    /// <param name="source">The sequence to access.</param>
+    /// <returns>A Maybe containing the first element if found or a CollectionError.</returns>
+    public static Maybe<T, CollectionError> TryFirst<T>(this IEnumerable<T> source)
+    {
+        if (source == null)
+        {
+            return new CollectionError("first", new ArgumentNullException(nameof(source)), "Source cannot be null");
+        }
+
+        try
+        {
+            using var enumerator = source.GetEnumerator();
+            if (enumerator.MoveNext())
+            {
+                return Maybe<T, CollectionError>.Some(enumerator.Current);
+            }
+            else
+            {
+                return new CollectionError("first", new InvalidOperationException("Sequence contains no elements"), "Sequence contains no elements");
+            }
+        }
+        catch (InvalidOperationException ex)
+        {
+            return new CollectionError("first", ex, "Sequence contains no elements");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError("first", ex, "Unexpected error getting first element from sequence");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get the last element from a sequence, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the sequence elements.</typeparam>
+    /// <param name="source">The sequence to access.</param>
+    /// <returns>A Maybe containing the last element if found or a CollectionError.</returns>
+    public static Maybe<T, CollectionError> TryLast<T>(this IEnumerable<T> source)
+    {
+        if (source == null)
+        {
+            return new CollectionError("last", new ArgumentNullException(nameof(source)), "Source cannot be null");
+        }
+
+        try
+        {
+            if (source is IList<T> list)
+            {
+                if (list.Count > 0)
+                {
+                    return Maybe<T, CollectionError>.Some(list[list.Count - 1]);
+                }
+            }
+            else
+            {
+                using var enumerator = source.GetEnumerator();
+                if (!enumerator.MoveNext())
+                {
+                    return new CollectionError("last", new InvalidOperationException("Sequence contains no elements"), "Sequence contains no elements");
+                }
+
+                T last = enumerator.Current;
+                while (enumerator.MoveNext())
+                {
+                    last = enumerator.Current;
+                }
+                return Maybe<T, CollectionError>.Some(last);
+            }
+
+            return new CollectionError("last", new InvalidOperationException("Sequence contains no elements"), "Sequence contains no elements");
+        }
+        catch (InvalidOperationException ex)
+        {
+            return new CollectionError("last", ex, "Sequence contains no elements");
+        }
+        catch (Exception ex)
+        {
+            return new CollectionError("last", ex, "Unexpected error getting last element from sequence");
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/FileError.cs b/Maybe.Toolkit/FileError.cs
new file mode 100644
index 0000000..51b28f4
--- /dev/null
+++ b/Maybe.Toolkit/FileError.cs
@@ -0,0 +1,35 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Error for file I/O operations.
+/// </summary>
+public class FileError : FailureError
+{
+    public override OutcomeType Type => OutcomeType.Failure;
+    public override string Code => "File.IOError";
+    public override string Message => "File operation failed.";
+
+    /// <summary>
+    /// The original exception that caused the file error.
+    /// </summary>
+    public Exception? OriginalException { get; private set; }
+
+    /// <summary>
+    /// The file path that was being accessed when the error occurred.
+    /// </summary>
+    public string? FilePath { get; private set; }
+
+    public FileError() { }
+
+    public FileError(Exception originalException, string? filePath = null, string? customMessage = null)
+    {
+        OriginalException = originalException;
+        FilePath = filePath;
+        if (customMessage != null)
+        {
+            Message = customMessage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/FileToolkit.cs b/Maybe.Toolkit/FileToolkit.cs
new file mode 100644
index 0000000..2d7e388
--- /dev/null
+++ b/Maybe.Toolkit/FileToolkit.cs
@@ -0,0 +1,230 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Provides Maybe-based wrapper methods for System.IO.File operations.
+/// </summary>
+public static class FileToolkit
+{
+    /// <summary>
+    /// Attempts to read all text from a file, returning a Maybe result.
+    /// </summary>
+    /// <param name="path">The path to the file to read.</param>
+    /// <returns>A Maybe containing the file contents or a FileError.</returns>
+    public static Maybe<string, FileError> TryReadAllText(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return new FileError(new ArgumentException("File path cannot be null or empty"), path, "File path cannot be null or empty");
+        }
+
+        try
+        {
+            var content = File.ReadAllText(path);
+            return Maybe<string, FileError>.Some(content);
+        }
+        catch (FileNotFoundException ex)
+        {
+            return new FileError(ex, path, $"File not found: {path}");
+        }
+        catch (DirectoryNotFoundException ex)
+        {
+            return new FileError(ex, path, $"Directory not found for file: {path}");
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            return new FileError(ex, path, $"Access denied to file: {path}");
+        }
+        catch (IOException ex)
+        {
+            return new FileError(ex, path, $"I/O error reading file: {path}");
+        }
+        catch (Exception ex)
+        {
+            return new FileError(ex, path, $"Unexpected error reading file: {path}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to read all text from a file with the specified encoding, returning a Maybe result.
+    /// </summary>
+    /// <param name="path">The path to the file to read.</param>
+    /// <param name="encoding">The encoding to use when reading the file.</param>
+    /// <returns>A Maybe containing the file contents or a FileError.</returns>
+    public static Maybe<string, FileError> TryReadAllText(string path, System.Text.Encoding encoding)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return new FileError(new ArgumentException("File path cannot be null or empty"), path, "File path cannot be null or empty");
+        }
+
+        if (encoding == null)
+        {
+            return new FileError(new ArgumentNullException(nameof(encoding)), path, "Encoding cannot be null");
+        }
+
+        try
+        {
+            var content = File.ReadAllText(path, encoding);
+            return Maybe<string, FileError>.Some(content);
+        }
+        catch (FileNotFoundException ex)
+        {
+            return new FileError(ex, path, $"File not found: {path}");
+        }
+        catch (DirectoryNotFoundException ex)
+        {
+            return new FileError(ex, path, $"Directory not found for file: {path}");
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            return new FileError(ex, path, $"Access denied to file: {path}");
+        }
+        catch (IOException ex)
+        {
+            return new FileError(ex, path, $"I/O error reading file: {path}");
+        }
+        catch (Exception ex)
+        {
+            return new FileError(ex, path, $"Unexpected error reading file: {path}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to read all bytes from a file, returning a Maybe result.
+    /// </summary>
+    /// <param name="path">The path to the file to read.</param>
+    /// <returns>A Maybe containing the file bytes or a FileError.</returns>
+    public static Maybe<byte[], FileError> TryReadAllBytes(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return new FileError(new ArgumentException("File path cannot be null or empty"), path, "File path cannot be null or empty");
+        }
+
+        try
+        {
+            var bytes = File.ReadAllBytes(path);
+            return Maybe<byte[], FileError>.Some(bytes);
+        }
+        catch (FileNotFoundException ex)
+        {
+            return new FileError(ex, path, $"File not found: {path}");
+        }
+        catch (DirectoryNotFoundException ex)
+        {
+            return new FileError(ex, path, $"Directory not found for file: {path}");
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            return new FileError(ex, path, $"Access denied to file: {path}");
+        }
+        catch (IOException ex)
+        {
+            return new FileError(ex, path, $"I/O error reading file: {path}");
+        }
+        catch (Exception ex)
+        {
+            return new FileError(ex, path, $"Unexpected error reading file: {path}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to write all text to a file, returning a Maybe result.
+    /// </summary>
+    /// <param name="path">The path to the file to write.</param>
+    /// <param name="contents">The string to write to the file.</param>
+    /// <returns>A Maybe indicating success or a FileError.</returns>
+    public static Maybe<Unit, FileError> TryWriteAllText(string path, string contents)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return new FileError(new ArgumentException("File path cannot be null or empty"), path, "File path cannot be null or empty");
+        }
+
+        if (contents == null)
+        {
+            return new FileError(new ArgumentNullException(nameof(contents)), path, "Contents cannot be null");
+        }
+
+        try
+        {
+            File.WriteAllText(path, contents);
+            return Maybe<Unit, FileError>.Some(Unit.Value);
+        }
+        catch (DirectoryNotFoundException ex)
+        {
+            return new FileError(ex, path, $"Directory not found for file: {path}");
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            return new FileError(ex, path, $"Access denied to file: {path}");
+        }
+        catch (IOException ex)
+        {
+            return new FileError(ex, path, $"I/O error writing file: {path}");
+        }
+        catch (Exception ex)
+        {
+            return new FileError(ex, path, $"Unexpected error writing file: {path}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to write all bytes to a file, returning a Maybe result.
+    /// </summary>
+    /// <param name="path">The path to the file to write.</param>
+    /// <param name="bytes">The bytes to write to the file.</param>
+    /// <returns>A Maybe indicating success or a FileError.</returns>
+    public static Maybe<Unit, FileError> TryWriteAllBytes(string path, byte[] bytes)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return new FileError(new ArgumentException("File path cannot be null or empty"), path, "File path cannot be null or empty");
+        }
+
+        if (bytes == null)
+        {
+            return new FileError(new ArgumentNullException(nameof(bytes)), path, "Bytes cannot be null");
+        }
+
+        try
+        {
+            File.WriteAllBytes(path, bytes);
+            return Maybe<Unit, FileError>.Some(Unit.Value);
+        }
+        catch (DirectoryNotFoundException ex)
+        {
+            return new FileError(ex, path, $"Directory not found for file: {path}");
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            return new FileError(ex, path, $"Access denied to file: {path}");
+        }
+        catch (IOException ex)
+        {
+            return new FileError(ex, path, $"I/O error writing file: {path}");
+        }
+        catch (Exception ex)
+        {
+            return new FileError(ex, path, $"Unexpected error writing file: {path}");
+        }
+    }
+}
+
+/// <summary>
+/// Represents a unit value - a type with only one value, used to indicate success without a meaningful return value.
+/// </summary>
+public readonly struct Unit
+{
+    /// <summary>
+    /// The singleton value of Unit.
+    /// </summary>
+    public static readonly Unit Value = new();
+    
+    /// <summary>
+    /// Returns a string representation of the Unit value.
+    /// </summary>
+    public override string ToString() => "()";
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/HttpError.cs b/Maybe.Toolkit/HttpError.cs
new file mode 100644
index 0000000..7fc805a
--- /dev/null
+++ b/Maybe.Toolkit/HttpError.cs
@@ -0,0 +1,41 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Error for HTTP request operations.
+/// </summary>
+public class HttpError : FailureError
+{
+    public override OutcomeType Type => OutcomeType.Failure;
+    public override string Code => "Http.RequestError";
+    public override string Message => "HTTP request failed.";
+
+    /// <summary>
+    /// The original exception that caused the HTTP error.
+    /// </summary>
+    public Exception? OriginalException { get; private set; }
+
+    /// <summary>
+    /// The URL that was being accessed when the error occurred.
+    /// </summary>
+    public string? RequestUrl { get; private set; }
+
+    /// <summary>
+    /// The HTTP status code if available.
+    /// </summary>
+    public System.Net.HttpStatusCode? StatusCode { get; private set; }
+
+    public HttpError() { }
+
+    public HttpError(Exception originalException, string? requestUrl = null, System.Net.HttpStatusCode? statusCode = null, string? customMessage = null)
+    {
+        OriginalException = originalException;
+        RequestUrl = requestUrl;
+        StatusCode = statusCode;
+        if (customMessage != null)
+        {
+            Message = customMessage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/HttpJsonError.cs b/Maybe.Toolkit/HttpJsonError.cs
new file mode 100644
index 0000000..4d3e0f5
--- /dev/null
+++ b/Maybe.Toolkit/HttpJsonError.cs
@@ -0,0 +1,63 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Represents an error that occurred during combined HTTP and JSON operations.
+/// This error can wrap either an HttpError or a JsonError.
+/// </summary>
+public class HttpJsonError : FailureError
+{
+    private readonly BaseError? _innerError;
+
+    /// <summary>
+    /// Initializes a new instance of the HttpJsonError class.
+    /// Required for Maybe constraint.
+    /// </summary>
+    public HttpJsonError() : base("Unknown HTTP/JSON error", "HTTP_JSON_UNKNOWN")
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the HttpJsonError class with an HttpError.
+    /// </summary>
+    /// <param name="httpError">The HTTP error that occurred.</param>
+    public HttpJsonError(HttpError httpError) : base(httpError.Message, $"HTTP_JSON_{httpError.Code}")
+    {
+        _innerError = httpError;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the HttpJsonError class with a JsonError.
+    /// </summary>
+    /// <param name="jsonError">The JSON error that occurred.</param>
+    public HttpJsonError(JsonError jsonError) : base(jsonError.Message, $"HTTP_JSON_{jsonError.Code}")
+    {
+        _innerError = jsonError;
+    }
+
+    /// <summary>
+    /// Gets the original HTTP error if this error was caused by an HTTP operation.
+    /// </summary>
+    public HttpError? HttpError => _innerError as HttpError;
+
+    /// <summary>
+    /// Gets the original JSON error if this error was caused by a JSON operation.
+    /// </summary>
+    public JsonError? JsonError => _innerError as JsonError;
+
+    /// <summary>
+    /// Gets the underlying error that caused this composite error.
+    /// </summary>
+    public BaseError? UnderlyingError => _innerError;
+
+    /// <summary>
+    /// Returns true if this error was caused by an HTTP operation.
+    /// </summary>
+    public bool IsHttpError => _innerError is HttpError;
+
+    /// <summary>
+    /// Returns true if this error was caused by a JSON operation.
+    /// </summary>
+    public bool IsJsonError => _innerError is JsonError;
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/HttpToolkit.cs b/Maybe.Toolkit/HttpToolkit.cs
new file mode 100644
index 0000000..ca7eb5e
--- /dev/null
+++ b/Maybe.Toolkit/HttpToolkit.cs
@@ -0,0 +1,743 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Provides Maybe-based wrapper methods for HttpClient operations.
+/// </summary>
+public static class HttpToolkit
+{
+    /// <summary>
+    /// Attempts to send a GET request to the specified Uri, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryGetAsync(this HttpClient client, string? requestUri)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri, null, "HttpClient cannot be null");
+        }
+
+        if (string.IsNullOrWhiteSpace(requestUri))
+        {
+            return new HttpError(new ArgumentException("Request URI cannot be null or empty"), requestUri, null, "Request URI cannot be null or empty");
+        }
+
+        try
+        {
+            var response = await client.GetAsync(requestUri).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri, null, $"Unexpected error during HTTP GET request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a GET request to the specified Uri, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryGetAsync(this HttpClient client, Uri? requestUri)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri?.ToString(), null, "HttpClient cannot be null");
+        }
+
+        if (requestUri == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(requestUri)), null, null, "Request URI cannot be null");
+        }
+
+        try
+        {
+            var response = await client.GetAsync(requestUri).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"Unexpected error during HTTP GET request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a POST request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPostAsync(this HttpClient client, string? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri, null, "HttpClient cannot be null");
+        }
+
+        if (string.IsNullOrWhiteSpace(requestUri))
+        {
+            return new HttpError(new ArgumentException("Request URI cannot be null or empty"), requestUri, null, "Request URI cannot be null or empty");
+        }
+
+        try
+        {
+            var response = await client.PostAsync(requestUri, content).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP POST request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP POST request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP POST request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri, null, $"Unexpected error during HTTP POST request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a POST request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPostAsync(this HttpClient client, Uri? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri?.ToString(), null, "HttpClient cannot be null");
+        }
+
+        if (requestUri == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(requestUri)), null, null, "Request URI cannot be null");
+        }
+
+        try
+        {
+            var response = await client.PostAsync(requestUri, content).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP POST request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP POST request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP POST request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"Unexpected error during HTTP POST request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a PUT request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPutAsync(this HttpClient client, string? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri, null, "HttpClient cannot be null");
+        }
+
+        if (string.IsNullOrWhiteSpace(requestUri))
+        {
+            return new HttpError(new ArgumentException("Request URI cannot be null or empty"), requestUri, null, "Request URI cannot be null or empty");
+        }
+
+        try
+        {
+            var response = await client.PutAsync(requestUri, content).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PUT request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PUT request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PUT request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri, null, $"Unexpected error during HTTP PUT request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a PUT request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPutAsync(this HttpClient client, Uri? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri?.ToString(), null, "HttpClient cannot be null");
+        }
+
+        if (requestUri == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(requestUri)), null, null, "Request URI cannot be null");
+        }
+
+        try
+        {
+            var response = await client.PutAsync(requestUri, content).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PUT request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PUT request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PUT request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"Unexpected error during HTTP PUT request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a PATCH request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPatchAsync(this HttpClient client, string? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri, null, "HttpClient cannot be null");
+        }
+
+        if (string.IsNullOrWhiteSpace(requestUri))
+        {
+            return new HttpError(new ArgumentException("Request URI cannot be null or empty"), requestUri, null, "Request URI cannot be null or empty");
+        }
+
+        try
+        {
+#if NET8_0
+            var response = await client.PatchAsync(requestUri, content).ConfigureAwait(false);
+#else
+            var request = new HttpRequestMessage(new HttpMethod("PATCH"), requestUri)
+            {
+                Content = content
+            };
+            var response = await client.SendAsync(request).ConfigureAwait(false);
+#endif
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PATCH request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PATCH request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP PATCH request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri, null, $"Unexpected error during HTTP PATCH request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a PATCH request to the specified Uri with the given content, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryPatchAsync(this HttpClient client, Uri? requestUri, HttpContent? content)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri?.ToString(), null, "HttpClient cannot be null");
+        }
+
+        if (requestUri == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(requestUri)), null, null, "Request URI cannot be null");
+        }
+
+        try
+        {
+#if NET8_0
+            var response = await client.PatchAsync(requestUri, content).ConfigureAwait(false);
+#else
+            var request = new HttpRequestMessage(new HttpMethod("PATCH"), requestUri)
+            {
+                Content = content
+            };
+            var response = await client.SendAsync(request).ConfigureAwait(false);
+#endif
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PATCH request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PATCH request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP PATCH request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"Unexpected error during HTTP PATCH request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a DELETE request to the specified Uri, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryDeleteAsync(this HttpClient client, string? requestUri)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri, null, "HttpClient cannot be null");
+        }
+
+        if (string.IsNullOrWhiteSpace(requestUri))
+        {
+            return new HttpError(new ArgumentException("Request URI cannot be null or empty"), requestUri, null, "Request URI cannot be null or empty");
+        }
+
+        try
+        {
+            var response = await client.DeleteAsync(requestUri).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP DELETE request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP DELETE request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri, null, $"HTTP DELETE request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri, null, $"Unexpected error during HTTP DELETE request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a DELETE request to the specified Uri, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpError>> TryDeleteAsync(this HttpClient client, Uri? requestUri)
+    {
+        if (client == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(client)), requestUri?.ToString(), null, "HttpClient cannot be null");
+        }
+
+        if (requestUri == null)
+        {
+            return new HttpError(new ArgumentNullException(nameof(requestUri)), null, null, "Request URI cannot be null");
+        }
+
+        try
+        {
+            var response = await client.DeleteAsync(requestUri).ConfigureAwait(false);
+            return Maybe<HttpResponseMessage, HttpError>.Some(response);
+        }
+        catch (HttpRequestException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP DELETE request failed for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP DELETE request timed out for URI: {requestUri}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"HTTP DELETE request was cancelled for URI: {requestUri}");
+        }
+        catch (Exception ex)
+        {
+            return new HttpError(ex, requestUri.ToString(), null, $"Unexpected error during HTTP DELETE request to URI: {requestUri}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to send a GET request and read the response content as string, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the response content as string or an HttpError.</returns>
+    public static async Task<Maybe<string, HttpError>> TryGetStringAsync(this HttpClient client, string? requestUri)
+    {
+        var responseResult = await client.TryGetAsync(requestUri).ConfigureAwait(false);
+        
+        return await responseResult.SelectAsync(async response =>
+        {
+            try
+            {
+                using (response)
+                {
+                    return await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new HttpRequestException($"Failed to read response content as string from URI: {requestUri}", ex);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Attempts to send a GET request and read the response content as byte array, returning a Maybe result.
+    /// </summary>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <returns>A Maybe containing the response content as byte array or an HttpError.</returns>
+    public static async Task<Maybe<byte[], HttpError>> TryGetByteArrayAsync(this HttpClient client, string? requestUri)
+    {
+        var responseResult = await client.TryGetAsync(requestUri).ConfigureAwait(false);
+        
+        return await responseResult.SelectAsync(async response =>
+        {
+            try
+            {
+                using (response)
+                {
+                    return await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new HttpRequestException($"Failed to read response content as byte array from URI: {requestUri}", ex);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    #region JSON-integrated HTTP methods
+
+    /// <summary>
+    /// Attempts to send a GET request and deserialize the JSON response to the specified type, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize the JSON response to.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="options">Optional JsonSerializerOptions for deserialization.</param>
+    /// <returns>A Maybe containing the deserialized object or an HttpJsonError.</returns>
+    public static async Task<Maybe<T, HttpJsonError>> TryGetJsonAsync<T>(this HttpClient client, string? requestUri, JsonSerializerOptions? options = null)
+    {
+        var stringResult = await client.TryGetStringAsync(requestUri).ConfigureAwait(false);
+        
+        if (stringResult.IsError)
+        {
+            return new HttpJsonError(stringResult.ErrorOrThrow());
+        }
+
+        var jsonResult = JsonToolkit.TryDeserialize<T>(stringResult.ValueOrThrow(), options);
+        if (jsonResult.IsError)
+        {
+            return new HttpJsonError(jsonResult.ErrorOrThrow());
+        }
+
+        return Maybe<T, HttpJsonError>.Some(jsonResult.ValueOrThrow());
+    }
+
+    /// <summary>
+    /// Attempts to send a GET request and deserialize the JSON response to the specified type, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize the JSON response to.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="options">Optional JsonSerializerOptions for deserialization.</param>
+    /// <returns>A Maybe containing the deserialized object or an HttpJsonError.</returns>
+    public static async Task<Maybe<T, HttpJsonError>> TryGetJsonAsync<T>(this HttpClient client, Uri? requestUri, JsonSerializerOptions? options = null)
+    {
+        return await client.TryGetJsonAsync<T>(requestUri?.ToString(), options).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a POST request, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpJsonError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpJsonError>> TryPostJsonAsync<TRequest>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var jsonResult = JsonToolkit.TrySerialize(value, options);
+        if (jsonResult.IsError)
+        {
+            return new HttpJsonError(jsonResult.ErrorOrThrow());
+        }
+
+        var content = new StringContent(jsonResult.ValueOrThrow(), Encoding.UTF8, "application/json");
+        var httpResult = await client.TryPostAsync(requestUri, content).ConfigureAwait(false);
+        
+        if (httpResult.IsError)
+        {
+            return new HttpJsonError(httpResult.ErrorOrThrow());
+        }
+
+        return Maybe<HttpResponseMessage, HttpJsonError>.Some(httpResult.ValueOrThrow());
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a POST request, then deserialize the response, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <typeparam name="TResponse">The type to deserialize the JSON response to.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization/deserialization.</param>
+    /// <returns>A Maybe containing the deserialized response object or an HttpJsonError.</returns>
+    public static async Task<Maybe<TResponse, HttpJsonError>> TryPostJsonAsync<TRequest, TResponse>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var responseResult = await client.TryPostJsonAsync(requestUri, value, options).ConfigureAwait(false);
+        
+        if (responseResult.IsError)
+        {
+            return responseResult.ErrorOrThrow();
+        }
+
+        try
+        {
+            using (var response = responseResult.ValueOrThrow())
+            {
+                var jsonString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+                var jsonResult = JsonToolkit.TryDeserialize<TResponse>(jsonString, options);
+                
+                if (jsonResult.IsError)
+                {
+                    return new HttpJsonError(jsonResult.ErrorOrThrow());
+                }
+
+                return Maybe<TResponse, HttpJsonError>.Some(jsonResult.ValueOrThrow());
+            }
+        }
+        catch (Exception ex)
+        {
+            return new HttpJsonError(new HttpError(ex, requestUri, null, $"Failed to read response content from URI: {requestUri}"));
+        }
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a PUT request, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpJsonError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpJsonError>> TryPutJsonAsync<TRequest>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var jsonResult = JsonToolkit.TrySerialize(value, options);
+        if (jsonResult.IsError)
+        {
+            return new HttpJsonError(jsonResult.ErrorOrThrow());
+        }
+
+        var content = new StringContent(jsonResult.ValueOrThrow(), Encoding.UTF8, "application/json");
+        var httpResult = await client.TryPutAsync(requestUri, content).ConfigureAwait(false);
+        
+        if (httpResult.IsError)
+        {
+            return new HttpJsonError(httpResult.ErrorOrThrow());
+        }
+
+        return Maybe<HttpResponseMessage, HttpJsonError>.Some(httpResult.ValueOrThrow());
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a PUT request, then deserialize the response, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <typeparam name="TResponse">The type to deserialize the JSON response to.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization/deserialization.</param>
+    /// <returns>A Maybe containing the deserialized response object or an HttpJsonError.</returns>
+    public static async Task<Maybe<TResponse, HttpJsonError>> TryPutJsonAsync<TRequest, TResponse>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var responseResult = await client.TryPutJsonAsync(requestUri, value, options).ConfigureAwait(false);
+        
+        if (responseResult.IsError)
+        {
+            return responseResult.ErrorOrThrow();
+        }
+
+        try
+        {
+            using (var response = responseResult.ValueOrThrow())
+            {
+                var jsonString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+                var jsonResult = JsonToolkit.TryDeserialize<TResponse>(jsonString, options);
+                
+                if (jsonResult.IsError)
+                {
+                    return new HttpJsonError(jsonResult.ErrorOrThrow());
+                }
+
+                return Maybe<TResponse, HttpJsonError>.Some(jsonResult.ValueOrThrow());
+            }
+        }
+        catch (Exception ex)
+        {
+            return new HttpJsonError(new HttpError(ex, requestUri, null, $"Failed to read response content from URI: {requestUri}"));
+        }
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a PATCH request, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization.</param>
+    /// <returns>A Maybe containing the HttpResponseMessage or an HttpJsonError.</returns>
+    public static async Task<Maybe<HttpResponseMessage, HttpJsonError>> TryPatchJsonAsync<TRequest>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var jsonResult = JsonToolkit.TrySerialize(value, options);
+        if (jsonResult.IsError)
+        {
+            return new HttpJsonError(jsonResult.ErrorOrThrow());
+        }
+
+        var content = new StringContent(jsonResult.ValueOrThrow(), Encoding.UTF8, "application/json");
+        var httpResult = await client.TryPatchAsync(requestUri, content).ConfigureAwait(false);
+        
+        if (httpResult.IsError)
+        {
+            return new HttpJsonError(httpResult.ErrorOrThrow());
+        }
+
+        return Maybe<HttpResponseMessage, HttpJsonError>.Some(httpResult.ValueOrThrow());
+    }
+
+    /// <summary>
+    /// Attempts to serialize an object to JSON and send it as a PATCH request, then deserialize the response, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="TRequest">The type of the object to serialize and send.</typeparam>
+    /// <typeparam name="TResponse">The type to deserialize the JSON response to.</typeparam>
+    /// <param name="client">The HttpClient to use for the request.</param>
+    /// <param name="requestUri">The Uri the request is sent to.</param>
+    /// <param name="value">The object to serialize and send.</param>
+    /// <param name="options">Optional JsonSerializerOptions for serialization/deserialization.</param>
+    /// <returns>A Maybe containing the deserialized response object or an HttpJsonError.</returns>
+    public static async Task<Maybe<TResponse, HttpJsonError>> TryPatchJsonAsync<TRequest, TResponse>(this HttpClient client, string? requestUri, TRequest value, JsonSerializerOptions? options = null)
+    {
+        var responseResult = await client.TryPatchJsonAsync(requestUri, value, options).ConfigureAwait(false);
+        
+        if (responseResult.IsError)
+        {
+            return responseResult.ErrorOrThrow();
+        }
+
+        try
+        {
+            using (var response = responseResult.ValueOrThrow())
+            {
+                var jsonString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+                var jsonResult = JsonToolkit.TryDeserialize<TResponse>(jsonString, options);
+                
+                if (jsonResult.IsError)
+                {
+                    return new HttpJsonError(jsonResult.ErrorOrThrow());
+                }
+
+                return Maybe<TResponse, HttpJsonError>.Some(jsonResult.ValueOrThrow());
+            }
+        }
+        catch (Exception ex)
+        {
+            return new HttpJsonError(new HttpError(ex, requestUri, null, $"Failed to read response content from URI: {requestUri}"));
+        }
+    }
+
+    #endregion
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/JsonError.cs b/Maybe.Toolkit/JsonError.cs
new file mode 100644
index 0000000..9cc0cf5
--- /dev/null
+++ b/Maybe.Toolkit/JsonError.cs
@@ -0,0 +1,29 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Error for JSON serialization/deserialization failures.
+/// </summary>
+public class JsonError : FailureError
+{
+    public override OutcomeType Type => OutcomeType.Failure;
+    public override string Code => "Json.SerializationError";
+    public override string Message => "JSON operation failed.";
+
+    /// <summary>
+    /// The original exception that caused the JSON error.
+    /// </summary>
+    public Exception? OriginalException { get; private set; }
+
+    public JsonError() { }
+
+    public JsonError(Exception originalException, string? customMessage = null)
+    {
+        OriginalException = originalException;
+        if (customMessage != null)
+        {
+            Message = customMessage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/JsonToolkit.cs b/Maybe.Toolkit/JsonToolkit.cs
new file mode 100644
index 0000000..793ea37
--- /dev/null
+++ b/Maybe.Toolkit/JsonToolkit.cs
@@ -0,0 +1,120 @@
+using System.Text.Json;
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Provides Maybe-based wrapper methods for System.Text.Json.JsonSerializer operations.
+/// </summary>
+public static class JsonToolkit
+{
+    /// <summary>
+    /// Attempts to deserialize the JSON string to the specified type, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize to.</typeparam>
+    /// <param name="json">The JSON string to deserialize.</param>
+    /// <param name="options">Optional JsonSerializerOptions.</param>
+    /// <returns>A Maybe containing the deserialized object or a JsonError.</returns>
+    public static Maybe<T, JsonError> TryDeserialize<T>(string json, JsonSerializerOptions? options = null)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+        {
+            return new JsonError(new ArgumentException("JSON string cannot be null or empty"), "JSON string cannot be null or empty");
+        }
+
+        try
+        {
+            var result = JsonSerializer.Deserialize<T>(json, options);
+            if (result == null && !typeof(T).IsValueType && Nullable.GetUnderlyingType(typeof(T)) == null)
+            {
+                return new JsonError(new InvalidOperationException("Deserialization resulted in null"), "Deserialization resulted in null");
+            }
+            return Maybe<T, JsonError>.Some(result!);
+        }
+        catch (JsonException ex)
+        {
+            return new JsonError(ex, $"Failed to deserialize JSON to {typeof(T).Name}");
+        }
+        catch (ArgumentNullException ex)
+        {
+            return new JsonError(ex, "JSON input was null");
+        }
+        catch (NotSupportedException ex)
+        {
+            return new JsonError(ex, $"Type {typeof(T).Name} is not supported for JSON deserialization");
+        }
+        catch (Exception ex)
+        {
+            return new JsonError(ex, $"Unexpected error during JSON deserialization to {typeof(T).Name}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to deserialize the UTF-8 JSON bytes to the specified type, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize to.</typeparam>
+    /// <param name="utf8Json">The UTF-8 JSON bytes to deserialize.</param>
+    /// <param name="options">Optional JsonSerializerOptions.</param>
+    /// <returns>A Maybe containing the deserialized object or a JsonError.</returns>
+    public static Maybe<T, JsonError> TryDeserialize<T>(ReadOnlySpan<byte> utf8Json, JsonSerializerOptions? options = null)
+    {
+        if (utf8Json.Length == 0)
+        {
+            return new JsonError(new ArgumentException("UTF-8 JSON bytes cannot be empty"), "UTF-8 JSON bytes cannot be empty");
+        }
+
+        try
+        {
+            var result = JsonSerializer.Deserialize<T>(utf8Json, options);
+            if (result == null && !typeof(T).IsValueType && Nullable.GetUnderlyingType(typeof(T)) == null)
+            {
+                return new JsonError(new InvalidOperationException("Deserialization resulted in null"), "Deserialization resulted in null");
+            }
+            return Maybe<T, JsonError>.Some(result!);
+        }
+        catch (JsonException ex)
+        {
+            return new JsonError(ex, $"Failed to deserialize UTF-8 JSON to {typeof(T).Name}");
+        }
+        catch (ArgumentNullException ex)
+        {
+            return new JsonError(ex, "UTF-8 JSON input was null");
+        }
+        catch (NotSupportedException ex)
+        {
+            return new JsonError(ex, $"Type {typeof(T).Name} is not supported for JSON deserialization");
+        }
+        catch (Exception ex)
+        {
+            return new JsonError(ex, $"Unexpected error during UTF-8 JSON deserialization to {typeof(T).Name}");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to serialize the object to a JSON string, returning a Maybe result.
+    /// </summary>
+    /// <typeparam name="T">The type of the object to serialize.</typeparam>
+    /// <param name="value">The object to serialize.</param>
+    /// <param name="options">Optional JsonSerializerOptions.</param>
+    /// <returns>A Maybe containing the JSON string or a JsonError.</returns>
+    public static Maybe<string, JsonError> TrySerialize<T>(T value, JsonSerializerOptions? options = null)
+    {
+        try
+        {
+            var result = JsonSerializer.Serialize(value, options);
+            return Maybe<string, JsonError>.Some(result);
+        }
+        catch (JsonException ex)
+        {
+            return new JsonError(ex, $"Failed to serialize {typeof(T).Name} to JSON");
+        }
+        catch (NotSupportedException ex)
+        {
+            return new JsonError(ex, $"Type {typeof(T).Name} is not supported for JSON serialization");
+        }
+        catch (Exception ex)
+        {
+            return new JsonError(ex, $"Unexpected error during JSON serialization of {typeof(T).Name}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/Maybe.Toolkit.csproj b/Maybe.Toolkit/Maybe.Toolkit.csproj
new file mode 100644
index 0000000..0f21cef
--- /dev/null
+++ b/Maybe.Toolkit/Maybe.Toolkit.csproj
@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+    <IsPackable>true</IsPackable>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- NuGet Package Settings -->
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <PackageId>FluentCoder.Maybe.Toolkit</PackageId>
+    <Version>1.0.0</Version>
+    <Authors>Luca Fabbri</Authors>
+    <Company>Luca Fabbri</Company>
+    <Description>A toolkit providing fluent Maybe-based wrappers for common .NET operations that typically throw exceptions, including JSON serialization, file I/O, parsing, HTTP requests, and collection access.</Description>
+    <Copyright>Copyright (c) Luca Fabbri 2025</Copyright>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/lucafabbri/Maybe</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/lucafabbri/Maybe.git</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageTags>maybe result error-handling functional toolkit json file parsing http</PackageTags>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Maybe\Maybe.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Text.Json" Version="8.0.5" />
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/Maybe.Toolkit/ParseError.cs b/Maybe.Toolkit/ParseError.cs
new file mode 100644
index 0000000..c0bfe53
--- /dev/null
+++ b/Maybe.Toolkit/ParseError.cs
@@ -0,0 +1,41 @@
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Error for parsing operations.
+/// </summary>
+public class ParseError : ValidationError
+{
+    public override OutcomeType Type => OutcomeType.Validation;
+    public override string Code => "Parse.FormatError";
+    public override string Message => "Parsing operation failed.";
+
+    /// <summary>
+    /// The value that failed to parse.
+    /// </summary>
+    public string? InputValue { get; private set; }
+
+    /// <summary>
+    /// The target type that was being parsed to.
+    /// </summary>
+    public Type? TargetType { get; private set; }
+
+    /// <summary>
+    /// The original exception that caused the parse error.
+    /// </summary>
+    public Exception? OriginalException { get; private set; }
+
+    public ParseError() { }
+
+    public ParseError(string inputValue, Type targetType, Exception? originalException = null, string? customMessage = null)
+    {
+        InputValue = inputValue;
+        TargetType = targetType;
+        OriginalException = originalException;
+        if (customMessage != null)
+        {
+            Message = customMessage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/ParseToolkit.cs b/Maybe.Toolkit/ParseToolkit.cs
new file mode 100644
index 0000000..ebde664
--- /dev/null
+++ b/Maybe.Toolkit/ParseToolkit.cs
@@ -0,0 +1,225 @@
+using System.Globalization;
+using Maybe;
+
+namespace Maybe.Toolkit;
+
+/// <summary>
+/// Provides Maybe-based wrapper methods for common parsing operations.
+/// </summary>
+public static class ParseToolkit
+{
+    /// <summary>
+    /// Attempts to parse a string to an integer, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="style">Optional number style.</param>
+    /// <param name="provider">Optional format provider.</param>
+    /// <returns>A Maybe containing the parsed integer or a ParseError.</returns>
+    public static Maybe<int, ParseError> TryParseInt(string value, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(int), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = int.Parse(value, style, provider ?? CultureInfo.InvariantCulture);
+            return Maybe<int, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(int), ex, $"'{value}' is not a valid integer format");
+        }
+        catch (OverflowException ex)
+        {
+            return new ParseError(value, typeof(int), ex, $"'{value}' is too large or too small for an integer");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(int), ex, $"Unexpected error parsing '{value}' to integer");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a long, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="style">Optional number style.</param>
+    /// <param name="provider">Optional format provider.</param>
+    /// <returns>A Maybe containing the parsed long or a ParseError.</returns>
+    public static Maybe<long, ParseError> TryParseLong(string value, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(long), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = long.Parse(value, style, provider ?? CultureInfo.InvariantCulture);
+            return Maybe<long, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(long), ex, $"'{value}' is not a valid long format");
+        }
+        catch (OverflowException ex)
+        {
+            return new ParseError(value, typeof(long), ex, $"'{value}' is too large or too small for a long");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(long), ex, $"Unexpected error parsing '{value}' to long");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a double, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="style">Optional number style.</param>
+    /// <param name="provider">Optional format provider.</param>
+    /// <returns>A Maybe containing the parsed double or a ParseError.</returns>
+    public static Maybe<double, ParseError> TryParseDouble(string value, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(double), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = double.Parse(value, style, provider ?? CultureInfo.InvariantCulture);
+            return Maybe<double, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(double), ex, $"'{value}' is not a valid double format");
+        }
+        catch (OverflowException ex)
+        {
+            return new ParseError(value, typeof(double), ex, $"'{value}' is too large or too small for a double");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(double), ex, $"Unexpected error parsing '{value}' to double");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a decimal, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="style">Optional number style.</param>
+    /// <param name="provider">Optional format provider.</param>
+    /// <returns>A Maybe containing the parsed decimal or a ParseError.</returns>
+    public static Maybe<decimal, ParseError> TryParseDecimal(string value, NumberStyles style = NumberStyles.Number, IFormatProvider? provider = null)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(decimal), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = decimal.Parse(value, style, provider ?? CultureInfo.InvariantCulture);
+            return Maybe<decimal, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(decimal), ex, $"'{value}' is not a valid decimal format");
+        }
+        catch (OverflowException ex)
+        {
+            return new ParseError(value, typeof(decimal), ex, $"'{value}' is too large or too small for a decimal");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(decimal), ex, $"Unexpected error parsing '{value}' to decimal");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a Guid, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <returns>A Maybe containing the parsed Guid or a ParseError.</returns>
+    public static Maybe<Guid, ParseError> TryParseGuid(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(Guid), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = Guid.Parse(value);
+            return Maybe<Guid, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(Guid), ex, $"'{value}' is not a valid Guid format");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(Guid), ex, $"Unexpected error parsing '{value}' to Guid");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a DateTime, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="provider">Optional format provider.</param>
+    /// <param name="styles">Optional date time styles.</param>
+    /// <returns>A Maybe containing the parsed DateTime or a ParseError.</returns>
+    public static Maybe<DateTime, ParseError> TryParseDateTime(string value, IFormatProvider? provider = null, DateTimeStyles styles = DateTimeStyles.None)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(DateTime), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = DateTime.Parse(value, provider ?? CultureInfo.InvariantCulture, styles);
+            return Maybe<DateTime, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(DateTime), ex, $"'{value}' is not a valid DateTime format");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(DateTime), ex, $"Unexpected error parsing '{value}' to DateTime");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to parse a string to a boolean, returning a Maybe result.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <returns>A Maybe containing the parsed boolean or a ParseError.</returns>
+    public static Maybe<bool, ParseError> TryParseBool(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return new ParseError(value ?? "", typeof(bool), null, "Value cannot be null or empty");
+        }
+
+        try
+        {
+            var result = bool.Parse(value);
+            return Maybe<bool, ParseError>.Some(result);
+        }
+        catch (FormatException ex)
+        {
+            return new ParseError(value, typeof(bool), ex, $"'{value}' is not a valid boolean format");
+        }
+        catch (Exception ex)
+        {
+            return new ParseError(value, typeof(bool), ex, $"Unexpected error parsing '{value}' to boolean");
+        }
+    }
+}
\ No newline at end of file
diff --git a/Maybe.Toolkit/README.md b/Maybe.Toolkit/README.md
new file mode 100644
index 0000000..3f9b49a
--- /dev/null
+++ b/Maybe.Toolkit/README.md
@@ -0,0 +1,111 @@
+# Maybe.Toolkit
+
+A comprehensive toolkit that extends the [Maybe](https://github.com/lucafabbri/Maybe) library with fluent, exception-free wrappers for common .NET operations.
+
+## Overview
+
+The Maybe.Toolkit provides safe, Maybe-based alternatives to traditional .NET operations that typically throw exceptions. Instead of using try-catch blocks, you can use fluent, functional programming patterns to handle potential failures gracefully.
+
+## Features
+
+### JsonToolkit
+Safe JSON serialization and deserialization using `System.Text.Json`:
+```csharp
+// Traditional approach with try-catch
+try 
+{
+    var person = JsonSerializer.Deserialize<Person>(json);
+    // Process person...
+}
+catch (JsonException ex) 
+{
+    // Handle error...
+}
+
+// Maybe.Toolkit approach
+JsonToolkit.TryDeserialize<Person>(json)
+    .IfSome(person => Console.WriteLine($"Hello, {person.Name}!"))
+    .ElseDo(error => Console.WriteLine($"Failed to parse JSON: {error.Message}"));
+```
+
+### FileToolkit
+Safe file I/O operations:
+```csharp
+FileToolkit.TryReadAllText("config.json")
+    .IfSome(content => ProcessConfig(content))
+    .ElseDo(error => Console.WriteLine($"Failed to read config: {error.Message}"));
+```
+
+### ParseToolkit
+Safe parsing operations for common types:
+```csharp
+ParseToolkit.TryParseInt(userInput)
+    .IfSome(number => Console.WriteLine($"Number is: {number}"))
+    .ElseDo(error => Console.WriteLine("Invalid number format"));
+```
+
+### HttpToolkit
+Safe HTTP operations:
+```csharp
+using var client = new HttpClient();
+await client.TryGetStringAsync("https://api.example.com/data")
+    .IfSome(response => ProcessApiResponse(response))
+    .ElseDo(error => Console.WriteLine($"API call failed: {error.Message}"));
+```
+
+### CollectionToolkit
+Safe collection access:
+```csharp
+dictionary.TryGetValue("key")
+    .IfSome(value => Console.WriteLine($"Found: {value}"))
+    .ElseDo(error => Console.WriteLine("Key not found"));
+
+list.TryGetAt(index)
+    .IfSome(item => ProcessItem(item))
+    .ElseDo(error => Console.WriteLine("Index out of range"));
+```
+
+## Installation
+
+Install via NuGet Package Manager:
+```
+Install-Package FluentCoder.Maybe.Toolkit
+```
+
+Or via .NET CLI:
+```
+dotnet add package FluentCoder.Maybe.Toolkit
+```
+
+## Error Types
+
+The toolkit provides specialized error types for different operations:
+
+- **JsonError**: JSON serialization/deserialization failures
+- **FileError**: File I/O operations
+- **ParseError**: Parsing operations
+- **HttpError**: HTTP request operations  
+- **CollectionError**: Collection access operations
+
+Each error type includes the original exception and contextual information to help with debugging.
+
+## Usage Examples
+
+See the [demo program](Maybe.Toolkit.Demo/Program.cs) for comprehensive usage examples of all toolkit components.
+
+## Why Use Maybe.Toolkit?
+
+1. **Eliminates Exception Handling**: No more try-catch blocks for common operations
+2. **Fluent API**: Chain operations naturally with `IfSome`, `ElseDo`, `Select`, etc.
+3. **Functional Style**: Embrace functional programming patterns in .NET
+4. **Type Safety**: Compile-time guarantees that errors are handled
+5. **Consistent Error Handling**: Unified approach across different operation types
+6. **Composable**: Easy to combine with other Maybe operations
+
+## Contributing
+
+This toolkit is part of the Maybe library ecosystem. Contributions are welcome! Please see the main [Maybe repository](https://github.com/lucafabbri/Maybe) for contribution guidelines.
+
+## License
+
+MIT License - see the [LICENSE](../LICENSE) file for details.
\ No newline at end of file
diff --git a/Maybe.sln b/Maybe.sln
index e575778..65e5703 100644
--- a/Maybe.sln
+++ b/Maybe.sln
@@ -13,6 +13,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Maybe.UnitTest", "Maybe.Uni
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Maybe.Compat.ErrorOr", "Maybe.Compat.ErrorOr\Maybe.Compat.ErrorOr.csproj", "{9B591D9C-AD23-840A-F5DD-32314CC056D1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Maybe.Toolkit", "Maybe.Toolkit\Maybe.Toolkit.csproj", "{F1234567-ABCD-1234-ABCD-123456789ABC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Maybe.Toolkit.Tests", "Maybe.Toolkit.Tests\Maybe.Toolkit.Tests.csproj", "{F2345678-BCDE-2345-BCDE-23456789ABCD}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Maybe.Toolkit.Demo", "Maybe.Toolkit.Demo\Maybe.Toolkit.Demo.csproj", "{F3456789-CDEF-3456-CDEF-3456789ABCDE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -59,6 +65,42 @@ Global
 		{9B591D9C-AD23-840A-F5DD-32314CC056D1}.Release|x64.Build.0 = Release|Any CPU
 		{9B591D9C-AD23-840A-F5DD-32314CC056D1}.Release|x86.ActiveCfg = Release|Any CPU
 		{9B591D9C-AD23-840A-F5DD-32314CC056D1}.Release|x86.Build.0 = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|x64.Build.0 = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Debug|x86.Build.0 = Debug|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|x64.ActiveCfg = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|x64.Build.0 = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|x86.ActiveCfg = Release|Any CPU
+		{F1234567-ABCD-1234-ABCD-123456789ABC}.Release|x86.Build.0 = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|x64.Build.0 = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Debug|x86.Build.0 = Debug|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|x64.ActiveCfg = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|x64.Build.0 = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|x86.ActiveCfg = Release|Any CPU
+		{F2345678-BCDE-2345-BCDE-23456789ABCD}.Release|x86.Build.0 = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|x64.Build.0 = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Debug|x86.Build.0 = Debug|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|x64.ActiveCfg = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|x64.Build.0 = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|x86.ActiveCfg = Release|Any CPU
+		{F3456789-CDEF-3456-CDEF-3456789ABCDE}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -67,6 +109,8 @@ Global
 		{AD94EC06-1573-4F6B-95A1-41FA0B8E67E6} = {6C4D298B-81FB-2B6B-5AB6-46205EDDC72C}
 		{4A86A53C-FBB2-4604-A240-952C040FE942} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
 		{9B591D9C-AD23-840A-F5DD-32314CC056D1} = {6C4D298B-81FB-2B6B-5AB6-46205EDDC72C}
+		{F1234567-ABCD-1234-ABCD-123456789ABC} = {6C4D298B-81FB-2B6B-5AB6-46205EDDC72C}
+		{F2345678-BCDE-2345-BCDE-23456789ABCD} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {3E982516-B08B-4CFF-95FE-5A9D02BB0C72}