diff --git a/src/Exceptionless.Core/Models/Data/ProductTourProgress.cs b/src/Exceptionless.Core/Models/Data/ProductTourProgress.cs
new file mode 100644
index 0000000000..285da7c425
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Data/ProductTourProgress.cs
@@ -0,0 +1,22 @@
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+
+namespace Exceptionless.Core.Models.Data;
+
+public record ProductTourProgress
+{
+    public int Version { get; set; }
+    public ProductTourStatus Status { get; set; }
+    public DateTime UpdatedUtc { get; set; }
+}
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum ProductTourStatus
+{
+    [JsonStringEnumMemberName("dismissed")]
+    [EnumMember(Value = "dismissed")]
+    Dismissed,
+    [JsonStringEnumMemberName("completed")]
+    [EnumMember(Value = "completed")]
+    Completed
+}
diff --git a/src/Exceptionless.Core/Models/User.cs b/src/Exceptionless.Core/Models/User.cs
index 9e622dce0f..cfa2b6e494 100644
--- a/src/Exceptionless.Core/Models/User.cs
+++ b/src/Exceptionless.Core/Models/User.cs
@@ -1,6 +1,7 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel.DataAnnotations;
 using Exceptionless.Core.Attributes;
+using Exceptionless.Core.Models.Data;
 using Foundatio.Repositories.Models;
 
 namespace Exceptionless.Core.Models;
@@ -23,6 +24,7 @@ public record User : IIdentity, IHaveDates, IValidatableObject
     public string? PasswordResetToken { get; set; }
     public DateTime PasswordResetTokenExpiration { get; set; }
     public ICollection<OAuthAccount> OAuthAccounts { get; init; } = new Collection<OAuthAccount>();
+    public IDictionary<string, ProductTourProgress> ProductTours { get; init; } = new Dictionary<string, ProductTourProgress>(StringComparer.Ordinal);
 
     /// <summary>
     /// Gets or sets the users Full Name.
diff --git a/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs b/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
index 44ce3acd29..3928b0d721 100644
--- a/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
+++ b/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
@@ -37,6 +37,25 @@ public static IEndpointRouteBuilder MapUserEndpoints(this IEndpointRouteBuilder
             }
         });
 
+        group.MapPut("users/me/product-tours/{tourId:minlength(1):maxlength(64)}", async (string tourId, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] UpdateProductTourProgress? progress)
+            => progress is null ? ApiValidation.MissingRequestBody() : (await mediator.InvokeAsync<Result<ViewCurrentUser>>(new UserMessages.UpdateCurrentUserProductTour(tourId, progress))).ToHttpResult(resultMapper))
+        .Accepts<UpdateProductTourProgress>(false, "application/json", "application/*+json")
+        .Produces<ViewCurrentUser>()
+        .ProducesProblem(StatusCodes.Status422UnprocessableEntity)
+        .ProducesProblem(StatusCodes.Status404NotFound)
+        .WithSummary("Update current user product tour progress")
+        .WithMetadata(new EndpointDocumentation {
+            RequestBodyDescription = "The versioned product tour outcome.",
+            RequestBodyRequired = true,
+            ParameterDescriptions = new() {
+                ["tourId"] = "The stable product tour identifier.",
+            },
+            ResponseDescriptions = new() {
+                ["422"] = "The product tour progress is invalid.",
+                ["404"] = "The current user could not be found.",
+            }
+        });
+
         group.MapGet("users/me/oauth-grants", async (IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper)
             => (await mediator.InvokeAsync<Result<IReadOnlyCollection<ViewOAuthGrant>>>(new UserMessages.GetCurrentUserOAuthGrants())).ToHttpResult(resultMapper))
         .Produces<IReadOnlyCollection<ViewOAuthGrant>>()
diff --git a/src/Exceptionless.Web/Api/Handlers/UserHandler.cs b/src/Exceptionless.Web/Api/Handlers/UserHandler.cs
index 92e9bd563e..b374375d30 100644
--- a/src/Exceptionless.Web/Api/Handlers/UserHandler.cs
+++ b/src/Exceptionless.Web/Api/Handlers/UserHandler.cs
@@ -3,6 +3,7 @@
 using Exceptionless.Core.Extensions;
 using Exceptionless.Core.Mail;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Repositories;
 using Exceptionless.DateTimeExtensions;
 using Exceptionless.Web.Api.Infrastructure;
@@ -14,8 +15,10 @@
 using Exceptionless.Web.Models.OAuth;
 using Exceptionless.Web.Utility;
 using Foundatio.Caching;
+using Foundatio.Lock;
 using Foundatio.Repositories;
 using Foundatio.Mediator;
+using System.Text.RegularExpressions;
 
 namespace Exceptionless.Web.Api.Handlers;
 
@@ -26,6 +29,7 @@ public class UserHandler(
     IOAuthTokenRepository oauthTokenRepository,
     IOAuthApplicationRepository oauthApplicationRepository,
     ICacheClient cacheClient,
+    ILockProvider lockProvider,
     IMailer mailer,
     ApiMapper mapper,
     IntercomOptions intercomOptions,
@@ -33,6 +37,8 @@ public class UserHandler(
     IHttpContextAccessor httpContextAccessor,
     ILoggerFactory loggerFactory)
 {
+    private const int MaximumProductTours = 32;
+    private static readonly Regex ProductTourIdRegex = new("^[a-z0-9]+(?:-[a-z0-9]+)*$", RegexOptions.CultureInvariant);
     private readonly ICacheClient _cache = new ScopedCacheClient(cacheClient, "User");
     private readonly ILogger _logger = loggerFactory.CreateLogger<UserHandler>();
     private HttpContext HttpContext => httpContextAccessor.HttpContext ?? throw new InvalidOperationException("HttpContext is unavailable.");
@@ -49,6 +55,54 @@ public async Task<Result<ViewCurrentUser>> Handle(GetCurrentUser message)
         };
     }
 
+    public async Task<Result<ViewCurrentUser>> Handle(UpdateCurrentUserProductTour message)
+    {
+        if (!ProductTourIdRegex.IsMatch(message.TourId))
+            return Result.Invalid(ValidationError.Create("tour_id", "Tour id can only contain lowercase letters, numbers, and single dashes."));
+
+        string currentUserId = GetCurrentUserId();
+        Result<ViewCurrentUser>? result = null;
+        bool lockAcquired = await lockProvider.TryUsingAsync($"product-tours:{currentUserId}", async () =>
+        {
+            result = await UpdateCurrentUserProductTourAsync(currentUserId, message);
+        }, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10));
+
+        return lockAcquired && result is not null ? result : Result.Error("Unable to update product tour progress.");
+    }
+
+    private async Task<Result<ViewCurrentUser>> UpdateCurrentUserProductTourAsync(string currentUserId, UpdateCurrentUserProductTour message)
+    {
+        var currentUser = await GetModelAsync(currentUserId, useCache: false);
+        if (currentUser is null)
+            return Result.NotFound("User not found.");
+
+        bool isNewTour = !currentUser.ProductTours.TryGetValue(message.TourId, out var existingProgress);
+        if (isNewTour && currentUser.ProductTours.Count >= MaximumProductTours)
+            return Result.Invalid(ValidationError.Create("tour_id", $"A user cannot track more than {MaximumProductTours} product tours."));
+
+        var requestedStatus = message.Progress.Status!.Value;
+        if (existingProgress is null
+            || message.Progress.Version > existingProgress.Version
+            || (message.Progress.Version == existingProgress.Version
+                && existingProgress.Status == ProductTourStatus.Dismissed
+                && requestedStatus == ProductTourStatus.Completed))
+        {
+            currentUser.ProductTours[message.TourId] = new ProductTourProgress
+            {
+                Version = message.Progress.Version,
+                Status = requestedStatus,
+                UpdatedUtc = timeProvider.GetUtcNow().UtcDateTime
+            };
+
+            await repository.SaveAsync(currentUser, o => o.Cache());
+        }
+
+        return new ViewCurrentUser(currentUser, intercomOptions)
+        {
+            AvatarUrl = GetUserAvatarUrl(currentUser.Id, currentUser.AvatarFileName)
+        };
+    }
+
     public async Task<Result<IReadOnlyCollection<ViewOAuthGrant>>> Handle(GetCurrentUserOAuthGrants message)
     {
         var tokens = new List<OAuthToken>();
diff --git a/src/Exceptionless.Web/Api/Messages/UserMessages.cs b/src/Exceptionless.Web/Api/Messages/UserMessages.cs
index 7cc329710b..ca1435b293 100644
--- a/src/Exceptionless.Web/Api/Messages/UserMessages.cs
+++ b/src/Exceptionless.Web/Api/Messages/UserMessages.cs
@@ -6,6 +6,7 @@ namespace Exceptionless.Web.Api.Messages;
 public record GetCurrentUser;
 public record GetCurrentUserOAuthGrants;
 public record RevokeCurrentUserOAuthGrant(string Id);
+public record UpdateCurrentUserProductTour(string TourId, UpdateProductTourProgress Progress);
 public record GetUserById(string Id);
 public record GetUsersByOrganization(string OrganizationId, int Page, int Limit);
 public record UpdateUserMessage(string Id, Delta<UpdateUser> Changes);
diff --git a/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts b/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts
index 909b6f700d..cf5d84adbf 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts
@@ -301,6 +301,15 @@ export class E2EApiClient {
         await expectStatus(response, [202], 'submit event');
     }
 
+    async updateProductTour(token: string, tourId: string, version: number, status: 'completed' | 'dismissed'): Promise<void> {
+        const response = await this.request.put(this.url(`users/me/product-tours/${tourId}`), {
+            data: { status, version },
+            headers: this.authHeaders(token)
+        });
+
+        await expectStatus(response, [200], 'update product tour');
+    }
+
     async waitForCurrentUserDeleted(token: string, timeoutMs = 30_000): Promise<void> {
         await waitForCondition(
             async () => !(await this.getCurrentUser(token)),
diff --git a/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts b/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts
index 154144230d..3f2def61aa 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts
@@ -85,6 +85,7 @@ export const test = base.extend<E2EFixtures>({
             const project = await e2eApi.createProject(userToken, organization.id, projectName);
             projectId = project.id;
             const projectToken = await e2eApi.getProjectDefaultToken(userToken, project.id);
+            await e2eApi.updateProductTour(userToken, 'welcome', 1, 'dismissed');
 
             await page.addInitScript(
                 ({ organizationId, token }) => {
diff --git a/src/Exceptionless.Web/ClientApp/e2e/support/exceptionless-journey.ts b/src/Exceptionless.Web/ClientApp/e2e/support/exceptionless-journey.ts
index 27e53fd48d..0cee1689bc 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/support/exceptionless-journey.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/support/exceptionless-journey.ts
@@ -219,6 +219,18 @@ export class ExceptionlessE2EJourney {
 
         await expect(setupHeading).toBeVisible({ timeout: 30_000 });
 
+        const welcomeDialog = this.page.getByRole('dialog', { name: 'Welcome to the new Exceptionless UI' });
+        await expect(welcomeDialog).toBeVisible({ timeout: 30_000 });
+        const skippedResponse = this.page.waitForResponse(
+            (response) => response.request().method() === 'PUT' && response.url().includes('/api/v2/users/me/product-tours/welcome')
+        );
+        await welcomeDialog.getByRole('button', { name: 'Skip' }).click();
+        expect((await skippedResponse).ok()).toBe(true);
+        await expect(welcomeDialog).toBeHidden();
+        await this.page.reload();
+        await expect(setupHeading).toBeVisible();
+        await expect(welcomeDialog).toBeHidden();
+
         await this.page.getByLabel('Organization Name', { exact: true }).fill(this.organizationName);
         await this.page.getByLabel('Project Name', { exact: true }).fill(this.projectName);
         await this.page.getByRole('button', { name: 'Continue' }).click();
diff --git a/src/Exceptionless.Web/ClientApp/e2e/tests/event-effects-chaos.e2e.ts b/src/Exceptionless.Web/ClientApp/e2e/tests/event-effects-chaos.e2e.ts
index 029251c335..30d70c3f77 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/tests/event-effects-chaos.e2e.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/tests/event-effects-chaos.e2e.ts
@@ -363,13 +363,18 @@ function recordRequest(diagnostics: RuntimeDiagnostics, request: Request, organi
 }
 
 function recordRequestFailure(diagnostics: RuntimeDiagnostics, request: Request): void {
-    if (!new URL(request.url()).pathname.startsWith('/api/v2/')) {
+    const path = new URL(request.url()).pathname;
+    const error = request.failure()?.errorText ?? null;
+    const isDeliberateRemount = diagnostics.activeAction.endsWith('route remounts');
+    const isCanceledProjectRead = request.method() === 'GET' && /^\/api\/v2\/projects\/[a-f0-9]{24}$/.test(path) && error === 'net::ERR_ABORTED';
+    // Repeated page.goto calls intentionally tear down detail observers; Chromium reports their superseded project reads as aborted.
+    if (!path.startsWith('/api/v2/') || (isDeliberateRemount && isCanceledProjectRead)) {
         return;
     }
 
     diagnostics.requestFailures.push({
         action: diagnostics.activeAction,
-        error: request.failure()?.errorText ?? null,
+        error,
         method: request.method(),
         url: request.url()
     });
diff --git a/src/Exceptionless.Web/ClientApp/e2e/tests/product-tours.e2e.ts b/src/Exceptionless.Web/ClientApp/e2e/tests/product-tours.e2e.ts
new file mode 100644
index 0000000000..a6941be444
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/e2e/tests/product-tours.e2e.ts
@@ -0,0 +1,285 @@
+import { expect, test } from '../fixtures/e2e-test';
+import { seedRepresentativeEvent } from '../support/event-data';
+
+test.use({ e2eUseGeneratedUser: true });
+
+const seededUserTest = test.extend({ e2eUseGeneratedUser: false });
+
+test('Explore the new UI is replayable and clears when the authenticated app unmounts', async ({ e2eScenario: _e2eScenario, page }, testInfo) => {
+    void _e2eScenario;
+    await page.setViewportSize({ height: 900, width: 1440 });
+    await page.goto('/next/stack');
+
+    await startTourFromCommand(page, 'Explore the new UI');
+    const tour = page.locator('.driver-popover');
+    await expect(tour.getByText('Your workspace navigation')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('new-ui-overview-desktop.png') });
+    await tour.getByRole('button', { name: 'Close' }).click();
+    await expect(tour).toBeHidden();
+
+    await startTourFromCommand(page, 'Explore the new UI');
+    await expect(tour.getByText('Your workspace navigation')).toBeVisible();
+
+    const helpMenu = page.locator('[data-tour="help-menu"]');
+    await helpMenu.focus();
+    await helpMenu.press('Enter');
+    const logOut = page.getByRole('menuitem', { exact: true, name: 'Log Out' });
+    await expect(logOut).toBeVisible();
+    await logOut.focus();
+    await logOut.press('Enter');
+
+    await expect(page.getByRole('button', { exact: true, name: 'Login' })).toBeVisible({ timeout: 30_000 });
+    await expect(tour).toBeHidden();
+    await expect.poll(() => page.evaluate(() => sessionStorage.getItem('exceptionless.product-tour'))).toBeNull();
+});
+
+test('Explore the new UI opens its navigation target on mobile', async ({ e2eScenario: _e2eScenario, page }, testInfo) => {
+    void _e2eScenario;
+    await page.setViewportSize({ height: 844, width: 390 });
+    await page.goto('/next/stack');
+
+    await startTourFromCommand(page, 'Explore the new UI');
+    const tour = page.locator('.driver-popover');
+    await expect(tour.getByText('Your workspace navigation')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('new-ui-overview-mobile.png') });
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Reuse configured views')).toBeVisible();
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Help is always nearby')).toBeVisible();
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Find anything quickly')).toBeVisible();
+    await expect(page.locator('[data-tour="mobile-navigation-trigger"]')).toBeVisible();
+    await tour.getByRole('button', { name: 'Close' }).click();
+});
+
+test('Configure a project resumes through its first event', async ({ e2eApi, e2eScenario, page }, testInfo) => {
+    await page.setViewportSize({ height: 900, width: 1440 });
+    await page.goto('/next/stack');
+
+    let createdProjectId: string | undefined;
+    await startTourFromCommand(page, 'Configure a project');
+    if (await page.getByRole('alertdialog', { name: 'Create another project?' }).isVisible()) {
+        await page.getByRole('button', { name: 'Create Project' }).click();
+        await expect(page.getByRole('heading', { name: 'Add Project' })).toBeVisible();
+        await page.getByLabel('Project Name', { exact: true }).fill(`Tour Project ${e2eScenario.run}`);
+        await expect(page.locator('.driver-popover').getByText('Name your project', { exact: true })).toBeVisible();
+        await page.locator('.driver-popover').getByRole('button', { name: 'Next' }).click();
+        await expect(page.locator('.driver-popover').getByText('Continue to configuration')).toBeVisible();
+        await page.locator('.driver-popover').getByRole('button', { name: 'Continue' }).click();
+        await page.waitForURL(/\/next\/project\/[^/]+\/configure\?redirect=true/);
+        createdProjectId = page.url().match(/\/project\/([^/]+)\/configure/)?.[1];
+    }
+
+    await page.waitForURL(/\/next\/project\/[^/]+\/configure\?redirect=true/);
+    const tour = page.locator('.driver-popover');
+    await expect(tour.getByText('Choose your SDK')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('configure-project-platform.png') });
+
+    await page.locator('[data-tour="project-configure-platform"]').click();
+    await page.getByRole('option', { name: 'Browser applications' }).click();
+    await page.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Use the project token')).toBeVisible();
+    await page.getByRole('button', { name: 'Next' }).click();
+    await expect(page.getByText('Connect your application', { exact: true })).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('configure-project-inline.png') });
+    await page.getByRole('button', { name: 'Continue' }).click();
+    await expect(page.getByText('Waiting for your first event')).toBeVisible();
+
+    try {
+        const projectId = createdProjectId ?? e2eScenario.projectId;
+        const projectToken = createdProjectId ? (await e2eApi.getProjectDefaultToken(e2eScenario.userToken, createdProjectId)).id : e2eScenario.projectToken;
+        await seedRepresentativeEvent(e2eApi, e2eScenario.userToken, {
+            message: e2eScenario.message,
+            projectId,
+            projectToken,
+            referenceId: e2eScenario.referenceId
+        });
+        await expect(page).toHaveURL(/\/next\/event/);
+        await expect(page.getByText('First event received. Opening Events...')).toBeHidden();
+    } finally {
+        if (createdProjectId) {
+            await e2eApi.deleteProject(e2eScenario.userToken, createdProjectId);
+            await e2eApi.waitForProjectDeleted(e2eScenario.userToken, createdProjectId);
+        }
+    }
+});
+
+test('Create a saved view retains a private hydrated view', async ({ e2eScenario, page }, testInfo) => {
+    await page.setViewportSize({ height: 900, width: 1440 });
+    await page.goto('/next/event');
+
+    await startTourFromCommand(page, 'Create a saved view');
+    const tour = page.locator('.driver-popover');
+    await expect(tour.getByText('Open View settings')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('saved-view-open.png') });
+    await tour.getByRole('button', { name: 'Continue' }).click();
+    await expect(tour.getByText('Configure what the view remembers')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('saved-view-settings.png') });
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Create a new view')).toBeVisible();
+    await tour.getByRole('button', { name: 'Continue' }).click();
+
+    const viewName = `Tour View ${e2eScenario.run}`;
+    await expect(page.getByText('Review and name your view')).toBeVisible();
+    await page.getByLabel('Name', { exact: true }).fill(viewName);
+    await page.getByRole('button', { name: 'Continue' }).click();
+    await expect(page.getByText('Keep it private')).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('saved-view-private.png') });
+    await page.getByRole('button', { name: 'Continue' }).click();
+    await expect(page.getByText('Create the saved view')).toBeVisible();
+    await page.getByRole('button', { exact: true, name: 'Save' }).click();
+
+    await expect(page.getByRole('heading', { name: viewName })).toBeVisible({ timeout: 30_000 });
+    await expect(page).toHaveURL(/\/next\/event\/[^/]+/);
+    await expect(page.getByText('Create the saved view')).toBeHidden();
+});
+
+seededUserTest('Investigate an error resumes after navigation and advances only after an error opens', async ({ e2eApi, e2eScenario, page }, testInfo) => {
+    const event = await seedRepresentativeEvent(e2eApi, e2eScenario.userToken, {
+        message: e2eScenario.message,
+        projectId: e2eScenario.projectId,
+        projectToken: e2eScenario.projectToken,
+        referenceId: e2eScenario.referenceId
+    });
+
+    await page.setViewportSize({ height: 900, width: 1440 });
+    await page.goto('/next/event?time=all');
+    await expect(page.getByText(e2eScenario.message)).toBeVisible({ timeout: 30_000 });
+    await startTourFromCommand(page, 'Investigate an error');
+    const tour = page.locator('.driver-popover');
+    await expect(tour.getByText('Start with the right errors')).toBeVisible();
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Open a real error')).toBeVisible();
+    await expect(page).toHaveURL(/\/next\/event\?time=all&type=error/);
+    await tour.getByRole('button', { name: 'Close' }).click();
+
+    await page.goto('/next/stack');
+    await startTourFromCommand(page, 'Investigate an error');
+    const navigationConfirmation = page.getByRole('alertdialog', { name: 'Open Errors?' });
+    await expect(navigationConfirmation).toBeVisible();
+    await navigationConfirmation.getByRole('button', { name: 'Open Errors' }).click();
+    await expect(tour.getByText('Start with the right errors')).toBeVisible();
+    await tour.getByRole('button', { name: 'Next' }).click();
+    await expect(tour.getByText('Open a real error')).toBeVisible();
+    await expect(page).toHaveURL(/\/next\/event\?time=all&type=error/);
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('investigate-error-list.png') });
+    await page.locator('tr').filter({ hasText: e2eScenario.message }).first().click();
+    const investigationCallout = page.locator('[data-product-tour-inline="investigate-error"]');
+    await expect(investigationCallout.getByText('Understand the grouped issue')).toBeVisible({ timeout: 30_000 });
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('investigate-error-details.png') });
+
+    for (const title of [
+        'Triage deliberately',
+        'Inspect the occurrence',
+        'Begin with the overview',
+        'Follow the exception',
+        'Reconstruct the request',
+        'Check where it happened',
+        'Review custom context',
+        'Compare every occurrence'
+    ]) {
+        await investigationCallout.getByRole('button', { name: 'Continue' }).click();
+        await expect(investigationCallout.getByText(title)).toBeVisible();
+    }
+
+    await expect(page.locator('[data-tour="event-tab-extended-data"]')).toHaveAttribute('data-state', 'active');
+    await investigationCallout.getByRole('button', { name: 'Finish guide' }).click();
+    await expect(investigationCallout).toBeHidden();
+
+    await page.goto(`/next/event/${event.id}`);
+    await expect(page.locator('[data-tour="event-details"]')).toBeVisible({ timeout: 30_000 });
+    await startTourFromCommand(page, 'Investigate an error');
+    await expect(investigationCallout.getByText('Understand the grouped issue')).toBeVisible();
+    await investigationCallout.getByRole('button', { name: 'Continue' }).click();
+    await investigationCallout.getByRole('button', { name: 'End guide' }).click();
+    expect(event.type).toBe('error');
+
+    const usageReferenceId = `pw-e2e-tour-usage-${e2eScenario.run}`.slice(0, 100);
+    await e2eApi.submitEvent(e2eScenario.projectId, e2eScenario.projectToken, {
+        data: { e2e_reference: usageReferenceId },
+        message: `Feature usage ${e2eScenario.run}`,
+        reference_id: usageReferenceId,
+        source: 'playwright-e2e',
+        type: 'usage'
+    });
+    const usageEvent = await e2eApi.pollForEventByReference(e2eScenario.userToken, e2eScenario.projectId, usageReferenceId);
+    await page.goto(`/next/event/${usageEvent.id}`);
+    await expect(page.locator('[data-tour="event-details"][data-event-type="usage"]')).toBeVisible({ timeout: 30_000 });
+    await page.waitForURL(/\/next\/stack\/[^/]+\/event\/[^/]+/);
+
+    const usageUrl = page.url();
+    await startTourFromCommand(page, 'Investigate an error');
+    const nonErrorConfirmation = page.getByRole('alertdialog', { name: 'Open Errors?' });
+    await expect(nonErrorConfirmation).toBeVisible();
+    await nonErrorConfirmation.getByRole('button', { name: 'Cancel' }).click();
+    await expect(nonErrorConfirmation).toBeHidden();
+    expect(page.url()).toBe(usageUrl);
+    await expect(investigationCallout).toBeHidden();
+});
+
+test('Exie announcement can be dismissed without hiding the replayable guide', async ({ e2eScenario: _e2eScenario, page }, testInfo) => {
+    void _e2eScenario;
+    await page.route('**/api/v2/assistant/access**', async (route) => {
+        await route.fulfill({
+            contentType: 'application/json',
+            json: { enabled: true, has_access: true, message: null, upgrade_required: false }
+        });
+    });
+
+    await page.setViewportSize({ height: 900, width: 1440 });
+    await page.goto('/next/stack');
+
+    const announcement = page.locator('[data-product-tour-announcement="exie"]');
+    await expect(announcement).toBeVisible();
+    await page.screenshot({ fullPage: true, path: testInfo.outputPath('meet-exie-announcement.png') });
+    const dismissed = page.waitForResponse(
+        (response) => response.url().includes('/product-tours/exie-announcement') && response.request().method() === 'PUT' && response.status() === 200
+    );
+    await announcement.getByRole('button', { exact: true, name: 'Dismiss' }).click();
+    await dismissed;
+    await page.reload();
+    await expect(announcement).toBeHidden();
+
+    await startTourFromCommand(page, 'Meet Exie');
+    await expect(page.locator('.driver-popover').getByText('Open Exie', { exact: true })).toBeVisible();
+});
+
+test.describe('with the seeded user', () => {
+    test.use({ e2eUseGeneratedUser: false });
+
+    test('Meet Exie opens contextual UI without sending a provider request', async ({ e2eScenario: _e2eScenario, page }, testInfo) => {
+        void _e2eScenario;
+        let chatRequests = 0;
+        await page.route('**/api/v2/assistant/access**', async (route) => {
+            await route.fulfill({
+                contentType: 'application/json',
+                json: { enabled: true, has_access: true, message: null, upgrade_required: false }
+            });
+        });
+        await page.route('**/api/v2/assistant/chat**', async (route) => {
+            chatRequests += 1;
+            await route.abort();
+        });
+
+        await page.setViewportSize({ height: 900, width: 1440 });
+        await page.goto('/next/stack');
+        await startTourFromCommand(page, 'Meet Exie');
+
+        const tour = page.locator('.driver-popover');
+        await expect(tour.getByText('Open Exie', { exact: true })).toBeVisible();
+        await page.screenshot({ fullPage: true, path: testInfo.outputPath('meet-exie-trigger.png') });
+        await tour.getByRole('button', { name: 'Continue' }).click();
+        await expect(page.getByRole('dialog', { name: 'Exie' })).toBeVisible();
+        await expect(tour.getByText('You control every request')).toBeVisible();
+        await page.screenshot({ fullPage: true, path: testInfo.outputPath('meet-exie-panel.png') });
+        expect(chatRequests).toBe(0);
+
+        await tour.getByRole('button', { name: 'Next' }).click();
+        expect(chatRequests).toBe(0);
+    });
+});
+
+async function startTourFromCommand(page: import('@playwright/test').Page, title: string): Promise<void> {
+    await page.getByRole('button', { name: 'Search Exceptionless' }).click();
+    await page.getByRole('dialog').getByText(title, { exact: true }).click();
+}
diff --git a/src/Exceptionless.Web/ClientApp/package-lock.json b/src/Exceptionless.Web/ClientApp/package-lock.json
index 9333168e47..1305b26f61 100644
--- a/src/Exceptionless.Web/ClientApp/package-lock.json
+++ b/src/Exceptionless.Web/ClientApp/package-lock.json
@@ -24,6 +24,7 @@
                 "clsx": "^2.1.1",
                 "d3-scale": "^4.0.2",
                 "dompurify": "^3.4.13",
+                "driver.js": "^1.8.0",
                 "layerchart": "^2.1.0",
                 "mode-watcher": "^1.1.0",
                 "oidc-client-ts": "^3.5.0",
@@ -6047,6 +6048,12 @@
                 "url": "https://dotenvx.com"
             }
         },
+        "node_modules/driver.js": {
+            "version": "1.8.0",
+            "resolved": "https://registry.npmjs.org/driver.js/-/driver.js-1.8.0.tgz",
+            "integrity": "sha512-+8/IO7h1v14IzWh2GP60N7T3PFZweXwdn5e5POuxRSBoCYUojsBxzqawPeXh3YZIibRy7EehYNEyxe7slwwtdg==",
+            "license": "MIT"
+        },
         "node_modules/emoji-regex": {
             "version": "8.0.0",
             "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
diff --git a/src/Exceptionless.Web/ClientApp/package.json b/src/Exceptionless.Web/ClientApp/package.json
index 87c7e0ec44..2b815760cc 100644
--- a/src/Exceptionless.Web/ClientApp/package.json
+++ b/src/Exceptionless.Web/ClientApp/package.json
@@ -94,6 +94,7 @@
         "clsx": "^2.1.1",
         "d3-scale": "^4.0.2",
         "dompurify": "^3.4.13",
+        "driver.js": "^1.8.0",
         "layerchart": "^2.1.0",
         "mode-watcher": "^1.1.0",
         "oidc-client-ts": "^3.5.0",
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/assistant/components/assistant-panel.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/assistant/components/assistant-panel.svelte
index 916b8454b4..7001b41ba7 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/assistant/components/assistant-panel.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/assistant/components/assistant-panel.svelte
@@ -508,6 +508,7 @@
     <Sheet.Root bind:open>
         <Sheet.Content
             data-assistant-panel
+            data-tour="exie-panel"
             class="bg-background top-16! bottom-0! h-auto! w-full gap-0 sm:max-w-120!"
             onInteractOutside={handleInteractOutside}
             overlayProps={{
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/events-overview.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/events-overview.svelte
index 02fab21656..2abf0d584a 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/events-overview.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/events-overview.svelte
@@ -18,6 +18,10 @@
     import * as EventsFacetedFilter from '$features/events/components/filters';
     import { getExtendedDataItems, hasErrorOrSimpleError } from '$features/events/persistent-event';
     import { getOrganizationQuery } from '$features/organizations/api.svelte';
+    import { PRODUCT_TOUR_ANCHORS, productTourSelector } from '$features/product-tours/anchors';
+    import { investigateErrorSteps } from '$features/product-tours/catalog';
+    import ProductTourInlineCallout from '$features/product-tours/components/product-tour-inline-callout.svelte';
+    import { productTourHost } from '$features/product-tours/state.svelte';
     import { getProjectQuery, updateProject } from '$features/projects/api.svelte';
     import StackCard from '$features/stacks/components/stack-card.svelte';
     import Braces from '@lucide/svelte/icons/braces';
@@ -162,6 +166,54 @@
     let notifiedEventId = $state('');
     let showJsonDialog = $state(false);
 
+    const activeInvestigationStep = $derived(
+        productTourHost.activeTourId === 'investigate-error' ? investigateErrorSteps.find((step) => step.id === productTourHost.activeStepId) : undefined
+    );
+    const activeInvestigationTab = $derived.by(() => {
+        switch (activeInvestigationStep?.id) {
+            case 'tab-environment':
+                return 'Environment';
+            case 'tab-exception':
+                return 'Exception';
+            case 'tab-extended-data':
+                return 'Extended Data';
+            case 'tab-overview':
+                return 'Overview';
+            case 'tab-request':
+                return 'Request';
+            case 'tab-session':
+                return 'Session Events';
+            case 'tab-trace':
+                return 'Trace Log';
+            default:
+                return undefined;
+        }
+    });
+    const isStackInvestigationStep = $derived(activeInvestigationStep?.id === 'stack-summary' || activeInvestigationStep?.id === 'stack-triage');
+    const isEventInvestigationStep = $derived(activeInvestigationStep?.id === 'event-occurrence' || activeInvestigationStep?.id === 'filter-stack-events');
+    const isTabInvestigationStep = $derived(activeInvestigationStep?.id.startsWith('tab-') ?? false);
+
+    function getTabTourAnchor(tab: TabType): string | undefined {
+        switch (tab) {
+            case 'Environment':
+                return PRODUCT_TOUR_ANCHORS.eventTabEnvironment;
+            case 'Exception':
+                return PRODUCT_TOUR_ANCHORS.eventTabException;
+            case 'Extended Data':
+                return PRODUCT_TOUR_ANCHORS.eventTabExtendedData;
+            case 'Overview':
+                return PRODUCT_TOUR_ANCHORS.eventTabOverview;
+            case 'Request':
+                return PRODUCT_TOUR_ANCHORS.eventTabRequest;
+            case 'Session Events':
+                return PRODUCT_TOUR_ANCHORS.eventTabSession;
+            case 'Trace Log':
+                return PRODUCT_TOUR_ANCHORS.eventTabTrace;
+            default:
+                return undefined;
+        }
+    }
+
     function isPromotedTab(tab: TabType): boolean {
         return !!projectQuery.data?.promoted_tabs?.includes(tab);
     }
@@ -275,6 +327,23 @@
         }
     }
 
+    function continueInvestigationTour(): void {
+        if (!activeInvestigationStep) {
+            return;
+        }
+
+        if (activeInvestigationStep.id === 'filter-stack-events') {
+            void productTourHost.complete('investigate-error');
+            return;
+        }
+
+        productTourHost.advance('investigate-error', activeInvestigationStep.id);
+    }
+
+    function dismissInvestigationTour(): void {
+        productTourHost.dismiss('investigate-error');
+    }
+
     function prepareEventAssistantContext(): void {
         if (event) {
             assistantPageContext.setPageEvent(event);
@@ -294,6 +363,8 @@
     $effect(() => {
         if (event && event.id !== notifiedEventId) {
             notifiedEventId = event.id;
+            const eventType = hasErrorOrSimpleError(event) ? 'error' : event.type;
+            void tick().then(() => productTourHost.eventOpened(eventType));
             onEventLoaded?.(event);
         }
     });
@@ -307,6 +378,29 @@
         });
     });
 
+    $effect(() => {
+        const step = activeInvestigationStep;
+        const tab = activeInvestigationTab;
+        if (!event || !step) {
+            return;
+        }
+
+        if (tab && tabs.includes(tab)) {
+            activeTab = tab;
+        }
+
+        void tick().then(() => {
+            if (productTourHost.activeStepId !== step.id || !step.anchor) {
+                return;
+            }
+
+            document.querySelector<HTMLElement>(productTourSelector(step.anchor))?.scrollIntoView({
+                behavior: 'smooth',
+                block: 'center'
+            });
+        });
+    });
+
     onMount(() => {
         updateTabsOverflow();
 
@@ -324,19 +418,45 @@
     });
 </script>
 
-<section>
+{#if event && isStackInvestigationStep && activeInvestigationStep}
+    <ProductTourInlineCallout
+        description={activeInvestigationStep.description}
+        onContinue={continueInvestigationTour}
+        onDismiss={dismissInvestigationTour}
+        title={activeInvestigationStep.title}
+        tourId="investigate-error"
+    />
+{/if}
+
+<section
+    data-event-type={event ? (hasErrorOrSimpleError(event) ? 'error' : event.type) : undefined}
+    data-tour={event ? PRODUCT_TOUR_ANCHORS.eventDetails : undefined}
+>
     <h4 class="text-muted-foreground mb-3 text-sm font-semibold tracking-wide uppercase">Stack</h4>
     {#if event?.stack_id}
-        <StackCard
-            {assistantResource}
-            {filterChanged}
-            id={event.stack_id}
-            prepareAssistantContext={assistantResource === 'event' ? prepareEventAssistantContext : prepareStackAssistantContext}
-        ></StackCard>
+        <div data-tour={PRODUCT_TOUR_ANCHORS.eventStack}>
+            <StackCard
+                {assistantResource}
+                {filterChanged}
+                id={event.stack_id}
+                prepareAssistantContext={assistantResource === 'event' ? prepareEventAssistantContext : prepareStackAssistantContext}
+            ></StackCard>
+        </div>
     {/if}
 </section>
 
-<section class="mt-2">
+{#if event && isEventInvestigationStep && activeInvestigationStep}
+    <ProductTourInlineCallout
+        continueLabel={activeInvestigationStep.id === 'filter-stack-events' ? 'Finish guide' : 'Continue'}
+        description={activeInvestigationStep.description}
+        onContinue={continueInvestigationTour}
+        onDismiss={dismissInvestigationTour}
+        title={activeInvestigationStep.title}
+        tourId="investigate-error"
+    />
+{/if}
+
+<section class="mt-2" data-tour={event ? PRODUCT_TOUR_ANCHORS.eventOccurrence : undefined}>
     <div class="mb-2 flex items-center justify-between">
         <h4 class="text-muted-foreground text-sm font-semibold tracking-wide uppercase">Event</h4>
         <div class="flex items-center gap-1">
@@ -348,6 +468,7 @@
             {#if event?.stack_id}
                 <Button
                     aria-label="Show all events"
+                    data-tour={PRODUCT_TOUR_ANCHORS.eventStackFilter}
                     onclick={() => filterChanged(new EventsFacetedFilter.StringFilter('stack', event!.stack_id))}
                     size="icon-sm"
                     title="Show all events"
@@ -390,6 +511,15 @@
     </Table.Root>
 
     {#if event}
+        {#if isTabInvestigationStep && activeInvestigationStep}
+            <ProductTourInlineCallout
+                description={activeInvestigationStep.description}
+                onContinue={continueInvestigationTour}
+                onDismiss={dismissInvestigationTour}
+                title={activeInvestigationStep.title}
+                tourId="investigate-error"
+            />
+        {/if}
         <Tabs.Root class="mt-4 mb-4" value={activeTab}>
             <div class="relative">
                 {#if canScrollTabsLeft}
@@ -417,6 +547,7 @@
                                 draggedPromotedTab === tab && 'bg-accent/70'
                             ]}
                             draggable={isPromotedTab(tab)}
+                            data-tour={getTabTourAnchor(tab)}
                             ondragstart={(event) => handlePromotedTabDragStart(event, tab)}
                             ondragover={(event) => handlePromotedTabDragOver(event, tab)}
                             ondrop={(event) => handlePromotedTabDrop(event, tab)}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/anchors.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/anchors.ts
new file mode 100644
index 0000000000..b4d7e319db
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/anchors.ts
@@ -0,0 +1,40 @@
+export const PRODUCT_TOUR_ANCHORS = {
+    appNavigation: 'app-navigation',
+    commandSearch: 'command-search',
+    eventDetails: 'event-details',
+    eventFilters: 'event-filters',
+    eventList: 'event-list',
+    eventOccurrence: 'event-occurrence',
+    eventStack: 'event-stack',
+    eventStackFilter: 'event-stack-filter',
+    eventStackTriage: 'event-stack-triage',
+    eventTabEnvironment: 'event-tab-environment',
+    eventTabException: 'event-tab-exception',
+    eventTabExtendedData: 'event-tab-extended-data',
+    eventTabOverview: 'event-tab-overview',
+    eventTabRequest: 'event-tab-request',
+    eventTabSession: 'event-tab-session',
+    eventTabTrace: 'event-tab-trace',
+    exiePanel: 'exie-panel',
+    exieTrigger: 'exie-trigger',
+    helpMenu: 'help-menu',
+    projectConfigureInstructions: 'project-configure-instructions',
+    projectConfigurePlatform: 'project-configure-platform',
+    projectConfigureToken: 'project-configure-token',
+    projectConfigureWaiting: 'project-configure-waiting',
+    projectName: 'project-name',
+    projectSetupSubmit: 'project-setup-submit',
+    savedViewDialog: 'saved-view-dialog',
+    savedViewName: 'saved-view-name',
+    savedViewNavigation: 'saved-view-navigation',
+    savedViewPrivate: 'saved-view-private',
+    savedViewSaveAs: 'saved-view-save-as',
+    savedViewSettings: 'saved-view-settings',
+    savedViewSubmit: 'saved-view-submit',
+    savedViewTrigger: 'saved-view-trigger',
+    setupOrganizationName: 'setup-organization-name'
+} as const;
+
+export function productTourSelector(anchor: string): string {
+    return `[data-tour="${anchor}"]`;
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.test.ts
new file mode 100644
index 0000000000..bf5f5084db
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ProductTourContext } from './types';
+
+import { getProductTourItems, getRecommendedProductTourId, productTourCatalog } from './catalog';
+
+function context(overrides: Partial<ProductTourContext> = {}): ProductTourContext {
+    return {
+        errorEventAvailability: 'available',
+        isSetupPage: false,
+        organizationId: 'organization-id',
+        pathname: '/next/event',
+        projects: [],
+        ...overrides
+    };
+}
+
+describe('product tour catalog', () => {
+    it('contains the five stable, versioned guides with unique step ids', () => {
+        expect(productTourCatalog.map((tour) => tour.id)).toEqual([
+            'new-ui-overview',
+            'configure-project',
+            'create-saved-view',
+            'investigate-error',
+            'meet-exie'
+        ]);
+
+        for (const tour of productTourCatalog) {
+            expect(tour.version).toBeGreaterThan(0);
+            expect(tour.keywords.length).toBeGreaterThan(0);
+            const steps = tour.getSteps(context());
+            expect(new Set(steps.map((step) => step.id)).size).toBe(steps.length);
+            expect(steps.every((step) => (step.anchor ? step.anchor.length > 0 : true))).toBe(true);
+        }
+    });
+
+    it('recommends setup without an organization or with an unconfigured project', () => {
+        expect(getRecommendedProductTourId(context({ organizationId: undefined }))).toBe('configure-project');
+        expect(getRecommendedProductTourId(context({ projects: [{ is_configured: false } as never] }))).toBe('configure-project');
+        expect(getRecommendedProductTourId(context({ projects: [{ is_configured: true } as never] }))).toBe('new-ui-overview');
+    });
+
+    it('returns concrete availability reasons while retaining unavailable guides in the catalog', () => {
+        const items = getProductTourItems(context({ assistantAccess: { enabled: false } as never, organizationId: undefined }));
+        const exie = items.find((item) => item.id === 'meet-exie');
+        const investigate = items.find((item) => item.id === 'investigate-error');
+
+        expect(exie?.availability).toEqual({ available: false, reason: 'Exie is not enabled by this Exceptionless installation.' });
+        expect(investigate?.availability.available).toBe(false);
+        expect(investigate?.availability.reason).toBeTruthy();
+    });
+
+    it('reuses only an open error and otherwise asks before leaving a detail page', () => {
+        const investigate = productTourCatalog.find((tour) => tour.id === 'investigate-error')!;
+
+        expect(investigate.getStartAction?.(context({ openEventType: 'error', pathname: '/next/event/error-id' }))).toEqual({
+            stepId: 'stack-summary',
+            type: 'launch'
+        });
+        expect(investigate.getStartAction?.(context({ openEventType: 'usage', pathname: '/next/event/usage-id' }))).toMatchObject({
+            destination: '/next/event?time=all&type=error',
+            type: 'confirm-navigation'
+        });
+        expect(investigate.getStartAction?.(context({ pathname: '/next/event' }))).toEqual({
+            destination: '/next/event?time=all&type=error',
+            type: 'navigate'
+        });
+    });
+
+    it('teaches error filtering, stack triage, occurrence evidence, and only the tabs that are present', () => {
+        const investigate = productTourCatalog.find((tour) => tour.id === 'investigate-error')!;
+        const steps = investigate.getSteps(context());
+
+        expect(steps.map((step) => step.id)).toEqual([
+            'filter-errors',
+            'choose-error',
+            'stack-summary',
+            'stack-triage',
+            'event-occurrence',
+            'tab-overview',
+            'tab-exception',
+            'tab-request',
+            'tab-environment',
+            'tab-trace',
+            'tab-session',
+            'tab-extended-data',
+            'filter-stack-events'
+        ]);
+        expect(steps.filter((step) => step.id.startsWith('tab-') && step.id !== 'tab-overview').every((step) => step.optional)).toBe(true);
+        expect(steps.filter((step) => ['filter-stack-events', 'stack-triage'].includes(step.id)).every((step) => !step.advanceOnClick)).toBe(true);
+    });
+
+    it('requires confirmation before setup consumes capacity when every project is configured', () => {
+        const configure = productTourCatalog.find((tour) => tour.id === 'configure-project')!;
+
+        expect(configure.getStartAction?.(context({ pathname: '/next/stack', projects: [{ is_configured: true } as never] }))).toMatchObject({
+            destination: '/next/project/add',
+            type: 'confirm-navigation'
+        });
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.ts
new file mode 100644
index 0000000000..559cec793d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.ts
@@ -0,0 +1,447 @@
+import type { ProductTourProgress } from '$features/users/models';
+
+import { resolve } from '$app/paths';
+
+import type { ProductTourContext, ProductTourDefinition, ProductTourListItem, ProductTourStartAction, ProductTourStep } from './types';
+
+import { PRODUCT_TOUR_ANCHORS } from './anchors';
+
+function getConfigureProjectStartAction(context: ProductTourContext): ProductTourStartAction {
+    if (!context.organizationId) {
+        return { destination: resolve('/(app)/organization/add'), type: 'navigate' };
+    }
+
+    if (context.pathname.includes('/project/add')) {
+        return { type: 'launch' };
+    }
+
+    const project = context.projects.find((item) => !item.is_configured);
+    if (project?.id) {
+        return {
+            destination: `${resolve('/(app)/project/[projectId]/configure', { projectId: project.id })}?redirect=true`,
+            type: 'navigate'
+        };
+    }
+
+    return {
+        actionLabel: 'Create Project',
+        description: 'Every accessible project is already configured. A new project uses plan capacity and will remain after the guide.',
+        destination: resolve('/(app)/project/add'),
+        title: 'Create another project?',
+        type: 'confirm-navigation'
+    };
+}
+
+function getInvestigateErrorStartAction(context: ProductTourContext): ProductTourStartAction {
+    if (context.openEventType === 'error') {
+        return { stepId: 'stack-summary', type: 'launch' };
+    }
+
+    const destination = `${resolve('/(app)/event')}?time=all&type=error`;
+    if (context.pathname === resolve('/(app)/event')) {
+        return { destination, type: 'navigate' };
+    }
+
+    return {
+        actionLabel: 'Open Errors',
+        description: 'This guide starts in Errors so you can choose a real report. Your current page will change.',
+        destination,
+        title: 'Open Errors?',
+        type: 'confirm-navigation'
+    };
+}
+
+export const investigateErrorSteps: readonly ProductTourStep[] = [
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventFilters,
+        description: 'Errors are already selected. Narrow the list by project, status, date, version, tags, or search terms when you need a specific incident.',
+        id: 'filter-errors',
+        title: 'Start with the right errors'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventList,
+        description: 'Choose an error row to open its detail sheet. The guide continues only after a real error report is loaded.',
+        id: 'choose-error',
+        showDone: false,
+        title: 'Open a real error'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventStack,
+        description:
+            'The stack groups matching occurrences into one issue. Use its title, total events, affected users, first and last occurrence, and trend to judge scope and impact.',
+        id: 'stack-summary',
+        presentation: 'inline',
+        title: 'Understand the grouped issue',
+        waitForElement: 60000
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventStackTriage,
+        description:
+            'Status tracks the team workflow: open, fixed, snoozed, ignored, or discarded. Options manage critical occurrences, external promotion, references, stacking information, and deletion. These actions change shared state, so this guide will not click them.',
+        id: 'stack-triage',
+        presentation: 'inline',
+        title: 'Triage deliberately',
+        waitForElement: 60000
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventOccurrence,
+        description:
+            'Below the stack is this specific occurrence. Its timestamp, raw JSON, and older/newer controls help you compare what happened at one moment with neighboring events.',
+        id: 'event-occurrence',
+        presentation: 'inline',
+        title: 'Inspect the occurrence'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabOverview,
+        description: 'Overview summarizes the message and the most useful event fields. Field filter icons can turn evidence into a narrower Events query.',
+        id: 'tab-overview',
+        presentation: 'inline',
+        title: 'Begin with the overview'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabException,
+        description: 'Exception shows the error type, message, stack trace, and inner exceptions. Start here when you need the failing code path.',
+        id: 'tab-exception',
+        optional: true,
+        presentation: 'inline',
+        title: 'Follow the exception'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabRequest,
+        description: 'Request captures the URL, HTTP method, client, headers, cookies, and other request data that may explain how the failure was reached.',
+        id: 'tab-request',
+        optional: true,
+        presentation: 'inline',
+        title: 'Reconstruct the request'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabEnvironment,
+        description: 'Environment identifies the machine, runtime, architecture, and process context so you can spot deployment-specific failures.',
+        id: 'tab-environment',
+        optional: true,
+        presentation: 'inline',
+        title: 'Check where it happened'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabTrace,
+        description: 'Trace Log provides the diagnostic trail captured around this occurrence. It appears only when trace data was submitted.',
+        id: 'tab-trace',
+        optional: true,
+        presentation: 'inline',
+        title: 'Read the surrounding trace'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabSession,
+        description: 'Session Events shows nearby activity from the same session, helping you understand the actions that led to the error.',
+        id: 'tab-session',
+        optional: true,
+        presentation: 'inline',
+        title: 'Follow the user session'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventTabExtendedData,
+        description:
+            'Extended Data contains application-specific values that did not fit the standard fields. Treat it as supporting evidence after the core exception and request details.',
+        id: 'tab-extended-data',
+        optional: true,
+        presentation: 'inline',
+        title: 'Review custom context'
+    },
+    {
+        anchor: PRODUCT_TOUR_ANCHORS.eventStackFilter,
+        description:
+            'When you are ready to compare occurrences, use Show all events to filter the Events list to this stack. The guide leaves the page unchanged so you decide when to pivot.',
+        id: 'filter-stack-events',
+        presentation: 'inline',
+        showDone: true,
+        title: 'Compare every occurrence'
+    }
+] as const;
+
+function requireApplicationShell(context: ProductTourContext) {
+    if (context.isSetupPage || !context.organizationId) {
+        return { available: false, reason: 'Finish organization setup to explore the application UI.' };
+    }
+
+    return { available: true };
+}
+
+function requireErrorEvent(context: ProductTourContext) {
+    if (!context.organizationId) {
+        return { available: false, reason: 'Create an organization and project first.' };
+    }
+
+    if (context.errorEventAvailability === 'loading') {
+        return { available: false, reason: 'Checking for an accessible error report…' };
+    }
+
+    if (context.errorEventAvailability === 'error') {
+        return { available: false, reason: 'Error reports could not be checked right now. Try again shortly.' };
+    }
+
+    if (context.errorEventAvailability === 'empty') {
+        return { available: false, reason: 'Send or retain an error report before starting this guide.' };
+    }
+
+    return { available: true };
+}
+
+function requireOrganization(context: ProductTourContext) {
+    return context.organizationId ? { available: true } : { available: false, reason: 'Create an organization and project first.' };
+}
+
+export const productTourCatalog: readonly ProductTourDefinition[] = [
+    {
+        description: 'Learn navigation, command search, saved views, Exie, and where to get help.',
+        getAvailability: requireApplicationShell,
+        getSteps: (context) => [
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.appNavigation,
+                description: 'Move between dashboards, saved views, and settings from one consistent navigation area.',
+                id: 'navigation',
+                title: 'Your workspace navigation'
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.commandSearch,
+                description: 'Open this search or press / to jump to pages, projects, events, stacks, and actions.',
+                id: 'command-search',
+                title: 'Find anything quickly'
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewNavigation,
+                description: 'Saved views capture filters, time, sorting, charts, stats, and columns for quick reuse.',
+                id: 'saved-views',
+                optional: true,
+                title: 'Reuse configured views'
+            },
+            ...(context.assistantAccess?.enabled
+                ? [
+                      {
+                          anchor: PRODUCT_TOUR_ANCHORS.exieTrigger,
+                          description: context.assistantAccess.has_access
+                              ? 'Exie can investigate the page or error you are viewing. You always choose whether to send a prompt.'
+                              : (context.assistantAccess.message ?? 'Exie is available after upgrading your organization plan.'),
+                          id: 'exie',
+                          optional: true,
+                          title: 'Ask Exie with context'
+                      }
+                  ]
+                : []),
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.helpMenu,
+                description: 'Open Help for documentation, support, keyboard shortcuts, and these guided tours.',
+                id: 'help',
+                optional: true,
+                showDone: true,
+                title: 'Help is always nearby',
+                waitForElement: 5000
+            }
+        ],
+        id: 'new-ui-overview',
+        keywords: ['navigation', 'new ui', 'search', 'command', 'help', 'saved views'],
+        title: 'Explore the new UI',
+        version: 1
+    },
+    {
+        description: 'Create or resume a project, connect an SDK, and wait for its first real event.',
+        getAvailability: () => ({ available: true }),
+        getStartAction: getConfigureProjectStartAction,
+        getSteps: (context) => {
+            if (!context.organizationId) {
+                return [
+                    {
+                        anchor: PRODUCT_TOUR_ANCHORS.setupOrganizationName,
+                        description: 'Create the organization that will own your projects and error data.',
+                        id: 'organization-name',
+                        title: 'Name your organization'
+                    },
+                    {
+                        anchor: PRODUCT_TOUR_ANCHORS.projectName,
+                        description: 'Use the application or service name that will send events to Exceptionless.',
+                        id: 'project-name',
+                        title: 'Name your first project'
+                    },
+                    {
+                        advanceOnClick: true,
+                        anchor: PRODUCT_TOUR_ANCHORS.projectSetupSubmit,
+                        description: 'Create both records, then continue to the SDK instructions.',
+                        id: 'create-setup',
+                        resumeStepId: 'choose-platform',
+                        title: 'Continue to configuration'
+                    }
+                ];
+            }
+
+            if (context.pathname.includes('/project/add')) {
+                return [
+                    {
+                        anchor: PRODUCT_TOUR_ANCHORS.projectName,
+                        description: 'Use the application or service name that will send events to Exceptionless.',
+                        id: 'project-name',
+                        title: 'Name your project'
+                    },
+                    {
+                        advanceOnClick: true,
+                        anchor: PRODUCT_TOUR_ANCHORS.projectSetupSubmit,
+                        description: 'Create the project, then continue to its SDK instructions.',
+                        id: 'create-project',
+                        resumeStepId: 'choose-platform',
+                        title: 'Continue to configuration'
+                    }
+                ];
+            }
+
+            return [
+                {
+                    anchor: PRODUCT_TOUR_ANCHORS.projectConfigurePlatform,
+                    description: 'Choose the platform that matches the application you are connecting.',
+                    id: 'choose-platform',
+                    title: 'Choose your SDK'
+                },
+                {
+                    anchor: PRODUCT_TOUR_ANCHORS.projectConfigureToken,
+                    description: 'The generated client token identifies this project. Keep it with your application configuration.',
+                    id: 'client-token',
+                    optional: true,
+                    title: 'Use the project token'
+                },
+                {
+                    anchor: PRODUCT_TOUR_ANCHORS.projectConfigureInstructions,
+                    description: 'Follow these instructions in your own application. This guide stays ready while you work outside Exceptionless.',
+                    id: 'sdk-instructions',
+                    presentation: 'inline',
+                    title: 'Connect your application'
+                },
+                {
+                    anchor: PRODUCT_TOUR_ANCHORS.projectConfigureWaiting,
+                    description: 'The guide completes only after this project sends its first real event.',
+                    id: 'wait-for-event',
+                    presentation: 'inline',
+                    showDone: false,
+                    title: 'Waiting for the first event'
+                }
+            ];
+        },
+        id: 'configure-project',
+        keywords: ['add project', 'configure', 'sdk', 'api key', 'first event'],
+        title: 'Configure a project',
+        version: 1
+    },
+    {
+        description: 'Save the current Events configuration as a private view that only you can see.',
+        getAvailability: requireOrganization,
+        getStartAction: () => ({ destination: resolve('/(app)/event'), type: 'navigate' }),
+        getSteps: () => [
+            {
+                advanceOnClick: true,
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewTrigger,
+                description: 'A saved view can capture the current filters, date range, sort, display choices, and columns.',
+                id: 'open-view-menu',
+                title: 'Open View settings'
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewSettings,
+                description: 'Review filters, time range, sorting, chart and stat choices, and columns here. The guide will not change them for you.',
+                id: 'review-settings',
+                title: 'Configure what the view remembers',
+                waitForElement: 5000
+            },
+            {
+                advanceOnClick: true,
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewSaveAs,
+                description: 'Save As creates a reusable view without changing any existing view.',
+                id: 'save-as',
+                title: 'Create a new view',
+                waitForElement: 5000
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewName,
+                description: 'Choose a meaningful name. The URL name is generated automatically.',
+                id: 'name-view',
+                presentation: 'inline',
+                title: 'Name the view',
+                waitForElement: 5000
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewPrivate,
+                description: 'Private is enabled for this guide so the practice view does not affect your organization.',
+                id: 'private-view',
+                presentation: 'inline',
+                title: 'Keep it private'
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.savedViewSubmit,
+                description: 'Save when ready. Completion is recorded only after the view is successfully created and loaded.',
+                id: 'save-view',
+                presentation: 'inline',
+                showDone: false,
+                title: 'Create the saved view'
+            }
+        ],
+        id: 'create-saved-view',
+        keywords: ['saved view', 'filter', 'columns', 'private', 'dashboard'],
+        title: 'Create a saved view',
+        version: 1
+    },
+    {
+        description: 'Filter to a real error, assess its stack and status, then inspect the evidence available for that occurrence.',
+        getAvailability: requireErrorEvent,
+        getStartAction: getInvestigateErrorStartAction,
+        getSteps: () => [...investigateErrorSteps],
+        id: 'investigate-error',
+        keywords: ['error report', 'event details', 'exception', 'request', 'environment', 'filter', 'stack', 'status', 'triage'],
+        title: 'Investigate an error',
+        version: 1
+    },
+    {
+        description: 'See how Exie uses the current page as context without sending a prompt.',
+        getAvailability: (context) =>
+            context.assistantAccess?.enabled ? { available: true } : { available: false, reason: 'Exie is not enabled by this Exceptionless installation.' },
+        getSteps: (context) => [
+            {
+                advanceOnClick: true,
+                anchor: PRODUCT_TOUR_ANCHORS.exieTrigger,
+                description: context.assistantAccess?.has_access
+                    ? 'Open Exie to see the page context available for your next question.'
+                    : (context.assistantAccess?.message ?? 'Open Exie to review the plan requirement.'),
+                id: 'open-exie',
+                title: 'Open Exie'
+            },
+            {
+                anchor: PRODUCT_TOUR_ANCHORS.exiePanel,
+                description: context.assistantAccess?.has_access
+                    ? 'Exie can investigate with your current organization, project, event, or stack context. Nothing is sent until you choose a prompt; submitted requests use metered provider usage.'
+                    : 'This panel explains the access requirement. The guide will never start a provider request.',
+                id: 'exie-context',
+                showDone: true,
+                title: 'You control every request',
+                waitForElement: 5000
+            }
+        ],
+        id: 'meet-exie',
+        keywords: ['exie', 'assistant', 'ai', 'help', 'investigate'],
+        title: 'Meet Exie',
+        version: 1
+    }
+] as const;
+
+export function getProductTour(id: ProductTourDefinition['id']): ProductTourDefinition {
+    const definition = productTourCatalog.find((tour) => tour.id === id);
+    if (!definition) {
+        throw new Error(`Unknown product tour: ${id}`);
+    }
+
+    return definition;
+}
+
+export function getProductTourItems(context: ProductTourContext, progress: Record<string, ProductTourProgress> = {}): ProductTourListItem[] {
+    return productTourCatalog.map((definition) => ({
+        ...definition,
+        availability: definition.getAvailability(context),
+        progress: progress[definition.id]
+    }));
+}
+
+export function getRecommendedProductTourId(context: ProductTourContext): ProductTourDefinition['id'] {
+    return !context.organizationId || context.projects.some((project) => !project.is_configured) ? 'configure-project' : 'new-ui-overview';
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-catalog.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-catalog.svelte
new file mode 100644
index 0000000000..c98675df78
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-catalog.svelte
@@ -0,0 +1,50 @@
+<script lang="ts">
+    import { Badge } from '$comp/ui/badge';
+    import { Button } from '$comp/ui/button';
+    import * as Dialog from '$comp/ui/dialog';
+    import Compass from '@lucide/svelte/icons/compass';
+
+    import type { ProductTourId, ProductTourListItem } from '../types';
+
+    interface Props {
+        items: ProductTourListItem[];
+        onStart: (id: ProductTourId) => void;
+        open?: boolean;
+    }
+
+    let { items, onStart, open = $bindable(false) }: Props = $props();
+</script>
+
+<Dialog.Root bind:open>
+    <Dialog.Content class="max-h-[85vh] overflow-y-auto sm:max-w-2xl" data-product-tour-overlay>
+        <Dialog.Header>
+            <Dialog.Title>Guided Tours</Dialog.Title>
+            <Dialog.Description>Learn the new UI with short guides that use your real Exceptionless data.</Dialog.Description>
+        </Dialog.Header>
+
+        <div class="grid gap-3 py-2 sm:grid-cols-2">
+            {#each items as item (item.id)}
+                <section class="border-border bg-card flex min-h-44 flex-col gap-3 rounded-lg border p-4">
+                    <div class="flex items-start justify-between gap-3">
+                        <div class="bg-primary/10 text-primary flex size-9 shrink-0 items-center justify-center rounded-lg">
+                            <Compass aria-hidden="true" class="size-5" />
+                        </div>
+                        {#if item.progress?.status === 'completed' && item.progress.version >= item.version}
+                            <Badge variant="secondary">Completed</Badge>
+                        {/if}
+                    </div>
+                    <div class="flex-1">
+                        <h3 class="font-semibold">{item.title}</h3>
+                        <p class="text-muted-foreground mt-1 text-sm">{item.description}</p>
+                        {#if !item.availability.available}
+                            <p class="text-muted-foreground mt-2 text-xs">{item.availability.reason}</p>
+                        {/if}
+                    </div>
+                    <Button disabled={!item.availability.available} onclick={() => onStart(item.id)} variant="outline">
+                        {item.progress?.status === 'completed' && item.progress.version >= item.version ? 'Restart' : 'Start'}
+                    </Button>
+                </section>
+            {/each}
+        </div>
+    </Dialog.Content>
+</Dialog.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-feature-announcement.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-feature-announcement.svelte
new file mode 100644
index 0000000000..910b93917d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-feature-announcement.svelte
@@ -0,0 +1,44 @@
+<script lang="ts">
+    import * as Alert from '$comp/ui/alert';
+    import { Button } from '$comp/ui/button';
+    import Sparkles from '@lucide/svelte/icons/sparkles';
+    import X from '@lucide/svelte/icons/x';
+
+    interface Props {
+        hasAccess: boolean;
+        message?: string;
+        onDismiss: () => void;
+        onStart: () => void;
+        open?: boolean;
+    }
+
+    let { hasAccess, message, onDismiss, onStart, open = true }: Props = $props();
+</script>
+
+{#if open}
+    <Alert.Root
+        class="product-tour-feature-announcement fixed right-4 bottom-4 z-40 w-[min(24rem,calc(100vw-2rem))] shadow-lg"
+        data-product-tour-announcement="exie"
+    >
+        <Sparkles aria-hidden="true" class="text-primary mt-0.5" />
+        <div data-slot="alert-description">
+            <div class="flex items-start justify-between gap-3">
+                <div>
+                    <Alert.Title>New: Meet Exie</Alert.Title>
+                    <p class="text-muted-foreground mt-1 text-sm">
+                        {hasAccess
+                            ? 'See how Exie uses the page you are viewing as context for investigations.'
+                            : (message ?? 'Exie is available with an eligible organization plan.')}
+                    </p>
+                </div>
+                <Button aria-label="Dismiss Exie announcement" class="-mt-1 -mr-1 size-7" onclick={onDismiss} size="icon" variant="ghost">
+                    <X aria-hidden="true" class="size-4" />
+                </Button>
+            </div>
+            <div class="mt-3 flex flex-wrap gap-2">
+                <Button onclick={onStart} size="sm">See how it works</Button>
+                <Button onclick={onDismiss} size="sm" variant="outline">Dismiss</Button>
+            </div>
+        </div>
+    </Alert.Root>
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-inline-callout.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-inline-callout.svelte
new file mode 100644
index 0000000000..bbd88fcc80
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-inline-callout.svelte
@@ -0,0 +1,30 @@
+<script lang="ts">
+    import * as Alert from '$comp/ui/alert';
+    import { Button } from '$comp/ui/button';
+    import Info from '@lucide/svelte/icons/info';
+
+    interface Props {
+        continueLabel?: string;
+        description: string;
+        onContinue?: () => void;
+        onDismiss: () => void;
+        title: string;
+        tourId: string;
+    }
+
+    let { continueLabel = 'Continue', description, onContinue, onDismiss, title, tourId }: Props = $props();
+</script>
+
+<Alert.Root data-product-tour-inline={tourId}>
+    <Info aria-hidden="true" />
+    <Alert.Title>{title}</Alert.Title>
+    <Alert.Description>
+        {description}
+        <div class="mt-2 flex flex-wrap gap-2">
+            {#if onContinue}
+                <Button onclick={onContinue} size="sm" type="button">{continueLabel}</Button>
+            {/if}
+            <Button onclick={onDismiss} size="sm" type="button" variant="outline">End guide</Button>
+        </div>
+    </Alert.Description>
+</Alert.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte
new file mode 100644
index 0000000000..837da4fd8d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte
@@ -0,0 +1,48 @@
+<script lang="ts">
+    import { Button } from '$comp/ui/button';
+    import * as Dialog from '$comp/ui/dialog';
+    import Compass from '@lucide/svelte/icons/compass';
+
+    import type { ProductTourListItem } from '../types';
+
+    interface Props {
+        onBrowse: () => void;
+        onSkip: () => void;
+        onStart: () => void;
+        open?: boolean;
+        recommended: ProductTourListItem;
+    }
+
+    let { onBrowse, onSkip, onStart, open = $bindable(false), recommended }: Props = $props();
+</script>
+
+<Dialog.Root bind:open>
+    <Dialog.Content
+        class="sm:max-w-lg"
+        data-product-tour-overlay
+        onEscapeKeydown={(event) => event.preventDefault()}
+        onInteractOutside={(event) => event.preventDefault()}
+        showCloseButton={false}
+    >
+        <Dialog.Header>
+            <div class="bg-primary/10 text-primary mb-2 flex size-11 items-center justify-center rounded-xl">
+                <Compass aria-hidden="true" />
+            </div>
+            <Dialog.Title>Welcome to the new Exceptionless UI</Dialog.Title>
+            <Dialog.Description>Take a short guided tour now, or browse the guides whenever you need them.</Dialog.Description>
+        </Dialog.Header>
+
+        <section class="border-border bg-muted/30 rounded-lg border p-4">
+            <p class="text-sm font-semibold">Recommended: {recommended.title}</p>
+            <p class="text-muted-foreground mt-1 text-sm">{recommended.description}</p>
+        </section>
+
+        <Dialog.Footer class="gap-2 sm:justify-between">
+            <Button onclick={onSkip} variant="ghost">Skip</Button>
+            <div class="flex flex-col-reverse gap-2 sm:flex-row">
+                <Button onclick={onBrowse} variant="outline">Browse Guides</Button>
+                <Button onclick={onStart}>{recommended.id === 'configure-project' ? 'Continue setup' : 'Explore the new UI'}</Button>
+            </div>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte.test.ts
new file mode 100644
index 0000000000..c87d990aab
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-welcome.svelte.test.ts
@@ -0,0 +1,43 @@
+import { fireEvent, render, screen } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import ProductTourWelcome from './product-tour-welcome.svelte';
+
+const recommended = {
+    availability: { available: true },
+    description: 'Learn navigation and search.',
+    getAvailability: vi.fn(),
+    getSteps: vi.fn(),
+    id: 'new-ui-overview' as const,
+    keywords: ['navigation'],
+    title: 'Explore the new UI',
+    version: 1
+};
+
+describe('ProductTourWelcome', () => {
+    it('records only explicit chooser actions', async () => {
+        const onBrowse = vi.fn();
+        const onSkip = vi.fn();
+        const onStart = vi.fn();
+        render(ProductTourWelcome, { onBrowse, onSkip, onStart, open: true, recommended });
+
+        await fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+        expect(onBrowse).not.toHaveBeenCalled();
+        expect(onSkip).not.toHaveBeenCalled();
+        expect(onStart).not.toHaveBeenCalled();
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Explore the new UI' }));
+        expect(onStart).toHaveBeenCalledOnce();
+    });
+
+    it('provides Browse Guides and Skip choices', async () => {
+        const onBrowse = vi.fn();
+        const onSkip = vi.fn();
+        render(ProductTourWelcome, { onBrowse, onSkip, onStart: vi.fn(), open: true, recommended });
+
+        await fireEvent.click(screen.getByRole('button', { name: 'Browse Guides' }));
+        expect(onBrowse).toHaveBeenCalledOnce();
+        await fireEvent.click(screen.getByRole('button', { name: 'Skip' }));
+        expect(onSkip).toHaveBeenCalledOnce();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tours.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tours.svelte
new file mode 100644
index 0000000000..a715911ce2
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tours.svelte
@@ -0,0 +1,907 @@
+<script lang="ts">
+    import type { AssistantAccess } from '$features/assistant/models';
+    import type { ViewProject } from '$features/projects/models';
+    import type { ViewCurrentUser } from '$features/users/models';
+    import type { Driver } from 'driver.js';
+
+    import { goto } from '$app/navigation';
+    import { resolve } from '$app/paths';
+    import * as AlertDialog from '$comp/ui/alert-dialog';
+    import { submitFeatureUsage } from '$features/auth/exceptionless-session';
+    import { putCurrentUserProductTour } from '$features/users/api.svelte';
+    import { onMount, tick } from 'svelte';
+    import { toast } from 'svelte-sonner';
+
+    import type {
+        ProductTourContext,
+        ProductTourErrorEventAvailability,
+        ProductTourId,
+        ProductTourKey,
+        ProductTourLaunchSource,
+        ProductTourListItem,
+        ProductTourStartAction,
+        ProductTourStep
+    } from '../types';
+
+    import { PRODUCT_TOUR_ANCHORS, productTourSelector } from '../anchors';
+    import { getProductTour, getProductTourItems, getRecommendedProductTourId } from '../catalog';
+    import { shouldOfferProductTourAnnouncement, shouldOfferProductTourWelcome } from '../eligibility';
+    import { clearProductTourSession, readProductTourSession, writeProductTourSession } from '../session';
+    import { productTourHost, type ProductTourHostEvent } from '../state.svelte';
+    import { buildProductTourTelemetryEvent, type ProductTourTelemetryEvent } from '../telemetry';
+    import ProductTourCatalog from './product-tour-catalog.svelte';
+    import ProductTourFeatureAnnouncement from './product-tour-feature-announcement.svelte';
+    import ProductTourWelcome from './product-tour-welcome.svelte';
+    import 'driver.js/dist/driver.css';
+
+    import '../product-tours.css';
+
+    interface Props {
+        assistantAccess?: AssistantAccess;
+        closeOverlays: () => void;
+        currentUser?: ViewCurrentUser;
+        errorEventAvailability: ProductTourErrorEventAvailability;
+        isAnyOverlayOpen: boolean;
+        isImpersonating: boolean;
+        isSetupPage: boolean;
+        organizationId?: string;
+        pathname: string;
+        projects: ViewProject[];
+        requestErrorAvailability: () => void;
+        routeKey: string;
+        stateSettled: boolean;
+    }
+
+    const WELCOME_VERSION = 1;
+    const EXIE_ANNOUNCEMENT_VERSION = 1;
+    const EXIE_ANNOUNCEMENT_KEY = 'exie-announcement' as const;
+    const SYSTEM_PATH = resolve('/(app)/system');
+
+    let {
+        assistantAccess,
+        closeOverlays,
+        currentUser,
+        errorEventAvailability,
+        isAnyOverlayOpen,
+        isImpersonating,
+        isSetupPage,
+        organizationId,
+        pathname,
+        projects,
+        requestErrorAvailability,
+        routeKey,
+        stateSettled
+    }: Props = $props();
+
+    let catalogOpen = $state(false);
+    let catalogSource = $state<ProductTourLaunchSource>('catalog');
+    let welcomeOpen = $state(false);
+    let welcomeHandled = $state(false);
+    let welcomeShown = $state(false);
+    let welcomeBrowsePending = $state(false);
+    let exieAnnouncementOpen = $state(false);
+    let exieAnnouncementShown = $state(false);
+    let pendingConfirmation = $state<{
+        action: Extract<ProductTourStartAction, { type: 'confirm-navigation' }>;
+        id: ProductTourId;
+        source: ProductTourLaunchSource;
+    }>();
+    let driverInstance = $state.raw<Driver>();
+    let driverTransition: 'active' | 'finishing' | 'inline' | 'navigation' = 'active';
+    let driverRoute = '';
+    let resumeAttemptedRoute = '';
+    let overlayRevision = $state(0);
+
+    const progressMutation = putCurrentUserProductTour();
+    const context = $derived<ProductTourContext>({
+        assistantAccess,
+        errorEventAvailability,
+        isSetupPage,
+        organizationId,
+        pathname,
+        projects
+    });
+    const items = $derived(getProductTourItems(context, currentUser?.product_tours));
+    const recommended = $derived.by(() => {
+        const id = getRecommendedProductTourId(context);
+        return items.find((item) => item.id === id) ?? items[0]!;
+    });
+
+    $effect(() => {
+        const welcomeProgress = currentUser?.product_tours?.welcome;
+        void overlayRevision;
+        const shouldShow =
+            stateSettled &&
+            !!currentUser &&
+            !welcomeHandled &&
+            !welcomeOpen &&
+            !catalogOpen &&
+            !isAnyOverlayOpen &&
+            !hasCompetingOverlay() &&
+            !isImpersonating &&
+            !pathname.startsWith(SYSTEM_PATH) &&
+            shouldOfferProductTourWelcome(welcomeProgress, WELCOME_VERSION);
+
+        if (!shouldShow) {
+            return;
+        }
+
+        welcomeOpen = true;
+        if (!welcomeShown) {
+            welcomeShown = true;
+            void track('chooser-shown', 'welcome', WELCOME_VERSION, 'automatic');
+        }
+    });
+
+    $effect(() => {
+        const welcomeProgress = currentUser?.product_tours?.welcome;
+        const announcementProgress = currentUser?.product_tours?.[EXIE_ANNOUNCEMENT_KEY];
+        const isMeaningfulAppRoute = pathname.startsWith('/next/event') || pathname.startsWith('/next/stack');
+        const shouldShow =
+            stateSettled &&
+            !!currentUser &&
+            !!assistantAccess?.enabled &&
+            isMeaningfulAppRoute &&
+            !isSetupPage &&
+            !isImpersonating &&
+            !productTourHost.activeTourId &&
+            !exieAnnouncementShown &&
+            !exieAnnouncementOpen &&
+            !welcomeOpen &&
+            !catalogOpen &&
+            !isAnyOverlayOpen &&
+            !hasCompetingOverlay() &&
+            !pathname.startsWith(SYSTEM_PATH) &&
+            !shouldOfferProductTourWelcome(welcomeProgress, WELCOME_VERSION) &&
+            shouldOfferProductTourAnnouncement(announcementProgress, EXIE_ANNOUNCEMENT_VERSION);
+
+        if (!shouldShow) {
+            return;
+        }
+
+        exieAnnouncementOpen = true;
+        exieAnnouncementShown = true;
+        void track('announcement-shown', EXIE_ANNOUNCEMENT_KEY, EXIE_ANNOUNCEMENT_VERSION, 'feature-announcement');
+    });
+
+    $effect(() => {
+        const observer = new MutationObserver(() => (overlayRevision += 1));
+        observer.observe(document.body, {
+            attributes: true,
+            childList: true,
+            subtree: true
+        });
+        return () => observer.disconnect();
+    });
+
+    $effect(() => {
+        void overlayRevision;
+        if (productTourHost.activeTourId !== 'investigate-error' || productTourHost.activeStepId !== 'choose-error') {
+            return;
+        }
+
+        if (getVisibleEventType() === 'error') {
+            onEventOpened('error');
+        }
+    });
+
+    $effect(() => {
+        const currentRoute = routeKey;
+        if (!stateSettled || driverInstance || resumeAttemptedRoute === currentRoute) {
+            return;
+        }
+
+        const stored = readProductTourSession();
+        if (!stored) {
+            return;
+        }
+
+        let storedVersion: number;
+        try {
+            storedVersion = getProductTour(stored.tourId).version;
+        } catch {
+            clearProductTourSession();
+            return;
+        }
+
+        if (storedVersion !== stored.version) {
+            clearProductTourSession();
+            return;
+        }
+
+        resumeAttemptedRoute = currentRoute;
+        if (stored.tourId === 'investigate-error' && stored.stepId === 'choose-error' && /\/(event|stack)\//.test(pathname)) {
+            return;
+        }
+
+        void launch(stored.tourId, stored.source, stored.stepId, false);
+    });
+
+    $effect(() => {
+        const currentRoute = routeKey;
+        if (!driverInstance || !driverRoute || driverRoute === currentRoute) {
+            return;
+        }
+
+        driverTransition = 'navigation';
+        driverInstance.destroy();
+        driverTransition = 'active';
+        driverRoute = '';
+        resumeAttemptedRoute = '';
+    });
+
+    $effect(() => {
+        if (!stateSettled || currentUser) {
+            return;
+        }
+
+        driverInstance?.destroy();
+        driverInstance = undefined;
+        productTourHost.clear();
+        clearProductTourSession();
+    });
+
+    $effect(() => {
+        const currentOrganizationId = organizationId;
+        if (!productTourHost.activeTourId || productTourHost.organizationId === currentOrganizationId) {
+            return;
+        }
+
+        if (productTourHost.activeTourId === 'configure-project' && pathname === resolve('/(app)/organization/add')) {
+            productTourHost.set(productTourHost.activeTourId, productTourHost.activeStepId, productTourHost.source, currentOrganizationId);
+            return;
+        }
+
+        stopActiveTour(true);
+    });
+
+    function getItem(id: ProductTourId): ProductTourListItem {
+        return items.find((item) => item.id === id)!;
+    }
+
+    function hasCompetingOverlay(): boolean {
+        return Array.from(document.querySelectorAll<HTMLElement>('[role="alertdialog"], [role="dialog"], [data-assistant-panel]')).some(
+            (element) => element.getClientRects().length > 0 && !element.closest('.driver-popover') && !element.closest('[data-product-tour-overlay]')
+        );
+    }
+
+    async function waitForCompetingOverlaysToClose(timeout = 1000): Promise<boolean> {
+        await tick();
+        const deadline = performance.now() + timeout;
+        while (hasCompetingOverlay() && performance.now() < deadline) {
+            await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+        }
+
+        return !hasCompetingOverlay();
+    }
+
+    export function openCatalog(source: ProductTourLaunchSource = 'catalog'): void {
+        closeOverlays();
+        requestErrorAvailability();
+        catalogSource = source;
+        catalogOpen = true;
+    }
+
+    export async function startTour(id: ProductTourId, source: ProductTourLaunchSource = 'catalog'): Promise<void> {
+        if (productTourHost.activeTourId) {
+            stopActiveTour(true);
+        }
+
+        const item = getItem(id);
+        if (!item.availability.available) {
+            openCatalog(source);
+            return;
+        }
+
+        catalogOpen = false;
+        welcomeOpen = false;
+        exieAnnouncementOpen = false;
+        closeOverlays();
+        const startAction = item.getStartAction?.({
+            ...context,
+            openEventType: getVisibleEventType()
+        }) ?? {
+            type: 'launch'
+        };
+        const canLaunchInsideOverlay = startAction.type === 'launch' && startAction.stepId === 'stack-summary';
+        if (!(await waitForCompetingOverlaysToClose()) && !canLaunchInsideOverlay) {
+            toast.info('Close the open dialog or panel before starting a guided tour.');
+            return;
+        }
+
+        if (welcomeBrowsePending) {
+            try {
+                await recordProgress('welcome', WELCOME_VERSION, 'completed');
+            } catch {
+                toast.error('We could not save your guided-tour preference. Please try again.');
+                return;
+            }
+
+            welcomeBrowsePending = false;
+            void track('chooser-started', id, item.version, source);
+        }
+
+        await executeStartAction(id, source, startAction);
+    }
+
+    async function executeStartAction(id: ProductTourId, source: ProductTourLaunchSource, action: ProductTourStartAction): Promise<void> {
+        if (action.type === 'confirm-navigation') {
+            pendingConfirmation = {
+                action,
+                id,
+                source
+            };
+            return;
+        }
+
+        if (action.type === 'navigate' && action.destination !== routeKey) {
+            writeProductTourSession({
+                source,
+                tourId: id,
+                version: getProductTour(id).version
+            });
+            await goto(action.destination);
+            return;
+        }
+
+        await launch(id, source, action.type === 'launch' ? action.stepId : undefined);
+    }
+
+    async function launch(id: ProductTourId, source: ProductTourLaunchSource, resumeStepId?: string, emitStarted = true): Promise<void> {
+        const definition = getProductTour(id);
+        if (id === 'new-ui-overview' && isMobileViewport()) {
+            await ensureTarget({
+                anchor: PRODUCT_TOUR_ANCHORS.appNavigation,
+                description: '',
+                id: 'mobile-navigation',
+                title: ''
+            });
+        }
+
+        const allSteps = await getAvailableSteps(id, definition.getSteps(context));
+        let startIndex = resumeStepId ? allSteps.findIndex((step) => step.id === resumeStepId) : 0;
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+
+        const firstStep = allSteps[startIndex];
+        if (!firstStep || !(await ensureTarget(firstStep))) {
+            await failTour(id, definition.version, firstStep?.id ?? 'missing-start', source);
+            return;
+        }
+
+        if (firstStep.presentation === 'inline') {
+            productTourHost.set(id, firstStep.id, source, organizationId);
+            writeProductTourSession({
+                source,
+                stepId: firstStep.id,
+                tourId: id,
+                version: definition.version
+            });
+            void track(emitStarted ? 'started' : 'step', id, definition.version, source, firstStep.id);
+            return;
+        }
+
+        const { driver } = await import('driver.js');
+        driverTransition = 'active';
+        const steps = allSteps.slice(startIndex);
+
+        driverInstance = driver({
+            allowClose: true,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+            disableActiveInteraction: false,
+            onCloseClick: () => void dismissTour(id, definition.version, source),
+            onDestroyed: () => {
+                const activeStepId = productTourHost.activeStepId;
+                const preservingNavigation = driverTransition === 'navigation' || (driverRoute !== '' && driverRoute !== routeKey);
+                const preservingPendingEvent =
+                    id === 'investigate-error' && (activeStepId === 'choose-error' || readProductTourSession()?.stepId === 'choose-error');
+                driverInstance = undefined;
+                if (driverTransition !== 'inline' && !preservingNavigation && !preservingPendingEvent) {
+                    productTourHost.clear();
+                    if (driverTransition === 'active') {
+                        clearProductTourSession();
+                        void track('dismissed', id, definition.version, source, activeStepId);
+                    }
+                }
+
+                if (driverTransition === 'active' && !preservingNavigation && !preservingPendingEvent) {
+                    void recordProgress(id, definition.version, 'dismissed').catch(() => toast.error('We could not save your guided-tour progress.'));
+                }
+            },
+            onHighlighted: (_, __, options) => {
+                const index = options.state.activeIndex ?? 0;
+                const step = steps[index];
+                if (!step) {
+                    return;
+                }
+
+                productTourHost.set(id, step.id, source, organizationId);
+                writeProductTourSession({
+                    source,
+                    stepId: step.resumeStepId ?? step.id,
+                    tourId: id,
+                    version: definition.version
+                });
+                void track('step', id, definition.version, source, step.id);
+            },
+            overlayClickBehavior: 'close',
+            popoverClass: 'product-tour-popover',
+            showProgress: true,
+            smoothScroll: true,
+            steps: steps.map((step, index) => ({
+                element: step.anchor ? () => document.querySelector(productTourSelector(step.anchor!))! : undefined,
+                popover: {
+                    description: step.description,
+                    doneBtnText: 'Done',
+                    nextBtnText: step.advanceOnClick ? 'Continue' : 'Next',
+                    onNextClick: () => void advance(id, definition.version, source, steps, index),
+                    showButtons: getButtons(step),
+                    title: step.title
+                }
+            }))
+        });
+        driverRoute = routeKey;
+        productTourHost.set(id, firstStep.id, source, organizationId);
+        writeProductTourSession({
+            source,
+            stepId: firstStep.resumeStepId ?? firstStep.id,
+            tourId: id,
+            version: definition.version
+        });
+
+        if (emitStarted) {
+            void track('started', id, definition.version, source);
+        }
+
+        driverInstance.drive(0);
+    }
+
+    function getButtons(step: ProductTourStep): Array<'close' | 'next' | 'previous'> {
+        const buttons: Array<'close' | 'next' | 'previous'> = ['close'];
+
+        if (step.showDone !== false) {
+            buttons.push('next');
+        }
+
+        return buttons;
+    }
+
+    async function advance(id: ProductTourId, version: number, source: ProductTourLaunchSource, steps: ProductTourStep[], index: number): Promise<void> {
+        const step = steps[index]!;
+        if (id === 'configure-project' && step.id === 'choose-platform') {
+            const platform = document.querySelector(productTourSelector(PRODUCT_TOUR_ANCHORS.projectConfigurePlatform));
+            if (!platform || /Please select a project type/i.test(platform.textContent ?? '')) {
+                toast.info('Choose the SDK platform before continuing.');
+                return;
+            }
+        }
+
+        const previousRoute = routeKey;
+        if (step.advanceOnClick && step.anchor) {
+            (document.querySelector(productTourSelector(step.anchor)) as HTMLElement | null)?.click();
+            if (id === 'configure-project' && step.resumeStepId) {
+                if (!(await waitForRouteChange(previousRoute))) {
+                    toast.info('Finish the required fields before continuing this guide.');
+                    return;
+                }
+            } else {
+                await tick();
+            }
+        }
+
+        const next = steps[index + 1];
+        if (!next) {
+            if (step.advanceOnClick && step.resumeStepId) {
+                driverTransition = 'finishing';
+                writeProductTourSession({
+                    source,
+                    stepId: step.resumeStepId,
+                    tourId: id,
+                    version
+                });
+                driverInstance?.destroy();
+                driverInstance = undefined;
+                productTourHost.clear();
+                return;
+            }
+
+            await completeTour(id, version, source);
+            return;
+        }
+
+        if (id === 'new-ui-overview' && isMobileViewport() && next.id !== 'help' && next.id !== 'saved-views' && next.id !== 'navigation') {
+            closeMobileNavigation();
+            await tick();
+        }
+
+        if (!(await ensureTarget(next))) {
+            if (next.optional) {
+                driverInstance?.moveNext();
+                return;
+            }
+
+            await failTour(id, version, next.id, source);
+            return;
+        }
+
+        if (next.presentation === 'inline') {
+            driverTransition = 'inline';
+            writeProductTourSession({
+                source,
+                stepId: next.id,
+                tourId: id,
+                version
+            });
+            driverInstance?.destroy();
+            driverTransition = 'active';
+            productTourHost.set(id, next.id, source, organizationId);
+            void track('step', id, version, source, next.id);
+            return;
+        }
+
+        if (driverInstance && driverRoute === routeKey) {
+            driverInstance.moveNext();
+        } else {
+            driverTransition = 'navigation';
+            driverInstance?.destroy();
+            driverInstance = undefined;
+            driverTransition = 'active';
+            await launch(id, source, next.id, false);
+        }
+    }
+
+    async function ensureTarget(step: ProductTourStep): Promise<boolean> {
+        if (!step.anchor) {
+            return true;
+        }
+
+        const selector = productTourSelector(step.anchor);
+        if (step.anchor === PRODUCT_TOUR_ANCHORS.appNavigation && isMobileViewport() && !hasVisibleTarget(selector)) {
+            (document.querySelector(productTourSelector('mobile-navigation-trigger')) as HTMLElement | null)?.click();
+        }
+
+        if (hasVisibleTarget(selector)) {
+            return true;
+        }
+
+        const timeout = step.waitForElement ?? 1200;
+        return await new Promise((resolvePromise) => {
+            const observer = new MutationObserver(() => {
+                if (!hasVisibleTarget(selector)) {
+                    return;
+                }
+
+                observer.disconnect();
+                window.clearTimeout(timeoutId);
+                resolvePromise(true);
+            });
+            const timeoutId = window.setTimeout(() => {
+                observer.disconnect();
+                resolvePromise(false);
+            }, timeout);
+            observer.observe(document.body, {
+                attributes: true,
+                childList: true,
+                subtree: true
+            });
+        });
+    }
+
+    function hasVisibleTarget(selector: string): boolean {
+        const element = document.querySelector<HTMLElement>(selector);
+        return !!element && element.getClientRects().length > 0;
+    }
+
+    function getVisibleEventType(): string | undefined {
+        const element = document.querySelector<HTMLElement>(productTourSelector(PRODUCT_TOUR_ANCHORS.eventDetails));
+        return element?.getClientRects().length ? element.dataset.eventType : undefined;
+    }
+
+    function isMobileViewport(): boolean {
+        return window.matchMedia('(max-width: 767px)').matches;
+    }
+
+    async function getAvailableSteps(id: ProductTourId, steps: ProductTourStep[]): Promise<ProductTourStep[]> {
+        const orderedSteps = orderStepsForViewport(id, steps);
+        const availability = await Promise.all(orderedSteps.map((step) => (!step.optional || !step.anchor ? Promise.resolve(true) : ensureTarget(step))));
+
+        return orderedSteps.filter((_, index) => availability[index]);
+    }
+
+    function orderStepsForViewport(id: ProductTourId, steps: ProductTourStep[]): ProductTourStep[] {
+        if (id !== 'new-ui-overview' || !isMobileViewport()) {
+            return steps;
+        }
+
+        const order = ['navigation', 'saved-views', 'help', 'command-search', 'exie'];
+        return order.map((stepId) => steps.find((step) => step.id === stepId)).filter((step): step is ProductTourStep => !!step);
+    }
+
+    function closeMobileNavigation(): void {
+        if (hasVisibleTarget(productTourSelector(PRODUCT_TOUR_ANCHORS.appNavigation))) {
+            (document.querySelector(productTourSelector('mobile-navigation-trigger')) as HTMLElement | null)?.click();
+        }
+    }
+
+    async function waitForRouteChange(previousRoute: string, timeout = 10000): Promise<boolean> {
+        const deadline = performance.now() + timeout;
+        while (routeKey === previousRoute && `${window.location.pathname}${window.location.search}` === previousRoute && performance.now() < deadline) {
+            await new Promise<void>((resolvePromise) => setTimeout(resolvePromise, 50));
+        }
+
+        return routeKey !== previousRoute || `${window.location.pathname}${window.location.search}` !== previousRoute;
+    }
+
+    async function onWelcomeStart(): Promise<void> {
+        try {
+            await recordProgress('welcome', WELCOME_VERSION, 'completed');
+        } catch {
+            toast.error('We could not save your guided-tour preference. Please try again.');
+            return;
+        }
+
+        welcomeHandled = true;
+        welcomeOpen = false;
+        void track('chooser-started', recommended.id, recommended.version, 'automatic');
+        await startTour(recommended.id, 'automatic');
+    }
+
+    async function onExieAnnouncementStart(): Promise<void> {
+        try {
+            await recordProgress(EXIE_ANNOUNCEMENT_KEY, EXIE_ANNOUNCEMENT_VERSION, 'completed');
+        } catch {
+            toast.error('We could not save the Exie announcement preference. Please try again.');
+            return;
+        }
+
+        exieAnnouncementOpen = false;
+        void track('announcement-started', EXIE_ANNOUNCEMENT_KEY, EXIE_ANNOUNCEMENT_VERSION, 'feature-announcement');
+        await startTour('meet-exie', 'feature-announcement');
+    }
+
+    async function onExieAnnouncementDismiss(): Promise<void> {
+        try {
+            await recordProgress(EXIE_ANNOUNCEMENT_KEY, EXIE_ANNOUNCEMENT_VERSION, 'dismissed');
+        } catch {
+            toast.error('We could not save the Exie announcement preference. Please try again.');
+            return;
+        }
+
+        exieAnnouncementOpen = false;
+        void track('announcement-dismissed', EXIE_ANNOUNCEMENT_KEY, EXIE_ANNOUNCEMENT_VERSION, 'feature-announcement');
+    }
+
+    async function onWelcomeSkip(): Promise<void> {
+        try {
+            await recordProgress('welcome', WELCOME_VERSION, 'dismissed');
+        } catch {
+            toast.error('We could not save your guided-tour preference. Please try again.');
+            return;
+        }
+
+        welcomeHandled = true;
+        welcomeOpen = false;
+        void track('chooser-skipped', 'welcome', WELCOME_VERSION, 'automatic');
+    }
+
+    function onWelcomeBrowse(): void {
+        welcomeHandled = true;
+        welcomeBrowsePending = true;
+        welcomeOpen = false;
+        openCatalog('catalog');
+    }
+
+    async function confirmNavigation(): Promise<void> {
+        const confirmation = pendingConfirmation;
+        pendingConfirmation = undefined;
+        if (confirmation) {
+            await executeStartAction(confirmation.id, confirmation.source, {
+                destination: confirmation.action.destination,
+                type: 'navigate'
+            });
+        }
+    }
+
+    async function completeTour(id: ProductTourId, version: number, source: ProductTourLaunchSource): Promise<boolean> {
+        driverTransition = 'finishing';
+        try {
+            await recordProgress(id, version, 'completed');
+        } catch {
+            driverTransition = 'active';
+            toast.error('We could not save your guided-tour progress. Please try again.');
+            return false;
+        }
+
+        clearProductTourSession();
+        void track('completed', id, version, source);
+        driverInstance?.destroy();
+        productTourHost.clear();
+        driverTransition = 'active';
+        return true;
+    }
+
+    async function dismissTour(id: ProductTourId, version: number, source: ProductTourLaunchSource): Promise<void> {
+        driverTransition = 'finishing';
+        clearProductTourSession();
+        await recordProgress(id, version, 'dismissed').catch(() => toast.error('We could not save your guided-tour progress.'));
+        void track('dismissed', id, version, source, productTourHost.activeStepId);
+        driverInstance?.destroy();
+        productTourHost.clear();
+        driverTransition = 'active';
+    }
+
+    async function failTour(id: ProductTourId, version: number, stepId: string, source: ProductTourLaunchSource): Promise<void> {
+        driverTransition = 'finishing';
+        clearProductTourSession();
+        void track('failed', id, version, source, stepId);
+        toast.error('This guide could not find the next screen. You can restart it from Guided Tours.');
+        driverInstance?.destroy();
+        productTourHost.clear();
+        driverTransition = 'active';
+    }
+
+    function stopActiveTour(clearSession: boolean): void {
+        driverTransition = 'finishing';
+        if (clearSession) {
+            clearProductTourSession();
+        }
+
+        driverInstance?.destroy();
+        productTourHost.clear();
+        driverTransition = 'active';
+    }
+
+    async function recordProgress(key: string, version: number, status: 'completed' | 'dismissed'): Promise<void> {
+        await progressMutation.mutateAsync({
+            progress: {
+                status,
+                version
+            },
+            tourId: key
+        });
+    }
+
+    async function track(
+        event: ProductTourTelemetryEvent,
+        id: ProductTourKey,
+        version: number,
+        source: ProductTourLaunchSource,
+        stepId?: string
+    ): Promise<void> {
+        await submitFeatureUsage(buildProductTourTelemetryEvent(event, id, version, source, stepId)).catch(() => undefined);
+    }
+
+    async function onDomainComplete(id: ProductTourId): Promise<boolean> {
+        if (productTourHost.activeTourId !== id || !productTourHost.source) {
+            return true;
+        }
+
+        const definition = getProductTour(id);
+        return completeTour(id, definition.version, productTourHost.source);
+    }
+
+    function onDomainDismiss(id: ProductTourId): void {
+        if (productTourHost.activeTourId !== id || !productTourHost.source) {
+            return;
+        }
+
+        const definition = getProductTour(id);
+        void dismissTour(id, definition.version, productTourHost.source);
+    }
+
+    function onInlineAdvance(id: ProductTourId, stepId: string): void {
+        if (productTourHost.activeTourId !== id || productTourHost.activeStepId !== stepId || !productTourHost.source) {
+            return;
+        }
+
+        const definition = getProductTour(id);
+        const steps = definition.getSteps(context).filter((step) => !step.optional || !step.anchor || hasVisibleTarget(productTourSelector(step.anchor)));
+        const index = steps.findIndex((step) => step.id === stepId);
+        if (index >= 0) {
+            void advance(id, definition.version, productTourHost.source, steps, index);
+        }
+    }
+
+    function onEventOpened(eventType?: string): void {
+        const stored = readProductTourSession();
+        const isActiveChooseError =
+            productTourHost.activeTourId === 'investigate-error' && productTourHost.activeStepId === 'choose-error' && !!productTourHost.source;
+        const isResumableChooseError = stored?.tourId === 'investigate-error' && stored.stepId === 'choose-error';
+        if (eventType !== 'error' || (!isActiveChooseError && !isResumableChooseError)) {
+            if (productTourHost.activeTourId === 'investigate-error' && eventType && eventType !== 'error') {
+                toast.info('Choose an error event to continue this guide.');
+            }
+
+            return;
+        }
+
+        const definition = getProductTour('investigate-error');
+        if (!isActiveChooseError && stored) {
+            productTourHost.set('investigate-error', 'choose-error', stored.source, organizationId);
+        }
+
+        const source = productTourHost.source ?? stored?.source;
+        if (!source) {
+            return;
+        }
+
+        const steps = definition.getSteps(context).filter((step) => !step.optional || !step.anchor || hasVisibleTarget(productTourSelector(step.anchor)));
+        const index = steps.findIndex((step) => step.id === 'choose-error');
+        if (index >= 0) {
+            productTourHost.set('investigate-error', 'stack-summary', source, organizationId);
+            writeProductTourSession({
+                source,
+                stepId: 'stack-summary',
+                tourId: 'investigate-error',
+                version: definition.version
+            });
+            void advance('investigate-error', definition.version, source, steps, index);
+        }
+    }
+
+    function onHostEvent(event: ProductTourHostEvent): boolean | Promise<boolean | void> | void {
+        switch (event.type) {
+            case 'advance':
+                onInlineAdvance(event.tourId, event.stepId);
+                break;
+            case 'completed':
+                return onDomainComplete(event.tourId);
+            case 'dismissed':
+                onDomainDismiss(event.tourId);
+                break;
+            case 'event-opened':
+                onEventOpened(event.eventType);
+                break;
+        }
+    }
+
+    onMount(() => {
+        const unsubscribe = productTourHost.subscribe(onHostEvent);
+        return () => {
+            unsubscribe();
+            stopActiveTour(true);
+        };
+    });
+</script>
+
+<ProductTourWelcome
+    bind:open={welcomeOpen}
+    onBrowse={onWelcomeBrowse}
+    onSkip={() => void onWelcomeSkip()}
+    onStart={() => void onWelcomeStart()}
+    {recommended}
+/>
+
+{#if exieAnnouncementOpen && assistantAccess}
+    <ProductTourFeatureAnnouncement
+        hasAccess={assistantAccess.has_access}
+        message={assistantAccess.message}
+        onDismiss={() => void onExieAnnouncementDismiss()}
+        onStart={() => void onExieAnnouncementStart()}
+    />
+{/if}
+
+<ProductTourCatalog bind:open={catalogOpen} {items} onStart={(id) => void startTour(id, catalogSource)} />
+
+{#if pendingConfirmation}
+    <AlertDialog.Root
+        open
+        onOpenChange={(open) => {
+            if (!open) {
+                pendingConfirmation = undefined;
+            }
+        }}
+    >
+        <AlertDialog.Content data-product-tour-overlay>
+            <AlertDialog.Header>
+                <AlertDialog.Title>{pendingConfirmation.action.title}</AlertDialog.Title>
+                <AlertDialog.Description>{pendingConfirmation.action.description}</AlertDialog.Description>
+            </AlertDialog.Header>
+            <AlertDialog.Footer>
+                <AlertDialog.Cancel>Cancel</AlertDialog.Cancel>
+                <AlertDialog.Action onclick={() => void confirmNavigation()}>{pendingConfirmation.action.actionLabel}</AlertDialog.Action>
+            </AlertDialog.Footer>
+        </AlertDialog.Content>
+    </AlertDialog.Root>
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.test.ts
new file mode 100644
index 0000000000..eed9c6af2a
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.test.ts
@@ -0,0 +1,24 @@
+import { ProductTourStatus } from '$generated/api';
+import { describe, expect, it } from 'vitest';
+
+import { shouldOfferProductTourAnnouncement, shouldOfferProductTourWelcome } from './eligibility';
+
+describe('product tour welcome eligibility', () => {
+    it('offers legacy users and a newer welcome version', () => {
+        expect(shouldOfferProductTourWelcome(undefined, 1)).toBe(true);
+        expect(shouldOfferProductTourWelcome({ status: ProductTourStatus.Completed, updated_utc: '', version: 1 }, 2)).toBe(true);
+    });
+
+    it('suppresses both explicit Start and Skip outcomes for the current version', () => {
+        expect(shouldOfferProductTourWelcome({ status: ProductTourStatus.Completed, updated_utc: '', version: 1 }, 1)).toBe(false);
+        expect(shouldOfferProductTourWelcome({ status: ProductTourStatus.Dismissed, updated_utc: '', version: 1 }, 1)).toBe(false);
+    });
+});
+
+describe('product tour feature announcement eligibility', () => {
+    it('offers a new announcement version until explicitly recorded', () => {
+        expect(shouldOfferProductTourAnnouncement(undefined, 1)).toBe(true);
+        expect(shouldOfferProductTourAnnouncement({ status: ProductTourStatus.Dismissed, updated_utc: '', version: 1 }, 1)).toBe(false);
+        expect(shouldOfferProductTourAnnouncement({ status: ProductTourStatus.Completed, updated_utc: '', version: 2 }, 1)).toBe(false);
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.ts
new file mode 100644
index 0000000000..6967783729
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.ts
@@ -0,0 +1,9 @@
+import type { ProductTourProgress } from '$features/users/models';
+
+export function shouldOfferProductTourAnnouncement(progress: ProductTourProgress | undefined, announcementVersion: number): boolean {
+    return !progress || progress.version < announcementVersion;
+}
+
+export function shouldOfferProductTourWelcome(progress: ProductTourProgress | undefined, welcomeVersion: number): boolean {
+    return !progress || progress.version < welcomeVersion;
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/product-tours.css b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/product-tours.css
new file mode 100644
index 0000000000..dd0469df68
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/product-tours.css
@@ -0,0 +1,44 @@
+.driver-popover.product-tour-popover {
+    background: var(--popover);
+    color: var(--popover-foreground);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    box-shadow: 0 10px 25px color-mix(in srgb, var(--foreground) 12%, transparent);
+    font-family: var(--font-sans);
+    max-width: 22rem;
+}
+
+.product-tour-popover .driver-popover-title {
+    font-size: 0.95rem;
+    font-weight: 600;
+}
+
+.product-tour-popover .driver-popover-description,
+.product-tour-popover .driver-popover-progress-text {
+    color: var(--muted-foreground);
+}
+
+.product-tour-popover .driver-popover-footer button {
+    border: 1px solid var(--border);
+    border-radius: calc(var(--radius) - 2px);
+    box-shadow: none;
+    text-shadow: none;
+}
+
+/* Driver disables pointer events outside the active spotlight. Select menus are portaled
+   to the document body, so keep an open menu interactive while a tour is running. */
+.driver-active [data-slot='select-content'],
+.driver-active [data-slot='select-content'] * {
+    pointer-events: auto;
+}
+
+.driver-active [data-slot='select-content'] {
+    z-index: 10001 !important;
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .driver-overlay,
+    .driver-popover {
+        transition: none !important;
+    }
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.test.ts
new file mode 100644
index 0000000000..53221790d7
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { clearProductTourSession, readProductTourSession, writeProductTourSession } from './session';
+
+describe('product tour session', () => {
+    it('round-trips stable resume state', () => {
+        let value: null | string = null;
+        const storage = {
+            getItem: () => value,
+            removeItem: vi.fn(() => (value = null)),
+            setItem: vi.fn((_key: string, next: string) => (value = next))
+        };
+        const session = { source: 'command-palette', stepId: 'choose-error', tourId: 'investigate-error', version: 1 } as const;
+
+        writeProductTourSession(session, storage);
+        expect(readProductTourSession(storage)).toEqual(session);
+        clearProductTourSession(storage);
+        expect(value).toBeNull();
+    });
+
+    it('clears malformed state instead of blocking future guides', () => {
+        const removeItem = vi.fn();
+        const storage = { getItem: () => '{not-json', removeItem };
+
+        expect(readProductTourSession(storage)).toBeUndefined();
+        expect(removeItem).toHaveBeenCalledOnce();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.ts
new file mode 100644
index 0000000000..7f618048b8
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.ts
@@ -0,0 +1,28 @@
+import type { ProductTourId, ProductTourLaunchSource } from './types';
+
+export interface StoredProductTourSession {
+    source: ProductTourLaunchSource;
+    stepId?: string;
+    tourId: ProductTourId;
+    version: number;
+}
+
+const SESSION_KEY = 'exceptionless.product-tour';
+
+export function clearProductTourSession(storage: Pick<Storage, 'removeItem'> = sessionStorage): void {
+    storage.removeItem(SESSION_KEY);
+}
+
+export function readProductTourSession(storage: Pick<Storage, 'getItem' | 'removeItem'> = sessionStorage): StoredProductTourSession | undefined {
+    try {
+        const value = storage.getItem(SESSION_KEY);
+        return value ? (JSON.parse(value) as StoredProductTourSession) : undefined;
+    } catch {
+        clearProductTourSession(storage);
+        return undefined;
+    }
+}
+
+export function writeProductTourSession(session: StoredProductTourSession, storage: Pick<Storage, 'setItem'> = sessionStorage): void {
+    storage.setItem(SESSION_KEY, JSON.stringify(session));
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.test.ts
new file mode 100644
index 0000000000..817f11a1b8
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { productTourHost } from './state.svelte';
+
+describe('product tour host', () => {
+    it('waits for completion listeners before resolving', async () => {
+        let finishPersistence: () => void = () => undefined;
+        const persistence = new Promise<void>((resolve) => (finishPersistence = resolve));
+        let persisted = false;
+        const unsubscribe = productTourHost.subscribe(async () => {
+            await persistence;
+            persisted = true;
+        });
+
+        try {
+            const completion = productTourHost.complete('configure-project');
+            await Promise.resolve();
+            expect(persisted).toBe(false);
+
+            finishPersistence();
+            expect(await completion).toBe(true);
+            expect(persisted).toBe(true);
+        } finally {
+            unsubscribe();
+        }
+    });
+
+    it('propagates completion listener failures', async () => {
+        const unsubscribe = productTourHost.subscribe(() => false);
+
+        try {
+            await expect(productTourHost.complete('configure-project')).resolves.toBe(false);
+        } finally {
+            unsubscribe();
+        }
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.ts
new file mode 100644
index 0000000000..8d36962e3d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.ts
@@ -0,0 +1,100 @@
+import type { ProductTourId, ProductTourLaunchSource } from './types';
+
+export type ProductTourHostEvent =
+    | { eventType?: string; type: 'event-opened' }
+    | { stepId: string; tourId: ProductTourId; type: 'advance' }
+    | { tourId: ProductTourId; type: 'completed' | 'dismissed' };
+
+type ProductTourHostListener = (event: ProductTourHostEvent) => boolean | Promise<boolean | void> | void;
+
+class ProductTourHost {
+    get activeStepId(): string | undefined {
+        return this.session?.stepId;
+    }
+    get activeTourId(): ProductTourId | undefined {
+        return this.session?.tourId;
+    }
+
+    get organizationId(): string | undefined {
+        return this.session?.organizationId;
+    }
+
+    get source(): ProductTourLaunchSource | undefined {
+        return this.session?.source;
+    }
+
+    private readonly listeners = new Set<ProductTourHostListener>();
+
+    private session = $state<{
+        organizationId?: string;
+        source: ProductTourLaunchSource;
+        stepId?: string;
+        tourId: ProductTourId;
+    }>();
+
+    advance(tourId: ProductTourId, stepId: string): void {
+        this.publish({
+            stepId,
+            tourId,
+            type: 'advance'
+        });
+    }
+
+    clear(): void {
+        this.session = undefined;
+    }
+
+    async complete(tourId: ProductTourId): Promise<boolean> {
+        const event: ProductTourHostEvent = {
+            tourId,
+            type: 'completed'
+        };
+        const results = await Promise.all([...this.listeners].map((listener) => listener(event)));
+        return results.every((result) => result !== false);
+    }
+
+    dismiss(tourId: ProductTourId): void {
+        this.publish({
+            tourId,
+            type: 'dismissed'
+        });
+    }
+
+    eventOpened(eventType?: string): void {
+        this.publish({
+            eventType,
+            type: 'event-opened'
+        });
+    }
+
+    isActive(tourId: ProductTourId): boolean {
+        return this.activeTourId === tourId;
+    }
+
+    set(tourId: ProductTourId, stepId: string | undefined, source?: ProductTourLaunchSource, organizationId?: string): void {
+        const activeSource = source ?? this.session?.source;
+        if (!activeSource) {
+            throw new Error('A product tour session requires a launch source.');
+        }
+
+        this.session = {
+            organizationId: organizationId ?? this.session?.organizationId,
+            source: activeSource,
+            stepId,
+            tourId
+        };
+    }
+
+    subscribe(listener: ProductTourHostListener): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+
+    private publish(event: ProductTourHostEvent): void {
+        for (const listener of this.listeners) {
+            void listener(event);
+        }
+    }
+}
+
+export const productTourHost = new ProductTourHost();
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.test.ts
new file mode 100644
index 0000000000..3021de3d1c
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildProductTourTelemetryEvent } from './telemetry';
+
+describe('product tour telemetry', () => {
+    it('uses stable catalog metadata only', () => {
+        expect(buildProductTourTelemetryEvent('step', 'new-ui-overview', 1, 'command-palette', 'command-search')).toBe(
+            'product-tour.step.new-ui-overview.v1.command-palette.command-search'
+        );
+        expect(buildProductTourTelemetryEvent('announcement-started', 'exie-announcement', 1, 'feature-announcement')).toBe(
+            'product-tour.announcement-started.exie-announcement.v1.feature-announcement'
+        );
+    });
+
+    it('rejects resource data and invalid versions', () => {
+        expect(() => buildProductTourTelemetryEvent('step', 'new-ui-overview', 1, 'catalog', 'Customer Project' as never)).toThrow();
+        expect(() => buildProductTourTelemetryEvent('started', 'meet-exie', 0, 'catalog')).toThrow();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.ts
new file mode 100644
index 0000000000..bda21db74a
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.ts
@@ -0,0 +1,34 @@
+import type { ProductTourKey, ProductTourLaunchSource } from './types';
+
+export type ProductTourTelemetryEvent =
+    | 'announcement-dismissed'
+    | 'announcement-shown'
+    | 'announcement-started'
+    | 'chooser-shown'
+    | 'chooser-skipped'
+    | 'chooser-started'
+    | 'completed'
+    | 'dismissed'
+    | 'failed'
+    | 'started'
+    | 'step';
+
+const SAFE_SEGMENT = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export function buildProductTourTelemetryEvent(
+    event: ProductTourTelemetryEvent,
+    id: ProductTourKey,
+    version: number,
+    source: ProductTourLaunchSource,
+    stepId?: string
+): string {
+    if (!SAFE_SEGMENT.test(event) || !SAFE_SEGMENT.test(id) || !SAFE_SEGMENT.test(source) || (stepId && !SAFE_SEGMENT.test(stepId))) {
+        throw new Error('Product tour telemetry accepts stable catalog identifiers only.');
+    }
+
+    if (!Number.isSafeInteger(version) || version < 1) {
+        throw new Error('Product tour telemetry requires a positive version.');
+    }
+
+    return ['product-tour', event, id, `v${version}`, source, stepId].filter(Boolean).join('.');
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/types.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/types.ts
new file mode 100644
index 0000000000..4c42586ee4
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/types.ts
@@ -0,0 +1,57 @@
+import type { AssistantAccess } from '$features/assistant/models';
+import type { ViewProject } from '$features/projects/models';
+import type { ProductTourProgress } from '$features/users/models';
+
+export interface ProductTourAvailability {
+    available: boolean;
+    reason?: string;
+}
+export interface ProductTourContext {
+    assistantAccess?: AssistantAccess;
+    errorEventAvailability: ProductTourErrorEventAvailability;
+    isSetupPage: boolean;
+    openEventType?: string;
+    organizationId?: string;
+    pathname: string;
+    projects: ViewProject[];
+}
+export interface ProductTourDefinition {
+    description: string;
+    getAvailability: (context: ProductTourContext) => ProductTourAvailability;
+    getStartAction?: (context: ProductTourContext) => ProductTourStartAction;
+    getSteps: (context: ProductTourContext) => ProductTourStep[];
+    id: ProductTourId;
+    keywords: readonly string[];
+    title: string;
+    version: number;
+}
+export type ProductTourErrorEventAvailability = 'available' | 'empty' | 'error' | 'loading';
+export type ProductTourId = 'configure-project' | 'create-saved-view' | 'investigate-error' | 'meet-exie' | 'new-ui-overview';
+export type ProductTourKey = 'exie-announcement' | 'welcome' | ProductTourId;
+
+export type ProductTourLaunchSource = 'automatic' | 'catalog' | 'command-palette' | 'feature-announcement' | 'help-menu';
+
+export interface ProductTourListItem extends ProductTourDefinition {
+    availability: ProductTourAvailability;
+    progress?: ProductTourProgress;
+}
+
+export type ProductTourPresentation = 'inline' | 'spotlight';
+
+export type ProductTourStartAction =
+    | { actionLabel: string; description: string; destination: string; title: string; type: 'confirm-navigation' }
+    | { destination: string; type: 'navigate' }
+    | { stepId?: string; type: 'launch' };
+
+export interface ProductTourStep {
+    advanceOnClick?: boolean;
+    anchor?: string;
+    description: string;
+    id: string;
+    optional?: boolean;
+    presentation?: ProductTourPresentation;
+    resumeStepId?: string;
+    showDone?: boolean;
+    title: string;
+    waitForElement?: number;
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/api.svelte.ts
index 7dd981b258..be01c26312 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/api.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/api.svelte.ts
@@ -135,7 +135,11 @@ export function getSavedViewsByViewQuery(request: { route: { organizationId: str
         enabled: () => !!accessToken.current && !!request.route.organizationId && !!request.route.view,
         queryFn: async () => {
             const client = useFetchClient();
-            const response = await client.getJSON<SavedView[]>(`organizations/${request.route.organizationId}/saved-views/${request.route.view}`);
+            const response = await client.getJSON<SavedView[]>(`organizations/${request.route.organizationId}/saved-views/${request.route.view}`, {
+                params: {
+                    limit: 1000
+                }
+            });
             return response.data!;
         },
         queryKey: queryKeys.view(request.route.organizationId, request.route.view),
@@ -148,7 +152,11 @@ export function getSavedViewsQuery(request: { route: { organizationId: string |
         enabled: () => !!accessToken.current && !!request.route.organizationId,
         queryFn: async () => {
             const client = useFetchClient();
-            const response = await client.getJSON<SavedView[]>(`organizations/${request.route.organizationId}/saved-views`);
+            const response = await client.getJSON<SavedView[]>(`organizations/${request.route.organizationId}/saved-views`, {
+                params: {
+                    limit: 1000
+                }
+            });
             return response.data!;
         },
         queryKey: queryKeys.organization(request.route.organizationId),
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/save-view-dialog.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/save-view-dialog.svelte
index 95fc6808ec..3fe0029d30 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/save-view-dialog.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/save-view-dialog.svelte
@@ -5,6 +5,8 @@
     import { Input } from '$comp/ui/input';
     import { Label } from '$comp/ui/label';
     import { Switch } from '$comp/ui/switch';
+    import ProductTourInlineCallout from '$features/product-tours/components/product-tour-inline-callout.svelte';
+    import { productTourHost } from '$features/product-tours/state.svelte';
 
     import type { SavedView } from '../models';
 
@@ -19,16 +21,30 @@
     } from '../slugs';
 
     interface Props {
+        defaultPrivate?: boolean;
         duplicateView?: SavedView;
+        onCancel?: () => void;
         onClose: () => void;
-        onLoadView: (view: SavedView) => void;
+        onLoadView: (view: SavedView) => Promise<void> | void;
         onSave: (name: string, slug: string, isPrivate: boolean) => Promise<void>;
         open: boolean;
+        pendingCompletion?: boolean;
         savedViews: SavedView[];
         saving: boolean;
     }
 
-    let { duplicateView, onClose, onLoadView, onSave, open = $bindable(), savedViews, saving }: Props = $props();
+    let {
+        defaultPrivate = false,
+        duplicateView,
+        onCancel,
+        onClose,
+        onLoadView,
+        onSave,
+        open = $bindable(),
+        pendingCompletion = false,
+        savedViews,
+        saving
+    }: Props = $props();
 
     let saveName = $state('');
     let saveSlug = $state('');
@@ -80,14 +96,14 @@
     });
     const visibleNameError = $derived(attemptedSubmit || saveName.length > 0 ? nameError : undefined);
     const visibleSlugError = $derived(attemptedSubmit || saveName.length > 0 || saveSlug.length > 0 ? slugError : undefined);
-    const canSave = $derived(!nameError && !slugError && !saving);
+    const canSave = $derived((pendingCompletion || (!nameError && !slugError)) && !saving);
 
     $effect(() => {
         if (open) {
             saveName = '';
             saveSlug = '';
             isSlugDirty = false;
-            isPrivate = false;
+            isPrivate = defaultPrivate;
             attemptedSubmit = false;
         }
     });
@@ -113,24 +129,71 @@
 
         await onSave(trimmedName, normalizedSlug, isPrivate);
     }
+
+    function dismissTour(): void {
+        onClose();
+        onCancel?.();
+    }
 </script>
 
-<Dialog.Root bind:open>
-    <Dialog.Content class="sm:max-w-100">
+<Dialog.Root
+    {open}
+    onOpenChange={(nextOpen) => {
+        if (nextOpen || !saving) {
+            open = nextOpen;
+            if (!nextOpen) {
+                onCancel?.();
+            }
+        }
+    }}
+>
+    <Dialog.Content
+        class="sm:max-w-100"
+        data-tour="saved-view-dialog"
+        onEscapeKeydown={(event) => saving && event.preventDefault()}
+        onInteractOutside={(event) => saving && event.preventDefault()}
+    >
         <Dialog.Header>
             <Dialog.Title>Save View</Dialog.Title>
             <Dialog.Description>Save the current view configuration for quick access.</Dialog.Description>
         </Dialog.Header>
-        {#if duplicateView}
+        {#if defaultPrivate && productTourHost.activeStepId === 'name-view'}
+            <ProductTourInlineCallout
+                description="Review the current filters, time, display options, and columns. Choose a meaningful name, then continue."
+                onContinue={() => productTourHost.advance('create-saved-view', 'name-view')}
+                onDismiss={dismissTour}
+                title="Review and name your view"
+                tourId="create-saved-view"
+            />
+        {:else if defaultPrivate && productTourHost.activeStepId === 'private-view'}
+            <ProductTourInlineCallout
+                description="Private is enabled for this guide so the practice view is visible only to you. Continue when you are ready to save it."
+                onContinue={() => productTourHost.advance('create-saved-view', 'private-view')}
+                onDismiss={dismissTour}
+                title="Keep it private"
+                tourId="create-saved-view"
+            />
+        {:else if defaultPrivate && productTourHost.activeStepId === 'save-view'}
+            <ProductTourInlineCallout
+                description={pendingCompletion
+                    ? 'The view was created, but the guide could not save its progress. Retry to finish without creating another view.'
+                    : 'Click Save when ready. The guide completes only after the private view is successfully created and loaded.'}
+                onDismiss={dismissTour}
+                title="Create the saved view"
+                tourId="create-saved-view"
+            />
+        {/if}
+        {#if duplicateView && !pendingCompletion}
             <div class="bg-muted rounded-md p-3">
                 <Muted>
                     Current filters match <strong>"{duplicateView.name}"</strong>. You can
                     <Button
                         variant="link"
                         class="h-auto p-0 text-sm"
-                        onclick={() => {
+                        onclick={async () => {
                             open = false;
-                            onLoadView(duplicateView);
+                            await onLoadView(duplicateView);
+                            onCancel?.();
                         }}>load it</Button
                     > instead, or save with a different name.
                 </Muted>
@@ -146,6 +209,7 @@
             <div class="flex flex-col gap-2">
                 <Label for="view-name">Name</Label>
                 <Input
+                    data-tour="saved-view-name"
                     id="view-name"
                     bind:value={saveName}
                     placeholder="e.g., Production Errors"
@@ -154,6 +218,7 @@
                     aria-describedby={visibleNameError ? 'view-name-error' : undefined}
                     required
                     autofocus
+                    disabled={pendingCompletion}
                 />
                 {#if visibleNameError}
                     <p id="view-name-error" class="text-destructive text-sm">{visibleNameError}</p>
@@ -169,6 +234,7 @@
                     aria-invalid={!!visibleSlugError}
                     aria-describedby={visibleSlugError ? 'view-slug-error' : undefined}
                     required
+                    disabled={pendingCompletion}
                     oninput={() => {
                         isSlugDirty = true;
                     }}
@@ -177,17 +243,24 @@
                     <p id="view-slug-error" class="text-destructive text-sm">{visibleSlugError}</p>
                 {/if}
             </div>
-            <div class="flex items-center justify-between">
+            <div class="flex items-center justify-between" data-tour="saved-view-private">
                 <div>
                     <Label for="view-private" class="text-sm">Private</Label>
-                    <Muted>Only visible to you</Muted>
+                    <Muted>{defaultPrivate ? 'Required for this guided practice view' : 'Only visible to you'}</Muted>
                 </div>
-                <Switch id="view-private" bind:checked={isPrivate} />
+                <Switch disabled={defaultPrivate || pendingCompletion} id="view-private" bind:checked={isPrivate} />
             </div>
             <Dialog.Footer>
-                <Button variant="outline" onclick={onClose}>Cancel</Button>
-                <Button type="submit" disabled={!canSave}>
-                    {saving ? 'Saving...' : 'Save'}
+                <Button
+                    variant="outline"
+                    disabled={saving}
+                    onclick={() => {
+                        onClose();
+                        onCancel?.();
+                    }}>Cancel</Button
+                >
+                <Button data-tour="saved-view-submit" type="submit" disabled={!canSave}>
+                    {saving ? 'Saving...' : pendingCompletion ? 'Retry guide completion' : 'Save'}
                 </Button>
             </Dialog.Footer>
         </form>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/saved-view-picker.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/saved-view-picker.svelte
index 9287293041..da448df149 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/saved-view-picker.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/components/saved-view-picker.svelte
@@ -14,6 +14,7 @@
     import { toFilter } from '$features/events/components/filters/helpers.svelte';
     import { serializeFilters } from '$features/events/components/filters/helpers.svelte';
     import { organization } from '$features/organizations/context.svelte';
+    import { productTourHost } from '$features/product-tours/state.svelte';
     import Columns3 from '@lucide/svelte/icons/columns-3';
     import Pencil from '@lucide/svelte/icons/pencil';
     import Plus from '@lucide/svelte/icons/plus';
@@ -54,8 +55,9 @@
         filters: IFilter[];
         isModified: boolean;
         onClearSavedView: () => void;
-        onLoadView: (view: SavedView) => void;
+        onLoadView: (view: SavedView) => Promise<void> | void;
         onResetToSaved: () => void;
+        onSavedViewCreated?: (view: SavedView) => Promise<void> | void;
         savedViews: SavedView[];
         setAutoFillColumnId: (columnId: AutoFillColumnSelection) => void;
         setShowChart?: (show: boolean) => void;
@@ -80,6 +82,7 @@
         onClearSavedView,
         onLoadView,
         onResetToSaved,
+        onSavedViewCreated,
         savedViews,
         setAutoFillColumnId,
         setShowChart,
@@ -97,6 +100,8 @@
     let isDeleteDialogOpen = $state(false);
     let isColumnDialogOpen = $state(false);
     let isMenuOpen = $state(false);
+    let isCompletingTour = $state(false);
+    let pendingCreatedView = $state<SavedView>();
     let viewToDelete = $state<null | SavedView>(null);
 
     const organizationId = $derived(organization.current);
@@ -123,7 +128,7 @@
         }
     });
 
-    const saving = $derived(createMutation.isPending || updateMutation.isPending || removeMutation.isPending);
+    const saving = $derived(createMutation.isPending || updateMutation.isPending || removeMutation.isPending || isCompletingTour);
     const currentFilterString = $derived(toFilter(filters.filter((f) => f.type !== 'date')));
 
     // Auto-detect if current filters match an existing saved view for "load existing" hint
@@ -195,7 +200,7 @@
             columns: getSavedColumnSettings(),
             filter: currentFilterString || undefined,
             filter_definitions: filterDefinitions,
-            is_private: isPrivate || undefined,
+            is_private: productTourHost.isActive('create-saved-view') || isPrivate ? true : undefined,
             name,
             organization_id: organizationId,
             show_chart: showChart,
@@ -207,11 +212,25 @@
         };
 
         try {
-            const result = await createMutation.mutateAsync(body);
+            const result = pendingCreatedView ?? (await createMutation.mutateAsync(body));
+            if (!pendingCreatedView) {
+                await onSavedViewCreated?.(result);
+            }
+
+            isCompletingTour = true;
+            const completed = await productTourHost.complete('create-saved-view');
+            isCompletingTour = false;
+            if (!completed) {
+                pendingCreatedView = result;
+                return;
+            }
+
+            pendingCreatedView = undefined;
             isSaveDialogOpen = false;
-            onLoadView(result);
+            await onLoadView(result);
             toast.success(`Saved view "${result.name}" created.`);
         } catch (error) {
+            isCompletingTour = false;
             toast.error(getErrorMessage(error, 'Failed to save view. Please try again.'));
         }
     }
@@ -291,7 +310,7 @@
 <DropdownMenu.Root bind:open={isMenuOpen}>
     <DropdownMenu.Trigger>
         {#snippet child({ props })}
-            <Button {...props} class="relative gap-x-1.5 px-3" size="lg" variant="outline" title="Manage View Settings">
+            <Button {...props} class="relative gap-x-1.5 px-3" data-tour="saved-view-trigger" size="lg" variant="outline" title="Manage View Settings">
                 <SlidersHorizontal class="size-4" aria-hidden="true" />
                 <span>View</span>
                 {#if isModified}
@@ -300,7 +319,7 @@
             </Button>
         {/snippet}
     </DropdownMenu.Trigger>
-    <DropdownMenu.Content align="end" class="w-64">
+    <DropdownMenu.Content align="end" class="w-64" data-tour="saved-view-settings">
         <DropdownMenu.Group>
             <DropdownMenu.Label>Saved View</DropdownMenu.Label>
             {#if activeView}
@@ -309,7 +328,7 @@
                     Save
                 </DropdownMenu.Item>
             {/if}
-            <DropdownMenu.Item disabled={saving} onclick={openSaveDialog}>
+            <DropdownMenu.Item data-tour="saved-view-save-as" disabled={saving} onclick={openSaveDialog}>
                 <Plus class="mr-2 size-4" aria-hidden="true" />
                 Save As...
             </DropdownMenu.Item>
@@ -377,8 +396,16 @@
         {duplicateView}
         {savedViews}
         {saving}
+        defaultPrivate={productTourHost.isActive('create-saved-view')}
+        pendingCompletion={!!pendingCreatedView}
         onSave={handleSave}
         onClose={() => (isSaveDialogOpen = false)}
+        onCancel={() => {
+            pendingCreatedView = undefined;
+            if (productTourHost.isActive('create-saved-view')) {
+                productTourHost.dismiss('create-saved-view');
+            }
+        }}
         {onLoadView}
     />
 {/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/use-saved-views.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/use-saved-views.svelte.ts
index 59627e249f..22162b905d 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/use-saved-views.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/saved-views/use-saved-views.svelte.ts
@@ -345,9 +345,9 @@ export function useSavedViews(options: UseSavedViewsOptions): UseSavedViewsRetur
         })
     );
 
-    function handleLoadView(view: SavedView) {
+    async function handleLoadView(view: SavedView): Promise<void> {
         if (options.baseHref) {
-            goto(savedViewHref(view));
+            await goto(savedViewHref(view));
             return;
         }
 
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/shared/components/ui/sidebar/sidebar.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/shared/components/ui/sidebar/sidebar.svelte
index a4122d895a..ce02f11c3f 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/shared/components/ui/sidebar/sidebar.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/shared/components/ui/sidebar/sidebar.svelte
@@ -40,6 +40,7 @@
 	>
 		<Sheet.Content
 			bind:ref
+			data-tour="app-navigation"
 			data-sidebar="sidebar"
 			data-slot="sidebar"
 			data-mobile="true"
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/stacks/components/stack-card.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/stacks/components/stack-card.svelte
index d501ced127..0921bae731 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/stacks/components/stack-card.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/stacks/components/stack-card.svelte
@@ -184,10 +184,12 @@
                 <div class="ml-2 flex shrink-0 items-center gap-2">
                     <StackLogLevel {stack} />
                     <AssistantFixButton {prepareContext} resource={assistantResource} />
-                    <ButtonGroup.Root>
-                        <StackStatusDropdownMenu {stack} />
-                        <StackOptionsDropdownMenu {onDeleted} {stack} />
-                    </ButtonGroup.Root>
+                    <div data-tour="event-stack-triage">
+                        <ButtonGroup.Root>
+                            <StackStatusDropdownMenu {stack} />
+                            <StackOptionsDropdownMenu {onDeleted} {stack} />
+                        </ButtonGroup.Root>
+                    </div>
                 </div>
             </Card.Title>
         </Card.Header>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/users/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/users/api.svelte.ts
index e1b2055359..553ac1fc35 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/users/api.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/users/api.svelte.ts
@@ -7,7 +7,7 @@ import { fetchApiJson } from '$features/shared/api/api.svelte';
 import { type FetchClientResponse, ProblemDetails, useFetchClient } from '@foundatiofx/fetchclient';
 import { createMutation, createQuery, QueryClient, useQueryClient } from '@tanstack/svelte-query';
 
-import type { OAuthGrant, UpdateEmailAddressResult, UpdateUser, UpdateUserEmailAddress, ViewCurrentUser, ViewUser } from './models';
+import type { OAuthGrant, UpdateEmailAddressResult, UpdateProductTourProgress, UpdateUser, UpdateUserEmailAddress, ViewCurrentUser, ViewUser } from './models';
 
 export async function invalidateUserQueries(queryClient: QueryClient, message: WebSocketMessageValue<'UserChanged'>) {
     const { id } = message;
@@ -41,6 +41,7 @@ export const queryKeys = {
     organization: (id: string | undefined) => [...queryKeys.type, 'organization', id] as const,
     patchUser: (id: string | undefined) => [...queryKeys.id(id), 'patch'] as const,
     postEmailAddress: (id: string | undefined) => [...queryKeys.idEmailAddress(id), 'update'] as const,
+    productTour: () => [...queryKeys.me(), 'product-tour'] as const,
     type: ['User'] as const
 };
 
@@ -260,6 +261,28 @@ export function postEmailAddress(request: PostEmailAddressRequest) {
     }));
 }
 
+export function putCurrentUserProductTour() {
+    const queryClient = useQueryClient();
+    return createMutation<ViewCurrentUser, ProblemDetails, { progress: UpdateProductTourProgress; tourId: string }>(() => ({
+        enabled: () => !!accessToken.current,
+        mutationFn: async ({ progress, tourId }) => {
+            const client = useFetchClient();
+            const response = await client.putJSON<ViewCurrentUser>(`users/me/product-tours/${tourId}`, progress);
+            return response.data!;
+        },
+        mutationKey: queryKeys.productTour(),
+        onError: () => {
+            queryClient.invalidateQueries({
+                queryKey: queryKeys.me()
+            });
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(queryKeys.me(), data);
+            queryClient.setQueryData(queryKeys.id(data.id), data);
+        }
+    }));
+}
+
 export function resendVerificationEmail(request: ResendVerificationEmailRequest) {
     return createMutation<void, ProblemDetails, void>(() => ({
         enabled: () => !!accessToken.current && !!request.route.id,
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts
index a262d71122..3a41ba510e 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts
@@ -1,9 +1,20 @@
-export type { ViewOAuthGrant as OAuthGrant, UpdateEmailAddressResult, ViewCurrentUser, ViewUser } from '$generated/api';
+import type { ProductTourProgress as GeneratedProductTourProgress, ViewCurrentUser as GeneratedViewCurrentUser } from '$generated/api';
+
+export type { ViewOAuthGrant as OAuthGrant, UpdateEmailAddressResult, ViewUser } from '$generated/api';
 
 export interface InviteUserForm {
     email: string;
 }
 
+export type ProductTourProgress = GeneratedProductTourProgress;
+
+export type ProductTourStatus = 'completed' | 'dismissed';
+
+export interface UpdateProductTourProgress {
+    status: ProductTourStatus;
+    version: number;
+}
+
 export interface UpdateUser {
     email_notifications_enabled?: boolean;
     full_name?: string;
@@ -12,3 +23,5 @@ export interface UpdateUser {
 export interface UpdateUserEmailAddress {
     email_address: string;
 }
+
+export type ViewCurrentUser = GeneratedViewCurrentUser;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
index 2411510e46..f44891da73 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
@@ -7,6 +7,11 @@ export enum StackStatus {
   Discarded = "discarded",
 }
 
+export enum ProductTourStatus {
+  Dismissed = "dismissed",
+  Completed = "completed",
+}
+
 export enum BillingStatus {
   Trialing = 0,
   Active = 1,
@@ -15,6 +20,84 @@ export enum BillingStatus {
   Unpaid = 4,
 }
 
+export interface AdminAssistantOrganizationUsage {
+  organization_id: string;
+  organization_name: string;
+  plan_id: string;
+  /** @format date-time */
+  last_used_utc: string;
+  /** @format int64 */
+  turns: number;
+  /** @format int64 */
+  completed: number;
+  /** @format int64 */
+  failed: number;
+  /** @format int64 */
+  cancelled: number;
+  /** @format int64 */
+  provider_requests: number;
+  /** @format int64 */
+  tool_calls: number;
+  /** @format int64 */
+  prompt_tokens: number;
+  /** @format int64 */
+  completion_tokens: number;
+  /** @format double */
+  cost_usd: number;
+  /** @format int64 */
+  blocked_by_concurrency: number;
+  /** @format int64 */
+  blocked_by_rate_limit: number;
+  /** @format int64 */
+  blocked_by_token_limit: number;
+  /** @format int64 */
+  blocked_by_cost_limit: number;
+  /** @format int64 */
+  monthly_token_limit?: null | number;
+  /** @format double */
+  monthly_cost_limit_usd?: null | number;
+  /** @format double */
+  token_utilization?: null | number;
+  /** @format double */
+  cost_utilization?: null | number;
+}
+
+export interface AdminAssistantUsageResponse {
+  /** @format date-time */
+  month: string;
+  /** @format int64 */
+  active_organizations: number;
+  /** @format int64 */
+  turns: number;
+  /** @format int64 */
+  prompt_tokens: number;
+  /** @format int64 */
+  completion_tokens: number;
+  /** @format double */
+  cost_usd: number;
+  organizations: AdminAssistantOrganizationUsage[];
+}
+
+export interface AssistantAccessResponse {
+  enabled: boolean;
+  has_access: boolean;
+  upgrade_required: boolean;
+  message?: null | string;
+}
+
+export interface AssistantChatMessage {
+  role: string;
+  content: string;
+}
+
+export interface AssistantChatRequest {
+  messages: AssistantChatMessage[];
+  organization_id?: null | string;
+  project_id?: null | string;
+  path?: null | string;
+  conversation_id?: null | string;
+}
+
 export interface BillingPlan {
   id: string;
   name: string;
@@ -386,6 +469,14 @@ export interface ProblemDetails {
   instance?: null | string;
 }
 
+export interface ProductTourProgress {
+  /** @format int32 */
+  version: number;
+  status: ProductTourStatus;
+  /** @format date-time */
+  updated_utc: string;
+}
+
 export interface ResetPasswordModel {
   password_reset_token: string;
   password: string;
@@ -526,6 +617,16 @@ export interface UpdateEvent {
   description?: null | string;
 }
 
+export interface UpdateProductTourProgress {
+  /**
+   * @format int32
+   * @min 1
+   * @max 2147483647
+   */
+  version: number;
+  status: ProductTourStatus;
+}
+
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
 export interface UpdateProject {
   name: string;
@@ -604,6 +705,7 @@ export interface User {
   /** @format date-time */
   password_reset_token_expiration: string;
   o_auth_accounts: OAuthAccount[];
+  product_tours: Record<string, ProductTourProgress>;
   /** Gets or sets the users Full Name. */
   full_name: string;
   /** @format email */
@@ -635,6 +737,7 @@ export interface ViewCurrentUser {
   hash?: null | string;
   has_local_account: boolean;
   o_auth_accounts: OAuthAccount[];
+  product_tours: Record<string, ProductTourProgress>;
   /** @pattern ^[a-fA-F0-9]{24}$ */
   id: string;
   organization_ids: string[];
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
index 6be8a910b2..27672cd1f4 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
@@ -27,6 +27,7 @@ export const StackStatusSchema = zodEnum([
   "ignored",
   "discarded",
 ]);
+export const ProductTourStatusSchema = zodEnum(["dismissed", "completed"]);
 export const BillingStatusSchema = union([
   literal(0),
   literal(1),
@@ -35,6 +36,81 @@ export const BillingStatusSchema = union([
   literal(4),
 ]);
 
+export const AdminAssistantOrganizationUsageSchema = object({
+  organization_id: string().min(1, "Organization id is required"),
+  organization_name: string().min(1, "Organization name is required"),
+  plan_id: string().min(1, "Plan id is required"),
+  last_used_utc: iso.datetime(),
+  turns: int(),
+  completed: int(),
+  failed: int(),
+  cancelled: int(),
+  provider_requests: int(),
+  tool_calls: int(),
+  prompt_tokens: int(),
+  completion_tokens: int(),
+  cost_usd: number(),
+  blocked_by_concurrency: int(),
+  blocked_by_rate_limit: int(),
+  blocked_by_token_limit: int(),
+  blocked_by_cost_limit: int(),
+  monthly_token_limit: int().nullable(),
+  monthly_cost_limit_usd: number().nullable(),
+  token_utilization: number().nullable(),
+  cost_utilization: number().nullable(),
+});
+export type AdminAssistantOrganizationUsageFormData = Infer<
+  typeof AdminAssistantOrganizationUsageSchema
+>;
+
+export const AdminAssistantUsageResponseSchema = object({
+  month: iso.datetime(),
+  active_organizations: int(),
+  turns: int(),
+  prompt_tokens: int(),
+  completion_tokens: int(),
+  cost_usd: number(),
+  organizations: array(lazy(() => AdminAssistantOrganizationUsageSchema)),
+});
+export type AdminAssistantUsageResponseFormData = Infer<
+  typeof AdminAssistantUsageResponseSchema
+>;
+
+export const AssistantAccessResponseSchema = object({
+  enabled: boolean(),
+  has_access: boolean(),
+  upgrade_required: boolean(),
+  message: string().min(1, "Message is required").nullable().optional(),
+});
+export type AssistantAccessResponseFormData = Infer<
+  typeof AssistantAccessResponseSchema
+>;
+
+export const AssistantChatMessageSchema = object({
+  role: string().min(1, "Role is required"),
+  content: string().min(1, "Content is required"),
+});
+export type AssistantChatMessageFormData = Infer<
+  typeof AssistantChatMessageSchema
+>;
+
+export const AssistantChatRequestSchema = object({
+  messages: array(lazy(() => AssistantChatMessageSchema)),
+  organization_id: string()
+    .min(1, "Organization id is required")
+    .nullable()
+    .optional(),
+  project_id: string().min(1, "Project id is required").nullable().optional(),
+  path: string().min(1, "Path is required").nullable().optional(),
+  conversation_id: string()
+    .min(1, "Conversation id is required")
+    .nullable()
+    .optional(),
+});
+export type AssistantChatRequestFormData = Infer<
+  typeof AssistantChatRequestSchema
+>;
+
 export const BillingPlanSchema = object({
   id: string().min(1, "Id is required"),
   name: string().min(1, "Name is required"),
@@ -504,6 +580,15 @@ export const ProblemDetailsSchema = object({
 });
 export type ProblemDetailsFormData = Infer<typeof ProblemDetailsSchema>;
 
+export const ProductTourProgressSchema = object({
+  version: int32(),
+  status: ProductTourStatusSchema,
+  updated_utc: iso.datetime(),
+});
+export type ProductTourProgressFormData = Infer<
+  typeof ProductTourProgressSchema
+>;
+
 export const ResetPasswordModelSchema = object({
   password_reset_token: string().length(
     40,
@@ -620,6 +705,16 @@ export const UpdateEventSchema = object({
 });
 export type UpdateEventFormData = Infer<typeof UpdateEventSchema>;
 
+export const UpdateProductTourProgressSchema = object({
+  version: int32()
+    .min(1, "Version must be at least 1")
+    .max(2147483647, "Version must be at most 2147483647"),
+  status: ProductTourStatusSchema,
+});
+export type UpdateProductTourProgressFormData = Infer<
+  typeof UpdateProductTourProgressSchema
+>;
+
 export const UpdateProjectSchema = object({
   name: string().min(1, "Name is required").optional(),
   delete_bot_data_enabled: boolean().optional(),
@@ -694,6 +789,10 @@ export const UserSchema = object({
     .optional(),
   password_reset_token_expiration: iso.datetime(),
   o_auth_accounts: array(lazy(() => OAuthAccountSchema)),
+  product_tours: record(
+    string(),
+    lazy(() => ProductTourProgressSchema),
+  ),
   full_name: string().min(1, "Full name is required"),
   email_address: email(),
   avatar_file_name: string()
@@ -726,6 +825,10 @@ export const ViewCurrentUserSchema = object({
   hash: string().min(1, "Hash is required").nullable().optional(),
   has_local_account: boolean(),
   o_auth_accounts: array(lazy(() => OAuthAccountSchema)),
+  product_tours: record(
+    string(),
+    lazy(() => ProductTourProgressSchema),
+  ),
   id: string()
     .length(24, "Id must be exactly 24 characters")
     .regex(/^[a-fA-F0-9]{24}$/, "Id has invalid format"),
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/navbar.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/navbar.svelte
index e0dc023364..507a2ec701 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/navbar.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/navbar.svelte
@@ -27,7 +27,7 @@
     <div class="px-4 py-3">
         <div class="flex items-center justify-between">
             <div class="flex items-center justify-start">
-                <Sidebar.Trigger variant="outline" class="size-9" />
+                <Sidebar.Trigger data-tour="mobile-navigation-trigger" variant="outline" class="size-9" />
 
                 <A variant="ghost" class="mr-14 ml-2 flex md:min-w-62.5 lg:ml-3 dark:text-white" href={resolve('/(app)/stack')}>
                     {#if isMediumScreenQuery.current}
@@ -41,6 +41,7 @@
                 <Button
                     aria-label="Search Exceptionless"
                     class="w-9 justify-center sm:w-56 sm:justify-start md:w-72"
+                    data-tour="command-search"
                     onclick={openCommand}
                     size="default"
                     variant="outline"
@@ -55,6 +56,7 @@
                         aria-label={isAssistantOpen ? 'Close Exie' : 'Open Exie'}
                         class="px-2"
                         data-assistant-trigger
+                        data-tour="exie-trigger"
                         onclick={toggleAssistant}
                         title="Ask Exie"
                         variant="outline"
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar-user.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar-user.svelte
index 59cf26c487..e5536c4b63 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar-user.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar-user.svelte
@@ -23,6 +23,7 @@
     import Braces from '@lucide/svelte/icons/braces';
     import ChevronsUpDown from '@lucide/svelte/icons/chevrons-up-down';
     import Help from '@lucide/svelte/icons/circle-help';
+    import Compass from '@lucide/svelte/icons/compass';
     import CreditCard from '@lucide/svelte/icons/credit-card';
     import LogOut from '@lucide/svelte/icons/log-out';
     import Plus from '@lucide/svelte/icons/plus';
@@ -36,6 +37,7 @@
         isLoading: boolean;
         open?: boolean;
         openChat: () => void;
+        openGuidedTours: () => void;
         openKeyboardShortcuts: () => Promise<void> | void;
         organizations?: ViewOrganization[];
         user: undefined | ViewCurrentUser;
@@ -48,6 +50,7 @@
         isLoading,
         open = $bindable(false),
         openChat,
+        openGuidedTours,
         openKeyboardShortcuts,
         organizations = [],
         user
@@ -77,6 +80,12 @@
         void openKeyboardShortcuts();
     }
 
+    function onGuidedToursClick(): void {
+        onMenuClick();
+        open = false;
+        openGuidedTours();
+    }
+
     function navigateTo(href: string): void {
         onMenuClick();
         void goto(href);
@@ -131,7 +140,12 @@
             <DropdownMenu.Root bind:open>
                 <DropdownMenu.Trigger>
                     {#snippet child({ props })}
-                        <Sidebar.MenuButton size="lg" class="data-[state=open]:bg-sidebar-accent data-[state=open]:text-sidebar-accent-foreground" {...props}>
+                        <Sidebar.MenuButton
+                            size="lg"
+                            class="data-[state=open]:bg-sidebar-accent data-[state=open]:text-sidebar-accent-foreground"
+                            data-tour="help-menu"
+                            {...props}
+                        >
                             <Avatar.Root class="size-8 rounded-lg" title="Profile Image">
                                 {#await gravatar.src}
                                     <Avatar.Fallback class="rounded-lg">{gravatar.initials}</Avatar.Fallback>
@@ -225,6 +239,10 @@
                             Help
                         </DropdownMenu.SubTrigger>
                         <DropdownMenu.SubContent>
+                            <DropdownMenu.Item onSelect={onGuidedToursClick}>
+                                <Compass />
+                                <span class="w-full">Guided Tours…</span>
+                            </DropdownMenu.Item>
                             {#if isChatEnabled}
                                 <DropdownMenu.Item class="gap-2 p-2" onSelect={onChatClick}>
                                     <Help />
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar.svelte
index 41f84871ad..440dbc808d 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/layouts/sidebar.svelte
@@ -215,14 +215,14 @@
     });
 </script>
 
-<Sidebar.Root collapsible="icon" {...props}>
+<Sidebar.Root collapsible="icon" data-tour="app-navigation" {...props}>
     <Sidebar.Header class={!sidebar.isMobile ? 'mt-16' : ''}>
         {#if header}
             {@render header()}
         {/if}
     </Sidebar.Header>
     <Sidebar.Content>
-        <Sidebar.Group class="pt-0">
+        <Sidebar.Group class="pt-0" data-tour="saved-view-navigation">
             <Sidebar.Menu>
                 {#each dashboardRoutes as route (route.href)}
                     {@const Icon = route.icon}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte
index df3ebbb032..555591bac7 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
     import type { ViewOrganization } from '$features/organizations/models';
+    import type { ProductTourId, ProductTourListItem } from '$features/product-tours/types';
     import type { ViewProject } from '$features/projects/models';
     import type { FetchClientResponse } from '@foundatiofx/fetchclient';
 
@@ -24,6 +25,7 @@
     import Building2 from '@lucide/svelte/icons/building-2';
     import CircleHelp from '@lucide/svelte/icons/circle-help';
     import CircleUserRound from '@lucide/svelte/icons/circle-user-round';
+    import Compass from '@lucide/svelte/icons/compass';
     import Eye from '@lucide/svelte/icons/eye';
     import EyeOff from '@lucide/svelte/icons/eye-off';
     import Keyboard from '@lucide/svelte/icons/keyboard';
@@ -56,6 +58,7 @@
 
     type Props = {
         askExie: (prompt: string) => Promise<void> | void;
+        guidedTours: ProductTourListItem[];
         isChatEnabled: boolean;
         isExieEnabled: boolean;
         isGlobalAdmin: boolean;
@@ -63,6 +66,7 @@
         open: boolean;
         openChat: () => void;
         openExie: () => Promise<void> | void;
+        openGuidedTours: () => void;
         openImpersonateOrganization: () => Promise<void> | void;
         openKeyboardShortcuts: () => Promise<void> | void;
         openOrganizationSwitcher: () => Promise<void> | void;
@@ -70,6 +74,7 @@
         organizations: ViewOrganization[];
         resetKey: number;
         routes: NavigationItem[];
+        startGuidedTour: (id: ProductTourId) => void;
         stopImpersonating: () => Promise<void> | void;
     };
 
@@ -86,6 +91,7 @@
 
     let {
         askExie,
+        guidedTours,
         isChatEnabled,
         isExieEnabled,
         isGlobalAdmin,
@@ -93,6 +99,7 @@
         open = $bindable(),
         openChat,
         openExie,
+        openGuidedTours,
         openImpersonateOrganization,
         openKeyboardShortcuts,
         openOrganizationSwitcher,
@@ -100,6 +107,7 @@
         organizations,
         resetKey,
         routes,
+        startGuidedTour,
         stopImpersonating
     }: Props = $props();
     let searchText = $state('');
@@ -415,6 +423,16 @@
         openChat();
     }
 
+    function openGuidedTourCatalog(): void {
+        closeCommandWindow();
+        openGuidedTours();
+    }
+
+    function launchGuidedTour(id: ProductTourId): void {
+        closeCommandWindow();
+        startGuidedTour(id);
+    }
+
     function toggleTheme(): void {
         closeCommandWindow();
         toggleMode();
@@ -556,6 +574,19 @@
                 bind:selectedActionId={selectedProjectActionId}
             />
             {#if !selectingProject}
+                <Command.Group heading="Guided Tours">
+                    {#each guidedTours.filter((tour) => tour.availability.available) as tour (tour.id)}
+                        <Command.Item keywords={[...tour.keywords]} value={`Guided Tour ${tour.title}`} onSelect={() => launchGuidedTour(tour.id)}>
+                            <Compass />
+                            <span>{tour.title}</span>
+                        </Command.Item>
+                    {/each}
+                    <Command.Item value="Browse Guided Tours help onboarding guides" onSelect={openGuidedTourCatalog}>
+                        <CircleHelp />
+                        <span>Browse Guided Tours…</span>
+                    </Command.Item>
+                </Command.Group>
+                <Command.Separator />
                 {#if isExieEnabled}
                     <Command.Group heading="Exie" value="Exie Assistant">
                         <Command.Item value="Ask Exie open assistant AI chat" onSelect={() => void openExieAssistant()}>
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte.test.ts
index 43d732c0e9..cb8f78d733 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte.test.ts
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/(components)/navigation-command.svelte.test.ts
@@ -1,3 +1,5 @@
+import type { ProductTourListItem } from '$features/product-tours/types';
+
 import { fireEvent, render, screen, waitFor } from '@testing-library/svelte';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -53,14 +55,17 @@ import NavigationCommand from './navigation-command.svelte';
 
 type RenderOptions = {
     askExie?: (prompt: string) => Promise<void> | void;
+    guidedTours?: ProductTourListItem[];
     isChatEnabled?: boolean;
     isExieEnabled?: boolean;
     isGlobalAdmin?: boolean;
     isImpersonating?: boolean;
     openChat?: () => void;
     openExie?: () => Promise<void> | void;
+    openGuidedTours?: () => void;
     openImpersonateOrganization?: () => Promise<void> | void;
     organizations?: Array<{ id: string; name: string }>;
+    startGuidedTour?: (id: ProductTourListItem['id']) => void;
     stopImpersonating?: () => Promise<void> | void;
 };
 
@@ -74,6 +79,7 @@ const sessionsRoute: NavigationItem = {
 function renderCommandPalette(routes: NavigationItem[] = [], options: RenderOptions = {}) {
     return render(NavigationCommand, {
         askExie: options.askExie ?? vi.fn(),
+        guidedTours: options.guidedTours ?? [],
         isChatEnabled: options.isChatEnabled ?? false,
         isExieEnabled: options.isExieEnabled ?? true,
         isGlobalAdmin: options.isGlobalAdmin ?? false,
@@ -81,6 +87,7 @@ function renderCommandPalette(routes: NavigationItem[] = [], options: RenderOpti
         open: true,
         openChat: options.openChat ?? vi.fn(),
         openExie: options.openExie ?? vi.fn(),
+        openGuidedTours: options.openGuidedTours ?? vi.fn(),
         openImpersonateOrganization: options.openImpersonateOrganization ?? vi.fn(),
         openKeyboardShortcuts: vi.fn(),
         openOrganizationSwitcher: vi.fn(),
@@ -88,6 +95,7 @@ function renderCommandPalette(routes: NavigationItem[] = [], options: RenderOpti
         organizations: (options.organizations ?? []) as never,
         resetKey: 0,
         routes: [sessionsRoute, ...routes],
+        startGuidedTour: options.startGuidedTour ?? vi.fn(),
         stopImpersonating: options.stopImpersonating ?? vi.fn()
     });
 }
@@ -319,3 +327,33 @@ describe('NavigationCommand project actions', () => {
         expect(goto).toHaveBeenCalledWith('/next/login');
     });
 });
+
+describe('NavigationCommand guided tours', () => {
+    it('launches available tours directly and opens the full catalog', async () => {
+        const openGuidedTours = vi.fn();
+        const startGuidedTour = vi.fn();
+        renderCommandPalette([], {
+            guidedTours: [
+                {
+                    availability: { available: true },
+                    description: 'Learn the UI.',
+                    getAvailability: vi.fn(),
+                    getSteps: vi.fn(),
+                    id: 'new-ui-overview',
+                    keywords: ['tour'],
+                    title: 'Explore the new UI',
+                    version: 1
+                }
+            ],
+            openGuidedTours,
+            startGuidedTour
+        });
+
+        await fireEvent.click(screen.getByText('Explore the new UI'));
+        expect(startGuidedTour).toHaveBeenCalledWith('new-ui-overview');
+
+        renderCommandPalette([], { openGuidedTours });
+        await fireEvent.click(screen.getAllByText('Browse Guided Tours…').at(-1)!);
+        expect(openGuidedTours).toHaveBeenCalled();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
index 49b45fe8f0..672f970534 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
     import type { AssistantPromptRequest } from '$features/assistant/models';
+    import type { ProductTourId, ProductTourLaunchSource } from '$features/product-tours/types';
     import type { SavedView } from '$features/saved-views/models';
     import type { Snippet } from 'svelte';
 
@@ -17,6 +18,7 @@
     import { ChangePlanDialogHost, UpgradeRequiredDialog } from '$features/billing';
     import {
         createOrganizationEventNotificationRefresher,
+        getOrganizationEventsQuery,
         invalidatePersistentEventQueries,
         type OrganizationEventNotificationRefresher
     } from '$features/events/api.svelte';
@@ -36,7 +38,9 @@
     import { organization, showOrganizationNotifications } from '$features/organizations/context.svelte';
     import { premiumPage } from '$features/organizations/premium-page.svelte';
     import { getUtcMonthKey, ORGANIZATION_USAGE_ROLLOVER_CHECK_INTERVAL_MS } from '$features/organizations/utils';
-    import { invalidateProjectQueries } from '$features/projects/api.svelte';
+    import { getProductTourItems } from '$features/product-tours/catalog';
+    import ProductTours from '$features/product-tours/components/product-tours.svelte';
+    import { getProjectsQuery, invalidateProjectQueries } from '$features/projects/api.svelte';
     import { getSavedViewsQuery, invalidateSavedViewQueries, isSavedViewDeleted } from '$features/saved-views/api.svelte';
     import { savedViewHref } from '$features/saved-views/slugs';
     import { appKeyboardShortcuts, isKeyboardShortcut } from '$features/shared/keyboard-shortcuts';
@@ -92,6 +96,8 @@
     let isOrganizationSwitcherOpen = $state(false);
     let isImpersonateOrganizationOpen = $state(false);
     let isUserMenuOpen = $state(false);
+    let productToursComponent = $state<ProductTours>();
+    let productTourErrorCheckEnabled = $state(false);
 
     // Auto-reset premium page state on navigation so pages don't need cleanup
     beforeNavigate(() => {
@@ -100,6 +106,7 @@
 
     function openCommandPalette(): void {
         commandResetKey += 1;
+        productTourErrorCheckEnabled = true;
         isCommandOpen = true;
     }
 
@@ -228,6 +235,24 @@
         isImpersonateOrganizationOpen = true;
     }
 
+    function closeProductTourOverlays(): void {
+        isAssistantOpen = false;
+        isCommandOpen = false;
+        isImpersonateOrganizationOpen = false;
+        isKeyboardShortcutsOpen = false;
+        isOrganizationSwitcherOpen = false;
+        isUserMenuOpen = false;
+    }
+
+    function openGuidedTours(source: ProductTourLaunchSource): void {
+        productTourErrorCheckEnabled = true;
+        productToursComponent?.openCatalog(source);
+    }
+
+    function startGuidedTour(id: ProductTourId, source: ProductTourLaunchSource): void {
+        void productToursComponent?.startTour(id, source);
+    }
+
     async function stopImpersonating(): Promise<void> {
         isCommandOpen = false;
         await goto(resolve('/(app)/stack'));
@@ -484,6 +509,38 @@
 
     const organizationsQuery = getOrganizationsQuery({});
     const organizations = $derived(organizationsQuery.data?.data ?? []);
+    const projectsQuery = getProjectsQuery({
+        params: {
+            limit: 1000
+        }
+    });
+    const projects = $derived(projectsQuery.data?.data ?? []);
+    const productTourProjects = $derived(projects.filter((project) => !organization.current || project.organization_id === organization.current));
+    const productTourErrorEventsQuery = getOrganizationEventsQuery({
+        enabled: () => productTourErrorCheckEnabled,
+        params: {
+            filter: 'type:error',
+            limit: 1,
+            mode: 'summary',
+            time: 'all'
+        },
+        route: {
+            get organizationId() {
+                return organization.current;
+            }
+        }
+    });
+    const productTourErrorEventAvailability = $derived.by(() => {
+        if (!organization.current || !productTourErrorCheckEnabled || productTourErrorEventsQuery.isPending) {
+            return 'loading' as const;
+        }
+
+        if (productTourErrorEventsQuery.isError) {
+            return 'error' as const;
+        }
+
+        return (productTourErrorEventsQuery.data?.data?.length ?? 0) > 0 ? ('available' as const) : ('empty' as const);
+    });
 
     const impersonatingOrganizationId = $derived.by(() => {
         // Only consider impersonation if user data is loaded and user has organizations
@@ -643,6 +700,22 @@
 
     const setupPath = resolve('/(app)/organization/add');
     const isSetupPage = $derived(page.url.pathname === setupPath);
+    const productTourItems = $derived(
+        getProductTourItems(
+            {
+                assistantAccess,
+                errorEventAvailability: productTourErrorEventAvailability,
+                isSetupPage,
+                organizationId: organization.current,
+                pathname: page.url.pathname,
+                projects: productTourProjects
+            },
+            meQuery.data?.product_tours
+        )
+    );
+    const isAnyProductTourOverlayOpen = $derived(
+        isAssistantOpen || isCommandOpen || isImpersonateOrganizationOpen || isKeyboardShortcutsOpen || isOrganizationSwitcherOpen || isUserMenuOpen
+    );
 
     $effect(() => {
         if (assistantAccessQuery.isSuccess && !isAssistantEnabled) {
@@ -704,6 +777,7 @@
                 {organizations}
                 {openChat}
                 {openKeyboardShortcuts}
+                openGuidedTours={() => openGuidedTours('help-menu')}
                 {intercomUnreadCount}
                 bind:open={isUserMenuOpen}
             />
@@ -724,16 +798,19 @@
                     isExieEnabled={isAssistantEnabled}
                     {isGlobalAdmin}
                     {isImpersonating}
+                    guidedTours={productTourItems}
                     {openChat}
                     openExie={openAssistantPanel}
                     {openImpersonateOrganization}
                     {openKeyboardShortcuts}
                     {openOrganizationSwitcher}
                     {openUserMenu}
+                    openGuidedTours={() => openGuidedTours('command-palette')}
                     {organizations}
                     resetKey={commandResetKey}
                     routes={filteredRoutes}
                     {stopImpersonating}
+                    startGuidedTour={(id) => startGuidedTour(id, 'command-palette')}
                 />
                 <KeyboardShortcutsDialog bind:open={isKeyboardShortcutsOpen} />
 
@@ -787,6 +864,25 @@
 {/snippet}
 
 {#if isAuthenticated}
+    <ProductTours
+        {assistantAccess}
+        bind:this={productToursComponent}
+        closeOverlays={closeProductTourOverlays}
+        currentUser={meQuery.data}
+        errorEventAvailability={productTourErrorEventAvailability}
+        isAnyOverlayOpen={isAnyProductTourOverlayOpen}
+        {isImpersonating}
+        {isSetupPage}
+        organizationId={organization.current}
+        pathname={page.url.pathname}
+        projects={productTourProjects}
+        requestErrorAvailability={() => (productTourErrorCheckEnabled = true)}
+        routeKey={`${page.url.pathname}${page.url.search}`}
+        stateSettled={meQuery.isSuccess &&
+            organizationsQuery.isSuccess &&
+            projectsQuery.isSuccess &&
+            (!organization.current || assistantAccessQuery.isSuccess || assistantAccessQuery.isError)}
+    />
     <IntercomShell
         appId={intercomAppId || undefined}
         bootOptions={intercomBootOptions}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte
index 53b9549071..521ff8bd49 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte
@@ -936,7 +936,7 @@
 <div class="flex flex-col">
     <div class="mb-4 flex flex-wrap items-start gap-2">
         <H3 class="my-0 shrink-0">{pageTitle}</H3>
-        <div class="flex min-w-0 flex-1 flex-wrap items-start gap-2">
+        <div class="flex min-w-0 flex-1 flex-wrap items-start gap-2" data-tour="event-filters">
             <FacetedFilter.Root changed={onFilterChanged} {filters} remove={onFilterRemoved}>
                 <OrganizationDefaultsFacetedFilterBuilder />
             </FacetedFilter.Root>
@@ -995,30 +995,32 @@
             />
         {/if}
 
-        <EventsDataTable
-            autoFillColumnId={savedViewsState.autoFillColumnId}
-            bind:limit={eventsQueryParameters.limit!}
-            isLoading={isSavedViewRoutePending || eventsQuery.isFetching}
-            onAutoFillColumnResized={() => savedViewsState.setAutoFillColumnId(null)}
-            {rowClick}
-            {rowHref}
-            {table}
-        >
-            {#snippet footerChildren()}
-                <div class="h-9 min-w-35">
-                    {#if table.getSelectedRowModel().flatRows.length}
-                        <EventsBulkActionsDropdownMenu {table} />
-                    {/if}
-                </div>
-
-                <DataTable.Selection {table} />
-                <DataTable.PageSize bind:value={eventsQueryParameters.limit!} {table}></DataTable.PageSize>
-                <div class="flex items-center space-x-6 lg:space-x-8">
-                    <DataTable.PageCount {table} />
-                    <DataTable.Pagination {table} />
-                </div>
-            {/snippet}
-        </EventsDataTable>
+        <div data-tour="event-list">
+            <EventsDataTable
+                autoFillColumnId={savedViewsState.autoFillColumnId}
+                bind:limit={eventsQueryParameters.limit!}
+                isLoading={isSavedViewRoutePending || eventsQuery.isFetching}
+                onAutoFillColumnResized={() => savedViewsState.setAutoFillColumnId(null)}
+                {rowClick}
+                {rowHref}
+                {table}
+            >
+                {#snippet footerChildren()}
+                    <div class="h-9 min-w-35">
+                        {#if table.getSelectedRowModel().flatRows.length}
+                            <EventsBulkActionsDropdownMenu {table} />
+                        {/if}
+                    </div>
+
+                    <DataTable.Selection {table} />
+                    <DataTable.PageSize bind:value={eventsQueryParameters.limit!} {table}></DataTable.PageSize>
+                    <div class="flex items-center space-x-6 lg:space-x-8">
+                        <DataTable.PageCount {table} />
+                        <DataTable.Pagination {table} />
+                    </div>
+                {/snippet}
+            </EventsDataTable>
+        </div>
     </div>
 </div>
 
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/add/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/add/+page.svelte
index a06884acad..d8014cc740 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/add/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/add/+page.svelte
@@ -108,6 +108,7 @@
                     <Field.Field data-invalid={ariaInvalid(field)}>
                         <Field.Label for={field.name}>Organization Name</Field.Label>
                         <Input
+                            data-tour="setup-organization-name"
                             id={field.name}
                             name={field.name}
                             placeholder="Enter organization name"
@@ -125,6 +126,7 @@
                     <Field.Field data-invalid={ariaInvalid(field)}>
                         <Field.Label for={field.name}>Project Name</Field.Label>
                         <Input
+                            data-tour="project-name"
                             id={field.name}
                             name={field.name}
                             placeholder="Enter project name"
@@ -139,7 +141,7 @@
             </form.Field>
             <form.Subscribe selector={(state) => state.isSubmitting}>
                 {#snippet children(isSubmitting)}
-                    <Button type="submit" class="mt-4 w-full" disabled={isSubmitting}>
+                    <Button data-tour="project-setup-submit" type="submit" class="mt-4 w-full" disabled={isSubmitting}>
                         {#if isSubmitting}
                             <Spinner /> Creating Setup...
                         {:else}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/configure/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/configure/+page.svelte
index 1f06feb9c1..2770bdd5ef 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/configure/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/configure/+page.svelte
@@ -12,6 +12,9 @@
     import { openSupportChat } from '$features/intercom/chat';
     import { organization } from '$features/organizations/context.svelte';
     import { useHideOrganizationNotifications } from '$features/organizations/hooks/use-hide-organization-notifications.svelte';
+    import ProductTourInlineCallout from '$features/product-tours/components/product-tour-inline-callout.svelte';
+    import { productTourHost } from '$features/product-tours/state.svelte';
+    import { getProjectQuery } from '$features/projects/api.svelte';
     import { getProjectDefaultTokenQuery, patchToken } from '$features/tokens/api.svelte';
     import EnableTokenDialog from '$features/tokens/components/dialogs/enable-token-dialog.svelte';
     import { ChangeType, type WebSocketMessageValue } from '$features/websockets/models';
@@ -37,6 +40,13 @@
             }
         }
     });
+    const projectQuery = getProjectQuery({
+        route: {
+            get id() {
+                return projectId;
+            }
+        }
+    });
 
     const apiKey = $derived(defaultTokenQuery.data?.id || 'YOUR_API_KEY');
     const serverUrl = (env.PUBLIC_EXCEPTIONLESS_SERVER_URL || '').trim();
@@ -419,11 +429,36 @@ public partial class App : Application {
         const message = (event as CustomEvent<WebSocketMessageValue<'PersistentEventChanged'>>).detail;
 
         if (queryParams.redirect && message.project_id === projectId && message.change_type !== ChangeType.Removed) {
+            if (!(await productTourHost.complete('configure-project'))) {
+                return;
+            }
+
             toast.success('First event received. Opening Events...');
             await redirectToEventsWithFilter(organization.current, new ProjectFilter([projectId]));
         }
     });
 
+    async function refreshConfiguredProject(): Promise<void> {
+        if (!queryParams.redirect) {
+            return;
+        }
+
+        const result = await projectQuery.refetch();
+        if (!result.data?.is_configured) {
+            return;
+        }
+
+        if (!(await productTourHost.complete('configure-project'))) {
+            return;
+        }
+
+        toast.success('First event received. Opening Events...');
+        await redirectToEventsWithFilter(organization.current, new ProjectFilter([projectId]));
+    }
+
+    useEventListener(window, 'focus', () => void refreshConfiguredProject());
+    useEventListener(document, 'refresh', () => void refreshConfiguredProject());
+
     // Use Intercom from parent provider context
     const intercom = getIntercom();
 
@@ -462,311 +497,330 @@ public partial class App : Application {
     {/if}
 
     {#if queryParams.redirect}
-        <Notification>
+        <Notification data-tour="project-configure-waiting">
             <NotificationTitle>Waiting for your first event</NotificationTitle>
             <NotificationDescription>
                 <P>Send an event from your app. When it arrives, we'll open the project Events page automatically.</P>
+                {#if productTourHost.isActive('configure-project')}
+                    <P class="mt-2">You can leave this tab while updating your application. The guide will resume here when you return.</P>
+                    <Button class="mt-2" onclick={() => productTourHost.dismiss('configure-project')} size="sm" variant="outline">End guide</Button>
+                {/if}
             </NotificationDescription>
         </Notification>
     {/if}
 
-    <ol class="my-6 ml-6 list-decimal [&>li]:mt-2">
-        <li>
-            <P>Choose your project type.</P>
-            <Select.Root
-                type="single"
-                bind:value={queryParams.type as string | undefined}
-                onValueChange={(value) => {
-                    selectedProjectType = projectTypes.find((P) => P.id === value) || null;
-                    queryParams.type = value;
-                }}
-            >
-                <Select.Trigger class="w-full">
-                    <span
-                        >{#if selectedProjectType}
-                            {selectedProjectType.platform}: {selectedProjectType.label}
-                        {:else}
-                            Please select a project type
-                        {/if}</span
-                    >
-                </Select.Trigger>
-                <Select.Content>
-                    {#each Object.entries(projectTypesGroupedByPlatform) as [platform, types = []], index (platform)}
-                        <Select.Group>
-                            <Select.Label class="text-primary">{platform}</Select.Label>
-                            {#each types as type (type.id)}
-                                <Select.Item value={type.id}>
-                                    {type.label}
-                                </Select.Item>
-                            {/each}
-                        </Select.Group>
-                        {#if index < Object.keys(projectTypesGroupedByPlatform).length - 1}
-                            <Select.Separator />
-                        {/if}
-                    {/each}
-                </Select.Content>
-            </Select.Root>
-        </li>
-
-        {#if selectedProjectType}
-            {#if isCommandLine}
-                <li>
-                    <P>Execute the following in your shell.</P>
-                    <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                        {#if isBashShell}
-                            <CodeBlock code={codeSamples.bashShell} language="shellscript" />
-                        {:else}
-                            <CodeBlock code={codeSamples.powerShell} language="powershell" />
-                        {/if}
-                        <div class="absolute top-2 right-2">
-                            <CopyToClipboardButton value={isBashShell ? codeSamples.bashShell : codeSamples.powerShell} />
-                        </div>
-                    </div>
-                </li>
-            {:else if isDotNet}
-                <li>
-                    <P
-                        >Install the <A href="https://www.nuget.org/packages/{selectedProjectType.package}/" target="_blank"
-                            ><strong>{selectedProjectType.package}</strong> NuGet package</A
-                        > in your .NET project by executing this command from the project directory.</P
-                    >
-                    <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                        <CodeBlock code="dotnet add package {selectedProjectType.package}" language="shellscript" />
-                        <div class="absolute top-2 right-2">
-                            <CopyToClipboardButton value={`dotnet add package ${selectedProjectType.package}`} />
-                        </div>
-                    </div>
-                </li>
-                {#if selectedProjectType.package === 'Exceptionless'}
-                    <li>
-                        <P
-                            >On app startup, import the Exceptionless namespace and call the client.Startup() extension method to wire up to any runtime
-                            specific error handlers and read any available configuration.</P
+    <div data-tour="project-configure-instructions">
+        <ol class="my-6 ml-6 list-decimal [&>li]:mt-2" data-tour="project-configure-token">
+            <li>
+                <P>Choose your project type.</P>
+                <Select.Root
+                    type="single"
+                    bind:value={queryParams.type as string | undefined}
+                    onValueChange={(value) => {
+                        selectedProjectType = projectTypes.find((P) => P.id === value) || null;
+                        queryParams.type = value;
+                    }}
+                >
+                    <Select.Trigger class="w-full" data-tour="project-configure-platform">
+                        <span
+                            >{#if selectedProjectType}
+                                {selectedProjectType.platform}: {selectedProjectType.label}
+                            {:else}
+                                Please select a project type
+                            {/if}</span
                         >
+                    </Select.Trigger>
+                    <Select.Content>
+                        {#each Object.entries(projectTypesGroupedByPlatform) as [platform, types = []], index (platform)}
+                            <Select.Group>
+                                <Select.Label class="text-primary">{platform}</Select.Label>
+                                {#each types as type (type.id)}
+                                    <Select.Item value={type.id}>
+                                        {type.label}
+                                    </Select.Item>
+                                {/each}
+                            </Select.Group>
+                            {#if index < Object.keys(projectTypesGroupedByPlatform).length - 1}
+                                <Select.Separator />
+                            {/if}
+                        {/each}
+                    </Select.Content>
+                </Select.Root>
+            </li>
+
+            {#if selectedProjectType}
+                {#if isCommandLine}
+                    <li>
+                        <P>Execute the following in your shell.</P>
                         <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.exceptionless} language="csharp" />
+                            {#if isBashShell}
+                                <CodeBlock code={codeSamples.bashShell} language="shellscript" />
+                            {:else}
+                                <CodeBlock code={codeSamples.powerShell} language="powershell" />
+                            {/if}
                             <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.exceptionless} />
+                                <CopyToClipboardButton value={isBashShell ? codeSamples.bashShell : codeSamples.powerShell} />
                             </div>
                         </div>
-                        <P
-                            >This library is platform-agnostic and is compiled against different runtimes. Depending on the referenced runtime, Exceptionless
-                            will attempt to wire up to available error handlers and attempt to discover configuration settings available to that runtime. For
-                            these reasons if you are on a known platform then use the platform specific package to save you time configuring while giving you
-                            more contextual information. For more information and configuration examples please read the <A
-                                href="https://exceptionless.com/docs/clients/dotnet/configuration/"
-                                target="_blank">Exceptionless Configuration documentation</A
-                            > for more information.</P
-                        >
                     </li>
-                {:else if selectedProjectType.package === 'Exceptionless.AspNetCore'}
+                {:else if isDotNet}
                     <li>
-                        <P>You must import the Exceptionless namespace and add the following code to register and configure the Exceptionless client.</P>
-                        <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.aspNetCore} language="csharp" />
-                            <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.aspNetCore} />
-                            </div>
-                        </div>
                         <P
-                            >In order to start gathering unhandled exceptions, you need to register the Exceptionless middleware after building your application
-                            as shown above. Alternatively, you can use different overloads of the AddExceptionless method for additional configuration options.</P
+                            >Install the <A href="https://www.nuget.org/packages/{selectedProjectType.package}/" target="_blank"
+                                ><strong>{selectedProjectType.package}</strong> NuGet package</A
+                            > in your .NET project by executing this command from the project directory.</P
                         >
-                    </li>
-                {:else if selectedProjectType.package === 'Exceptionless.Windows' || selectedProjectType.package === 'Exceptionless.Wpf'}
-                    <li>
-                        <P>Configure your Exceptionless assembly attribute to your projects AssemblyInfo.cs file.</P>
                         <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.windowsAttributeConfiguration} language="csharp" />
+                            <CodeBlock code="dotnet add package {selectedProjectType.package}" language="shellscript" />
                             <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.windowsAttributeConfiguration} />
+                                <CopyToClipboardButton value={`dotnet add package ${selectedProjectType.package}`} />
                             </div>
                         </div>
                     </li>
-                    {#if selectedProjectType.package === 'Exceptionless.Wpf'}
+                    {#if selectedProjectType.package === 'Exceptionless'}
                         <li>
                             <P
-                                >Finally, import the Exceptionless namespace and include the following line of code in your App.xaml.cs file to enable reporting
-                                of unhandled exceptions.</P
+                                >On app startup, import the Exceptionless namespace and call the client.Startup() extension method to wire up to any runtime
+                                specific error handlers and read any available configuration.</P
                             >
                             <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                                <CodeBlock code={codeSamples.wpfRegister} language="csharp" />
+                                <CodeBlock code={codeSamples.exceptionless} language="csharp" />
                                 <div class="absolute top-2 right-2">
-                                    <CopyToClipboardButton value={codeSamples.wpfRegister} />
+                                    <CopyToClipboardButton value={codeSamples.exceptionless} />
                                 </div>
                             </div>
+                            <P
+                                >This library is platform-agnostic and is compiled against different runtimes. Depending on the referenced runtime,
+                                Exceptionless will attempt to wire up to available error handlers and attempt to discover configuration settings available to
+                                that runtime. For these reasons if you are on a known platform then use the platform specific package to save you time
+                                configuring while giving you more contextual information. For more information and configuration examples please read the <A
+                                    href="https://exceptionless.com/docs/clients/dotnet/configuration/"
+                                    target="_blank">Exceptionless Configuration documentation</A
+                                > for more information.</P
+                            >
                         </li>
-                    {:else}
+                    {:else if selectedProjectType.package === 'Exceptionless.AspNetCore'}
                         <li>
+                            <P>You must import the Exceptionless namespace and add the following code to register and configure the Exceptionless client.</P>
+                            <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                <CodeBlock code={codeSamples.aspNetCore} language="csharp" />
+                                <div class="absolute top-2 right-2">
+                                    <CopyToClipboardButton value={codeSamples.aspNetCore} />
+                                </div>
+                            </div>
                             <P
-                                >Finally, import the Exceptionless namespace and include the following line of code in your Program.cs file to enable reporting
-                                of unhandled exceptions.</P
+                                >In order to start gathering unhandled exceptions, you need to register the Exceptionless middleware after building your
+                                application as shown above. Alternatively, you can use different overloads of the AddExceptionless method for additional
+                                configuration options.</P
                             >
+                        </li>
+                    {:else if selectedProjectType.package === 'Exceptionless.Windows' || selectedProjectType.package === 'Exceptionless.Wpf'}
+                        <li>
+                            <P>Configure your Exceptionless assembly attribute to your projects AssemblyInfo.cs file.</P>
                             <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                                <CodeBlock code={codeSamples.windowsRegister} language="csharp" />
+                                <CodeBlock code={codeSamples.windowsAttributeConfiguration} language="csharp" />
                                 <div class="absolute top-2 right-2">
-                                    <CopyToClipboardButton value={codeSamples.windowsRegister} />
+                                    <CopyToClipboardButton value={codeSamples.windowsAttributeConfiguration} />
                                 </div>
                             </div>
                         </li>
+                        {#if selectedProjectType.package === 'Exceptionless.Wpf'}
+                            <li>
+                                <P
+                                    >Finally, import the Exceptionless namespace and include the following line of code in your App.xaml.cs file to enable
+                                    reporting of unhandled exceptions.</P
+                                >
+                                <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                    <CodeBlock code={codeSamples.wpfRegister} language="csharp" />
+                                    <div class="absolute top-2 right-2">
+                                        <CopyToClipboardButton value={codeSamples.wpfRegister} />
+                                    </div>
+                                </div>
+                            </li>
+                        {:else}
+                            <li>
+                                <P
+                                    >Finally, import the Exceptionless namespace and include the following line of code in your Program.cs file to enable
+                                    reporting of unhandled exceptions.</P
+                                >
+                                <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                    <CodeBlock code={codeSamples.windowsRegister} language="csharp" />
+                                    <div class="absolute top-2 right-2">
+                                        <CopyToClipboardButton value={codeSamples.windowsRegister} />
+                                    </div>
+                                </div>
+                            </li>
+                        {/if}
                     {/if}
-                {/if}
-            {:else if isDotNetLegacy}
-                <li>
-                    <P
-                        >Install the <A href="https://www.nuget.org/packages/{selectedProjectType.package}/" target="_blank"
-                            ><strong>{selectedProjectType.package}</strong> NuGet package</A
-                        > to your Visual Studio project by running this command in the <A
-                            href="http://docs.nuget.org/docs/start-here/using-the-package-manager-console"
-                            target="_blank">Package Manager Console.</A
-                        ></P
-                    >
-                    <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                        <CodeBlock code="Install-Package {selectedProjectType.package}" language="shellscript" />
-                        <div class="absolute top-2 right-2">
-                            <CopyToClipboardButton value={`Install-Package ${selectedProjectType.package}`} />
-                        </div>
-                    </div>
-                </li>
-                {#if selectedProjectType.package === 'Exceptionless'}
+                {:else if isDotNetLegacy}
                     <li>
                         <P
-                            >On app startup, import the Exceptionless namespace and call the client.Startup() extension method to wire up to any runtime
-                            specific error handlers and read any available configuration.</P
+                            >Install the <A href="https://www.nuget.org/packages/{selectedProjectType.package}/" target="_blank"
+                                ><strong>{selectedProjectType.package}</strong> NuGet package</A
+                            > to your Visual Studio project by running this command in the <A
+                                href="http://docs.nuget.org/docs/start-here/using-the-package-manager-console"
+                                target="_blank">Package Manager Console.</A
+                            ></P
                         >
                         <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.exceptionless} language="csharp" />
+                            <CodeBlock code="Install-Package {selectedProjectType.package}" language="shellscript" />
                             <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.exceptionless} />
+                                <CopyToClipboardButton value={`Install-Package ${selectedProjectType.package}`} />
                             </div>
                         </div>
-                        <P
-                            >For more information and additional configuration methods please read the <A
-                                href="https://exceptionless.com/docs/clients/dotnet/configuration/"
-                                target="_blank">Exceptionless Configuration documentation</A
-                            > for more information.</P
-                        >
                     </li>
-                {:else if selectedProjectType.package === 'Exceptionless.Windows' || selectedProjectType.package === 'Exceptionless.Wpf'}
-                    <li>
-                        <P
-                            >Configure your Exceptionless API key in your project's app.config file, and add it under the Exceptionless section within the file.</P
-                        >
-                        <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.legacyAppConfigSectionXml} language="xml" />
-                            <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.legacyAppConfigSectionXml} />
+                    {#if selectedProjectType.package === 'Exceptionless'}
+                        <li>
+                            <P
+                                >On app startup, import the Exceptionless namespace and call the client.Startup() extension method to wire up to any runtime
+                                specific error handlers and read any available configuration.</P
+                            >
+                            <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                <CodeBlock code={codeSamples.exceptionless} language="csharp" />
+                                <div class="absolute top-2 right-2">
+                                    <CopyToClipboardButton value={codeSamples.exceptionless} />
+                                </div>
                             </div>
-                        </div>
-                    </li>
-                    {#if selectedProjectType.package === 'Exceptionless.Wpf'}
+                            <P
+                                >For more information and additional configuration methods please read the <A
+                                    href="https://exceptionless.com/docs/clients/dotnet/configuration/"
+                                    target="_blank">Exceptionless Configuration documentation</A
+                                > for more information.</P
+                            >
+                        </li>
+                    {:else if selectedProjectType.package === 'Exceptionless.Windows' || selectedProjectType.package === 'Exceptionless.Wpf'}
                         <li>
                             <P
-                                >Finally, import the Exceptionless namespace and include the following line of code in your App.xaml.cs file to enable reporting
-                                of unhandled exceptions.</P
+                                >Configure your Exceptionless API key in your project's app.config file, and add it under the Exceptionless section within the
+                                file.</P
                             >
                             <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                                <CodeBlock code={codeSamples.wpfRegister} language="csharp" />
+                                <CodeBlock code={codeSamples.legacyAppConfigSectionXml} language="xml" />
                                 <div class="absolute top-2 right-2">
-                                    <CopyToClipboardButton value={codeSamples.wpfRegister} />
+                                    <CopyToClipboardButton value={codeSamples.legacyAppConfigSectionXml} />
                                 </div>
                             </div>
                         </li>
-                    {:else}
+                        {#if selectedProjectType.package === 'Exceptionless.Wpf'}
+                            <li>
+                                <P
+                                    >Finally, import the Exceptionless namespace and include the following line of code in your App.xaml.cs file to enable
+                                    reporting of unhandled exceptions.</P
+                                >
+                                <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                    <CodeBlock code={codeSamples.wpfRegister} language="csharp" />
+                                    <div class="absolute top-2 right-2">
+                                        <CopyToClipboardButton value={codeSamples.wpfRegister} />
+                                    </div>
+                                </div>
+                            </li>
+                        {:else}
+                            <li>
+                                <P
+                                    >Finally, import the Exceptionless namespace and include the following line of code in your Program.cs file to enable
+                                    reporting of unhandled exceptions.</P
+                                >
+                                <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                    <CodeBlock code={codeSamples.windowsRegister} language="csharp" />
+                                    <div class="absolute top-2 right-2">
+                                        <CopyToClipboardButton value={codeSamples.windowsRegister} />
+                                    </div>
+                                </div>
+                            </li>
+                        {/if}
+                    {/if}
+
+                    {#if selectedProjectType.package === 'Exceptionless.Mvc' || selectedProjectType.package === 'Exceptionless.Web' || selectedProjectType.package === 'Exceptionless.WebApi'}
                         <li>
                             <P
-                                >Finally, import the Exceptionless namespace and include the following line of code in your Program.cs file to enable reporting
-                                of unhandled exceptions.</P
+                                >Configure your Exceptionless API key in your project's web.config file, and add it under the Exceptionless section within the
+                                file.</P
                             >
                             <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                                <CodeBlock code={codeSamples.windowsRegister} language="csharp" />
+                                <CodeBlock code={codeSamples.legacyAppConfigSectionXml} language="xml" />
                                 <div class="absolute top-2 right-2">
-                                    <CopyToClipboardButton value={codeSamples.windowsRegister} />
+                                    <CopyToClipboardButton value={codeSamples.legacyAppConfigSectionXml} />
                                 </div>
                             </div>
                         </li>
                     {/if}
-                {/if}
 
-                {#if selectedProjectType.package === 'Exceptionless.Mvc' || selectedProjectType.package === 'Exceptionless.Web' || selectedProjectType.package === 'Exceptionless.WebApi'}
-                    <li>
-                        <P
-                            >Configure your Exceptionless API key in your project's web.config file, and add it under the Exceptionless section within the file.</P
-                        >
-                        <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.legacyAppConfigSectionXml} language="xml" />
-                            <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.legacyAppConfigSectionXml} />
+                    {#if selectedProjectType.package === 'Exceptionless.WebApi'}
+                        <li>
+                            <P
+                                >Finally, you must import the Exceptionless namespace and call <CodeBlock
+                                    code="ExceptionlessClient.Default.RegisterWebApi(config)"
+                                    language="csharp"
+                                    class="inline-block"
+                                /> method with an instance of HttpConfiguration during the startup of your app.</P
+                            >
+                            <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                <CodeBlock code={codeSamples.webApiRegister} language="csharp" />
+                                <div class="absolute top-2 right-2">
+                                    <CopyToClipboardButton value={codeSamples.webApiRegister} />
+                                </div>
                             </div>
-                        </div>
-                    </li>
+                            <P>If you are hosting Web API inside of ASP.NET, you would register Exceptionless using GlobalConfiguration.</P>
+                            <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                <CodeBlock code={codeSamples.webApiRegisterAspNet} language="csharp" />
+                                <div class="absolute top-2 right-2">
+                                    <CopyToClipboardButton value={codeSamples.webApiRegisterAspNet} />
+                                </div>
+                            </div>
+                        </li>
+                    {/if}
                 {/if}
 
-                {#if selectedProjectType.package === 'Exceptionless.WebApi'}
+                {#if isJavaScript && javascriptClientConfiguration}
                     <li>
                         <P
-                            >Finally, you must import the Exceptionless namespace and call <CodeBlock
-                                code="ExceptionlessClient.Default.RegisterWebApi(config)"
-                                language="csharp"
-                                class="inline-block"
-                            /> method with an instance of HttpConfiguration during the startup of your app.</P
+                            >Install the <strong>{javascriptClientConfiguration.packageName}</strong> npm package in your JavaScript project by running this
+                            command in the project directory. {javascriptClientConfiguration.installNote ?? ''}</P
                         >
                         <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.webApiRegister} language="csharp" />
+                            <CodeBlock code={javascriptClientConfiguration.installCommand} language="shellscript" />
                             <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.webApiRegister} />
-                            </div>
-                        </div>
-                        <P>If you are hosting Web API inside of ASP.NET, you would register Exceptionless using GlobalConfiguration.</P>
-                        <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={codeSamples.webApiRegisterAspNet} language="csharp" />
-                            <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={codeSamples.webApiRegisterAspNet} />
+                                <CopyToClipboardButton value={javascriptClientConfiguration.installCommand} />
                             </div>
                         </div>
                     </li>
-                {/if}
-            {/if}
-
-            {#if isJavaScript && javascriptClientConfiguration}
-                <li>
-                    <P
-                        >Install the <strong>{javascriptClientConfiguration.packageName}</strong> npm package in your JavaScript project by running this command
-                        in the project directory. {javascriptClientConfiguration.installNote ?? ''}</P
-                    >
-                    <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                        <CodeBlock code={javascriptClientConfiguration.installCommand} language="shellscript" />
-                        <div class="absolute top-2 right-2">
-                            <CopyToClipboardButton value={javascriptClientConfiguration.installCommand} />
-                        </div>
-                    </div>
-                </li>
-                {#each javascriptClientConfiguration.extraSteps ?? [] as step (step.description)}
+                    {#each javascriptClientConfiguration.extraSteps ?? [] as step (step.description)}
+                        <li>
+                            <P>{step.description}</P>
+                            <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
+                                <CodeBlock code={step.code} language={step.language} />
+                                <div class="absolute top-2 right-2">
+                                    <CopyToClipboardButton value={step.code} />
+                                </div>
+                            </div>
+                            {#if step.note}
+                                <P>{step.note}</P>
+                            {/if}
+                        </li>
+                    {/each}
                     <li>
-                        <P>{step.description}</P>
+                        <P>Configure the ExceptionlessClient with your Exceptionless API key.</P>
                         <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                            <CodeBlock code={step.code} language={step.language} />
+                            <CodeBlock code={javascriptClientConfiguration.startupCode} language="javascript" />
                             <div class="absolute top-2 right-2">
-                                <CopyToClipboardButton value={step.code} />
+                                <CopyToClipboardButton value={javascriptClientConfiguration.startupCode} />
                             </div>
                         </div>
-                        {#if step.note}
-                            <P>{step.note}</P>
-                        {/if}
                     </li>
-                {/each}
-                <li>
-                    <P>Configure the ExceptionlessClient with your Exceptionless API key.</P>
-                    <div class="bg-muted relative min-h-13 overflow-hidden rounded-md">
-                        <CodeBlock code={javascriptClientConfiguration.startupCode} language="javascript" />
-                        <div class="absolute top-2 right-2">
-                            <CopyToClipboardButton value={javascriptClientConfiguration.startupCode} />
-                        </div>
-                    </div>
-                </li>
+                {/if}
             {/if}
-        {/if}
-    </ol>
+        </ol>
+    </div>
+
+    {#if productTourHost.isActive('configure-project') && productTourHost.activeStepId === 'sdk-instructions'}
+        <ProductTourInlineCallout
+            description="Follow these SDK instructions in your own application. When it is connected, return here and continue to wait for the first event."
+            onContinue={() => productTourHost.advance('configure-project', 'sdk-instructions')}
+            onDismiss={() => productTourHost.dismiss('configure-project')}
+            title="Connect your application"
+            tourId="configure-project"
+        />
+    {/if}
 
     {#if selectedProjectType}
         <P
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/add/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/add/+page.svelte
index d5211667cb..56c3a5a6fc 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/add/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/add/+page.svelte
@@ -91,6 +91,7 @@
                 <Field.Field data-invalid={ariaInvalid(field)}>
                     <Field.Label for={field.name}>Project Name</Field.Label>
                     <Input
+                        data-tour="project-name"
                         id={field.name}
                         name={field.name}
                         placeholder="Enter project name"
@@ -105,7 +106,7 @@
         </form.Field>
         <form.Subscribe selector={(state) => state.isSubmitting}>
             {#snippet children(isSubmitting)}
-                <Button type="submit" class="mt-4" disabled={isSubmitting}>
+                <Button data-tour="project-setup-submit" type="submit" class="mt-4" disabled={isSubmitting}>
                     {#if isSubmitting}
                         <Spinner /> Adding Project...
                     {:else}
diff --git a/src/Exceptionless.Web/Models/User/UpdateProductTourProgress.cs b/src/Exceptionless.Web/Models/User/UpdateProductTourProgress.cs
new file mode 100644
index 0000000000..e8d0fe4b9c
--- /dev/null
+++ b/src/Exceptionless.Web/Models/User/UpdateProductTourProgress.cs
@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using Exceptionless.Core.Models.Data;
+
+namespace Exceptionless.Web.Models;
+
+public record UpdateProductTourProgress
+{
+    [Range(1, Int32.MaxValue)]
+    public int Version { get; init; }
+
+    [Required]
+    [EnumDataType(typeof(ProductTourStatus))]
+    public ProductTourStatus? Status { get; init; }
+}
diff --git a/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs b/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
index d0106044e4..bbc608afbe 100644
--- a/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
+++ b/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
@@ -2,12 +2,19 @@
 using System.Text;
 using Exceptionless.Core.Configuration;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 
 namespace Exceptionless.Web.Models;
 
 public record ViewCurrentUser : ViewUser
 {
-    public ViewCurrentUser(User user, IntercomOptions options)
+    public ViewCurrentUser()
+    {
+        OAuthAccounts = [];
+        ProductTours = new Dictionary<string, ProductTourProgress>(StringComparer.Ordinal);
+    }
+
+    public ViewCurrentUser(User user, IntercomOptions options) : this()
     {
         Id = user.Id;
         OrganizationIds = user.OrganizationIds;
@@ -22,11 +29,13 @@ public ViewCurrentUser(User user, IntercomOptions options)
         Hash = HMACSHA256HashString(user.Id, options);
         HasLocalAccount = !String.IsNullOrWhiteSpace(user.Password);
         OAuthAccounts = user.OAuthAccounts;
+        ProductTours = new Dictionary<string, ProductTourProgress>(user.ProductTours, StringComparer.Ordinal);
     }
 
     public string? Hash { get; set; }
     public bool HasLocalAccount { get; set; }
     public ICollection<OAuthAccount> OAuthAccounts { get; set; }
+    public IDictionary<string, ProductTourProgress> ProductTours { get; set; }
 
     private static string? HMACSHA256HashString(string value, IntercomOptions options)
     {
diff --git a/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json b/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json
index 100eaae183..e2f5d79c68 100644
--- a/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json
+++ b/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json
@@ -2588,6 +2588,20 @@
     "authorizationRoles": [],
     "authenticationSchemes": []
   },
+  {
+    "method": "PUT",
+    "route": "/api/v2/users/me/product-tours/{tourId:minlength(1):maxlength(64)}",
+    "displayName": "HTTP: PUT api/v2/users/me/product-tours/{tourId:minlength(1):maxlength(64)}",
+    "tags": [
+      "User"
+    ],
+    "allowAnonymous": false,
+    "authorizationPolicies": [
+      "UserPolicy"
+    ],
+    "authorizationRoles": [],
+    "authenticationSchemes": []
+  },
   {
     "method": "POST",
     "route": "/api/v2/users/unverify-email-address",
diff --git a/tests/Exceptionless.Tests/Api/Data/openapi.json b/tests/Exceptionless.Tests/Api/Data/openapi.json
index ec1efe8815..b555ea2059 100644
--- a/tests/Exceptionless.Tests/Api/Data/openapi.json
+++ b/tests/Exceptionless.Tests/Api/Data/openapi.json
@@ -3510,6 +3510,75 @@
         }
       }
     },
+    "/api/v2/users/me/product-tours/{tourId}": {
+      "put": {
+        "tags": [
+          "User"
+        ],
+        "summary": "Update current user product tour progress",
+        "parameters": [
+          {
+            "name": "tourId",
+            "in": "path",
+            "description": "The stable product tour identifier.",
+            "required": true,
+            "schema": {
+              "maxLength": 64,
+              "minLength": 1,
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "description": "The versioned product tour outcome.",
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateProductTourProgress"
+              }
+            },
+            "application/*\u002Bjson": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateProductTourProgress"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ViewCurrentUser"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "The product tour progress is invalid.",
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "The current user could not be found.",
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/v2/users/me/oauth-grants": {
       "get": {
         "tags": [
@@ -12731,6 +12800,37 @@
           }
         }
       },
+      "ProductTourProgress": {
+        "required": [
+          "version",
+          "status",
+          "updated_utc"
+        ],
+        "type": "object",
+        "properties": {
+          "version": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "status": {
+            "$ref": "#/components/schemas/ProductTourStatus"
+          },
+          "updated_utc": {
+            "type": "string",
+            "format": "date-time"
+          }
+        }
+      },
+      "ProductTourStatus": {
+        "enum": [
+          "dismissed",
+          "completed"
+        ],
+        "x-enumNames": [
+          "Dismissed",
+          "Completed"
+        ]
+      },
       "ResetPasswordModel": {
         "required": [
           "password_reset_token",
@@ -13098,6 +13198,31 @@
         },
         "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
       },
+      "UpdateProductTourProgress": {
+        "required": [
+          "status",
+          "version"
+        ],
+        "type": "object",
+        "properties": {
+          "version": {
+            "maximum": 2147483647,
+            "minimum": 1,
+            "type": "integer",
+            "format": "int32"
+          },
+          "status": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProductTourStatus"
+              }
+            ]
+          }
+        }
+      },
       "UpdateProject": {
         "type": "object",
         "properties": {
@@ -13296,6 +13421,7 @@
           "organization_ids",
           "password_reset_token_expiration",
           "o_auth_accounts",
+          "product_tours",
           "email_notifications_enabled",
           "is_email_address_verified",
           "verify_email_address_token_expiration",
@@ -13349,6 +13475,12 @@
               "$ref": "#/components/schemas/OAuthAccount"
             }
           },
+          "product_tours": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/components/schemas/ProductTourProgress"
+            }
+          },
           "full_name": {
             "type": "string",
             "description": "Gets or sets the users Full Name."
@@ -13432,6 +13564,7 @@
         "required": [
           "has_local_account",
           "o_auth_accounts",
+          "product_tours",
           "id",
           "organization_ids",
           "full_name",
@@ -13459,6 +13592,12 @@
               "$ref": "#/components/schemas/OAuthAccount"
             }
           },
+          "product_tours": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/components/schemas/ProductTourProgress"
+            }
+          },
           "id": {
             "maxLength": 24,
             "minLength": 24,
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
index 2bcd528a36..ae22dd3c38 100644
--- a/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
+++ b/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
@@ -2,6 +2,7 @@
 using Exceptionless.Core.Authorization;
 using Exceptionless.Core.Extensions;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Repositories;
 using Exceptionless.Core.Services;
 using Exceptionless.Core.Utility;
@@ -37,6 +38,190 @@ protected override async Task ResetDataAsync()
         await service.CreateDataAsync();
     }
 
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_NewProgress_PersistsAndReturnsCurrentUser()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+
+        var updatedUser = await SendRequestAsAsync<ViewCurrentUser>(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "new-ui-overview")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Dismissed })
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updatedUser);
+        var progress = Assert.Contains("new-ui-overview", updatedUser.ProductTours);
+        Assert.Equal(1, progress.Version);
+        Assert.Equal(ProductTourStatus.Dismissed, progress.Status);
+
+        var persistedUser = await _userRepository.GetByIdAsync(currentUser.Id, o => o.Cache(false));
+        Assert.NotNull(persistedUser);
+        Assert.Equal(ProductTourStatus.Dismissed, persistedUser.ProductTours["new-ui-overview"].Status);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_SameVersionCompletedThenDismissed_PreservesCompleted()
+    {
+        await GetTestOrganizationUserAsync();
+
+        await SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "create-saved-view")
+            .Content(new UpdateProductTourProgress { Version = 2, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeOk()
+        );
+
+        var updatedUser = await SendRequestAsAsync<ViewCurrentUser>(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "create-saved-view")
+            .Content(new UpdateProductTourProgress { Version = 2, Status = ProductTourStatus.Dismissed })
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updatedUser);
+        Assert.Equal(ProductTourStatus.Completed, updatedUser.ProductTours["create-saved-view"].Status);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_LowerVersion_DoesNotOverwriteNewerProgress()
+    {
+        await GetTestOrganizationUserAsync();
+
+        await SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "meet-exie")
+            .Content(new UpdateProductTourProgress { Version = 3, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeOk()
+        );
+
+        var updatedUser = await SendRequestAsAsync<ViewCurrentUser>(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "meet-exie")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Dismissed })
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updatedUser);
+        Assert.Equal(3, updatedUser.ProductTours["meet-exie"].Version);
+        Assert.Equal(ProductTourStatus.Completed, updatedUser.ProductTours["meet-exie"].Status);
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_InvalidTourId_ReturnsUnprocessableEntity()
+    {
+        return SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "Invalid--Tour")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeUnprocessableEntity()
+        );
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_AnonymousUser_ReturnsUnauthorized()
+    {
+        return SendRequestAsync(r => r
+            .Put()
+            .AppendPaths("users", "me", "product-tours", "welcome")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Dismissed })
+            .StatusCodeShouldBeUnauthorized());
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_RepeatedRequest_IsIdempotent()
+    {
+        const string tourId = "idempotent-guide";
+        var first = await SendRequestAsAsync<ViewCurrentUser>(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", tourId)
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeOk());
+        var second = await SendRequestAsAsync<ViewCurrentUser>(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", tourId)
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeOk());
+
+        Assert.NotNull(first);
+        Assert.NotNull(second);
+        Assert.Equal(first.ProductTours[tourId].UpdatedUtc, second.ProductTours[tourId].UpdatedUtc);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_ConcurrentKeys_PreservesBoth()
+    {
+        Task first = SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "concurrent-one")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Dismissed })
+            .StatusCodeShouldBeOk());
+        Task second = SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "concurrent-two")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeOk());
+
+        await Task.WhenAll(first, second);
+        var currentUser = await SendRequestAsAsync<ViewCurrentUser>(r => r.AsTestOrganizationUser().AppendPath("users/me").StatusCodeShouldBeOk());
+        Assert.NotNull(currentUser);
+        Assert.Contains("concurrent-one", currentUser.ProductTours);
+        Assert.Contains("concurrent-two", currentUser.ProductTours);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_AtEntryLimit_ReturnsUnprocessableEntity()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+        var user = await _userRepository.GetByIdAsync(currentUser.Id, o => o.Cache(false));
+        Assert.NotNull(user);
+        user.ProductTours.Clear();
+        foreach (int index in Enumerable.Range(0, 32))
+            user.ProductTours[$"guide-{index}"] = new ProductTourProgress { Status = ProductTourStatus.Dismissed, UpdatedUtc = DateTime.UtcNow, Version = 1 };
+        await _userRepository.SaveAsync(user, o => o.Cache().ImmediateConsistency());
+
+        await SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "one-too-many")
+            .Content(new UpdateProductTourProgress { Version = 1, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeUnprocessableEntity());
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    public Task UpdateCurrentUserProductTourAsync_NonPositiveVersion_ReturnsUnprocessableEntity(int version)
+    {
+        return SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "invalid-version")
+            .Content(new UpdateProductTourProgress { Version = version, Status = ProductTourStatus.Completed })
+            .StatusCodeShouldBeUnprocessableEntity());
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_UndefinedStatus_ReturnsUnprocessableEntity()
+    {
+        return SendRequestAsync(r => r
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "invalid-status")
+            .Content(new { Version = 1, Status = 999 })
+            .StatusCodeShouldBeUnprocessableEntity());
+    }
+
     [Fact]
     public async Task AddAdminRoleAsync_AnonymousUser_ReturnsUnauthorized()
     {
diff --git a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
index f42d3bb6bf..1faa6da4e6 100644
--- a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
+++ b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
@@ -61,6 +61,11 @@ public async Task GetOpenApiJson_Default_ContainsExpectedRoutesOperationsAndResp
         Assert.True(projectsPost.TryGetProperty("requestBody", out _));
         AssertResponseCodes(projectsPost, "201");
 
+        Assert.True(paths.TryGetProperty("/api/v2/users/me/product-tours/{tourId}", out var productTourPath));
+        Assert.True(productTourPath.TryGetProperty("put", out var productTourPut));
+        Assert.True(productTourPut.TryGetProperty("requestBody", out _));
+        AssertResponseCodes(productTourPut, "200", "404", "422");
+
         Assert.True(paths.TryGetProperty("/api/v2/assistant/chat", out var assistantChatPath));
         Assert.True(assistantChatPath.TryGetProperty("post", out var assistantChatPost));
         AssertResponseCodes(assistantChatPost, "200", "400", "401", "403", "404", "426", "429", "503");
@@ -100,6 +105,8 @@ public async Task GetOpenApiJson_Default_ContainsExpectedSchemasAndSecuritySchem
         Assert.True(schemas.TryGetProperty("NewProject", out _));
         Assert.True(schemas.TryGetProperty("SavedViewColumnSettings", out var savedViewColumnSettings));
         Assert.True(schemas.TryGetProperty("TokenResult", out _));
+        Assert.True(schemas.TryGetProperty("ProductTourProgress", out _));
+        Assert.True(schemas.TryGetProperty("UpdateProductTourProgress", out _));
         Assert.True(schemas.TryGetProperty("ViewOrganization", out _));
 
         var savedViewColumnProperties = savedViewColumnSettings.GetProperty("properties");
@@ -166,6 +173,7 @@ public async Task GetOpenApiJson_MigratedContracts_PreserveControllerMetadata()
         AssertDictionaryValueSchema(document.RootElement, "ViewSavedView", "columns", "SavedViewColumnSettings");
         AssertRequiredJsonRequestBody(paths, "/api/v2/users/{id}", "patch", "UpdateUser");
         AssertRequiredJsonRequestBody(paths, "/api/v2/users/{id}", "put", "UpdateUser");
+        AssertRequiredJsonRequestBody(paths, "/api/v2/users/me/product-tours/{tourId}", "put", "UpdateProductTourProgress");
 
         AssertRequestContentTypes(paths, "/api/v1/error", "post", "application/json", "text/plain");
         AssertRequestContentTypes(paths, "/api/v1/events", "post", "application/json", "text/plain");
diff --git a/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs b/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs
index 9766e07805..a6467d235f 100644
--- a/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs
+++ b/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs
@@ -1,4 +1,5 @@
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 using Foundatio.Serializer;
 using Xunit;
 
@@ -208,6 +209,60 @@ public void Deserialize_SnakeCaseJson_PreservesOrganizationIds()
         Assert.Contains("client", user.Roles);
     }
 
+    [Fact]
+    public void Deserialize_User_PreservesProductTourProgress()
+    {
+        var original = new User
+        {
+            Id = "tour-user",
+            FullName = "Tour User",
+            EmailAddress = "tour@example.com",
+            IsEmailAddressVerified = true,
+            ProductTours = new Dictionary<string, ProductTourProgress>(StringComparer.Ordinal)
+            {
+                ["welcome"] = new()
+                {
+                    Version = 1,
+                    Status = ProductTourStatus.Dismissed,
+                    UpdatedUtc = FixedDateTime
+                },
+                ["new-ui-overview"] = new()
+                {
+                    Version = 2,
+                    Status = ProductTourStatus.Completed,
+                    UpdatedUtc = FixedDateTime.AddMinutes(1)
+                }
+            }
+        };
+
+        string? json = _serializer.SerializeToString(original);
+        var deserialized = _serializer.Deserialize<User>(json);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(2, deserialized.ProductTours.Count);
+        Assert.Equal(ProductTourStatus.Dismissed, deserialized.ProductTours["welcome"].Status);
+        Assert.Equal(2, deserialized.ProductTours["new-ui-overview"].Version);
+        Assert.Equal(ProductTourStatus.Completed, deserialized.ProductTours["new-ui-overview"].Status);
+    }
+
+    [Fact]
+    public void Deserialize_LegacyUserWithoutProductTours_ReturnsEmptyCollection()
+    {
+        const string json = """
+            {
+                "id": "legacy-user",
+                "full_name": "Legacy User",
+                "email_address": "legacy@example.com",
+                "is_email_address_verified": true
+            }
+            """;
+
+        var user = _serializer.Deserialize<User>(json);
+
+        Assert.NotNull(user);
+        Assert.Empty(user.ProductTours);
+    }
+
     [Fact]
     public void Deserialize_SnakeCaseJson_PreservesOAuthAccounts()
     {
diff --git a/tests/http/users.http b/tests/http/users.http
index 38b9d2cee5..f9b2a6a240 100644
--- a/tests/http/users.http
+++ b/tests/http/users.http
@@ -26,6 +26,16 @@ Authorization: Bearer {{token}}
 @avatarFile = ./avatar.png
 @oauthGrantId = replace-with-oauth-grant-id
 
+### Record Product Tour Progress
+PUT {{apiUrl}}/users/me/product-tours/new-ui-overview
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{
+    "version": 1,
+    "status": "completed"
+}
+
 ### Get OAuth Grants
 GET {{apiUrl}}/users/me/oauth-grants
 Authorization: Bearer {{token}}