diff --git a/docs/docs/operator/building-blocks/controllers.mdx b/docs/docs/operator/building-blocks/controllers.mdx
index 1aba0b3b..fe0cb7e7 100644
--- a/docs/docs/operator/building-blocks/controllers.mdx
+++ b/docs/docs/operator/building-blocks/controllers.mdx
@@ -31,6 +31,95 @@ public class V1DemoEntityController(
 }
 ```
 
+## Label Selectors
+
+Label selectors allow you to filter which resources your controller watches based on Kubernetes labels. This is useful when you want a controller to only process resources with specific labels.
+
+### Basic Label Selector
+
+By default, controllers use the `DefaultEntityLabelSelector<TEntity>` which doesn't apply any filtering (watches all resources of the specified type).
+
+### Custom Label Selector
+
+To create a custom label selector, implement the `IEntityLabelSelector<TEntity, TSelf>` interface:
+
+```csharp
+public class V1DemoEntityLabelSelector : IEntityLabelSelector<V1DemoEntity, V1DemoEntityLabelSelector>
+{
+    public ValueTask<string?> GetLabelSelectorAsync(CancellationToken cancellationToken)
+    {
+        // Return a Kubernetes label selector string
+        return ValueTask.FromResult<string?>("app=demo,environment=production");
+    }
+}
+```
+
+### Implementing a Controller with Label Selector
+
+You can implement a controller that directly uses a custom label selector by implementing the `IEntityController<TEntity, TLabelSelector>` interface:
+
+```csharp
+public class V1DemoEntityController : IEntityController<V1DemoEntity, V1DemoEntityLabelSelector>
+{
+    private readonly ILogger<V1DemoEntityController> _logger;
+    private readonly IKubernetesClient _client;
+
+    public V1DemoEntityController(
+        ILogger<V1DemoEntityController> logger,
+        IKubernetesClient client)
+    {
+        _logger = logger;
+        _client = client;
+    }
+
+    public async Task ReconcileAsync(V1DemoEntity entity, CancellationToken token)
+    {
+        _logger.LogInformation("Reconciling entity {Entity} with custom label selector.", entity);
+        // Implement your reconciliation logic here
+    }
+
+    public async Task DeletedAsync(V1DemoEntity entity, CancellationToken token)
+    {
+        _logger.LogInformation("Deleting entity {Entity} with custom label selector.", entity);
+        // Implement your cleanup logic here
+    }
+}
+```
+
+### Using Label Selectors with Controllers
+
+There are multiple ways to register a controller with a label selector:
+
+#### New Style (Recommended)
+
+For controllers that implement `IEntityController<TEntity, TLabelSelector>` as shown above:
+
+```csharp
+// In your Startup.cs or Program.cs
+services.AddKubernetesOperator()
+    .AddController<V1DemoEntityController, V1DemoEntity, V1DemoEntityLabelSelector>();
+```
+
+#### Backward Compatibility
+
+By default, controllers that implement the simpler `IEntityController<TEntity>` interface use `DefaultEntityLabelSelector<TEntity>` behind the scenes, which doesn't apply any filtering.
+
+However, you can still use a custom label selector with these controllers:
+
+```csharp
+// Controller implementation using the simpler interface
+public class V1DemoEntityController : IEntityController<V1DemoEntity>
+{
+    // Implementation details...
+}
+
+// In your Startup.cs or Program.cs
+services.AddKubernetesOperator()
+    .AddController<V1DemoEntityController, V1DemoEntity, V1DemoEntityLabelSelector>(null);
+```
+
+The null parameter is used for method overload disambiguation. This approach allows you to use a custom label selector with controllers that implement the simpler interface, providing backward compatibility.
+
 ## Resource Watcher
 
 When you create a controller, KubeOps automatically creates a resource watcher (informer) for your entity type. This watcher:
diff --git a/src/KubeOps.Abstractions/Builder/IOperatorBuilder.cs b/src/KubeOps.Abstractions/Builder/IOperatorBuilder.cs
index 24e5db3c..469ba8e0 100644
--- a/src/KubeOps.Abstractions/Builder/IOperatorBuilder.cs
+++ b/src/KubeOps.Abstractions/Builder/IOperatorBuilder.cs
@@ -40,9 +40,24 @@ IOperatorBuilder AddController<TImplementation, TEntity>()
     /// <typeparam name="TLabelSelector">Label Selector type.</typeparam>
     /// <returns>The builder for chaining.</returns>
     IOperatorBuilder AddController<TImplementation, TEntity, TLabelSelector>()
+        where TImplementation : class, IEntityController<TEntity, TLabelSelector>
+        where TEntity : IKubernetesObject<V1ObjectMeta>
+        where TLabelSelector : class, IEntityLabelSelector<TEntity, TLabelSelector>;
+
+    /// <summary>
+    /// Add a controller implementation for a specific entity to the operator with backward compatibility.
+    /// This overload allows controllers that implement IEntityController&lt;TEntity&gt; to be registered
+    /// with a specific label selector for backward compatibility.
+    /// </summary>
+    /// <typeparam name="TImplementation">Implementation type of the controller.</typeparam>
+    /// <typeparam name="TEntity">Entity type.</typeparam>
+    /// <typeparam name="TLabelSelector">Label Selector type.</typeparam>
+    /// <param name="_">Unused parameter for method overload disambiguation.</param>
+    /// <returns>The builder for chaining.</returns>
+    IOperatorBuilder AddController<TImplementation, TEntity, TLabelSelector>(TImplementation? _ = null)
         where TImplementation : class, IEntityController<TEntity>
         where TEntity : IKubernetesObject<V1ObjectMeta>
-        where TLabelSelector : class, IEntityLabelSelector<TEntity>;
+        where TLabelSelector : class, IEntityLabelSelector<TEntity, TLabelSelector>;
 
     /// <summary>
     /// Add a finalizer implementation for a specific entity.
@@ -76,3 +91,4 @@ IOperatorBuilder AddFinalizer<TImplementation, TEntity>(string identifier)
     /// <returns>The builder for chaining.</returns>
     IOperatorBuilder AddCrdInstaller(Action<CrdInstallerSettings>? configure = null);
 }
+
diff --git a/src/KubeOps.Abstractions/Controller/IEntityController{TEntity}.cs b/src/KubeOps.Abstractions/Controller/IEntityController{TEntity}.cs
index 87856087..1c30c858 100644
--- a/src/KubeOps.Abstractions/Controller/IEntityController{TEntity}.cs
+++ b/src/KubeOps.Abstractions/Controller/IEntityController{TEntity}.cs
@@ -1,17 +1,19 @@
 using k8s;
 using k8s.Models;
+using KubeOps.Abstractions.Entities;
 
 namespace KubeOps.Abstractions.Controller;
 
 /// <summary>
 /// Generic entity controller. The controller manages the reconcile loop
-/// for a given entity type.
+/// for a given entity type with a selector.
 /// </summary>
 /// <typeparam name="TEntity">The type of the Kubernetes entity.</typeparam>
+/// <typeparam name="TSelector">The type of the label selector for the entity.</typeparam>
 /// <example>
 /// Simple example controller that just logs the entity.
 /// <code>
-/// public class V1TestEntityController : IEntityController&lt;V1TestEntity&gt;
+/// public class V1TestEntityController : IEntityController&lt;V1TestEntity, DefaultEntityLabelSelector&lt;V1TestEntity&gt;&gt;
 /// {
 ///     private readonly ILogger&lt;V1TestEntityController&gt; _logger;
 ///
@@ -33,8 +35,9 @@ namespace KubeOps.Abstractions.Controller;
 /// }
 /// </code>
 /// </example>
-public interface IEntityController<in TEntity>
+public interface IEntityController<TEntity, in TSelector>
     where TEntity : IKubernetesObject<V1ObjectMeta>
+    where TSelector : class, IEntityLabelSelector<TEntity, TSelector>
 {
     /// <summary>
     /// Called for `added` and `modified` events from the watcher.
@@ -54,3 +57,37 @@ public interface IEntityController<in TEntity>
     /// </returns>
     Task DeletedAsync(TEntity entity, CancellationToken cancellationToken);
 }
+
+/// <summary>
+/// Generic entity controller. The controller manages the reconcile loop
+/// for a given entity type. This is a compatibility interface that inherits
+/// from the new two-parameter interface with a default selector.
+/// </summary>
+/// <typeparam name="TEntity">The type of the Kubernetes entity.</typeparam>
+/// <example>
+/// Simple example controller that just logs the entity.
+/// <code>
+/// public class V1TestEntityController : IEntityController&lt;V1TestEntity&gt;
+/// {
+///     private readonly ILogger&lt;V1TestEntityController&gt; _logger;
+///
+///     public V1TestEntityController(
+///         ILogger&lt;V1TestEntityController&gt; logger)
+///     {
+///         _logger = logger;
+///     }
+///
+///     public async Task ReconcileAsync(V1TestEntity entity, CancellationToken token)
+///     {
+///         _logger.LogInformation("Reconciling entity {Entity}.", entity);
+///     }
+///
+///     public async Task DeletedAsync(V1TestEntity entity, CancellationToken token)
+///     {
+///         _logger.LogInformation("Deleting entity {Entity}.", entity);
+///     }
+/// }
+/// </code>
+/// </example>
+public interface IEntityController<TEntity> : IEntityController<TEntity, DefaultEntityLabelSelector<TEntity>>
+    where TEntity : IKubernetesObject<V1ObjectMeta>;
diff --git a/src/KubeOps.Abstractions/Entities/DefaultEntityLabelSelector{TEntity}.cs b/src/KubeOps.Abstractions/Entities/DefaultEntityLabelSelector{TEntity}.cs
index e03abe07..dc42303a 100644
--- a/src/KubeOps.Abstractions/Entities/DefaultEntityLabelSelector{TEntity}.cs
+++ b/src/KubeOps.Abstractions/Entities/DefaultEntityLabelSelector{TEntity}.cs
@@ -3,7 +3,7 @@
 
 namespace KubeOps.Abstractions.Entities;
 
-public class DefaultEntityLabelSelector<TEntity> : IEntityLabelSelector<TEntity>
+public class DefaultEntityLabelSelector<TEntity> : IEntityLabelSelector<TEntity, DefaultEntityLabelSelector<TEntity>>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     public ValueTask<string?> GetLabelSelectorAsync(CancellationToken cancellationToken) => ValueTask.FromResult<string?>(null);
diff --git a/src/KubeOps.Abstractions/Entities/IEntityLabelSelector{TEntity}.cs b/src/KubeOps.Abstractions/Entities/IEntityLabelSelector{TEntity}.cs
index c8e0d0a8..b634b256 100644
--- a/src/KubeOps.Abstractions/Entities/IEntityLabelSelector{TEntity}.cs
+++ b/src/KubeOps.Abstractions/Entities/IEntityLabelSelector{TEntity}.cs
@@ -7,9 +7,13 @@ namespace KubeOps.Abstractions.Entities;
 // An alternative would be to use a KeyedSingleton when registering this however that's only valid from .NET 8 and above.
 // Other methods are far less elegant
 #pragma warning disable S2326
-public interface IEntityLabelSelector<TEntity>
+public interface IEntityLabelSelector<TEntity, TSelf>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     ValueTask<string?> GetLabelSelectorAsync(CancellationToken cancellationToken);
 }
+
+public interface IEntityLabelSelector<TEntity> : IEntityLabelSelector<TEntity, DefaultEntityLabelSelector<TEntity>>
+    where TEntity : IKubernetesObject<V1ObjectMeta>;
+
 #pragma warning restore S2326
diff --git a/src/KubeOps.Operator/Builder/OperatorBuilder.cs b/src/KubeOps.Operator/Builder/OperatorBuilder.cs
index f1dc4381..6e5a2e78 100644
--- a/src/KubeOps.Operator/Builder/OperatorBuilder.cs
+++ b/src/KubeOps.Operator/Builder/OperatorBuilder.cs
@@ -38,50 +38,66 @@ public OperatorBuilder(IServiceCollection services, OperatorSettings settings)
 
     public IOperatorBuilder AddController<TImplementation, TEntity>()
         where TImplementation : class, IEntityController<TEntity>
+        where TEntity : IKubernetesObject<V1ObjectMeta> =>
+        AddController<TImplementation, TEntity, DefaultEntityLabelSelector<TEntity>>();
+
+    public IOperatorBuilder AddController<TImplementation, TEntity, TLabelSelector>()
+        where TImplementation : class, IEntityController<TEntity, TLabelSelector>
         where TEntity : IKubernetesObject<V1ObjectMeta>
+        where TLabelSelector : class, IEntityLabelSelector<TEntity, TLabelSelector>
     {
-        Services.AddHostedService<EntityRequeueBackgroundService<TEntity>>();
-        Services.TryAddScoped<IEntityController<TEntity>, TImplementation>();
+        Services.AddHostedService<EntityRequeueBackgroundService<TEntity, TLabelSelector>>();
+
+        // Register the implementation for the two-parameter interface
+        Services.TryAddScoped<IEntityController<TEntity, TLabelSelector>, TImplementation>();
         Services.TryAddSingleton(new TimedEntityQueue<TEntity>());
         Services.TryAddTransient<IEntityRequeueFactory, KubeOpsEntityRequeueFactory>();
-        Services.TryAddTransient<EntityRequeue<TEntity>>(services =>
-            services.GetRequiredService<IEntityRequeueFactory>().Create<TEntity>());
+        Services.TryAddTransient<EntityRequeue<TEntity>>(
+            services => services.GetRequiredService<IEntityRequeueFactory>().Create<TEntity>()
+        );
+        Services.TryAddSingleton<IEntityLabelSelector<TEntity, TLabelSelector>, TLabelSelector>();
 
         if (_settings.EnableLeaderElection)
         {
-            Services.AddHostedService<LeaderAwareResourceWatcher<TEntity>>();
+            Services.AddHostedService<LeaderAwareResourceWatcher<TEntity, TLabelSelector>>();
         }
         else
         {
-            Services.AddHostedService<ResourceWatcher<TEntity>>();
+            Services.AddHostedService<ResourceWatcher<TEntity, TLabelSelector>>();
         }
 
         return this;
     }
 
-    public IOperatorBuilder AddController<TImplementation, TEntity, TLabelSelector>()
+    // Overload for controllers that implement IEntityController<TEntity> but are being registered with a specific label selector
+    // This allows backward compatibility for users who call AddController<Controller, Entity, LabelSelector>()
+    // even when their controller only implements IEntityController<Entity>
+    public IOperatorBuilder AddController<TImplementation, TEntity, TLabelSelector>(TImplementation? _ = null)
         where TImplementation : class, IEntityController<TEntity>
         where TEntity : IKubernetesObject<V1ObjectMeta>
-        where TLabelSelector : class, IEntityLabelSelector<TEntity>
+        where TLabelSelector : class, IEntityLabelSelector<TEntity, TLabelSelector>
     {
-        Services.AddHostedService<EntityRequeueBackgroundService<TEntity>>();
-        Services.TryAddScoped<IEntityController<TEntity>, TImplementation>();
-        Services.TryAddSingleton(new TimedEntityQueue<TEntity>());
-        Services.TryAddTransient<IEntityRequeueFactory, KubeOpsEntityRequeueFactory>();
-        Services.TryAddTransient<EntityRequeue<TEntity>>(services =>
-            services.GetRequiredService<IEntityRequeueFactory>().Create<TEntity>());
-        Services.TryAddSingleton<IEntityLabelSelector<TEntity>, TLabelSelector>();
-
-        if (_settings.EnableLeaderElection)
+        // Check if TImplementation actually implements IEntityController<TEntity, TLabelSelector>
+        if (typeof(IEntityController<TEntity, TLabelSelector>).IsAssignableFrom(typeof(TImplementation)))
         {
-            Services.AddHostedService<LeaderAwareResourceWatcher<TEntity>>();
+            // If it does, call the main method
+            return AddController<TImplementation, TEntity, TLabelSelector>();
         }
-        else
+
+        // If the controller only implements IEntityController<TEntity>, we can only register it with DefaultEntityLabelSelector
+        // We cannot support arbitrary label selectors with controllers that don't implement the two-parameter interface
+        if (typeof(TLabelSelector) != typeof(DefaultEntityLabelSelector<TEntity>))
         {
-            Services.AddHostedService<ResourceWatcher<TEntity>>();
+            throw new InvalidOperationException(
+                $"Controller {typeof(TImplementation).Name} only implements IEntityController<{typeof(TEntity).Name}> "
+                    + $"and cannot be used with label selector {typeof(TLabelSelector).Name}. "
+                    + $"Either implement IEntityController<{typeof(TEntity).Name}, {typeof(TLabelSelector).Name}> "
+                    + $"or use AddController<{typeof(TImplementation).Name}, {typeof(TEntity).Name}>() instead."
+            );
         }
 
-        return this;
+        // If TLabelSelector is DefaultEntityLabelSelector<TEntity>, delegate to the two-parameter method
+        return AddController<TImplementation, TEntity>();
     }
 
     public IOperatorBuilder AddFinalizer<TImplementation, TEntity>(string identifier)
@@ -90,9 +106,12 @@ public IOperatorBuilder AddFinalizer<TImplementation, TEntity>(string identifier
     {
         Services.TryAddKeyedTransient<IEntityFinalizer<TEntity>, TImplementation>(identifier);
         Services.TryAddTransient<IEventFinalizerAttacherFactory, KubeOpsEventFinalizerAttacherFactory>();
-        Services.TryAddTransient<EntityFinalizerAttacher<TImplementation, TEntity>>(services =>
-            services.GetRequiredService<IEventFinalizerAttacherFactory>()
-                .Create<TImplementation, TEntity>(identifier));
+        Services.TryAddTransient<EntityFinalizerAttacher<TImplementation, TEntity>>(
+            services =>
+                services
+                    .GetRequiredService<IEventFinalizerAttacherFactory>()
+                    .Create<TImplementation, TEntity>(identifier)
+        );
 
         return this;
     }
@@ -131,7 +150,9 @@ private void AddOperatorBase()
         Services.TryAddTransient<EventPublisher>(services =>
             services.GetRequiredService<IEventPublisherFactory>().Create());
 
-        Services.AddSingleton(typeof(IEntityLabelSelector<>), typeof(DefaultEntityLabelSelector<>));
+        // Register default entity label selector for all entities
+        // Note: We cannot register the open generic types directly due to arity mismatch
+        // The registration happens in AddController when specific types are needed
 
         if (_settings.EnableLeaderElection)
         {
diff --git a/src/KubeOps.Operator/Queue/EntityRequeueBackgroundService.cs b/src/KubeOps.Operator/Queue/EntityRequeueBackgroundService.cs
index dcfff6c9..7285f9af 100644
--- a/src/KubeOps.Operator/Queue/EntityRequeueBackgroundService.cs
+++ b/src/KubeOps.Operator/Queue/EntityRequeueBackgroundService.cs
@@ -2,6 +2,7 @@
 using k8s.Models;
 
 using KubeOps.Abstractions.Controller;
+using KubeOps.Abstractions.Entities;
 using KubeOps.KubernetesClient;
 
 using Microsoft.Extensions.DependencyInjection;
@@ -10,12 +11,13 @@
 
 namespace KubeOps.Operator.Queue;
 
-internal sealed class EntityRequeueBackgroundService<TEntity>(
+internal sealed class EntityRequeueBackgroundService<TEntity, TSelector>(
     IKubernetesClient client,
     TimedEntityQueue<TEntity> queue,
     IServiceProvider provider,
-    ILogger<EntityRequeueBackgroundService<TEntity>> logger) : IHostedService, IDisposable, IAsyncDisposable
+    ILogger<EntityRequeueBackgroundService<TEntity, TSelector>> logger) : IHostedService, IDisposable, IAsyncDisposable
     where TEntity : IKubernetesObject<V1ObjectMeta>
+    where TSelector : class, IEntityLabelSelector<TEntity, TSelector>
 {
     private readonly CancellationTokenSource _cts = new();
     private bool _disposed;
@@ -119,7 +121,7 @@ private async Task ReconcileSingleAsync(TEntity queued, CancellationToken cancel
         }
 
         await using var scope = provider.CreateAsyncScope();
-        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity>>();
+        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity, TSelector>>();
         await controller.ReconcileAsync(entity, cancellationToken);
     }
 }
diff --git a/src/KubeOps.Operator/Watcher/LeaderAwareResourceWatcher{TEntity}.cs b/src/KubeOps.Operator/Watcher/LeaderAwareResourceWatcher{TEntity}.cs
index add231f7..5e1f68e5 100644
--- a/src/KubeOps.Operator/Watcher/LeaderAwareResourceWatcher{TEntity}.cs
+++ b/src/KubeOps.Operator/Watcher/LeaderAwareResourceWatcher{TEntity}.cs
@@ -20,18 +20,36 @@ internal sealed class LeaderAwareResourceWatcher<TEntity>(
     IServiceProvider provider,
     TimedEntityQueue<TEntity> queue,
     OperatorSettings settings,
-    IEntityLabelSelector<TEntity> labelSelector,
+    IEntityLabelSelector<TEntity, DefaultEntityLabelSelector<TEntity>> labelSelector,
     IKubernetesClient client,
     IHostApplicationLifetime hostApplicationLifetime,
-    LeaderElector elector)
-    : ResourceWatcher<TEntity>(
+    LeaderElector elector
+)
+    : LeaderAwareResourceWatcher<TEntity, DefaultEntityLabelSelector<TEntity>>(
         activitySource,
         logger,
         provider,
         queue,
         settings,
         labelSelector,
-        client)
+        client,
+        hostApplicationLifetime,
+        elector
+    )
+    where TEntity : IKubernetesObject<V1ObjectMeta>;
+
+internal class LeaderAwareResourceWatcher<TEntity, TSelector>(
+    ActivitySource activitySource,
+    ILogger<LeaderAwareResourceWatcher<TEntity, TSelector>> logger,
+    IServiceProvider provider,
+    TimedEntityQueue<TEntity> queue,
+    OperatorSettings settings,
+    IEntityLabelSelector<TEntity, TSelector> labelSelector,
+    IKubernetesClient client,
+    IHostApplicationLifetime hostApplicationLifetime,
+    LeaderElector elector
+) : ResourceWatcher<TEntity, TSelector>(activitySource, logger, provider, queue, settings, labelSelector, client)
+    where TSelector : class, IEntityLabelSelector<TEntity, TSelector>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     private CancellationTokenSource _cts = new();
diff --git a/src/KubeOps.Operator/Watcher/ResourceWatcher{TEntity}.cs b/src/KubeOps.Operator/Watcher/ResourceWatcher{TEntity}.cs
index 8d74ba6b..67d85d19 100644
--- a/src/KubeOps.Operator/Watcher/ResourceWatcher{TEntity}.cs
+++ b/src/KubeOps.Operator/Watcher/ResourceWatcher{TEntity}.cs
@@ -23,13 +23,34 @@ namespace KubeOps.Operator.Watcher;
 
 public class ResourceWatcher<TEntity>(
     ActivitySource activitySource,
-    ILogger<ResourceWatcher<TEntity>> logger,
+    ILogger<ResourceWatcher<TEntity, DefaultEntityLabelSelector<TEntity>>> logger,
     IServiceProvider provider,
     TimedEntityQueue<TEntity> requeue,
     OperatorSettings settings,
-    IEntityLabelSelector<TEntity> labelSelector,
-    IKubernetesClient client)
-    : IHostedService, IAsyncDisposable, IDisposable
+    IEntityLabelSelector<TEntity, DefaultEntityLabelSelector<TEntity>> labelSelector,
+    IKubernetesClient client
+)
+    : ResourceWatcher<TEntity, DefaultEntityLabelSelector<TEntity>>(
+        activitySource,
+        logger,
+        provider,
+        requeue,
+        settings,
+        labelSelector,
+        client
+    )
+    where TEntity : IKubernetesObject<V1ObjectMeta>;
+
+public class ResourceWatcher<TEntity, TSelector>(
+    ActivitySource activitySource,
+    ILogger<ResourceWatcher<TEntity, TSelector>> logger,
+    IServiceProvider provider,
+    TimedEntityQueue<TEntity> requeue,
+    OperatorSettings settings,
+    IEntityLabelSelector<TEntity, TSelector> labelSelector,
+    IKubernetesClient client
+) : IHostedService, IAsyncDisposable, IDisposable
+    where TSelector : class, IEntityLabelSelector<TEntity, TSelector>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     private readonly ConcurrentDictionary<string, long> _entityCache = new();
@@ -314,7 +335,7 @@ private async Task ReconcileDeletionAsync(TEntity entity, CancellationToken canc
         _entityCache.TryRemove(entity.Uid(), out _);
 
         await using var scope = provider.CreateAsyncScope();
-        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity>>();
+        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity, TSelector>>();
         await controller.DeletedAsync(entity, cancellationToken);
     }
 
@@ -355,7 +376,7 @@ private async Task ReconcileModificationAsync(TEntity entity, CancellationToken
         // Re-queue should requested in the controller reconcile method. Invalidate any existing queues.
         requeue.Remove(entity);
         await using var scope = provider.CreateAsyncScope();
-        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity>>();
+        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity, TSelector>>();
         await controller.ReconcileAsync(entity, cancellationToken);
     }
 }
diff --git a/test/KubeOps.Operator.Test/Builder/OperatorBuilder.Test.cs b/test/KubeOps.Operator.Test/Builder/OperatorBuilder.Test.cs
index c8b514c0..28687c0b 100644
--- a/test/KubeOps.Operator.Test/Builder/OperatorBuilder.Test.cs
+++ b/test/KubeOps.Operator.Test/Builder/OperatorBuilder.Test.cs
@@ -6,6 +6,7 @@
 using KubeOps.Abstractions.Events;
 using KubeOps.Abstractions.Finalizer;
 using KubeOps.Abstractions.Queue;
+using KubeOps.KubernetesClient;
 using KubeOps.KubernetesClient.LabelSelectors;
 using KubeOps.Operator.Builder;
 using KubeOps.Operator.Finalizer;
@@ -26,6 +27,11 @@ public class OperatorBuilderTest
     [Fact]
     public void Should_Add_Default_Resources()
     {
+        // Add controllers to trigger the label selector registrations
+        _builder.AddController<TestControllerWithSelector<TestLabelSelector>, V1OperatorIntegrationTestEntity, TestLabelSelector>();
+        _builder.AddController<TestControllerWithSelector<TestLabelSelector2>, V1OperatorIntegrationTestEntity, TestLabelSelector2>();
+
+        // This test verifies the basic services that are registered
         _builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(OperatorSettings) &&
             s.Lifetime == ServiceLifetime.Singleton);
@@ -33,8 +39,18 @@ public void Should_Add_Default_Resources()
             s.ServiceType == typeof(EventPublisher) &&
             s.Lifetime == ServiceLifetime.Transient);
         _builder.Services.Should().Contain(s =>
-            s.ServiceType == typeof(IEntityLabelSelector<>) &&
-            s.ImplementationType == typeof(DefaultEntityLabelSelector<>) &&
+            s.ServiceType == typeof(IEventPublisherFactory) &&
+            s.Lifetime == ServiceLifetime.Transient);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IKubernetesClient) &&
+            s.Lifetime == ServiceLifetime.Singleton);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector>) &&
+            s.ImplementationType == typeof(TestLabelSelector) &&
+            s.Lifetime == ServiceLifetime.Singleton);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector2>) &&
+            s.ImplementationType == typeof(TestLabelSelector2) &&
             s.Lifetime == ServiceLifetime.Singleton);
     }
 
@@ -45,16 +61,27 @@ public void Should_Use_Specific_EntityLabelSelector_Implementation()
         var services = new ServiceCollection();
 
         // Register the default and specific implementations
-        services.AddSingleton(typeof(IEntityLabelSelector<>), typeof(DefaultEntityLabelSelector<>));
-        services.TryAddSingleton<IEntityLabelSelector<V1OperatorIntegrationTestEntity>, TestLabelSelector>();
+        services.TryAddSingleton<IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector>, TestLabelSelector>();
+        services.TryAddSingleton<IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector2>, TestLabelSelector2>();
+
 
         var serviceProvider = services.BuildServiceProvider();
 
-        // Act
-        var resolvedService = serviceProvider.GetRequiredService<IEntityLabelSelector<V1OperatorIntegrationTestEntity>>();
+        {
+            // Act
+            var resolvedService = serviceProvider.GetRequiredService<IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector>>();
 
-        // Assert
-        Assert.IsType<TestLabelSelector>(resolvedService);
+            // Assert
+            Assert.IsType<TestLabelSelector>(resolvedService);
+        }
+
+        {
+            // Act
+            var resolvedService = serviceProvider.GetRequiredService<IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector2>>();
+
+            // Assert
+            Assert.IsType<TestLabelSelector2>(resolvedService);
+        }
     }
 
     [Fact]
@@ -63,12 +90,12 @@ public void Should_Add_Controller_Resources()
         _builder.AddController<TestController, V1OperatorIntegrationTestEntity>();
 
         _builder.Services.Should().Contain(s =>
-            s.ServiceType == typeof(IEntityController<V1OperatorIntegrationTestEntity>) &&
+            s.ServiceType == typeof(IEntityController<V1OperatorIntegrationTestEntity, DefaultEntityLabelSelector<V1OperatorIntegrationTestEntity>>) &&
             s.ImplementationType == typeof(TestController) &&
             s.Lifetime == ServiceLifetime.Scoped);
         _builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(IHostedService) &&
-            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity>) &&
+            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity, DefaultEntityLabelSelector<V1OperatorIntegrationTestEntity>>) &&
             s.Lifetime == ServiceLifetime.Singleton);
         _builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(TimedEntityQueue<V1OperatorIntegrationTestEntity>) &&
@@ -81,15 +108,24 @@ public void Should_Add_Controller_Resources()
     [Fact]
     public void Should_Add_Controller_Resources_With_Label_Selector()
     {
-        _builder.AddController<TestController, V1OperatorIntegrationTestEntity, TestLabelSelector>();
+        _builder.AddController<TestControllerWithSelector<TestLabelSelector>, V1OperatorIntegrationTestEntity, TestLabelSelector>();
+        _builder.AddController<TestControllerWithSelector<TestLabelSelector2>, V1OperatorIntegrationTestEntity, TestLabelSelector2>();
 
         _builder.Services.Should().Contain(s =>
-            s.ServiceType == typeof(IEntityController<V1OperatorIntegrationTestEntity>) &&
-            s.ImplementationType == typeof(TestController) &&
+            s.ServiceType == typeof(IEntityController<V1OperatorIntegrationTestEntity, TestLabelSelector>) &&
+            s.ImplementationType == typeof(TestControllerWithSelector<TestLabelSelector>) &&
             s.Lifetime == ServiceLifetime.Scoped);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IEntityController<V1OperatorIntegrationTestEntity, TestLabelSelector2>) &&
+            s.ImplementationType == typeof(TestControllerWithSelector<TestLabelSelector2>) &&
+            s.Lifetime == ServiceLifetime.Scoped);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IHostedService) &&
+            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity, TestLabelSelector>) &&
+            s.Lifetime == ServiceLifetime.Singleton);
         _builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(IHostedService) &&
-            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity>) &&
+            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity, TestLabelSelector2>) &&
             s.Lifetime == ServiceLifetime.Singleton);
         _builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(TimedEntityQueue<V1OperatorIntegrationTestEntity>) &&
@@ -98,9 +134,13 @@ public void Should_Add_Controller_Resources_With_Label_Selector()
             s.ServiceType == typeof(EntityRequeue<V1OperatorIntegrationTestEntity>) &&
             s.Lifetime == ServiceLifetime.Transient);
         _builder.Services.Should().Contain(s =>
-            s.ServiceType == typeof(IEntityLabelSelector<V1OperatorIntegrationTestEntity>) &&
+            s.ServiceType == typeof(IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector>) &&
             s.ImplementationType == typeof(TestLabelSelector) &&
             s.Lifetime == ServiceLifetime.Singleton);
+        _builder.Services.Should().Contain(s =>
+            s.ServiceType == typeof(IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector2>) &&
+            s.ImplementationType == typeof(TestLabelSelector2) &&
+            s.Lifetime == ServiceLifetime.Singleton);
     }
 
     [Fact]
@@ -134,11 +174,11 @@ public void Should_Add_LeaderAwareResourceWatcher()
 
         builder.Services.Should().Contain(s =>
             s.ServiceType == typeof(IHostedService) &&
-            s.ImplementationType == typeof(LeaderAwareResourceWatcher<V1OperatorIntegrationTestEntity>) &&
+            s.ImplementationType == typeof(LeaderAwareResourceWatcher<V1OperatorIntegrationTestEntity, DefaultEntityLabelSelector<V1OperatorIntegrationTestEntity>>) &&
             s.Lifetime == ServiceLifetime.Singleton);
         builder.Services.Should().NotContain(s =>
             s.ServiceType == typeof(IHostedService) &&
-            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity>) &&
+            s.ImplementationType == typeof(ResourceWatcher<V1OperatorIntegrationTestEntity, DefaultEntityLabelSelector<V1OperatorIntegrationTestEntity>>) &&
             s.Lifetime == ServiceLifetime.Singleton);
     }
 
@@ -151,13 +191,23 @@ public Task DeletedAsync(V1OperatorIntegrationTestEntity entity, CancellationTok
             Task.CompletedTask;
     }
 
+    private class TestControllerWithSelector<TSelector> : IEntityController<V1OperatorIntegrationTestEntity, TSelector>
+        where TSelector : class, IEntityLabelSelector<V1OperatorIntegrationTestEntity, TSelector>
+    {
+        public Task ReconcileAsync(V1OperatorIntegrationTestEntity entity, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+
+        public Task DeletedAsync(V1OperatorIntegrationTestEntity entity, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+
     private class TestFinalizer : IEntityFinalizer<V1OperatorIntegrationTestEntity>
     {
         public Task FinalizeAsync(V1OperatorIntegrationTestEntity entity, CancellationToken cancellationToken) =>
             Task.CompletedTask;
     }
 
-    private class TestLabelSelector : IEntityLabelSelector<V1OperatorIntegrationTestEntity>
+    private class TestLabelSelector : IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector>
     {
         public ValueTask<string?> GetLabelSelectorAsync(CancellationToken cancellationToken)
         {
@@ -169,4 +219,18 @@ private class TestLabelSelector : IEntityLabelSelector<V1OperatorIntegrationTest
             return ValueTask.FromResult<string?>(labelSelectors.ToExpression());
         }
     }
+
+    private class TestLabelSelector2 : IEntityLabelSelector<V1OperatorIntegrationTestEntity, TestLabelSelector2>
+    {
+        public ValueTask<string?> GetLabelSelectorAsync(CancellationToken cancellationToken)
+        {
+            var labelSelectors = new LabelSelector[]
+            {
+                new EqualsSelector("label", "value"),
+                new EqualsSelector("label2", "value")
+            };
+
+            return ValueTask.FromResult<string?>(labelSelectors.ToExpression());
+        }
+    }
 }