diff --git a/src/Finbuckle.MultiTenant/DependencyInjection/MultiTenantBuilder.cs b/src/Finbuckle.MultiTenant/DependencyInjection/MultiTenantBuilder.cs
index 6dc6e1c2..8637e9f0 100644
--- a/src/Finbuckle.MultiTenant/DependencyInjection/MultiTenantBuilder.cs
+++ b/src/Finbuckle.MultiTenant/DependencyInjection/MultiTenantBuilder.cs
@@ -40,7 +40,7 @@ public FinbuckleMultiTenantBuilder<T> WithPerTenantOptions<TOptions>(
         Action<TOptions, T> tenantConfigureOptions) where TOptions : class, new()
     {
         // TODO maybe change this to string empty so null an be used for all options, note remarks.
-        return WithPerTenantNamedOptions(null, tenantConfigureOptions);
+        return WithPerTenantNamedOptions<TOptions>(null, tenantConfigureOptions);
     }
 
     /// <summary>
@@ -58,32 +58,16 @@ public FinbuckleMultiTenantBuilder<T> WithPerTenantNamedOptions<TOptions>(string
             throw new ArgumentNullException(nameof(tenantConfigureNamedOptions));
         }
 
-        // Handles multiplexing cached options.
-        Services.TryAddSingleton<IOptionsMonitorCache<TOptions>, MultiTenantOptionsCache<TOptions, T>>();
-
-        // Necessary to apply tenant named options in between configuration and post configuration
-        Services.AddSingleton<ITenantConfigureNamedOptions<TOptions, T>,
-            TenantConfigureNamedOptions<TOptions, T>>(_ => new TenantConfigureNamedOptions<TOptions,
-            T>(name, tenantConfigureNamedOptions));
-        Services.TryAddTransient<IOptionsFactory<TOptions>, MultiTenantOptionsFactory<TOptions, T>>();
-        Services.TryAddScoped<IOptionsSnapshot<TOptions>>(BuildOptionsManager<TOptions>);
-        Services.TryAddSingleton<IOptions<TOptions>>(BuildOptionsManager<TOptions>);
+        Services.AddPerTenantOptionsCore<TOptions>();
+        Services.TryAddEnumerable(ServiceDescriptor.Scoped<IConfigureOptions<TOptions>, TenantConfigureNamedOptionsWrapper<TOptions, T>>());
+        Services.AddScoped<ITenantConfigureNamedOptions<TOptions, T>>(sp => new TenantConfigureNamedOptions<TOptions, T>(name, tenantConfigureNamedOptions));
 
         return this;
     }
 
     // TODO consider per tenant AllOptions variation
     // TODO consider per-tenant post options
-    // TODO consider OptionsBuilder api
-
-    private static MultiTenantOptionsManager<TOptions> BuildOptionsManager<TOptions>(IServiceProvider sp)
-        where TOptions : class, new()
-    {
-        var cache = (IOptionsMonitorCache<TOptions>)ActivatorUtilities.CreateInstance(sp,
-            typeof(MultiTenantOptionsCache<TOptions, T>));
-        return (MultiTenantOptionsManager<TOptions>)
-            ActivatorUtilities.CreateInstance(sp, typeof(MultiTenantOptionsManager<TOptions>), cache);
-    }
+    
 
     /// <summary>
     /// Adds and configures an IMultiTenantStore to the application using default dependency injection.
diff --git a/src/Finbuckle.MultiTenant/Extensions/ServiceCollectionExtensions.cs b/src/Finbuckle.MultiTenant/Extensions/ServiceCollectionExtensions.cs
index 62b1c35a..a8db44ad 100644
--- a/src/Finbuckle.MultiTenant/Extensions/ServiceCollectionExtensions.cs
+++ b/src/Finbuckle.MultiTenant/Extensions/ServiceCollectionExtensions.cs
@@ -5,6 +5,9 @@
 using System.Linq;
 using Finbuckle.MultiTenant;
 using Finbuckle.MultiTenant.Internal;
+using Finbuckle.MultiTenant.Options;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
 
 // ReSharper disable once CheckNamespace
 namespace Microsoft.Extensions.DependencyInjection;
@@ -55,6 +58,29 @@ public static FinbuckleMultiTenantBuilder<T> AddMultiTenant<T>(this IServiceColl
         return services.AddMultiTenant<T>(_ => { });
     }
 
+    /// <summary>
+    /// Gets an options builder that forwards Configure calls for the same named per-tenant <typeparamref name="TOptions"/> to the underlying service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to be configured.</typeparam>
+    /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
+    /// <param name="name">The name of the options instance.</param>
+    /// <returns>The <see cref="OptionsBuilder{TOptions}"/> so that configure calls can be chained in it.</returns>
+    public static OptionsBuilder<TOptions> AddPerTenantOptions<TOptions>(this IServiceCollection services, string? name) where TOptions : class, new()
+    {
+
+        services.AddPerTenantOptionsCore<TOptions>();
+        return new OptionsBuilder<TOptions>(services, name);
+    }
+
+    /// <summary>
+    /// Gets an options builder that forwards Configure calls for the same per-tenant <typeparamref name="TOptions"/> to the underlying service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to be configured.</typeparam>
+    /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
+    /// <returns>The <see cref="OptionsBuilder{TOptions}"/> so that configure calls can be chained in it.</returns>
+    public static OptionsBuilder<TOptions> AddPerTenantOptions<TOptions>(this IServiceCollection services) where TOptions : class, new() =>
+        services.AddPerTenantOptions<TOptions>(Options.Options.DefaultName);
+
     public static bool DecorateService<TService, TImpl>(this IServiceCollection services, params object[] parameters)
     {
         var existingService = services.SingleOrDefault(s => s.ServiceType == typeof(TService));
@@ -118,4 +144,27 @@ public static bool DecorateService<TService, TImpl>(this IServiceCollection serv
 
         return true;
     }
+
+    internal static void AddPerTenantOptionsCore<TOptions>(this IServiceCollection services) where TOptions : class, new()
+    {
+        if (services == null)
+        {
+            throw new ArgumentNullException(nameof(services));
+        }
+
+        // Handles multiplexing cached options.
+        services.TryAddSingleton<IOptionsMonitorCache<TOptions>, MultiTenantOptionsCache<TOptions>>();
+        services.TryAddTransient<IOptionsFactory<TOptions>, MultiTenantOptionsFactory<TOptions>>();
+        services.TryAddScoped<IOptionsSnapshot<TOptions>>(BuildOptionsManager<TOptions>);
+        services.TryAddSingleton<IOptions<TOptions>>(BuildOptionsManager<TOptions>);
+    }
+
+    private static MultiTenantOptionsManager<TOptions> BuildOptionsManager<TOptions>(IServiceProvider sp)
+        where TOptions : class, new()
+    {
+        var cache = (IOptionsMonitorCache<TOptions>)ActivatorUtilities.CreateInstance(sp,
+            typeof(MultiTenantOptionsCache<TOptions>));
+        return (MultiTenantOptionsManager<TOptions>)
+            ActivatorUtilities.CreateInstance(sp, typeof(MultiTenantOptionsManager<TOptions>), cache);
+    }
 }
\ No newline at end of file
diff --git a/src/Finbuckle.MultiTenant/Options/ITenantConfigureNamedOptionsWrapper.cs b/src/Finbuckle.MultiTenant/Options/ITenantConfigureNamedOptionsWrapper.cs
new file mode 100644
index 00000000..d5749a11
--- /dev/null
+++ b/src/Finbuckle.MultiTenant/Options/ITenantConfigureNamedOptionsWrapper.cs
@@ -0,0 +1,11 @@
+// Copyright Finbuckle LLC, Andrew White, and Contributors.
+// Refer to the solution LICENSE file for more information.
+
+using Microsoft.Extensions.Options;
+
+namespace Finbuckle.MultiTenant.Options;
+
+interface ITenantConfigureNamedOptionsWrapper<TOptions> : IConfigureNamedOptions<TOptions>
+    where TOptions : class, new()
+{
+}
diff --git a/src/Finbuckle.MultiTenant/Options/ITenantConfigureOptions.cs b/src/Finbuckle.MultiTenant/Options/ITenantConfigureOptions.cs
index 4215fb70..04f684d9 100644
--- a/src/Finbuckle.MultiTenant/Options/ITenantConfigureOptions.cs
+++ b/src/Finbuckle.MultiTenant/Options/ITenantConfigureOptions.cs
@@ -1,6 +1,7 @@
 // Copyright Finbuckle LLC, Andrew White, and Contributors.
 // Refer to the solution LICENSE file for more information.
 
+using Microsoft.Extensions.Options;
 using System;
 
 namespace Finbuckle.MultiTenant.Options;
@@ -11,4 +12,4 @@ public interface ITenantConfigureOptions<TOptions, TTenantInfo>
     where TTenantInfo : class, ITenantInfo, new()
 {
     void Configure(TOptions options, TTenantInfo tenantInfo);
-}
\ No newline at end of file
+}
diff --git a/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsCache.cs b/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsCache.cs
index bf24f075..66daa3e8 100644
--- a/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsCache.cs
+++ b/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsCache.cs
@@ -7,6 +7,111 @@
 
 namespace Finbuckle.MultiTenant.Options;
 
+/// <summary>
+/// Adds, retrieves, and removes instances of TOptions after adjusting them for the current TenantContext.
+/// </summary>
+public class MultiTenantOptionsCache<TOptions> : IOptionsMonitorCache<TOptions>
+    where TOptions : class
+{
+    private readonly IMultiTenantContextAccessor multiTenantContextAccessor;
+
+    // The object is just a dummy because there is no ConcurrentSet<T> class.
+    //private readonly ConcurrentDictionary<string, ConcurrentDictionary<string, object>> _adjustedOptionsNames =
+    //  new ConcurrentDictionary<string, ConcurrentDictionary<string, object>>();
+
+    private readonly ConcurrentDictionary<string, IOptionsMonitorCache<TOptions>> map = new ConcurrentDictionary<string, IOptionsMonitorCache<TOptions>>();
+
+    /// <summary>
+    /// Constructs a new instance of MultiTenantOptionsCache.
+    /// </summary>
+    /// <param name="multiTenantContextAccessor"></param>
+    /// <exception cref="ArgumentNullException"></exception>
+    public MultiTenantOptionsCache(IMultiTenantContextAccessor multiTenantContextAccessor)
+    {
+        this.multiTenantContextAccessor = multiTenantContextAccessor ?? throw new ArgumentNullException(nameof(multiTenantContextAccessor));
+    }
+
+    /// <summary>
+    /// Clears all cached options for the current tenant.
+    /// </summary>
+    public void Clear()
+    {
+        var tenantId = multiTenantContextAccessor.MultiTenantContext?.TenantInfo?.Id ?? "";
+        var cache = map.GetOrAdd(tenantId, new OptionsCache<TOptions>());
+
+        cache.Clear();
+    }
+
+    /// <summary>
+    /// Clears all cached options for the given tenant.
+    /// </summary>
+    /// <param name="tenantId">The Id of the tenant which will have its options cleared.</param>
+    public void Clear(string tenantId)
+    {
+        var cache = map.GetOrAdd(tenantId, new OptionsCache<TOptions>());
+
+        cache.Clear();
+    }
+
+    /// <summary>
+    /// Clears all cached options for all tenants and no tenant.
+    /// </summary>
+    public void ClearAll()
+    {
+        foreach (var cache in map.Values)
+            cache.Clear();
+    }
+
+    /// <summary>
+    /// Gets a named options instance for the current tenant, or adds a new instance created with createOptions.
+    /// </summary>
+    /// <param name="name">The options name.</param>
+    /// <param name="createOptions">The factory function for creating the options instance.</param>
+    /// <returns>The existing or new options instance.</returns>
+    public TOptions GetOrAdd(string? name, Func<TOptions> createOptions)
+    {
+        if (createOptions == null)
+        {
+            throw new ArgumentNullException(nameof(createOptions));
+        }
+
+        name = name ?? Microsoft.Extensions.Options.Options.DefaultName;
+        var tenantId = multiTenantContextAccessor.MultiTenantContext?.TenantInfo?.Id ?? "";
+        var cache = map.GetOrAdd(tenantId, new OptionsCache<TOptions>());
+
+        return cache.GetOrAdd(name, createOptions);
+    }
+
+    /// <summary>
+    /// Tries to adds a new option to the cache for the current tenant.
+    /// </summary>
+    /// <param name="name">The options name.</param>
+    /// <param name="options">The options instance.</param>
+    /// <returns>True if the options was added to the cache for the current tenant.</returns>
+    public bool TryAdd(string? name, TOptions options)
+    {
+        name = name ?? Microsoft.Extensions.Options.Options.DefaultName;
+        var tenantId = multiTenantContextAccessor.MultiTenantContext?.TenantInfo?.Id ?? "";
+        var cache = map.GetOrAdd(tenantId, new OptionsCache<TOptions>());
+
+        return cache.TryAdd(name, options);
+    }
+
+    /// <summary>
+    /// Try to remove an options instance for the current tenant.
+    /// </summary>
+    /// <param name="name">The options name.</param>
+    /// <returns>True if the options was removed from the cache for the current tenant.</returns>
+    public bool TryRemove(string? name)
+    {
+        name = name ?? Microsoft.Extensions.Options.Options.DefaultName;
+        var tenantId = multiTenantContextAccessor.MultiTenantContext?.TenantInfo?.Id ?? "";
+        var cache = map.GetOrAdd(tenantId, new OptionsCache<TOptions>());
+
+        return cache.TryRemove(name);
+    }
+}
+
 /// <summary>
 /// Adds, retrieves, and removes instances of TOptions after adjusting them for the current TenantContext.
 /// </summary>
@@ -59,7 +164,7 @@ public void Clear(string tenantId)
     /// </summary>
     public void ClearAll()
     {
-        foreach(var cache in map.Values)
+        foreach (var cache in map.Values)
             cache.Clear();
     }
 
diff --git a/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsFactory.cs b/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsFactory.cs
index d73c2c7e..042ab843 100644
--- a/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsFactory.cs
+++ b/src/Finbuckle.MultiTenant/Options/MultiTenantOptionsFactory.cs
@@ -4,16 +4,103 @@
 //    Portions of this file are derived from the .NET Foundation source file located at:
 //    https://github.com/dotnet/runtime/blob/5aad989cebe00f0987fcb842ea5b7cbe986c67df/src/libraries/Microsoft.Extensions.Options/src/OptionsFactory.cs
 
+using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.Options;
 
 namespace Finbuckle.MultiTenant.Options;
 
+/// <summary>
+/// Implementation of IOptionsFactory.
+/// </summary>
+/// <typeparam name="TOptions">The type of options being requested.</typeparam>
+public class MultiTenantOptionsFactory<TOptions> : IOptionsFactory<TOptions>
+    where TOptions : class, new()
+{
+    private readonly IConfigureOptions<TOptions>[] _configureOptions;
+    private readonly IPostConfigureOptions<TOptions>[] _postConfigureOptions;
+    private readonly IValidateOptions<TOptions>[] _validations;
+
+    /// <summary>
+    /// Initializes a new instance with the specified options configurations.
+    /// </summary>
+    public MultiTenantOptionsFactory(
+        IEnumerable<IConfigureOptions<TOptions>> configureOptions,
+        IEnumerable<IPostConfigureOptions<TOptions>> postConfigureOptions,
+        IEnumerable<IValidateOptions<TOptions>> validations)
+    {
+        // The default DI container uses arrays under the covers. Take advantage of this knowledge
+        // by checking for an array and enumerate over that, so we don't need to allocate an enumerator.
+        // When it isn't already an array, convert it to one, but don't use System.Linq to avoid pulling Linq in to
+        // small trimmed applications.
+
+        _configureOptions = configureOptions as IConfigureOptions<TOptions>[] ??
+                            new List<IConfigureOptions<TOptions>>(configureOptions).ToArray();
+        _postConfigureOptions = postConfigureOptions as IPostConfigureOptions<TOptions>[] ??
+                                new List<IPostConfigureOptions<TOptions>>(postConfigureOptions).ToArray();
+        _validations = validations as IValidateOptions<TOptions>[] ??
+                       new List<IValidateOptions<TOptions>>(validations).ToArray();
+    }
+
+    /// <inheritdoc />
+    public TOptions Create(string name)
+    {
+        ITenantConfigureNamedOptionsWrapper<TOptions>? tenantConfigureNamedOptionsWrapper = null;
+        var options = new TOptions();
+        foreach (var setup in _configureOptions)
+        {
+            // consider directly injecting this to avoid a conditional.
+            if (setup is ITenantConfigureNamedOptionsWrapper<TOptions> wrapper)
+            {
+                tenantConfigureNamedOptionsWrapper = wrapper;
+            }
+            else if (setup is IConfigureNamedOptions<TOptions> namedSetup)
+            {
+                namedSetup.Configure(name, options);
+            }
+            else if (name == Microsoft.Extensions.Options.Options.DefaultName)
+            {
+                setup.Configure(options);
+            }
+        }
+
+        tenantConfigureNamedOptionsWrapper?.Configure(name, options);
+
+        foreach (var post in _postConfigureOptions)
+        {
+            post.PostConfigure(name, options);
+        }
+            
+        // TODO consider per tenant post configure
+
+        if (_validations.Length > 0)
+        {
+            var failures = new List<string>();
+            foreach (IValidateOptions<TOptions> validate in _validations)
+            {
+                ValidateOptionsResult result = validate.Validate(name, options);
+                if (result is { Failed: true })
+                {
+                    failures.AddRange(result.Failures);
+                }
+            }
+
+            if (failures.Count > 0)
+            {
+                throw new OptionsValidationException(name, typeof(TOptions), failures);
+            }
+        }
+
+        return options;
+    }
+}
+
 /// <summary>
 /// Implementation of IOptionsFactory.
 /// </summary>
 /// <typeparam name="TOptions">The type of options being requested.</typeparam>
 /// <typeparam name="TTenantInfo">The type of the tenant info.</typeparam>
+[Obsolete]
 public class MultiTenantOptionsFactory<TOptions, TTenantInfo> : IOptionsFactory<TOptions>
     where TOptions : class, new()
     where TTenantInfo : class, ITenantInfo, new()
@@ -22,7 +109,9 @@ public class MultiTenantOptionsFactory<TOptions, TTenantInfo> : IOptionsFactory<
     private readonly IPostConfigureOptions<TOptions>[] _postConfigureOptions;
     private readonly IValidateOptions<TOptions>[] _validations;
 
+#pragma warning disable CS0612 // Type or member is obsolete
     private readonly ITenantConfigureOptions<TOptions, TTenantInfo>[] _tenantConfigureOptions;
+#pragma warning restore CS0612 // Type or member is obsolete
     private readonly ITenantConfigureNamedOptions<TOptions, TTenantInfo>[] _tenantConfigureNamedOptions;
     private readonly IMultiTenantContextAccessor<TTenantInfo> _multiTenantContextAccessor;
 
@@ -32,7 +121,9 @@ public class MultiTenantOptionsFactory<TOptions, TTenantInfo> : IOptionsFactory<
     public MultiTenantOptionsFactory(IEnumerable<IConfigureOptions<TOptions>> configureOptions,
         IEnumerable<IPostConfigureOptions<TOptions>> postConfigureOptions,
         IEnumerable<IValidateOptions<TOptions>> validations,
+#pragma warning disable CS0612 // Type or member is obsolete
         IEnumerable<ITenantConfigureOptions<TOptions, TTenantInfo>> tenantConfigureOptions,
+#pragma warning restore CS0612 // Type or member is obsolete
         IEnumerable<ITenantConfigureNamedOptions<TOptions, TTenantInfo>> tenantConfigureNamedOptions,
         IMultiTenantContextAccessor<TTenantInfo> multiTenantContextAccessor)
     {
@@ -47,9 +138,11 @@ public MultiTenantOptionsFactory(IEnumerable<IConfigureOptions<TOptions>> config
                                 new List<IPostConfigureOptions<TOptions>>(postConfigureOptions).ToArray();
         _validations = validations as IValidateOptions<TOptions>[] ??
                        new List<IValidateOptions<TOptions>>(validations).ToArray();
+#pragma warning disable CS0612 // Type or member is obsolete
         _tenantConfigureOptions = tenantConfigureOptions as ITenantConfigureOptions<TOptions, TTenantInfo>[] ??
                                   new List<ITenantConfigureOptions<TOptions, TTenantInfo>>(tenantConfigureOptions)
                                       .ToArray();
+#pragma warning restore CS0612 // Type or member is obsolete
         _tenantConfigureNamedOptions =
             tenantConfigureNamedOptions as ITenantConfigureNamedOptions<TOptions, TTenantInfo>[] ??
             new List<ITenantConfigureNamedOptions<TOptions, TTenantInfo>>(tenantConfigureNamedOptions).ToArray();
@@ -88,7 +181,7 @@ public TOptions Create(string name)
         {
             post.PostConfigure(name, options);
         }
-            
+
         // TODO consider per tenant post configure
 
         if (_validations.Length > 0)
diff --git a/src/Finbuckle.MultiTenant/Options/TenantConfigureNamedOptionsWrapper.cs b/src/Finbuckle.MultiTenant/Options/TenantConfigureNamedOptionsWrapper.cs
new file mode 100644
index 00000000..baba7df2
--- /dev/null
+++ b/src/Finbuckle.MultiTenant/Options/TenantConfigureNamedOptionsWrapper.cs
@@ -0,0 +1,55 @@
+// Copyright Finbuckle LLC, Andrew White, and Contributors.
+// Refer to the solution LICENSE file for more information.
+
+using System.Collections.Generic;
+
+namespace Finbuckle.MultiTenant.Options;
+
+class TenantConfigureNamedOptionsWrapper<TOptions, TTenantInfo> : ITenantConfigureNamedOptionsWrapper<TOptions>
+    where TOptions : class, new()
+    where TTenantInfo : class, ITenantInfo, new()
+{
+    private readonly IMultiTenantContextAccessor<TTenantInfo> multiTenantContextAccessor;
+    private readonly ITenantConfigureOptions<TOptions, TTenantInfo>[] tenantConfigureOptions;
+    private readonly ITenantConfigureNamedOptions<TOptions, TTenantInfo>[] tenantConfigureNamedOptions;
+
+    public TenantConfigureNamedOptionsWrapper(
+        IMultiTenantContextAccessor<TTenantInfo> multiTenantContextAccessor,
+        IEnumerable<ITenantConfigureOptions<TOptions, TTenantInfo>> tenantConfigureOptions,
+        IEnumerable<ITenantConfigureNamedOptions<TOptions, TTenantInfo>> tenantConfigureNamedOptions)
+    {
+        this.multiTenantContextAccessor = multiTenantContextAccessor;
+        this.tenantConfigureOptions = tenantConfigureOptions as ITenantConfigureOptions<TOptions, TTenantInfo>[] ??
+            new List<ITenantConfigureOptions<TOptions, TTenantInfo>>(tenantConfigureOptions).ToArray();
+        this.tenantConfigureNamedOptions = tenantConfigureNamedOptions as ITenantConfigureNamedOptions<TOptions, TTenantInfo>[] ??
+            new List<ITenantConfigureNamedOptions<TOptions, TTenantInfo>>(tenantConfigureNamedOptions).ToArray();
+    }
+
+    public void Configure(string name, TOptions options)
+    {
+        if (multiTenantContextAccessor.MultiTenantContext?.HasResolvedTenant ?? false)
+        {
+            foreach (var tenantConfigureOption in tenantConfigureOptions)
+                tenantConfigureOption.Configure(options, multiTenantContextAccessor.MultiTenantContext.TenantInfo!);
+
+            // Configure tenant named options.
+            foreach (var tenantConfigureNamedOption in tenantConfigureNamedOptions)
+                tenantConfigureNamedOption.Configure(name, options,
+                    multiTenantContextAccessor.MultiTenantContext.TenantInfo!);
+        }
+    }
+
+    public void Configure(TOptions options)
+    {
+        if (multiTenantContextAccessor.MultiTenantContext?.HasResolvedTenant ?? false)
+        {
+            foreach (var tenantConfigureOption in tenantConfigureOptions)
+                tenantConfigureOption.Configure(options, multiTenantContextAccessor.MultiTenantContext.TenantInfo!);
+
+            // Configure tenant named options.
+            foreach (var tenantConfigureNamedOption in tenantConfigureNamedOptions)
+                tenantConfigureNamedOption.Configure(Microsoft.Extensions.Options.Options.DefaultName, options,
+                    multiTenantContextAccessor.MultiTenantContext.TenantInfo!);
+        }
+    }
+}
diff --git a/test/Finbuckle.MultiTenant.Test/DependencyInjection/ServiceCollectionShould.cs b/test/Finbuckle.MultiTenant.Test/DependencyInjection/ServiceCollectionShould.cs
new file mode 100644
index 00000000..9f4b7606
--- /dev/null
+++ b/test/Finbuckle.MultiTenant.Test/DependencyInjection/ServiceCollectionShould.cs
@@ -0,0 +1,35 @@
+// Copyright Finbuckle LLC, Andrew White, and Co ntributors.
+// Refer to the solution LICENSE file for more information.
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace Finbuckle.MultiTenant.Test.DependencyInjection
+{
+    public class ServiceCollectionShould
+    {
+        // Used in some tests.
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local
+        private string? TestProperty { get; set; }
+        
+        [Fact]
+        public void AddPerTenantOptions()
+        {
+            var services = new ServiceCollection();
+            _ = services.AddMultiTenant<TenantInfo>();
+
+            services.AddPerTenantOptions<ServiceCollectionShould>()
+                .Configure<TenantInfo>((o, ti) => o.TestProperty = ti.Id);
+            
+            var sp = services.BuildServiceProvider();
+            var multiTenantContextAccessor = sp.GetRequiredService<IMultiTenantContextAccessor<TenantInfo>>();
+            multiTenantContextAccessor.MultiTenantContext = new MultiTenantContext<TenantInfo>{ TenantInfo = new TenantInfo { Id = "initech" } };
+
+            using var scope = sp.CreateScope();
+            var options = scope.ServiceProvider.GetRequiredService<IOptions<ServiceCollectionShould>>();
+
+            Assert.Equal("initech", options.Value.TestProperty);
+        }
+    }
+}
\ No newline at end of file