diff --git a/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceDialog.razor b/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceDialog.razor
index eab859dd..7de0e077 100644
--- a/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceDialog.razor
+++ b/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceDialog.razor
@@ -47,6 +47,20 @@
     </Tab>
 </Tabs>
 
+<div class="py-3">
+    @if (Operators != null && Operators.Count() > 0)
+    {
+        <select class="form-select m-2" @onchange="OnSelectOperatorChanged">
+            <option value="">Any Operator</option>
+            @foreach (var op in Operators)
+            {
+                var name = op.GetName() + "." + op.GetNamespace();
+                <option value="@name" selected="@(name == operatorName)">@name</option>
+            }
+        </select>
+    }
+</div>
+
 <div class="text-center">
     <Button Outline="true" Color="ButtonColor.Primary" class="m-auto mt-3 w-100" @onclick="async _ => await OnStartAsync()">
         <Icon Name="IconName.Play" />
@@ -61,10 +75,13 @@
     string payload = string.Empty;
     string modelName = string.Empty;
     EquatableDictionary<string, object>? input;
+    string? operatorName;
 
     [Parameter] public WorkflowDefinition? WorkflowDefinition { get; set; }
+    [Parameter] public IEnumerable<Operator> Operators { get; set; } = [];
+    [Parameter] public string? OperatorName { get; set; } = null;
     [Parameter] public EquatableDictionary<string, object>? Input { get; set; }
-    [Parameter] public EventCallback<string> OnCreate { get; set; }
+    [Parameter] public EventCallback<CreateWorkflowInstanceParameters> OnCreate { get; set; }
     [Parameter] public EventCallback<ProblemDetails> OnProblem { get; set; }
 
     void OnValueChanged(object? value)
@@ -81,6 +98,7 @@
     {
         await base.OnParametersSetAsync();
         if (input != Input) input = Input;
+        if (operatorName != OperatorName) operatorName = OperatorName;
         if (workflowDefinition != WorkflowDefinition) 
         {
             workflowDefinition = WorkflowDefinition;
@@ -93,6 +111,11 @@
         }
     }
 
+    protected void OnSelectOperatorChanged(ChangeEventArgs e)
+    {
+        operatorName = e.Value?.ToString();
+    }
+
     async Task OnStartAsync()
     {
         if (schema != null)
@@ -111,7 +134,13 @@
                 return;
             }
         }
-        if (OnCreate.HasDelegate) await OnCreate.InvokeAsync(payload);
+        if (OnCreate.HasDelegate)
+        {
+            await OnCreate.InvokeAsync(new CreateWorkflowInstanceParameters() { 
+                Input = payload,
+                Operator = operatorName
+            });
+        }
     }
 
     async Task LoadSchemaAsync()
diff --git a/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceParameters.cs b/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceParameters.cs
new file mode 100644
index 00000000..871838b9
--- /dev/null
+++ b/src/dashboard/Synapse.Dashboard/Components/CreateWorkflowInstanceDialog/CreateWorkflowInstanceParameters.cs
@@ -0,0 +1,30 @@
+// Copyright © 2024-Present The Synapse Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"),
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Synapse.Dashboard.Components;
+
+/// <summary>
+/// Represents the parameters for creating a new workflow instance.
+/// </summary>
+public record CreateWorkflowInstanceParameters
+{
+    /// <summary>
+    /// Gets/sets the workflow instance input.
+    /// </summary>
+    public string? Input { get; set; }
+
+    /// <summary>
+    /// Gets/sets the workflow instance operator.
+    /// </summary>
+    public string? Operator { get; set; }
+}
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/State.cs b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/State.cs
index c13ec748..9fc796c3 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/State.cs
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/State.cs
@@ -12,6 +12,7 @@
 // limitations under the License.
 
 using ServerlessWorkflow.Sdk.Models;
+using Synapse.Resources;
 
 namespace Synapse.Dashboard.Pages.Workflows.Create;
 
@@ -96,6 +97,16 @@ public record CreateWorkflowViewState
     /// </summary>
     public int ProblemStatus { get; set; } = 0;
 
+    /// <summary>
+    /// Gets a <see cref="EquatableList{T}"/> that contains all <see cref="Operator"/>s
+    /// </summary>
+    public EquatableList<Operator>? Operators { get; set; }
+
+    /// <summary>
+    /// Gets/sets the active operator filter
+    /// </summary>
+    public string? Operator { get; set; } = null;
+
     /// <summary>
     /// Gets/sets the list of <see cref="ProblemDetails"/> errors that occurred when trying to save the resource, if any
     /// </summary>
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/Store.cs b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/Store.cs
index d849a137..71b31363 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/Store.cs
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/Store.cs
@@ -17,6 +17,7 @@
 using ServerlessWorkflow.Sdk.Models;
 using ServerlessWorkflow.Sdk.Validation;
 using Synapse.Api.Client.Services;
+using Synapse.Dashboard.Pages.Workflows.List;
 using Synapse.Resources;
 using System.Text.RegularExpressions;
 
@@ -171,15 +172,25 @@ IWorkflowDefinitionValidator workflowDefinitionValidator
     /// </summary>
     public IObservable<IDictionary<string, string[]>> ProblemErrors => this.Select(state => state.ProblemErrors).DistinctUntilChanged();
 
+    /// <summary>
+    /// Gets an <see cref="IObservable{T}"/> used to observe <see cref="WorkflowListState.Operators"/> changes
+    /// </summary>
+    public IObservable<EquatableList<Operator>?> Operators => this.Select(s => s.Operators).DistinctUntilChanged();
+
+    /// <summary>
+    /// Gets an <see cref="IObservable{T}"/> used to observe <see cref="WorkflowListState.Operator"/> changes
+    /// </summary>
+    public IObservable<string?> Operator => this.Select(s => s.Operator).DistinctUntilChanged();
+
     /// <summary>
     /// Gets an <see cref="IObservable{T}"/> used to observe computed <see cref="Neuroglia.ProblemDetails"/>
     /// </summary>
     public IObservable<ProblemDetails?> ProblemDetails => Observable.CombineLatest(
-        this.ProblemType,
-        this.ProblemTitle,
-        this.ProblemStatus,
-        this.ProblemDetail,
-        this.ProblemErrors,
+        ProblemType,
+        ProblemTitle,
+        ProblemStatus,
+        ProblemDetail,
+        ProblemErrors,
         (type, title, status, details, errors) =>
         {
             if (string.IsNullOrWhiteSpace(title))
@@ -198,7 +209,7 @@ IWorkflowDefinitionValidator workflowDefinitionValidator
     /// <param name="ns">The new <see cref="CreateWorkflowViewState.Namespace"/> value</param>
     public void SetNamespace(string? ns)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             Namespace = ns,
             Loading = true
@@ -211,7 +222,7 @@ public void SetNamespace(string? ns)
     /// <param name="name">The new <see cref="CreateWorkflowViewState.Name"/> value</param>
     public void SetName(string? name)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             Name = name,
             Loading = true
@@ -224,7 +235,7 @@ public void SetName(string? name)
     /// <param name="isNew">The new <see cref="CreateWorkflowViewState.IsNew"/> value</param>
     public void SetIsNew(bool isNew)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             IsNew = isNew
         });
@@ -236,7 +247,7 @@ public void SetIsNew(bool isNew)
     /// <param name="problem">The <see cref="ProblemDetails"/> to populate the data with</param>
     public void SetProblemDetails(ProblemDetails? problem)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             ProblemType = problem?.Type,
             ProblemTitle = problem?.Title ?? string.Empty,
@@ -258,14 +269,16 @@ public async Task GetWorkflowDefinitionAsync(string @namespace, string name)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(@namespace);
         ArgumentException.ThrowIfNullOrWhiteSpace(name);
-        var workflow = await this.Api.Workflows.GetAsync(name, @namespace) ?? throw new NullReferenceException($"Failed to find the specified workflow '{name}.{@namespace}'");
+        var workflow = await Api.Workflows.GetAsync(name, @namespace) ?? throw new NullReferenceException($"Failed to find the specified workflow '{name}.{@namespace}'");
+        var operatorName = workflow.Metadata.Labels?.Get(SynapseDefaults.Resources.Labels.Operator);
         var definition = workflow.Spec.Versions.GetLatest();
         var nextVersion = SemVersion.Parse(definition.Document.Version, SemVersionStyles.Strict);
         nextVersion = nextVersion.WithPatch(nextVersion.Patch + 1);
         definition.Document.Version = nextVersion.ToString();
-        this.Reduce(s => s with
+        Reduce(s => s with
         {
             WorkflowDefinition = definition,
+            Operator = operatorName,
             Loading = false
         });
     }
@@ -277,25 +290,25 @@ public async Task GetWorkflowDefinitionAsync(string @namespace, string name)
     /// <returns></returns>
     public async Task ToggleTextBasedEditorLanguageAsync(string _)
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        var language = this.MonacoEditorHelper.PreferredLanguage;
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        var language = MonacoEditorHelper.PreferredLanguage;
         try
         {
-            var document = await this.TextEditor.GetValue();
+            var document = await TextEditor.GetValue();
             if (document == null) return;
             document = language == PreferredLanguage.YAML ?
-                this.YamlSerializer.ConvertFromJson(document) :
-                this.YamlSerializer.ConvertToJson(document);
-            this.Reduce(state => state with
+                YamlSerializer.ConvertFromJson(document) :
+                YamlSerializer.ConvertToJson(document);
+            Reduce(state => state with
             {
                 WorkflowDefinitionText = document
             });
-            await this.InitializeTextBasedEditorAsync();
+            await InitializeTextBasedEditorAsync();
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to change text editor language: {exception}", ex.ToString());
-            await this.MonacoEditorHelper.ChangePreferredLanguageAsync(language == PreferredLanguage.YAML ? PreferredLanguage.JSON : PreferredLanguage.YAML);
+            Logger.LogError("Unable to change text editor language: {exception}", ex.ToString());
+            await MonacoEditorHelper.ChangePreferredLanguageAsync(language == PreferredLanguage.YAML ? PreferredLanguage.JSON : PreferredLanguage.YAML);
         }
     }
 
@@ -305,8 +318,8 @@ public async Task ToggleTextBasedEditorLanguageAsync(string _)
     /// <returns></returns>
     public async Task OnTextBasedEditorInitAsync()
     {
-        this._hasTextEditorInitialized = true;
-        await this.InitializeTextBasedEditorAsync();
+        _hasTextEditorInitialized = true;
+        await InitializeTextBasedEditorAsync();
     }
 
     /// <summary>
@@ -315,9 +328,9 @@ public async Task OnTextBasedEditorInitAsync()
     /// <returns></returns>
     public async Task InitializeTextBasedEditorAsync()
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        await this.SetTextBasedEditorLanguageAsync();
-        await this.SetTextEditorValueAsync();
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        await SetTextBasedEditorLanguageAsync();
+        await SetTextEditorValueAsync();
     }
 
     /// <summary>
@@ -326,18 +339,18 @@ public async Task InitializeTextBasedEditorAsync()
     /// <returns></returns>
     public async Task SetTextBasedEditorLanguageAsync()
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
         try
         {
-            var language = this.MonacoEditorHelper.PreferredLanguage;
-            this._textModel = await Global.GetModel(this.JSRuntime, this._textModelUri);
-            this._textModel ??= await Global.CreateModel(this.JSRuntime, "", language, this._textModelUri);
-            await Global.SetModelLanguage(this.JSRuntime, this._textModel, language);
-            await this.TextEditor!.SetModel(this._textModel);
+            var language = MonacoEditorHelper.PreferredLanguage;
+            _textModel = await Global.GetModel(JSRuntime, _textModelUri);
+            _textModel ??= await Global.CreateModel(JSRuntime, "", language, _textModelUri);
+            await Global.SetModelLanguage(JSRuntime, _textModel, language);
+            await TextEditor!.SetModel(_textModel);
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to set text editor language: {exception}", ex.ToString());
+            Logger.LogError("Unable to set text editor language: {exception}", ex.ToString());
         }
     }
 
@@ -347,17 +360,17 @@ public async Task SetTextBasedEditorLanguageAsync()
     /// <returns></returns>
     async Task SetTextEditorValueAsync()
     {
-        var document = this.Get(state => state.WorkflowDefinitionText);
-        if (this.TextEditor == null || string.IsNullOrWhiteSpace(document) || !this._hasTextEditorInitialized) return;
+        var document = Get(state => state.WorkflowDefinitionText);
+        if (TextEditor == null || string.IsNullOrWhiteSpace(document) || !_hasTextEditorInitialized) return;
         try
         {
-            await this.TextEditor.SetValue(document);
+            await TextEditor.SetValue(document);
             await Task.Delay(10);
-            await this.TextEditor.Trigger("", "editor.action.formatDocument");
+            await TextEditor.Trigger("", "editor.action.formatDocument");
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to set text editor value: {exception}", ex.ToString());
+            Logger.LogError("Unable to set text editor value: {exception}", ex.ToString());
         }
     }
 
@@ -368,9 +381,9 @@ async Task SetTextEditorValueAsync()
     /// <returns>An awaitable task</returns>
     public async Task OnDidChangeModelContent(ModelContentChangedEvent e)
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        var document = await this.TextEditor.GetValue();
-        this.Reduce(state => state with
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        var document = await TextEditor.GetValue();
+        Reduce(state => state with
         {
             WorkflowDefinitionText = document
         });
@@ -382,19 +395,19 @@ public async Task OnDidChangeModelContent(ModelContentChangedEvent e)
     /// <returns>A new awaitable <see cref="Task"/></returns>
     public async Task SaveWorkflowDefinitionAsync()
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized)
+        if (TextEditor == null || !_hasTextEditorInitialized)
         {
-            this.Reduce(state => state with
+            Reduce(state => state with
             {
                 ProblemTitle = "Text editor",
                 ProblemDetail = "The text editor must be initialized."
             });
             return;
         }
-        var workflowDefinitionText = await this.TextEditor.GetValue();
+        var workflowDefinitionText = await TextEditor.GetValue();
         if (string.IsNullOrWhiteSpace(workflowDefinitionText))
         {
-            this.Reduce(state => state with
+            Reduce(state => state with
             {
                 ProblemTitle = "Invalid definition",
                 ProblemDetail = "The workflow definition cannot be empty."
@@ -403,10 +416,10 @@ public async Task SaveWorkflowDefinitionAsync()
         }
         try
         {
-            var workflowDefinition = this.MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
-                this.JsonSerializer.Deserialize<WorkflowDefinition>(workflowDefinitionText)! :
-                this.YamlSerializer.Deserialize<WorkflowDefinition>(workflowDefinitionText)!;
-            var validationResult = await this.WorkflowDefinitionValidator.ValidateAsync(workflowDefinition);
+            var workflowDefinition = MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
+                JsonSerializer.Deserialize<WorkflowDefinition>(workflowDefinitionText)! :
+                YamlSerializer.Deserialize<WorkflowDefinition>(workflowDefinitionText)!;
+            var validationResult = await WorkflowDefinitionValidator.ValidateAsync(workflowDefinition);
             if (!validationResult.IsValid)
             {
                 var errors = new Dictionary<string, string[]>();
@@ -414,7 +427,7 @@ public async Task SaveWorkflowDefinitionAsync()
                 {
                     errors.Add(reference, validationResult.Errors!.Where(e => e.Reference == reference).Select(e => e.Details ?? "").ToArray());
                 });
-                this.Reduce(state => state with
+                Reduce(state => state with
                 {
                     ProblemTitle = "Invalid definition",
                     ProblemDetail = "The workflow definition is not valid.",
@@ -425,16 +438,17 @@ public async Task SaveWorkflowDefinitionAsync()
             var @namespace = workflowDefinition!.Document.Namespace;
             var name = workflowDefinition.Document.Name;
             var version = workflowDefinition.Document.Version;
-            var isNew = this.Get(state => state.IsNew);
-            this.Reduce(s => s with
+            var isNew = Get(state => state.IsNew);
+            var operatorName = Get(state => state.Operator);
+            Reduce(s => s with
             {
                 Saving = true
             });
             Workflow? workflow = null;
             if (isNew)
             {
-                try { 
-                    workflow = await this.Api.Workflows.CreateAsync(new()
+                try {
+                    workflow = new()
                     {
                         Metadata = new()
                         {
@@ -445,8 +459,14 @@ public async Task SaveWorkflowDefinitionAsync()
                         {
                             Versions = [workflowDefinition]
                         }
-                    });
-                    this.NavigationManager.NavigateTo($"/workflows/details/{@namespace}/{name}/{version}");
+                    };
+                    if (!string.IsNullOrWhiteSpace(operatorName))
+                    {
+                        workflow.Metadata.Labels = workflow.Metadata.Labels ?? new EquatableDictionary<string, string>();
+                        workflow.Metadata.Labels.Add(SynapseDefaults.Resources.Labels.Operator, operatorName);
+                    }
+                    workflow = await Api.Workflows.CreateAsync(workflow);
+                    NavigationManager.NavigateTo($"/workflows/details/{@namespace}/{name}/{version}");
                     return;
                 }
                 catch (ProblemDetailsException ex) when (ex.Problem.Title == "Conflict" && ex.Problem.Detail != null && ex.Problem.Detail.EndsWith("already exists"))
@@ -454,36 +474,41 @@ public async Task SaveWorkflowDefinitionAsync()
                     // the workflow exists, try to update it instead
                 }
             }
-            workflow = await this.Api.Workflows.GetAsync(name, @namespace);
+            workflow = await Api.Workflows.GetAsync(name, @namespace);
             var updatedResource = workflow.Clone()!;
             var documentVersion = SemVersion.Parse(version, SemVersionStyles.Strict)!;
             var latestVersion = SemVersion.Parse(updatedResource.Spec.Versions.GetLatest().Document.Version, SemVersionStyles.Strict)!;
             if (updatedResource.Spec.Versions.Any(v => SemVersion.Parse(v.Document.Version, SemVersionStyles.Strict).CompareSortOrderTo(documentVersion) >= 0))
             {
-                this.Reduce(state => state with
+                Reduce(state => state with
                 {
                     ProblemTitle = "Invalid version",
                     ProblemDetail = $"The specified version '{documentVersion}' must be strictly superior to the latest version '{latestVersion}'."
                 });
                 return;
             }
+            if (!string.IsNullOrWhiteSpace(operatorName) && updatedResource.Metadata.Labels?.Get(SynapseDefaults.Resources.Labels.Operator) != operatorName)
+            {
+                updatedResource.Metadata.Labels ??= new EquatableDictionary<string, string>();
+                updatedResource.Metadata.Labels[SynapseDefaults.Resources.Labels.Operator] = operatorName;
+            }
             updatedResource.Spec.Versions.Add(workflowDefinition!);
-            var jsonPatch = JsonPatch.FromDiff(this.JsonSerializer.SerializeToElement(workflow)!.Value, this.JsonSerializer.SerializeToElement(updatedResource)!.Value);
-            var patch = this.JsonSerializer.Deserialize<Json.Patch.JsonPatch>(jsonPatch.RootElement);
+            var jsonPatch = JsonPatch.FromDiff(JsonSerializer.SerializeToElement(workflow)!.Value, JsonSerializer.SerializeToElement(updatedResource)!.Value);
+            var patch = JsonSerializer.Deserialize<Json.Patch.JsonPatch>(jsonPatch.RootElement);
             if (patch != null)
             {
                 var resourcePatch = new Patch(PatchType.JsonPatch, jsonPatch);
-                await this.Api.ManageNamespaced<Workflow>().PatchAsync(name, @namespace, resourcePatch, null, this.CancellationTokenSource.Token);
+                await Api.ManageNamespaced<Workflow>().PatchAsync(name, @namespace, resourcePatch, null, CancellationTokenSource.Token);
             }
-            this.NavigationManager.NavigateTo($"/workflows/details/{@namespace}/{name}/{version}");
+            NavigationManager.NavigateTo($"/workflows/details/{@namespace}/{name}/{version}");
         }
         catch (ProblemDetailsException ex)
         {
-            this.SetProblemDetails(ex.Problem);
+            SetProblemDetails(ex.Problem);
         }
         catch (YamlDotNet.Core.YamlException ex)
         {
-            this.Reduce(state => state with
+            Reduce(state => state with
             {
                 ProblemTitle = "Serialization error",
                 ProblemDetail = "The workflow definition cannot be serialized.",
@@ -497,7 +522,7 @@ public async Task SaveWorkflowDefinitionAsync()
         }
         catch (System.Text.Json.JsonException ex)
         {
-            this.Reduce(state => state with
+            Reduce(state => state with
             {
                 ProblemTitle = "Serialization error",
                 ProblemDetail = "The workflow definition cannot be serialized.",
@@ -510,8 +535,8 @@ public async Task SaveWorkflowDefinitionAsync()
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to save workflow definition: {exception}", ex.ToString());
-            this.Reduce(state => state with
+            Logger.LogError("Unable to save workflow definition: {exception}", ex.ToString());
+            Reduce(state => state with
             {
                 ProblemTitle = "Error",
                 ProblemDetail = "An error occurred while saving the workflow.",
@@ -523,55 +548,80 @@ public async Task SaveWorkflowDefinitionAsync()
         }
         finally
         {
-            this.Reduce(s => s with
+            Reduce(s => s with
             {
                 Saving = false
             });
         }
     }
+    /// <summary>
+    /// Lists all available <see cref="Operator"/>s
+    /// </summary>
+    /// <returns>A new awaitable <see cref="Task"/></returns>
+    public async Task ListOperatorsAsync()
+    {
+        var operatorList = new EquatableList<Operator>(await (await api.Operators.ListAsync().ConfigureAwait(false)).OrderBy(ns => ns.GetQualifiedName()).ToListAsync().ConfigureAwait(false));
+        Reduce(s => s with
+        {
+            Operators = operatorList
+        });
+    }
+
+    /// <summary>
+    /// Sets the <see cref="WorkflowListState.Operator"/> 
+    /// </summary>
+    /// <param name="operatorName">The new value</param>
+    public void SetOperator(string? operatorName)
+    {
+        Reduce(state => state with
+        {
+            Operator = operatorName
+        });
+    }
     #endregion
 
     /// <inheritdoc/>
     public override async Task InitializeAsync()
     {
-        this.Loading.Where(loading => loading == true).Subscribe(loading =>
+        await ListOperatorsAsync().ConfigureAwait(false);
+        Loading.Where(loading => loading == true).Subscribe(loading =>
         {
-            this._hasTextEditorInitialized = false; // reset text editor state when loading
-        }, token: this.CancellationTokenSource.Token);
-        this.WorkflowDefinition.SubscribeAsync(async definition => {
+            _hasTextEditorInitialized = false; // reset text editor state when loading
+        }, token: CancellationTokenSource.Token);
+        WorkflowDefinition.SubscribeAsync(async definition => {
             string document = "";
             if (definition != null)
             {
-                document = this.MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
-                    this.JsonSerializer.SerializeToText(definition) :
-                    this.YamlSerializer.SerializeToText(definition);
+                document = MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
+                    JsonSerializer.SerializeToText(definition) :
+                    YamlSerializer.SerializeToText(definition);
             }
-            this.Reduce(state => state with
+            Reduce(state => state with
             {
                 WorkflowDefinitionText = document
             });
-            await this.InitializeTextBasedEditorAsync();
-        }, cancellationToken: this.CancellationTokenSource.Token);
+            await InitializeTextBasedEditorAsync();
+        }, cancellationToken: CancellationTokenSource.Token);
         Observable.CombineLatest(
-            this.Namespace.Where(ns => !string.IsNullOrWhiteSpace(ns)),
-            this.Name.Where(name => !string.IsNullOrWhiteSpace(name)),
+            Namespace.Where(ns => !string.IsNullOrWhiteSpace(ns)),
+            Name.Where(name => !string.IsNullOrWhiteSpace(name)),
             (ns, name) => (ns!, name!)
         ).SubscribeAsync(async ((string ns, string name) workflow) =>
         {
-            await this.GetWorkflowDefinitionAsync(workflow.ns, workflow.name);
-        }, cancellationToken: this.CancellationTokenSource.Token);
-        this.WorkflowDefinitionText.Where(document => !string.IsNullOrEmpty(document)).Throttle(new(100)).SubscribeAsync(async (document) => 
+            await GetWorkflowDefinitionAsync(workflow.ns, workflow.name);
+        }, cancellationToken: CancellationTokenSource.Token);
+        WorkflowDefinitionText.Where(document => !string.IsNullOrEmpty(document)).Throttle(new(100)).SubscribeAsync(async (document) => 
         {
             if (string.IsNullOrWhiteSpace(document)) return;
-            var currentDslVersion = this.Get(state => state.DslVersion);
+            var currentDslVersion = Get(state => state.DslVersion);
             var versionExtractor = new Regex("'?\"?(dsl|DSL)'?\"?\\s*:\\s*'?\"?([\\w\\.\\-\\+]*)'?\"?");
             var match = versionExtractor.Match(document);
             if (match == null) return;
             var documentDslVersion = match.Groups[2].Value;
             if (documentDslVersion == currentDslVersion) return;
-            await this.SetValidationSchema(documentDslVersion);
-        }, cancellationToken: this.CancellationTokenSource.Token);
-        this.MonacoEditorHelper.PreferredThemeChanged += OnPreferredThemeChangedAsync;
+            await SetValidationSchema(documentDslVersion);
+        }, cancellationToken: CancellationTokenSource.Token);
+        MonacoEditorHelper.PreferredThemeChanged += OnPreferredThemeChangedAsync;
         await base.InitializeAsync();
     }
 
@@ -582,35 +632,35 @@ public override async Task InitializeAsync()
     /// <returns>An awaitable task</returns>
     protected async Task SetValidationSchema(string? version = null)
     {
-        version ??= await this.SpecificationSchemaManager.GetLatestVersion();
-        var currentVersion = this.Get(state => state.DslVersion);
+        version ??= await SpecificationSchemaManager.GetLatestVersion();
+        var currentVersion = Get(state => state.DslVersion);
         if (currentVersion == version)
         {
             return;
         }
-        if (this._processingVersion)
+        if (_processingVersion)
         {
             return;
         }
-        this.SetProblemDetails(null);
-        this._processingVersion = true;
+        SetProblemDetails(null);
+        _processingVersion = true;
         try
         {
-            var schema = await this.SpecificationSchemaManager.GetSchema(version);
+            var schema = await SpecificationSchemaManager.GetSchema(version);
             var type = $"create_{typeof(WorkflowDefinition).Name.ToLower()}_{version}_schema";
-            await this.MonacoInterop.AddValidationSchemaAsync(schema, $"https://synapse.io/schemas/{type}.json", $"{type}*").ConfigureAwait(false);
-            this._textModelUri = this.MonacoEditorHelper.GetResourceUri(type);
-            this.Reduce(state => state with
+            await MonacoInterop.AddValidationSchemaAsync(schema, $"https://synapse.io/schemas/{type}.json", $"{type}*").ConfigureAwait(false);
+            _textModelUri = MonacoEditorHelper.GetResourceUri(type);
+            Reduce(state => state with
             {
                 DslVersion = version
             });
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to set the validation schema: {exception}", ex.ToString());
-            this.SetProblemDetails(new ProblemDetails(new Uri("about:blank"), "Unable to set the validation schema", 404, $"Unable to set the validation schema for the specification version '{version}'. Make sure the version exists."));
+            Logger.LogError("Unable to set the validation schema: {exception}", ex.ToString());
+            SetProblemDetails(new ProblemDetails(new Uri("about:blank"), "Unable to set the validation schema", 404, $"Unable to set the validation schema for the specification version '{version}'. Make sure the version exists."));
         }
-        this._processingVersion = false;
+        _processingVersion = false;
     }
 
     /// <summary>
@@ -620,9 +670,9 @@ protected async Task SetValidationSchema(string? version = null)
     /// <returns></returns>
     protected async Task OnPreferredThemeChangedAsync(string newTheme)
     {
-        if (this.TextEditor != null && this._hasTextEditorInitialized)
+        if (TextEditor != null && _hasTextEditorInitialized)
         {
-            await this.TextEditor.UpdateOptions(new EditorUpdateOptions() { Theme = newTheme });
+            await TextEditor.UpdateOptions(new EditorUpdateOptions() { Theme = newTheme });
         }
     }
 
@@ -632,23 +682,23 @@ protected async Task OnPreferredThemeChangedAsync(string newTheme)
     /// <param name="disposing">A boolean indicating whether or not the dispose of the store</param>
     protected override void Dispose(bool disposing)
     {
-        if (!this._disposed)
+        if (!_disposed)
         {
             if (disposing)
             {
-                if (this._textModel != null)
+                if (_textModel != null)
                 {
-                    this._textModel.DisposeModel();
-                    this._textModel = null;
+                    _textModel.DisposeModel();
+                    _textModel = null;
                 }
-                if (this.TextEditor != null)
+                if (TextEditor != null)
                 {
-                    this.TextEditor.Dispose();
-                    this.TextEditor = null;
+                    TextEditor.Dispose();
+                    TextEditor = null;
                 }
-                this.MonacoEditorHelper.PreferredThemeChanged -= OnPreferredThemeChangedAsync;
+                MonacoEditorHelper.PreferredThemeChanged -= OnPreferredThemeChangedAsync;
             }
-            this._disposed = true;
+            _disposed = true;
         }
     }
 
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/View.razor b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/View.razor
index 72454b1d..1f11bb59 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/View.razor
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Create/View.razor
@@ -64,6 +64,21 @@ else
             </Callout>
         </div>
     }
+
+    <div class="py-3">
+        @if (operators != null && operators.Count() > 0)
+        {
+            <select class="form-select m-2" @onchange="(e) => Store.SetOperator(e.Value?.ToString())">
+                <option value="">Any Operator</option>
+                @foreach (var op in operators)
+                {
+                    var name = op.GetName() + "." + op.GetNamespace();
+                    <option value="@name" selected="@(name == operatorName)">@name</option>
+                }
+            </select>
+        }
+    </div>
+
     <Button class="mt-3" Color="ButtonColor.Primary" Outline="true" Disabled="saving" @onclick="async (_) => await Store.SaveWorkflowDefinitionAsync()">
         @if(!saving)
         {
@@ -83,7 +98,9 @@ else
     bool loading = true;
     bool saving;
     private ProblemDetails? problemDetails = null;
-
+    protected IEnumerable<Operator>? operators { get; set; }
+    protected string? operatorName { get; set; }
+    
     [Parameter] public string? Namespace { get; set; }
     [Parameter] public string? Name { get; set; }
 
@@ -94,6 +111,8 @@ else
         BreadcrumbManager.Use(Breadcrumbs.Workflows);
         BreadcrumbManager.Add(new($"New", $"/workflows/new"));
         Store.SetIsNew(true);
+        Store.Operators.Subscribe(value => OnStateChanged(_ => operators = value), token: CancellationTokenSource.Token);
+        Store.Operator.Subscribe(value => OnStateChanged(_ => operatorName = value), token: CancellationTokenSource.Token);
         Store.Namespace.Subscribe(value => OnStateChanged(_ => ns = value), token: CancellationTokenSource.Token);
         Store.Name.Subscribe(value => OnStateChanged(_ => name = value), token: CancellationTokenSource.Token);
         Store.Loading.Subscribe(value => OnStateChanged(_ => loading = value), token: CancellationTokenSource.Token);
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/State.cs b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/State.cs
index b78750d0..5fac8972 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/State.cs
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/State.cs
@@ -53,4 +53,14 @@ public record WorkflowDetailsState
     /// </summary>
     public ProblemDetails? ProblemDetails { get; set; }
 
+    /// <summary>
+    /// Gets a <see cref="EquatableList{T}"/> that contains all <see cref="Operator"/>s
+    /// </summary>
+    public EquatableList<Operator>? Operators { get; set; }
+
+    /// <summary>
+    /// Gets/sets the active operator filter
+    /// </summary>
+    public string? Operator { get; set; } = null;
+
 }
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/Store.cs b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/Store.cs
index b0b1c372..5677eb2a 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/Store.cs
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/Store.cs
@@ -15,6 +15,7 @@
 using Neuroglia.Collections;
 using ServerlessWorkflow.Sdk.Models;
 using Synapse.Api.Client.Services;
+using Synapse.Dashboard.Pages.Workflows.List;
 using Synapse.Resources;
 
 namespace Synapse.Dashboard.Pages.Workflows.Details;
@@ -95,7 +96,7 @@ ToastService toastService
     public Modal? Modal { get; set; }
 
     #region Selectors
-    
+
     /// <summary>
     /// Gets an <see cref="IObservable{T}"/> used to observe <see cref="WorkflowDetailsState.Workflow"/> changes
     /// </summary>
@@ -111,12 +112,22 @@ ToastService toastService
     /// </summary>
     public IObservable<string?> WorkflowInstanceName => this.Select(state => state.WorkflowInstanceName).DistinctUntilChanged();
 
+    /// <summary>
+    /// Gets an <see cref="IObservable{T}"/> used to observe <see cref="WorkflowListState.Operators"/> changes
+    /// </summary>
+    public IObservable<EquatableList<Operator>?> Operators => this.Select(s => s.Operators).DistinctUntilChanged();
+
+    /// <summary>
+    /// Gets an <see cref="IObservable{T}"/> used to observe <see cref="WorkflowListState.Operator"/> changes
+    /// </summary>
+    public IObservable<string?> Operator => this.Select(s => s.Operator).DistinctUntilChanged();
+
     /// <summary>
     /// Gets an <see cref="IObservable{T}"/> exposing the <see cref="WorkflowDefinition"/>
     /// </summary>
     public IObservable<WorkflowDefinition?> WorkflowDefinition => Observable.CombineLatest(
-        this.Workflow,
-        this.WorkflowDefinitionVersion,
+        Workflow,
+        WorkflowDefinitionVersion,
         (workflow, version) =>
         {
             if (workflow == null)
@@ -128,7 +139,7 @@ ToastService toastService
                 var latest = workflow.Spec.Versions.GetLatest()?.Document.Version;
                 if (!string.IsNullOrWhiteSpace(latest))
                 {
-                    this.SetWorkflowDefinitionVersion(latest);
+                    SetWorkflowDefinitionVersion(latest);
                 }
                 return null;
             }
@@ -150,8 +161,8 @@ ToastService toastService
     /// Gets an <see cref="IObservable{T}"/> used to observe the displayed <see cref="WorkflowInstance"/> changes
     /// </summary>
     public IObservable<WorkflowInstance?> WorkflowInstance => Observable.CombineLatest(
-        this.Resources,
-        this.WorkflowInstanceName,
+        Resources,
+        WorkflowInstanceName,
         (instances, name) => {
             if (instances == null || instances.Count == 0 || name == null)
             {
@@ -174,7 +185,7 @@ ToastService toastService
     public override void SetActiveResourceName(string activeResourceName)
     {
         //base.SetActiveResourceName(activeResourceName);
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             ActiveResourceName = activeResourceName,
             Workflow = null
@@ -187,7 +198,7 @@ public override void SetActiveResourceName(string activeResourceName)
     /// <param name="workflowDefinitionVersion">The new <see cref="WorkflowDetailsState.WorkflowDefinitionVersion"/> value</param>
     public void SetWorkflowDefinitionVersion(string? workflowDefinitionVersion)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             WorkflowDefinitionVersion = workflowDefinitionVersion
         });
@@ -199,7 +210,7 @@ public void SetWorkflowDefinitionVersion(string? workflowDefinitionVersion)
     /// <param name="instanceName">The new <see cref="WorkflowDetailsState.WorkflowInstanceName"/> value</param>
     public void SetWorkflowInstanceName(string? instanceName)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             WorkflowInstanceName = instanceName
         });
@@ -211,7 +222,7 @@ public void SetWorkflowInstanceName(string? instanceName)
     /// <param name="problemDetails">The <see cref="ProblemDetails"/> to set</param>
     public void SetProblemDetails(ProblemDetails? problemDetails)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             ProblemDetails = problemDetails
         });
@@ -227,22 +238,22 @@ public void SetProblemDetails(ProblemDetails? problemDetails)
     /// <returns>A awaitable task</returns>
     async Task SetTextEditorValueAsync()
     {
-        var document = this.Get(state => state.WorkflowDefinitionJson);
-        var language = this.MonacoEditorHelper.PreferredLanguage;
-        if (this.TextEditor != null && !string.IsNullOrWhiteSpace(document))
+        var document = Get(state => state.WorkflowDefinitionJson);
+        var language = MonacoEditorHelper.PreferredLanguage;
+        if (TextEditor != null && !string.IsNullOrWhiteSpace(document))
         {
             try
             {
                 if (language == PreferredLanguage.YAML)
                 {
-                    document = this.YamlSerializer.ConvertFromJson(document);
+                    document = YamlSerializer.ConvertFromJson(document);
                 }
-                await this.TextEditor.SetValue(document);
+                await TextEditor.SetValue(document);
             }
             catch (Exception ex)
             {
-                this.Logger.LogError("Unable to set text editor value: {exception}", ex.ToString());
-                await this.MonacoEditorHelper.ChangePreferredLanguageAsync(language == PreferredLanguage.YAML ? PreferredLanguage.JSON : PreferredLanguage.YAML);
+                Logger.LogError("Unable to set text editor value: {exception}", ex.ToString());
+                await MonacoEditorHelper.ChangePreferredLanguageAsync(language == PreferredLanguage.YAML ? PreferredLanguage.JSON : PreferredLanguage.YAML);
             }
         }
     }
@@ -257,15 +268,15 @@ public async Task GetWorkflowAsync(string ns, string name)
     {
         try
         {
-            var workflow = await this.ApiClient.Workflows.GetAsync(name, ns);
-            this.Reduce(state => state with
+            var workflow = await ApiClient.Workflows.GetAsync(name, ns);
+            Reduce(state => state with
             {
                 Workflow = workflow
             });
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to get workflow '{name}.{ns}': {exception}", name, ns, ex.ToString());
+            Logger.LogError("Unable to get workflow '{name}.{ns}': {exception}", name, ns, ex.ToString());
         }
     }
 
@@ -276,7 +287,7 @@ public async Task GetWorkflowAsync(string ns, string name)
     /// <returns>A awaitable task</returns>
     public async Task ToggleTextBasedEditorLanguageAsync(string _)
     {
-        await this.InitializeTextBasedEditorAsync();
+        await InitializeTextBasedEditorAsync();
     }
 
     /// <summary>
@@ -285,8 +296,8 @@ public async Task ToggleTextBasedEditorLanguageAsync(string _)
     /// <returns></returns>
     public async Task OnTextBasedEditorInitAsync()
     {
-        this._hasTextEditorInitialized = true;
-        await this.InitializeTextBasedEditorAsync();
+        _hasTextEditorInitialized = true;
+        await InitializeTextBasedEditorAsync();
     }
 
     /// <summary>
@@ -295,9 +306,9 @@ public async Task OnTextBasedEditorInitAsync()
     /// <returns></returns>
     public async Task InitializeTextBasedEditorAsync()
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        await this.SetTextBasedEditorLanguageAsync();
-        await this.SetTextEditorValueAsync();
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        await SetTextBasedEditorLanguageAsync();
+        await SetTextEditorValueAsync();
     }
 
     /// <summary>
@@ -308,26 +319,26 @@ public async Task SetTextBasedEditorLanguageAsync()
     {
         try
         {
-            var language = this.MonacoEditorHelper.PreferredLanguage;
-            if (this.TextEditor != null && this._hasTextEditorInitialized)
+            var language = MonacoEditorHelper.PreferredLanguage;
+            if (TextEditor != null && _hasTextEditorInitialized)
             {
-                if (this._textModel != null)
+                if (_textModel != null)
                 {
-                    await Global.SetModelLanguage(this.JSRuntime, this._textModel, language);
+                    await Global.SetModelLanguage(JSRuntime, _textModel, language);
                 }
                 else
                 {
-                    var version = this.Get(state => state.WorkflowDefinitionVersion);
-                    var reference = this.Get(state => state.Namespaces) + "." + this.Get(state => state.ActiveResourceName) + (!string.IsNullOrWhiteSpace(version) ? $":{version}" : "");
+                    var version = Get(state => state.WorkflowDefinitionVersion);
+                    var reference = Get(state => state.Namespaces) + "." + Get(state => state.ActiveResourceName) + (!string.IsNullOrWhiteSpace(version) ? $":{version}" : "");
                     var resourceUri = $"inmemory://{reference.ToLower()}";
-                    this._textModel = await Global.CreateModel(this.JSRuntime, "", language, resourceUri);
+                    _textModel = await Global.CreateModel(JSRuntime, "", language, resourceUri);
                 }
-                await this.TextEditor!.SetModel(this._textModel);
+                await TextEditor!.SetModel(_textModel);
             }
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to set text editor language: {exception}", ex.ToString());
+            Logger.LogError("Unable to set text editor language: {exception}", ex.ToString());
         }
     }
 
@@ -337,18 +348,18 @@ public async Task SetTextBasedEditorLanguageAsync()
     /// <returns>A awaitable task</returns>
     public async Task OnCopyToClipboard()
     {
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        var text = await this.TextEditor.GetValue();
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        var text = await TextEditor.GetValue();
         if (string.IsNullOrWhiteSpace(text)) return;
         try
         {
-            await this.JSRuntime.InvokeVoidAsync("navigator.clipboard.writeText", text);
-            this.ToastService.Notify(new(ToastType.Success, "Copied to the clipboard!"));
+            await JSRuntime.InvokeVoidAsync("navigator.clipboard.writeText", text);
+            ToastService.Notify(new(ToastType.Success, "Copied to the clipboard!"));
         }
         catch (Exception ex)
         {
-            this.ToastService.Notify(new(ToastType.Danger, "Failed to copy the definition to the clipboard."));
-            this.Logger.LogError("Unable to copy to clipboard: {exception}", ex.ToString());
+            ToastService.Notify(new(ToastType.Danger, "Failed to copy the definition to the clipboard."));
+            Logger.LogError("Unable to copy to clipboard: {exception}", ex.ToString());
         }
     }
 
@@ -356,20 +367,24 @@ public async Task OnCopyToClipboard()
     /// Displays the modal used to provide the new workflow input
     /// </summary>
     /// <param name="workflowDefinition">The definition to start a new instance of</param>
+    /// <param name="operators">The list of available operators</param>
     /// <param name="input">A default input payload, if any</param>
+    /// <param name="operatorName">A default operator name, if any</param>
     /// <returns>A awaitable task</returns>
-    public async Task OnShowCreateInstanceAsync(WorkflowDefinition workflowDefinition, EquatableDictionary<string, object>? input = null)
+    public async Task OnShowCreateInstanceAsync(WorkflowDefinition workflowDefinition, EquatableList<Operator> operators, EquatableDictionary<string, object>? input = null, string? operatorName = null)
     {
-        if (this.Modal != null)
+        if (Modal != null)
         {
             var parameters = new Dictionary<string, object>
             {
                 { nameof(CreateWorkflowInstanceDialog.WorkflowDefinition), workflowDefinition },
+                { nameof(CreateWorkflowInstanceDialog.Operators), operators },
+                { nameof(CreateWorkflowInstanceDialog.OperatorName), operatorName },
                 { nameof(CreateWorkflowInstanceDialog.Input), input! },
-                { nameof(CreateWorkflowInstanceDialog.OnCreate), EventCallback.Factory.Create<string>(this, CreateInstanceAsync) },
+                { nameof(CreateWorkflowInstanceDialog.OnCreate), EventCallback.Factory.Create<CreateWorkflowInstanceParameters>(this, CreateInstanceAsync) },
                 { nameof(CreateWorkflowInstanceDialog.OnProblem), EventCallback.Factory.Create<ProblemDetails>(this, SetProblemDetails) }
             };
-            await this.Modal.ShowAsync<CreateWorkflowInstanceDialog>(title: "Start a new workflow", parameters: parameters);
+            await Modal.ShowAsync<CreateWorkflowInstanceDialog>(title: "Start a new workflow", parameters: parameters);
         }
     }
 
@@ -380,7 +395,7 @@ public async Task OnShowCreateInstanceAsync(WorkflowDefinition workflowDefinitio
     /// <returns>A awaitable task</returns>
     public async Task SuspendInstanceAsync(WorkflowInstance workflowInstance)
     {
-        await this.ApiClient.WorkflowInstances.SuspendAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
+        await ApiClient.WorkflowInstances.SuspendAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -390,7 +405,7 @@ public async Task SuspendInstanceAsync(WorkflowInstance workflowInstance)
     /// <returns>A awaitable task</returns>
     public async Task ResumeInstanceAsync(WorkflowInstance workflowInstance)
     {
-        await this.ApiClient.WorkflowInstances.ResumeAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
+        await ApiClient.WorkflowInstances.ResumeAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -400,7 +415,7 @@ public async Task ResumeInstanceAsync(WorkflowInstance workflowInstance)
     /// <returns>A awaitable task</returns>
     public async Task CancelInstanceAsync(WorkflowInstance workflowInstance)
     {
-        await this.ApiClient.WorkflowInstances.CancelAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
+        await ApiClient.WorkflowInstances.CancelAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -409,13 +424,13 @@ public async Task CancelInstanceAsync(WorkflowInstance workflowInstance)
     /// <returns>A awaitable task</returns>
     public async Task OnSuspendSelectedInstancesAsync()
     {
-        var selectedResourcesNames = this.Get(state => state.SelectedResourceNames);
-        var resources = (this.Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
+        var selectedResourcesNames = Get(state => state.SelectedResourceNames);
+        var resources = (Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
         foreach (var resource in resources)
         {
-            await this.SuspendInstanceAsync(resource);
+            await SuspendInstanceAsync(resource);
         }
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             SelectedResourceNames = []
         });
@@ -427,13 +442,13 @@ public async Task OnSuspendSelectedInstancesAsync()
     /// <returns>A awaitable task</returns>
     public async Task OnResumeSelectedInstancesAsync()
     {
-        var selectedResourcesNames = this.Get(state => state.SelectedResourceNames);
-        var resources = (this.Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
+        var selectedResourcesNames = Get(state => state.SelectedResourceNames);
+        var resources = (Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
         foreach (var resource in resources)
         {
-            await this.ResumeInstanceAsync(resource);
+            await ResumeInstanceAsync(resource);
         }
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             SelectedResourceNames = []
         });
@@ -445,13 +460,13 @@ public async Task OnResumeSelectedInstancesAsync()
     /// <returns>A awaitable task</returns>
     public async Task OnCancelSelectedInstancesAsync()
     {
-        var selectedResourcesNames = this.Get(state => state.SelectedResourceNames);
-        var resources = (this.Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
+        var selectedResourcesNames = Get(state => state.SelectedResourceNames);
+        var resources = (Get(state => state.Resources) ?? []).Where(resource => selectedResourcesNames.Contains(resource.GetName()));
         foreach (var resource in resources)
         {
-            await this.CancelInstanceAsync(resource);
+            await CancelInstanceAsync(resource);
         }
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             SelectedResourceNames = []
         });
@@ -460,29 +475,29 @@ public async Task OnCancelSelectedInstancesAsync()
     /// <summary>
     /// Creates a new instance of the workflow
     /// </summary>
-    /// <param name="input">The input data, if any</param>
+    /// <param name="parameters">The <see cref="CreateWorkflowInstanceParameters"/> used to create the instance.</param>
     /// <returns>A awaitable task</returns>
-    public async Task CreateInstanceAsync(string input)
+    public async Task CreateInstanceAsync(CreateWorkflowInstanceParameters parameters)
     {
-        var workflowName = this.Get(state => state.ActiveResourceName);
-        var workflowVersion = this.Get(state => state.WorkflowDefinitionVersion);
-        var ns = this.Get(state => state.Namespace);
+        var workflowName = Get(state => state.ActiveResourceName);
+        var workflowVersion = Get(state => state.WorkflowDefinitionVersion);
+        var ns = Get(state => state.Namespace);
         if (string.IsNullOrWhiteSpace(workflowName) || string.IsNullOrWhiteSpace(workflowVersion) || string.IsNullOrWhiteSpace(ns))
         {
-            await this.Modal!.HideAsync();
+            await Modal!.HideAsync();
             return;
         }
         var inputData = new EquatableDictionary<string, object> { };
-        if (!string.IsNullOrWhiteSpace(input)) inputData = this.MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
-                this.JsonSerializer.Deserialize<EquatableDictionary<string, object>>(input) :
-                this.YamlSerializer.Deserialize<EquatableDictionary<string, object>>(input);
+        if (!string.IsNullOrWhiteSpace(parameters.Input)) inputData = MonacoEditorHelper.PreferredLanguage == PreferredLanguage.JSON ?
+                JsonSerializer.Deserialize<EquatableDictionary<string, object>>(parameters.Input) :
+                YamlSerializer.Deserialize<EquatableDictionary<string, object>>(parameters.Input);
         try
         {
-            var instance = await this.ApiClient.WorkflowInstances.CreateAsync(new()
+            var instance = new WorkflowInstance()
             {
                 Metadata = new()
                 {
-                    Namespace =ns,
+                    Namespace = ns,
                     Name = $"{workflowName}-"
                 },
                 Spec = new()
@@ -495,13 +510,31 @@ public async Task CreateInstanceAsync(string input)
                     },
                     Input = inputData
                 }
-            });
+            };
+            if (!string.IsNullOrWhiteSpace(parameters.Operator))
+            {
+                instance.Metadata.Labels = instance.Metadata.Labels ?? new EquatableDictionary<string, string>();
+                instance.Metadata.Labels.Add(SynapseDefaults.Resources.Labels.Operator, parameters.Operator);
+            }
+            instance = await ApiClient.WorkflowInstances.CreateAsync(instance);
         }
         catch (Exception ex)
         {
-            this.Logger.LogError("Unable to set create workflow instance: {exception}", ex.ToString());
+            Logger.LogError("Unable to set create workflow instance: {exception}", ex.ToString());
         }
-        await this.Modal!.HideAsync();
+        await Modal!.HideAsync();
+    }
+
+    /// <summary>
+    /// Sets the <see cref="WorkflowListState.Operator"/> 
+    /// </summary>
+    /// <param name="operatorName">The new value</param>
+    public void SetOperator(string? operatorName)
+    {
+        Reduce(state => state with
+        {
+            Operator = operatorName
+        });
     }
 
     /// <summary>
@@ -511,7 +544,7 @@ public async Task CreateInstanceAsync(string input)
     /// <returns>A awaitable task</returns>
     public async Task DeleteWorkflowInstanceAsync(WorkflowInstance workflowInstance)
     {
-        await this.ApiClient.ManageNamespaced<WorkflowInstance>().DeleteAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
+        await ApiClient.ManageNamespaced<WorkflowInstance>().DeleteAsync(workflowInstance.GetName(), workflowInstance.GetNamespace()!).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -522,50 +555,73 @@ public async Task DeleteWorkflowInstanceAsync(WorkflowInstance workflowInstance)
     public async Task SelectNodeInEditor(GraphEventArgs<MouseEventArgs> e)
     {
         if (e.GraphElement == null) return;
-        if (this.TextEditor == null || !this._hasTextEditorInitialized) return;
-        var source = await this.TextEditor.GetValue();
+        if (TextEditor == null || !_hasTextEditorInitialized) return;
+        var source = await TextEditor.GetValue();
         var pointer = e.GraphElement.Id;
-        var language = this.MonacoEditorHelper.PreferredLanguage;
-        var range = await this.MonacoInterop.GetJsonPointerRangeAsync(source, pointer, language);
-        await this.TextEditor.SetSelection(range, string.Empty);
-        await this.TextEditor.RevealRangeInCenter(range);
+        var language = MonacoEditorHelper.PreferredLanguage;
+        var range = await MonacoInterop.GetJsonPointerRangeAsync(source, pointer, language);
+        await TextEditor.SetSelection(range, string.Empty);
+        await TextEditor.RevealRangeInCenter(range);
     }
 
+    /// <summary>
+    /// Lists all available <see cref="Operator"/>s
+    /// </summary>
+    /// <returns>A new awaitable <see cref="Task"/></returns>
+    public async Task ListOperatorsAsync()
+    {
+        var operatorList = new EquatableList<Operator>(await (await ApiClient.Operators.ListAsync().ConfigureAwait(false)).OrderBy(ns => ns.GetQualifiedName()).ToListAsync().ConfigureAwait(false));
+        Reduce(s => s with
+        {
+            Operators = operatorList
+        });
+    }
     #endregion
 
     /// <inheritdoc/>
     public override async Task InitializeAsync()
     {
+        await ListOperatorsAsync().ConfigureAwait(false);
+        Operator.Subscribe(operatorName => {
+            if (string.IsNullOrWhiteSpace(operatorName))
+            {
+                RemoveLabelSelector(SynapseDefaults.Resources.Labels.Operator);
+            }
+            else
+            {
+                AddLabelSelector(new(SynapseDefaults.Resources.Labels.Operator, LabelSelectionOperator.Equals, operatorName));
+            }
+        }, token: CancellationTokenSource.Token);
         Observable.CombineLatest(
-            this.Namespace.Where(ns => !string.IsNullOrWhiteSpace(ns)),
-            this.ActiveResourceName.Where(name => !string.IsNullOrWhiteSpace(name)),
+            Namespace.Where(ns => !string.IsNullOrWhiteSpace(ns)),
+            ActiveResourceName.Where(name => !string.IsNullOrWhiteSpace(name)),
             (ns, name) => (ns!, name!)
         ).SubscribeAsync(async ((string ns, string name) workflow) =>
         {
-            this.RemoveLabelSelector(SynapseDefaults.Resources.Labels.Workflow);
-            this.AddLabelSelector(new(SynapseDefaults.Resources.Labels.Workflow, LabelSelectionOperator.Equals, $"{workflow.name}.{workflow.ns}"));
-            await this.GetWorkflowAsync(workflow.ns, workflow.name);
-        }, cancellationToken: this.CancellationTokenSource.Token);
-        this.WorkflowDefinitionVersion.Where(version => version != null).Subscribe(version =>
+            RemoveLabelSelector(SynapseDefaults.Resources.Labels.Workflow);
+            AddLabelSelector(new(SynapseDefaults.Resources.Labels.Workflow, LabelSelectionOperator.Equals, $"{workflow.name}.{workflow.ns}"));
+            await GetWorkflowAsync(workflow.ns, workflow.name);
+        }, cancellationToken: CancellationTokenSource.Token);
+        WorkflowDefinitionVersion.Where(version => version != null).Subscribe(version =>
         {
-            this.RemoveLabelSelector(SynapseDefaults.Resources.Labels.WorkflowVersion);
-            this.AddLabelSelector(new(SynapseDefaults.Resources.Labels.WorkflowVersion, LabelSelectionOperator.Equals, version!));
+            RemoveLabelSelector(SynapseDefaults.Resources.Labels.WorkflowVersion);
+            AddLabelSelector(new(SynapseDefaults.Resources.Labels.WorkflowVersion, LabelSelectionOperator.Equals, version!));
         });
-        this.WorkflowDefinition.Where(definition => definition != null).SubscribeAsync(async (definition) =>
+        WorkflowDefinition.Where(definition => definition != null).SubscribeAsync(async (definition) =>
         {
             await Task.Delay(1);
-            var document = this.JsonSerializer.SerializeToText(definition.Clone());
-            this.Reduce(state => state with
+            var document = JsonSerializer.SerializeToText(definition.Clone());
+            Reduce(state => state with
             {
                 WorkflowDefinitionJson = document
             });
-            await this.SetTextEditorValueAsync();
-            if (this.MonacoEditorHelper.PreferredLanguage != PreferredLanguage.YAML)
+            await SetTextEditorValueAsync();
+            if (MonacoEditorHelper.PreferredLanguage != PreferredLanguage.YAML)
             {
-                await this.MonacoEditorHelper.ChangePreferredLanguageAsync(PreferredLanguage.YAML);
+                await MonacoEditorHelper.ChangePreferredLanguageAsync(PreferredLanguage.YAML);
             }
-        }, cancellationToken: this.CancellationTokenSource.Token);
-        this.MonacoEditorHelper.PreferredThemeChanged += OnPreferredThemeChangedAsync;
+        }, cancellationToken: CancellationTokenSource.Token);
+        MonacoEditorHelper.PreferredThemeChanged += OnPreferredThemeChangedAsync;
         await base.InitializeAsync();
     }
 
@@ -576,9 +632,9 @@ public override async Task InitializeAsync()
     /// <returns></returns>
     protected async Task OnPreferredThemeChangedAsync(string newTheme)
     {
-        if (this.TextEditor != null && this._hasTextEditorInitialized)
+        if (TextEditor != null && _hasTextEditorInitialized)
         {
-            await this.TextEditor.UpdateOptions(new EditorUpdateOptions() { Theme = newTheme });
+            await TextEditor.UpdateOptions(new EditorUpdateOptions() { Theme = newTheme });
         }
     }
 
@@ -588,23 +644,23 @@ protected async Task OnPreferredThemeChangedAsync(string newTheme)
     /// <param name="disposing">A boolean indicating whether or not the dispose of the store</param>
     protected override void Dispose(bool disposing)
     {
-        if (!this._disposed)
+        if (!_disposed)
         {
             if (disposing)
             {
-                if (this._textModel != null)
+                if (_textModel != null)
                 {
-                    this._textModel.DisposeModel();
-                    this._textModel = null;
+                    _textModel.DisposeModel();
+                    _textModel = null;
                 }
-                if (this.TextEditor != null)
+                if (TextEditor != null)
                 {
-                    this.TextEditor.Dispose();
-                    this.TextEditor = null;
+                    TextEditor.Dispose();
+                    TextEditor = null;
                 }
-                this.MonacoEditorHelper.PreferredThemeChanged -= OnPreferredThemeChangedAsync;
+                MonacoEditorHelper.PreferredThemeChanged -= OnPreferredThemeChangedAsync;
             }
-            this._disposed = true;
+            _disposed = true;
         }
     }
 }
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/View.razor b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/View.razor
index c884151d..ed230846 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/View.razor
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/Details/View.razor
@@ -28,25 +28,34 @@
     <HorizontalCollapsible @ref="instancesListPanel" class="collapsible-instances">
         <Label>Instances</Label>
         <Content>
-            <WorkflowInstancesList class="h-100" 
-            Loading="@Loading"
-            WorkflowInstances="@Resources"
-            SelectedInstanceNames="@SelectedResourceNames"
-            ActiveRow="@instanceName"
-            Columns="@columns"
-            OnSearchInput="Store.SetSearchTerm"
-            OnShowDetails="OnShowInstanceDetails"
-            OnSuspend="async (instance) => await Store.SuspendInstanceAsync(instance)"
-            OnResume="async (instance) => await Store.ResumeInstanceAsync(instance)"
-            OnCancel="async (instance) => await Store.CancelInstanceAsync(instance)"
-            OnReplay="async (instance) => await Store.OnShowCreateInstanceAsync(workflowDefinition, instance.Spec?.Input)"
-            OnDelete="OnDeleteWorkflowInstanceAsync"
-            OnToggleSelected="Store.ToggleResourceSelection"
-            OnSuspendSelected="async () => await Store.OnSuspendSelectedInstancesAsync()"
-            OnResumeSelected="async () => await Store.OnResumeSelectedInstancesAsync()"
-            OnCancelSelected="async () => await Store.OnCancelSelectedInstancesAsync()"
-            OnDeleteSelected="OnDeleteSelectedResourcesAsync" />
-            <Button Outline="true" Color="ButtonColor.Primary" @onclick="async _ => await Store.OnShowCreateInstanceAsync(workflowDefinition)" class="w-100 mt-3">
+            <WorkflowInstancesList 
+                class="h-100" 
+                Loading="@Loading"
+                Operators="operators"
+                OperatorName="@operatorName"
+                WorkflowInstances="@Resources"
+                SelectedInstanceNames="@SelectedResourceNames"
+                ActiveRow="@instanceName"
+                Columns="@columns"
+                OnSearchInput="Store.SetSearchTerm"
+                OnShowDetails="OnShowInstanceDetails"
+                OnOperatorChanged="Store.SetOperator"
+                OnSuspend="async (instance) => await Store.SuspendInstanceAsync(instance)"
+                OnResume="async (instance) => await Store.ResumeInstanceAsync(instance)"
+                OnCancel="async (instance) => await Store.CancelInstanceAsync(instance)"
+                OnReplay="async (instance) => await Store.OnShowCreateInstanceAsync(
+                    workflowDefinition, operators ?? [], 
+                    instance.Spec?.Input, 
+                    instance.Metadata.Labels?.Get(SynapseDefaults.Resources.Labels.Operator) ?? operatorName
+                )"
+                OnDelete="OnDeleteWorkflowInstanceAsync"
+                OnToggleSelected="Store.ToggleResourceSelection"
+                OnSuspendSelected="async () => await Store.OnSuspendSelectedInstancesAsync()"
+                OnResumeSelected="async () => await Store.OnResumeSelectedInstancesAsync()"
+                OnCancelSelected="async () => await Store.OnCancelSelectedInstancesAsync()"
+                OnDeleteSelected="OnDeleteSelectedResourcesAsync" 
+            />
+            <Button Outline="true" Color="ButtonColor.Primary" @onclick="async _ => await Store.OnShowCreateInstanceAsync(workflowDefinition, operators ?? [], null, operatorName)" class="w-100 mt-3">
                 <Icon Name="IconName.Plus"/>
             </Button>
         </Content>
@@ -63,9 +72,9 @@
             else
             {
                 <WorkflowDiagram 
-                WorkflowDefinition="@workflowDefinition" 
-                WorkflowInstances="@(workflowInstance != null ? [workflowInstance] : (Resources ?? []))"
-                OnMouseUp="async (e) => await Store.SelectNodeInEditor(e)"
+                    WorkflowDefinition="@workflowDefinition" 
+                    WorkflowInstances="@(workflowInstance != null ? [workflowInstance] : (Resources ?? []))"
+                    OnMouseUp="async (e) => await Store.SelectNodeInEditor(e)"
                 />
             }
         </Content>
@@ -158,11 +167,13 @@
     readonly IEnumerable<string> columns = 
     [
         "Name",
-    "Status",
-    "Start Time",
-    "End Time",
-    ..WorkflowInstancesList.DirectActions
+        "Status",
+        "Start Time",
+        "End Time",
+        ..WorkflowInstancesList.DirectActions
     ];
+    protected EquatableList<Operator>? operators { get; set; }
+    protected string? operatorName { get; set; }
 
     [Parameter] public string? Version { get; set; }
     [Parameter] public string? InstanceName { get; set; }
@@ -174,6 +185,8 @@
         UpdateBreadcrumb();
         Store.WorkflowInstanceName.Subscribe(value => OnStateChanged(_ => instanceName = value), token: CancellationTokenSource.Token);
         Store.WorkflowDefinition.Where(value => value != null).Subscribe(value => OnStateChanged(_ => workflowDefinition = value!), token: CancellationTokenSource.Token);
+        Store.Operators.Subscribe(value => OnStateChanged(_ => operators = value), token: CancellationTokenSource.Token);
+        Store.Operator.Subscribe(value => OnStateChanged(_ => operatorName = value), token: CancellationTokenSource.Token);
         Store.WorkflowDefinitionVersion.Where(value => !string.IsNullOrWhiteSpace(value)).Subscribe(value =>
         {
             OnStateChanged(_ => version = value!);
@@ -255,8 +268,8 @@
     /// <param name="instance">The <see cref="WorkflowInstance"/> to delete</param>
     protected async Task OnDeleteWorkflowInstanceAsync(WorkflowInstance instance)
     {
-        if (this.Dialog == null) return;
-        var confirmation = await this.Dialog.ShowAsync(
+        if (Dialog == null) return;
+        var confirmation = await Dialog.ShowAsync(
             title: $"Are you sure you want to delete '{instance.Metadata.Name}'?",
             message1: $"The workflow instance will be permanently deleted. Are you sure you want to proceed ?",
             confirmDialogOptions: new ConfirmDialogOptions()
@@ -268,10 +281,10 @@
                 }
         );
         if (!confirmation) return;
-        await this.Store.DeleteWorkflowInstanceAsync(instance);
+        await Store.DeleteWorkflowInstanceAsync(instance);
     }
 
-    void OnCreateWorkflowVersion() => this.NavigationManager.NavigateTo($"/workflows/new/{@namespace}/{Name}");
+    void OnCreateWorkflowVersion() => NavigationManager.NavigateTo($"/workflows/new/{@namespace}/{Name}");
 
     void OnShowInstanceDetails(WorkflowInstance instance) => NavigationManager.NavigateTo($"/workflows/details/{@namespace}/{Name}/{version}/{instance.GetName()}");
 
@@ -286,7 +299,7 @@
 
     void OnDismissProblemDetails()
     {
-        this.Store.SetProblemDetails(null);
+        Store.SetProblemDetails(null);
     }
 
 }
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/Store.cs b/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/Store.cs
index c98b8e5e..e834aaa5 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/Store.cs
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/Store.cs
@@ -12,7 +12,6 @@
 // limitations under the License.
 
 using Synapse.Api.Client.Services;
-using Synapse.Dashboard.Components.DocumentDetailsStateManagement;
 using Synapse.Resources;
 
 namespace Synapse.Dashboard.Pages.Workflows.List;
@@ -43,8 +42,8 @@ public class WorkflowListComponentStore(ILogger<WorkflowListComponentStore> logg
     /// <returns>A new awaitable <see cref="Task"/></returns>
     public async Task ListOperatorsAsync()
     {
-        var operatorList = new EquatableList<Operator>(await (await this.ApiClient.Operators.ListAsync().ConfigureAwait(false)).OrderBy(ns => ns.GetQualifiedName()).ToListAsync().ConfigureAwait(false));
-        this.Reduce(s => s with
+        var operatorList = new EquatableList<Operator>(await (await ApiClient.Operators.ListAsync().ConfigureAwait(false)).OrderBy(ns => ns.GetQualifiedName()).ToListAsync().ConfigureAwait(false));
+        Reduce(s => s with
         {
             Operators = operatorList
         });
@@ -56,7 +55,7 @@ public async Task ListOperatorsAsync()
     /// <param name="operatorName">The new value</param>
     public void SetOperator(string? operatorName)
     {
-        this.Reduce(state => state with
+        Reduce(state => state with
         {
             Operator = operatorName
         });
@@ -66,16 +65,16 @@ public void SetOperator(string? operatorName)
     public override async Task InitializeAsync()
     {
         await base.InitializeAsync();
-        await this.ListOperatorsAsync().ConfigureAwait(false);
-        this.Operator.Subscribe(operatorName => {
+        await ListOperatorsAsync().ConfigureAwait(false);
+        Operator.Subscribe(operatorName => {
             if (string.IsNullOrWhiteSpace(operatorName))
             {
-                this.RemoveLabelSelector(SynapseDefaults.Resources.Labels.Operator);
+                RemoveLabelSelector(SynapseDefaults.Resources.Labels.Operator);
             }
             else
             {
-                this.AddLabelSelector(new(SynapseDefaults.Resources.Labels.Operator, LabelSelectionOperator.Equals, operatorName));
+                AddLabelSelector(new(SynapseDefaults.Resources.Labels.Operator, LabelSelectionOperator.Equals, operatorName));
             }
-        }, token: this.CancellationTokenSource.Token);
+        }, token: CancellationTokenSource.Token);
     }
 }
diff --git a/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/View.razor b/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/View.razor
index 6bb425c0..75cb7fea 100644
--- a/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/View.razor
+++ b/src/dashboard/Synapse.Dashboard/Pages/Workflows/List/View.razor
@@ -163,9 +163,9 @@
     protected override void OnInitialized()
     {
         base.OnInitialized();
-        this.BreadcrumbManager.Use(Breadcrumbs.Workflows);
-        this.Store.Operators.Subscribe(value => this.OnStateChanged(_ => Operators = value), token: this.CancellationTokenSource.Token);
-        this.Store.Operator.Subscribe(value => this.OnStateChanged(_ => Operator = value), token: this.CancellationTokenSource.Token);
+        BreadcrumbManager.Use(Breadcrumbs.Workflows);
+        Store.Operators.Subscribe(value => OnStateChanged(_ => Operators = value), token: CancellationTokenSource.Token);
+        Store.Operator.Subscribe(value => OnStateChanged(_ => Operator = value), token: CancellationTokenSource.Token);
     }
 
     string GetScheduleType(Workflow workflow)
@@ -179,10 +179,10 @@
         else throw new NotSupportedException("The specified schedule type is not supported");
     }
 
-    void OnViewWorkflow(Workflow workflow) => this.NavigationManager.NavigateTo($"workflows/details/{workflow.GetNamespace()}/{workflow.GetName()}/{workflow.Spec.Versions.GetLatest().Document.Version}");
+    void OnViewWorkflow(Workflow workflow) => NavigationManager.NavigateTo($"workflows/details/{workflow.GetNamespace()}/{workflow.GetName()}/{workflow.Spec.Versions.GetLatest().Document.Version}");
 
-    void OnCreateWorkflow() => this.NavigationManager.NavigateTo("/workflows/new");
+    void OnCreateWorkflow() => NavigationManager.NavigateTo("/workflows/new");
 
-    void OnCreateWorkflowVersion(string ns, string name) => this.NavigationManager.NavigateTo($"/workflows/new/{ns}/{name}");
+    void OnCreateWorkflowVersion(string ns, string name) => NavigationManager.NavigateTo($"/workflows/new/{ns}/{name}");
 
 }
\ No newline at end of file
diff --git a/src/dashboard/Synapse.Dashboard/Synapse.Dashboard.csproj b/src/dashboard/Synapse.Dashboard/Synapse.Dashboard.csproj
index f6a2a55e..4a67ce79 100644
--- a/src/dashboard/Synapse.Dashboard/Synapse.Dashboard.csproj
+++ b/src/dashboard/Synapse.Dashboard/Synapse.Dashboard.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-	<PackageReference Include="Blazor.Bootstrap" Version="3.3.0" />
+	<PackageReference Include="Blazor.Bootstrap" Version="3.4.0" />
     <PackageReference Include="BlazorMonaco" Version="3.3.0" />
     <PackageReference Include="IdentityModel" Version="7.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.1" />