diff --git a/docs/api/create_docker_container.md b/docs/api/create_docker_container.md
index 8dd663a34..24a885c80 100644
--- a/docs/api/create_docker_container.md
+++ b/docs/api/create_docker_container.md
@@ -100,6 +100,37 @@ _ = new ContainerBuilder()
 
 The static class `Consume` offers pre-configured implementations of the `IOutputConsumer` interface for common use cases. If you need additional functionalities beyond those provided by the default implementations, you can create your own implementations of `IOutputConsumer`.
 
+## Composing command arguments
+
+Testcontainers for .NET provides the `WithCommand(ComposableEnumerable<string>)` API to give you flexible control over container command arguments. While currently used for container commands, the `ComposableEnumerable<T>` abstraction is designed to support other builder APIs in the future, allowing similar composition and override functionality.
+
+Because our builders are immutable, this feature allows you to extend or override pre-configured configurations, such as those in Testcontainers [modules](../modules/index.md), without modifying the original builder.
+
+`ComposableEnumerable<T>` lets you decide how new API arguments should be combined with existing ones. You can choose to append, overwrite, or apply other strategies based on your needs.
+
+If a module applies default commands and you need to override or remove them entirely, you can do this e.g. by explicitly resetting the command list:
+
+```csharp title="Resetting command arguments"
+// Default PostgreSQL builder configuration:
+//
+// base.Init()
+//   ...
+//   .WithCommand("-c", "fsync=off")
+//   .WithCommand("-c", "full_page_writes=off")
+//   .WithCommand("-c", "synchronous_commit=off")
+//   ...
+
+var postgreSqlContainer = new PostgreSqlBuilder()
+  .WithCommand(new OverwriteEnumerable<string>(Array.Empty<string>()))
+  .Build();
+```
+
+Using `OverwriteEnumerable<string>(Array.Empty<string>())` removes all default command configurations. This is useful when you want full control over the PostgreSQL startup or when the default configurations do not match your requirements.
+
+!!!tip
+
+    You can create your own `ComposableEnumerable<T>` implementation to control exactly how configuration values are composed or modified.
+
 ## Examples
 
 An NGINX container that binds the HTTP port to a random host port and hosts static content. The example connects to the web server and checks the HTTP status code.
diff --git a/src/Testcontainers/Builders/BuildConfiguration.cs b/src/Testcontainers/Builders/BuildConfiguration.cs
index 824008646..a4dcec675 100644
--- a/src/Testcontainers/Builders/BuildConfiguration.cs
+++ b/src/Testcontainers/Builders/BuildConfiguration.cs
@@ -4,29 +4,38 @@ namespace DotNet.Testcontainers.Builders
   using System.Collections.Generic;
   using System.Collections.ObjectModel;
   using System.Linq;
+  using DotNet.Testcontainers.Configurations;
 
+  /// <summary>
+  /// Provides static utility methods for combining old and new configuration values
+  /// across various collection and value types.
+  /// </summary>
   public static class BuildConfiguration
   {
     /// <summary>
-    /// Returns the changed configuration object. If there is no change, the previous configuration object is returned.
+    /// Returns the updated configuration value. If the new value is <c>null</c> or
+    /// <c>default</c>, the old value is returned.
     /// </summary>
-    /// <param name="oldValue">The old configuration object.</param>
-    /// <param name="newValue">The new configuration object.</param>
+    /// <param name="oldValue">The old configuration value.</param>
+    /// <param name="newValue">The new configuration value.</param>
     /// <typeparam name="T">Any class.</typeparam>
-    /// <returns>Changed configuration object. If there is no change, the previous configuration object.</returns>
+    /// <returns>The updated value, or the old value if unchanged.</returns>
     public static T Combine<T>(T oldValue, T newValue)
     {
       return Equals(default(T), newValue) ? oldValue : newValue;
     }
 
     /// <summary>
-    /// Combines all existing and new configuration changes. If there are no changes, the previous configurations are returned.
+    /// Combines all existing and new configuration changes. If there are no changes,
+    /// the previous configurations are returned.
     /// </summary>
     /// <param name="oldValue">The old configuration.</param>
     /// <param name="newValue">The new configuration.</param>
-    /// <typeparam name="T">Type of <see cref="IEnumerable{T}" />.</typeparam>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
     /// <returns>An updated configuration.</returns>
-    public static IEnumerable<T> Combine<T>(IEnumerable<T> oldValue, IEnumerable<T> newValue)
+    public static IEnumerable<T> Combine<T>(
+      IEnumerable<T> oldValue,
+      IEnumerable<T> newValue)
     {
       if (newValue == null && oldValue == null)
       {
@@ -42,14 +51,17 @@ public static IEnumerable<T> Combine<T>(IEnumerable<T> oldValue, IEnumerable<T>
     }
 
     /// <summary>
-    /// Combines all existing and new configuration changes while preserving the order of insertion.
-    /// If there are no changes, the previous configurations are returned.
+    /// Combines all existing and new configuration changes while preserving the
+    /// order of insertion. If there are no changes, the previous configurations
+    /// are returned.
     /// </summary>
     /// <param name="oldValue">The old configuration.</param>
     /// <param name="newValue">The new configuration.</param>
-    /// <typeparam name="T">Type of <see cref="IReadOnlyList{T}" />.</typeparam>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
     /// <returns>An updated configuration.</returns>
-    public static IReadOnlyList<T> Combine<T>(IReadOnlyList<T> oldValue, IReadOnlyList<T> newValue)
+    public static IReadOnlyList<T> Combine<T>(
+      IReadOnlyList<T> oldValue,
+      IReadOnlyList<T> newValue)
     {
       if (newValue == null && oldValue == null)
       {
@@ -65,14 +77,51 @@ public static IReadOnlyList<T> Combine<T>(IReadOnlyList<T> oldValue, IReadOnlyLi
     }
 
     /// <summary>
-    /// Combines all existing and new configuration changes. If there are no changes, the previous configurations are returned.
+    /// Combines all existing and new configuration changes. If there are no changes,
+    /// the previous configuration is returned.
     /// </summary>
+    /// <remarks>
+    /// Uses <see cref="ComposableEnumerable{T}.Compose" /> on <paramref name="newValue" />
+    /// to combine configurations. The existing <paramref name="oldValue" /> is passed as
+    /// an argument to that method.
+    /// </remarks>
     /// <param name="oldValue">The old configuration.</param>
     /// <param name="newValue">The new configuration.</param>
-    /// <typeparam name="TKey">The type of keys in the read-only dictionary.</typeparam>
-    /// <typeparam name="TValue">The type of values in the read-only dictionary.</typeparam>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
     /// <returns>An updated configuration.</returns>
-    public static IReadOnlyDictionary<TKey, TValue> Combine<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> oldValue, IReadOnlyDictionary<TKey, TValue> newValue)
+    public static ComposableEnumerable<T> Combine<T>(
+      ComposableEnumerable<T> oldValue,
+      ComposableEnumerable<T> newValue)
+    {
+      // Creating a new container configuration before merging will follow this branch
+      // and return the default value. If we use the overwrite implementation,
+      // merging will reset the collection, we should either return null or use
+      // the append implementation.
+      if (newValue == null && oldValue == null)
+      {
+        return new AppendEnumerable<T>(Array.Empty<T>());
+      }
+
+      if (newValue == null || oldValue == null)
+      {
+        return newValue ?? oldValue;
+      }
+
+      return newValue.Compose(oldValue);
+    }
+
+    /// <summary>
+    /// Combines all existing and new configuration changes. If there are no changes,
+    /// the previous configurations are returned.
+    /// </summary>
+    /// <param name="oldValue">The old configuration.</param>
+    /// <param name="newValue">The new configuration.</param>
+    /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+    /// <returns>An updated configuration.</returns>
+    public static IReadOnlyDictionary<TKey, TValue> Combine<TKey, TValue>(
+      IReadOnlyDictionary<TKey, TValue> oldValue,
+      IReadOnlyDictionary<TKey, TValue> newValue)
     {
       if (newValue == null && oldValue == null)
       {
@@ -84,7 +133,19 @@ public static IReadOnlyDictionary<TKey, TValue> Combine<TKey, TValue>(IReadOnlyD
         return newValue ?? oldValue;
       }
 
-      return newValue.Concat(oldValue.Where(item => !newValue.Keys.Contains(item.Key))).ToDictionary(item => item.Key, item => item.Value);
+      var result = new Dictionary<TKey, TValue>(oldValue.Count + newValue.Count);
+
+      foreach (var kvp in oldValue)
+      {
+        result[kvp.Key] = kvp.Value;
+      }
+
+      foreach (var kvp in newValue)
+      {
+        result[kvp.Key] = kvp.Value;
+      }
+
+      return new ReadOnlyDictionary<TKey, TValue>(result);
     }
   }
 }
diff --git a/src/Testcontainers/Builders/ContainerBuilder`3.cs b/src/Testcontainers/Builders/ContainerBuilder`3.cs
index 468c894c9..f508e7b51 100644
--- a/src/Testcontainers/Builders/ContainerBuilder`3.cs
+++ b/src/Testcontainers/Builders/ContainerBuilder`3.cs
@@ -133,6 +133,13 @@ public TBuilderEntity WithEntrypoint(params string[] entrypoint)
 
     /// <inheritdoc />
     public TBuilderEntity WithCommand(params string[] command)
+    {
+      var composable = new AppendEnumerable<string>(command);
+      return WithCommand(composable);
+    }
+
+    /// <inheritdoc />
+    public TBuilderEntity WithCommand(ComposableEnumerable<string> command)
     {
       return Clone(new ContainerConfiguration(command: command));
     }
diff --git a/src/Testcontainers/Builders/IContainerBuilder`2.cs b/src/Testcontainers/Builders/IContainerBuilder`2.cs
index 0493fcbe5..b5cbb905e 100644
--- a/src/Testcontainers/Builders/IContainerBuilder`2.cs
+++ b/src/Testcontainers/Builders/IContainerBuilder`2.cs
@@ -140,6 +140,17 @@ public interface IContainerBuilder<out TBuilderEntity, out TContainerEntity> : I
     [PublicAPI]
     TBuilderEntity WithCommand(params string[] command);
 
+    /// <summary>
+    /// Overrides the container's command arguments.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="ComposableEnumerable{T}" /> allows to choose how existing builder configurations are composed.
+    /// </remarks>
+    /// <param name="command">A list of commands, "executable", "param1", "param2" or "param1", "param2".</param>
+    /// <returns>A configured instance of <typeparamref name="TBuilderEntity" />.</returns>
+    [PublicAPI]
+    TBuilderEntity WithCommand(ComposableEnumerable<string> command);
+
     /// <summary>
     /// Sets the environment variable.
     /// </summary>
diff --git a/src/Testcontainers/Configurations/Commons/AppendDictionary`2.cs b/src/Testcontainers/Configurations/Commons/AppendDictionary`2.cs
new file mode 100644
index 000000000..f20f1cb69
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/AppendDictionary`2.cs
@@ -0,0 +1,31 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Collections.Generic;
+  using JetBrains.Annotations;
+  using DotNet.Testcontainers.Builders;
+
+  /// <summary>
+  /// Represents a composable dictionary that combines its elements by appending
+  /// the elements of another dictionary with overwriting existing keys.
+  /// </summary>
+  /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+  /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+  [PublicAPI]
+  public sealed class AppendDictionary<TKey, TValue> : ComposableDictionary<TKey, TValue>
+  {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AppendDictionary{TKey,TValue}" /> class.
+    /// </summary>
+    /// <param name="dictionary">The dictionary whose elements are copied to the new dictionary.</param>
+    public AppendDictionary(IReadOnlyDictionary<TKey, TValue> dictionary)
+      : base(dictionary)
+    {
+    }
+
+    /// <inheritdoc />
+    public override ComposableDictionary<TKey, TValue> Compose(IReadOnlyDictionary<TKey, TValue> other)
+    {
+      return new AppendDictionary<TKey, TValue>(BuildConfiguration.Combine(other, this));
+    }
+  }
+}
diff --git a/src/Testcontainers/Configurations/Commons/AppendEnumerable`1.cs b/src/Testcontainers/Configurations/Commons/AppendEnumerable`1.cs
new file mode 100644
index 000000000..49c94c189
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/AppendEnumerable`1.cs
@@ -0,0 +1,30 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Collections.Generic;
+  using JetBrains.Annotations;
+  using DotNet.Testcontainers.Builders;
+
+  /// <summary>
+  /// Represents a composable collection that combines its elements by appending
+  /// the elements of another collection.
+  /// </summary>
+  /// <typeparam name="T">The type of elements in the collection.</typeparam>
+  [PublicAPI]
+  public sealed class AppendEnumerable<T> : ComposableEnumerable<T>
+  {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AppendEnumerable{T}" /> class.
+    /// </summary>
+    /// <param name="collection">The collection of items. If <c>null</c>, an empty collection is used.</param>
+    public AppendEnumerable(IEnumerable<T> collection)
+      : base(collection)
+    {
+    }
+
+    /// <inheritdoc />
+    public override ComposableEnumerable<T> Compose(IEnumerable<T> other)
+    {
+      return new AppendEnumerable<T>(BuildConfiguration.Combine(other, this));
+    }
+  }
+}
diff --git a/src/Testcontainers/Configurations/Commons/ComposableDictionary`2.cs b/src/Testcontainers/Configurations/Commons/ComposableDictionary`2.cs
new file mode 100644
index 000000000..f677e6097
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/ComposableDictionary`2.cs
@@ -0,0 +1,66 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Collections;
+  using System.Collections.Generic;
+  using System.Collections.ObjectModel;
+  using JetBrains.Annotations;
+
+  /// <summary>
+  /// Represents an immutable dictionary that defines a custom strategy for
+  /// composing its elements with those of another dictionary. This class is
+  /// intended to be inherited by implementations that specify how two dictionaries
+  /// should be combined.
+  /// </summary>
+  /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+  /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+  [PublicAPI]
+  public abstract class ComposableDictionary<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>
+  {
+    private readonly IReadOnlyDictionary<TKey, TValue> _dictionary;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ComposableDictionary{TKey, TValue}" /> class.
+    /// </summary>
+    /// <param name="dictionary">The dictionary of items. If <c>null</c>, an empty dictionary is used.</param>
+    protected ComposableDictionary(IReadOnlyDictionary<TKey, TValue> dictionary)
+    {
+      _dictionary = dictionary ?? new ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>());
+    }
+
+    /// <summary>
+    /// Combines the current dictionary with the specified dictionary according to
+    /// the composition strategy defined by the class.
+    /// </summary>
+    /// <remarks>
+    /// The <paramref name="other" /> parameter corresponds to the previous builder
+    /// configuration.
+    /// </remarks>
+    /// <param name="other">The incoming dictionary to compose with this dictionary.</param>
+    /// <returns>A new <see cref="IReadOnlyDictionary{TKey, TValue}" /> that contains the result of the composition.</returns>
+    public abstract ComposableDictionary<TKey, TValue> Compose([NotNull] IReadOnlyDictionary<TKey, TValue> other);
+
+    /// <inheritdoc />
+    public IEnumerable<TKey> Keys => _dictionary.Keys;
+
+    /// <inheritdoc />
+    public IEnumerable<TValue> Values => _dictionary.Values;
+
+    /// <inheritdoc />
+    public int Count => _dictionary.Count;
+
+    /// <inheritdoc />
+    public TValue this[TKey key] => _dictionary[key];
+
+    /// <inheritdoc />
+    public bool ContainsKey(TKey key) => _dictionary.ContainsKey(key);
+
+    /// <inheritdoc />
+    public bool TryGetValue(TKey key, out TValue value) => _dictionary.TryGetValue(key, out value);
+
+    /// <inheritdoc />
+    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary.GetEnumerator();
+
+    /// <inheritdoc />
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+  }
+}
diff --git a/src/Testcontainers/Configurations/Commons/ComposableEnumerable`1.cs b/src/Testcontainers/Configurations/Commons/ComposableEnumerable`1.cs
new file mode 100644
index 000000000..2f3c898b4
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/ComposableEnumerable`1.cs
@@ -0,0 +1,53 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System;
+  using System.Collections;
+  using System.Collections.Generic;
+  using JetBrains.Annotations;
+
+  /// <summary>
+  /// Represents an immutable collection that defines a custom strategy for
+  /// composing its elements with those of another collection. This class is
+  /// intended to be inherited by implementations that specify how two collections
+  /// should be combined.
+  /// </summary>
+  /// <typeparam name="T">The type of the elements in the collection.</typeparam>
+  [PublicAPI]
+  public abstract class ComposableEnumerable<T> : IEnumerable<T>
+  {
+    private readonly IEnumerable<T> _collection;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ComposableEnumerable{T}" /> class.
+    /// </summary>
+    /// <param name="collection">The collection of items. If <c>null</c>, an empty collection is used.</param>
+    protected ComposableEnumerable(IEnumerable<T> collection)
+    {
+      _collection = collection ?? Array.Empty<T>();
+    }
+
+    /// <summary>
+    /// Combines the current collection with the specified collection according to
+    /// the composition strategy defined by the class.
+    /// </summary>
+    /// <remarks>
+    /// The <paramref name="other" /> parameter corresponds to the previous builder
+    /// configuration.
+    /// </remarks>
+    /// <param name="other">The incoming collection to compose with this collection.</param>
+    /// <returns>A new <see cref="IEnumerable{T}" /> that contains the result of the composition.</returns>
+    public abstract ComposableEnumerable<T> Compose([NotNull] IEnumerable<T> other);
+
+    /// <summary>
+    /// Returns an enumerator that iterates through the collection.
+    /// </summary>
+    /// <returns>An enumerator for the current collection.</returns>
+    public IEnumerator<T> GetEnumerator() => _collection.GetEnumerator();
+
+    /// <summary>
+    /// Returns an enumerator that iterates through the collection.
+    /// </summary>
+    /// <returns>An enumerator for the current collection.</returns>
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+  }
+}
diff --git a/src/Testcontainers/Configurations/Commons/OverwriteDictionary`2.cs b/src/Testcontainers/Configurations/Commons/OverwriteDictionary`2.cs
new file mode 100644
index 000000000..cd0631ebf
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/OverwriteDictionary`2.cs
@@ -0,0 +1,31 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Collections.Generic;
+  using JetBrains.Annotations;
+
+  /// <summary>
+  /// Represents a composable dictionary that combines its elements by replacing
+  /// the current dictionary with the elements of another dictionary.
+  /// </summary>
+  /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+  /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+  [PublicAPI]
+  public sealed class OverwriteDictionary<TKey, TValue> : ComposableDictionary<TKey, TValue>
+  {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OverwriteDictionary{TKey, TValue}" /> class.
+    /// </summary>
+    /// <param name="dictionary">The dictionary whose elements are copied to the new dictionary.</param>
+    public OverwriteDictionary(IReadOnlyDictionary<TKey, TValue> dictionary)
+      : base(dictionary)
+    {
+    }
+
+    /// <inheritdoc />
+    public override ComposableDictionary<TKey, TValue> Compose(IReadOnlyDictionary<TKey, TValue> other)
+    {
+      // Ignores all previous configurations.
+      return this;
+    }
+  }
+}
diff --git a/src/Testcontainers/Configurations/Commons/OverwriteEnumerable`1.cs b/src/Testcontainers/Configurations/Commons/OverwriteEnumerable`1.cs
new file mode 100644
index 000000000..7b7ed1b01
--- /dev/null
+++ b/src/Testcontainers/Configurations/Commons/OverwriteEnumerable`1.cs
@@ -0,0 +1,30 @@
+namespace DotNet.Testcontainers.Configurations
+{
+  using System.Collections.Generic;
+  using JetBrains.Annotations;
+
+  /// <summary>
+  /// Represents a composable collection that combines its elements by replacing
+  /// the current collection with the elements of another collection.
+  /// </summary>
+  /// <typeparam name="T">The type of elements in the collection.</typeparam>
+  [PublicAPI]
+  public sealed class OverwriteEnumerable<T> : ComposableEnumerable<T>
+  {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OverwriteEnumerable{T}" /> class.
+    /// </summary>
+    /// <param name="collection">The collection of items. If <c>null</c>, an empty collection is used.</param>
+    public OverwriteEnumerable(IEnumerable<T> collection)
+      : base(collection)
+    {
+    }
+
+    /// <inheritdoc />
+    public override ComposableEnumerable<T> Compose(IEnumerable<T> other)
+    {
+      // Ignores all previous configurations.
+      return this;
+    }
+  }
+}
diff --git a/src/Testcontainers/Configurations/Containers/ContainerConfiguration.cs b/src/Testcontainers/Configurations/Containers/ContainerConfiguration.cs
index b2a26a0d2..4a3c2b4aa 100644
--- a/src/Testcontainers/Configurations/Containers/ContainerConfiguration.cs
+++ b/src/Testcontainers/Configurations/Containers/ContainerConfiguration.cs
@@ -49,7 +49,7 @@ public ContainerConfiguration(
       string macAddress = null,
       string workingDirectory = null,
       IEnumerable<string> entrypoint = null,
-      IEnumerable<string> command = null,
+      ComposableEnumerable<string> command = null,
       IReadOnlyDictionary<string, string> environments = null,
       IReadOnlyDictionary<string, string> exposedPorts = null,
       IReadOnlyDictionary<string, string> portBindings = null,
@@ -173,7 +173,7 @@ public ContainerConfiguration(IContainerConfiguration oldValue, IContainerConfig
     public IEnumerable<string> Entrypoint { get; }
 
     /// <inheritdoc />
-    public IEnumerable<string> Command { get; }
+    public ComposableEnumerable<string> Command { get; }
 
     /// <inheritdoc />
     public IReadOnlyDictionary<string, string> Environments { get; }
diff --git a/src/Testcontainers/Configurations/Containers/IContainerConfiguration.cs b/src/Testcontainers/Configurations/Containers/IContainerConfiguration.cs
index 8966f48d3..b62ba5e85 100644
--- a/src/Testcontainers/Configurations/Containers/IContainerConfiguration.cs
+++ b/src/Testcontainers/Configurations/Containers/IContainerConfiguration.cs
@@ -64,7 +64,7 @@ public interface IContainerConfiguration : IResourceConfiguration<CreateContaine
     /// <summary>
     /// Gets the command.
     /// </summary>
-    IEnumerable<string> Command { get; }
+    ComposableEnumerable<string> Command { get; }
 
     /// <summary>
     /// Gets a dictionary of environment variables.
diff --git a/tests/Testcontainers.Platform.Linux.Tests/ComposableTest.cs b/tests/Testcontainers.Platform.Linux.Tests/ComposableTest.cs
new file mode 100644
index 000000000..638e8001c
--- /dev/null
+++ b/tests/Testcontainers.Platform.Linux.Tests/ComposableTest.cs
@@ -0,0 +1,70 @@
+namespace Testcontainers.Tests;
+
+public sealed class ComposableTest
+{
+    private static readonly ComposableEnumerable<string> AppendListFlag =
+        new AppendEnumerable<string>(new[] { "-l" });
+
+    private static readonly ComposableEnumerable<string> OverwriteWithSearchArg =
+        new OverwriteEnumerable<string>(new[] { "pattern", "*.log" });
+
+    [Fact]
+    public void AppendsFlagAfterInitialArgument()
+    {
+        var command = new ComposableContainerBuilder()
+            .WithCommand("foo")
+            .WithCommand(AppendListFlag)
+            .GetCommand();
+
+        Assert.Equal(new[] { "foo", "-l" }, command);
+    }
+
+    [Fact]
+    public void OverwritesArgumentCompletely()
+    {
+        var command = new ComposableContainerBuilder()
+            .WithCommand("foo")
+            .WithCommand(OverwriteWithSearchArg)
+            .GetCommand();
+
+        Assert.Equal(new[] { "pattern", "*.log" }, command);
+    }
+
+    [Fact]
+    public void OverwritesThenAppendsFlag()
+    {
+        var command = new ComposableContainerBuilder()
+            .WithCommand("foo")
+            .WithCommand(OverwriteWithSearchArg)
+            .WithCommand(AppendListFlag)
+            .GetCommand();
+
+        Assert.Equal(new[] { "pattern", "*.log", "-l" }, command);
+    }
+
+    private sealed class ComposableContainerBuilder : ContainerBuilder<ComposableContainerBuilder, DockerContainer, ContainerConfiguration>
+    {
+        public ComposableContainerBuilder() : this(new ContainerConfiguration())
+            => DockerResourceConfiguration = Init().DockerResourceConfiguration;
+
+        private ComposableContainerBuilder(ContainerConfiguration configuration) : base(configuration)
+            => DockerResourceConfiguration = configuration;
+
+        protected override ContainerConfiguration DockerResourceConfiguration { get; }
+
+        public IEnumerable<string> GetCommand()
+            => DockerResourceConfiguration.Command;
+
+        public override DockerContainer Build()
+            => new(DockerResourceConfiguration);
+
+        protected override ComposableContainerBuilder Clone(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+            => Merge(DockerResourceConfiguration, new ContainerConfiguration(resourceConfiguration));
+
+        protected override ComposableContainerBuilder Clone(IContainerConfiguration resourceConfiguration)
+            => Merge(DockerResourceConfiguration, new ContainerConfiguration(resourceConfiguration));
+
+        protected override ComposableContainerBuilder Merge(ContainerConfiguration oldValue, ContainerConfiguration newValue)
+            => new(new ContainerConfiguration(oldValue, newValue));
+    }
+}
\ No newline at end of file
diff --git a/tests/Testcontainers.Tests/Unit/Builders/BuildConfigurationTest.cs b/tests/Testcontainers.Tests/Unit/Builders/BuildConfigurationTest.cs
index 00e83b2bc..09b776285 100644
--- a/tests/Testcontainers.Tests/Unit/Builders/BuildConfigurationTest.cs
+++ b/tests/Testcontainers.Tests/Unit/Builders/BuildConfigurationTest.cs
@@ -2,9 +2,9 @@ namespace DotNet.Testcontainers.Tests.Unit
 {
   using System;
   using System.Collections.Generic;
-  using System.Collections.ObjectModel;
   using System.Linq;
   using DotNet.Testcontainers.Builders;
+  using DotNet.Testcontainers.Configurations;
   using Xunit;
 
   public sealed class BuildConfigurationTest
@@ -14,7 +14,10 @@ public sealed class BuildConfigurationTest
     [InlineData(null, "B", "B")]
     [InlineData("A", null, "A")]
     [InlineData("A", "B", "B")]
-    public void CombineReferenceTypes(string oldValue, string newValue, string expected)
+    public void CombineReferenceTypes(
+      string oldValue,
+      string newValue,
+      string expected)
     {
       var actual = BuildConfiguration.Combine(oldValue, newValue);
       Assert.Equal(expected, actual);
@@ -22,7 +25,10 @@ public void CombineReferenceTypes(string oldValue, string newValue, string expec
 
     [Theory]
     [ClassData(typeof(EnumerableCombinationTestData))]
-    public void CombineEnumerables(IEnumerable<string> oldValue, IEnumerable<string> newValue, IEnumerable<string> expected)
+    public void CombineEnumerables(
+      IEnumerable<string> oldValue,
+      IEnumerable<string> newValue,
+      IEnumerable<string> expected)
     {
       var actual = BuildConfiguration.Combine(oldValue, newValue);
       Assert.Equal(expected?.OrderBy(item => item), actual?.OrderBy(item => item));
@@ -30,7 +36,10 @@ public void CombineEnumerables(IEnumerable<string> oldValue, IEnumerable<string>
 
     [Theory]
     [ClassData(typeof(ReadOnlyListCombinationTestData))]
-    public void CombineReadOnlyLists(IReadOnlyList<string> oldValue, IReadOnlyList<string> newValue, IReadOnlyList<string> expected)
+    public void CombineReadOnlyLists(
+      IReadOnlyList<string> oldValue,
+      IReadOnlyList<string> newValue,
+      IReadOnlyList<string> expected)
     {
       var actual = BuildConfiguration.Combine(oldValue, newValue);
       Assert.Equal(expected, actual);
@@ -38,44 +47,347 @@ public void CombineReadOnlyLists(IReadOnlyList<string> oldValue, IReadOnlyList<s
 
     [Theory]
     [ClassData(typeof(DictionaryCombinationTestData))]
-    public void CombineReadOnlyDictionaries(IReadOnlyDictionary<string, string> oldValue, IReadOnlyDictionary<string, string> newValue, IReadOnlyDictionary<string, string> expected)
+    public void CombineReadOnlyDictionaries(
+      IReadOnlyDictionary<string, string> oldValue,
+      IReadOnlyDictionary<string, string> newValue,
+      IReadOnlyDictionary<string, string> expected)
     {
       var actual = BuildConfiguration.Combine(oldValue, newValue);
       Assert.Equal(expected, actual);
     }
 
-    private sealed class EnumerableCombinationTestData : List<object[]>
+    [Theory]
+    [ClassData(typeof(ComposableEnumerableCombinationTestData))]
+    public void CombineComposableEnumerables(
+      ComposableEnumerable<string> oldValue,
+      ComposableEnumerable<string> newValue,
+      IEnumerable<string> expected)
+    {
+      var actual = BuildConfiguration.Combine(oldValue, newValue);
+      Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [ClassData(typeof(AppendEnumerableTestData))]
+    public void AppendEnumerableCompose(
+      IEnumerable<string> oldValue,
+      IEnumerable<string> newValue,
+      IEnumerable<string> expected)
+    {
+      var append = new AppendEnumerable<string>(newValue);
+      var result = append.Compose(oldValue);
+      Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [ClassData(typeof(OverwriteEnumerableTestData))]
+    public void OverwriteEnumerableCompose(
+      IEnumerable<string> oldValue,
+      IEnumerable<string> newValue,
+      IEnumerable<string> expected)
+    {
+      var overwrite = new OverwriteEnumerable<string>(newValue);
+      var result = overwrite.Compose(oldValue);
+      Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [ClassData(typeof(AppendDictionaryTestData))]
+    public void AppendDictionaryCompose(
+      IReadOnlyDictionary<string, string> oldValue,
+      IReadOnlyDictionary<string, string> newValue,
+      IReadOnlyDictionary<string, string> expected)
+    {
+      var append = new AppendDictionary<string, string>(newValue);
+      var result = append.Compose(oldValue);
+      Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [ClassData(typeof(OverwriteDictionaryTestData))]
+    public void OverwriteDictionaryCompose(
+      IReadOnlyDictionary<string, string> oldValue,
+      IReadOnlyDictionary<string, string> newValue,
+      IReadOnlyDictionary<string, string> expected)
+    {
+      var overwrite = new OverwriteDictionary<string, string>(newValue);
+      var result = overwrite.Compose(oldValue);
+      Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void ComposableEnumerableHandlesNullCollection()
+    {
+      var append = new AppendEnumerable<string>(null);
+      Assert.Empty(append);
+
+      var overwrite = new OverwriteEnumerable<string>(null);
+      Assert.Empty(overwrite);
+    }
+
+    [Fact]
+    public void ComposableDictionaryHandlesNullDictionary()
+    {
+      var append = new AppendDictionary<string, string>(null);
+      Assert.Empty(append);
+
+      var overwrite = new OverwriteDictionary<string, string>(null);
+      Assert.Empty(overwrite);
+    }
+
+    private sealed class EnumerableCombinationTestData
+      : TheoryData<
+          IEnumerable<string>,
+          IEnumerable<string>,
+          IEnumerable<string>
+        >
     {
       public EnumerableCombinationTestData()
       {
-        Add(new object[] { null, null, Array.Empty<string>() });
-        Add(new object[] { null, new[] { "2" }, new[] { "2" } });
-        Add(new object[] { new[] { "1" }, null, new[] { "1" } });
-        Add(new object[] { new[] { "1" }, new[] { "2" }, new[] { "1", "2" } });
-        Add(new object[] { new[] { "1", "2", "3" }, new[] { "2", "3", "4" }, new[] { "1", "2", "2", "3", "3", "4" } });
+        Add(null,
+            null,
+            Array.Empty<string>());
+
+        Add(null,
+            new[] { "2" },
+            new[] { "2" });
+
+        Add(new[] { "1" },
+            null,
+            new[] { "1" });
+
+        Add(new[] { "1" },
+            new[] { "2" },
+            new[] { "1", "2" });
+
+        Add(new[] { "1", "2", "3" },
+            new[] { "2", "3", "4" },
+            new[] { "1", "2", "2", "3", "3", "4" });
       }
     }
 
-    private sealed class ReadOnlyListCombinationTestData : List<object[]>
+    private sealed class ReadOnlyListCombinationTestData
+      : TheoryData<
+          IReadOnlyList<string>,
+          IReadOnlyList<string>,
+          IReadOnlyList<string>
+        >
     {
       public ReadOnlyListCombinationTestData()
       {
-        Add(new object[] { null, null, Array.Empty<string>() });
-        Add(new object[] { null, new[] { "2" }, new[] { "2" } });
-        Add(new object[] { new[] { "1" }, null, new[] { "1" } });
-        Add(new object[] { new[] { "1" }, new[] { "2" }, new[] { "1", "2" } });
-        Add(new object[] { new[] { "1", "2", "3" }, new[] { "2", "3", "4" }, new[] { "1", "2", "3", "2", "3", "4" } });
+        Add(null,
+            null,
+            Array.Empty<string>());
+
+        Add(null,
+            new[] { "2" },
+            new[] { "2" });
+
+        Add(new[] { "1" },
+            null,
+            new[] { "1" });
+
+        Add(new[] { "1" },
+            new[] { "2" },
+            new[] { "1", "2" });
+
+        Add(new[] { "1", "2", "3" },
+            new[] { "2", "3", "4" },
+            new[] { "1", "2", "3", "2", "3", "4" });
       }
     }
 
-    private sealed class DictionaryCombinationTestData : List<object[]>
+    private sealed class DictionaryCombinationTestData
+      : TheoryData<
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>
+        >
     {
       public DictionaryCombinationTestData()
       {
-        Add(new object[] { null, null, new ReadOnlyDictionary<string, string>(new Dictionary<string, string>()) });
-        Add(new object[] { new Dictionary<string, string> { { "A", "A" } }, null, new Dictionary<string, string> { { "A", "A" } } });
-        Add(new object[] { null, new Dictionary<string, string> { { "B", "B" } }, new Dictionary<string, string> { { "B", "B" } } });
-        Add(new object[] { new Dictionary<string, string> { ["A"] = "old", ["B"] = "B" }, new Dictionary<string, string> { ["A"] = "new" }, new Dictionary<string, string> { ["A"] = "new", ["B"] = "B" } });
+        Add(null,
+            null,
+            new Dictionary<string, string>());
+
+        Add(new Dictionary<string, string> { ["A"] = "A" },
+            null,
+            new Dictionary<string, string> { ["A"] = "A" });
+
+        Add(null,
+            new Dictionary<string, string> { ["B"] = "B" },
+            new Dictionary<string, string> { ["B"] = "B" });
+
+        Add(new Dictionary<string, string> { ["A"] = "old", ["B"] = "B" },
+            new Dictionary<string, string> { ["A"] = "new" },
+            new Dictionary<string, string> { ["A"] = "new", ["B"] = "B" });
+      }
+    }
+
+    private sealed class ComposableEnumerableCombinationTestData
+      : TheoryData<
+          ComposableEnumerable<string>,
+          ComposableEnumerable<string>,
+          IEnumerable<string>
+        >
+    {
+      public ComposableEnumerableCombinationTestData()
+      {
+        Add(null,
+            null,
+            Array.Empty<string>());
+
+        Add(null,
+            new AppendEnumerable<string>(new[] { "2" }),
+            new[] { "2" });
+
+        Add(new AppendEnumerable<string>(new[] { "1" }),
+            null,
+            new[] { "1" });
+
+        Add(new AppendEnumerable<string>(new[] { "1" }),
+            new AppendEnumerable<string>(new[] { "2" }),
+            new[] { "1", "2" });
+
+        Add(new AppendEnumerable<string>(new[] { "1", "2" }),
+            new OverwriteEnumerable<string>(new[] { "3", "4" }),
+            new[] { "3", "4" });
+
+        Add(new AppendEnumerable<string>(new[] { "1", "2", "3" }),
+            new AppendEnumerable<string>(new[] { "4", "5" }),
+            new[] { "1", "2", "3", "4", "5" });
+      }
+    }
+
+    private sealed class AppendEnumerableTestData
+      : TheoryData<
+          IEnumerable<string>,
+          IEnumerable<string>,
+          IEnumerable<string>
+        >
+    {
+      public AppendEnumerableTestData()
+      {
+        Add(Array.Empty<string>(),
+            Array.Empty<string>(),
+            Array.Empty<string>());
+
+        Add(new[] { "old" },
+            Array.Empty<string>(),
+            new[] { "old" });
+
+        Add(Array.Empty<string>(),
+            new[] { "new" },
+            new[] { "new" });
+
+        Add(new[] { "old" },
+            new[] { "new" },
+            new[] { "old", "new" });
+
+        Add(new[] { "1", "2" },
+            new[] { "3", "4" },
+            new[] { "1", "2", "3", "4" });
+
+        Add(new[] { "A", "B", "C" },
+            new[] { "X", "Y" },
+            new[] { "A", "B", "C", "X", "Y" });
+      }
+    }
+
+    private sealed class OverwriteEnumerableTestData
+      : TheoryData<
+          IEnumerable<string>,
+          IEnumerable<string>,
+          IEnumerable<string>
+        >
+    {
+      public OverwriteEnumerableTestData()
+      {
+        Add(Array.Empty<string>(),
+            Array.Empty<string>(),
+            Array.Empty<string>());
+
+        Add(new[] { "old" },
+            Array.Empty<string>(),
+            Array.Empty<string>());
+
+        Add(Array.Empty<string>(),
+            new[] { "new" },
+            new[] { "new" });
+
+        Add(new[] { "old" },
+            new[] { "new" },
+            new[] { "new" });
+
+        Add(new[] { "1", "2" },
+            new[] { "3", "4" },
+            new[] { "3", "4" });
+
+        Add(new[] { "A", "B", "C" },
+            new[] { "X", "Y", "Z" },
+            new[] { "X", "Y", "Z" });
+      }
+    }
+
+    private sealed class AppendDictionaryTestData
+      : TheoryData<
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>
+        >
+    {
+      public AppendDictionaryTestData()
+      {
+        Add(new Dictionary<string, string>(),
+            new Dictionary<string, string>(),
+            new Dictionary<string, string>());
+
+        Add(new Dictionary<string, string> { ["A"] = "old" },
+            new Dictionary<string, string>(),
+            new Dictionary<string, string> { ["A"] = "old" });
+
+        Add(new Dictionary<string, string>(),
+            new Dictionary<string, string> { ["B"] = "new" },
+            new Dictionary<string, string> { ["B"] = "new" });
+
+        Add(new Dictionary<string, string> { ["A"] = "old" },
+            new Dictionary<string, string> { ["B"] = "new" },
+            new Dictionary<string, string> { ["A"] = "old", ["B"] = "new" });
+
+        Add(new Dictionary<string, string> { ["A"] = "old", ["B"] = "keep" },
+            new Dictionary<string, string> { ["A"] = "new" },
+            new Dictionary<string, string> { ["A"] = "new", ["B"] = "keep" });
+      }
+    }
+
+    private sealed class OverwriteDictionaryTestData
+      : TheoryData<
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>,
+          IReadOnlyDictionary<string, string>
+        >
+    {
+      public OverwriteDictionaryTestData()
+      {
+        Add(new Dictionary<string, string>(),
+            new Dictionary<string, string>(),
+            new Dictionary<string, string>());
+
+        Add(new Dictionary<string, string> { ["A"] = "old" },
+            new Dictionary<string, string>(),
+            new Dictionary<string, string>());
+
+        Add(new Dictionary<string, string>(),
+            new Dictionary<string, string> { ["B"] = "new" },
+            new Dictionary<string, string> { ["B"] = "new" });
+
+        Add(new Dictionary<string, string> { ["A"] = "old" },
+            new Dictionary<string, string> { ["B"] = "new" },
+            new Dictionary<string, string> { ["B"] = "new" });
+
+        Add(new Dictionary<string, string> { ["A"] = "old", ["B"] = "ignore" },
+            new Dictionary<string, string> { ["A"] = "new", ["C"] = "keep" },
+            new Dictionary<string, string> { ["A"] = "new", ["C"] = "keep" });
       }
     }
   }