diff --git a/src/Exceptionless.Core/Models/Data/ProductTourProgress.cs b/src/Exceptionless.Core/Models/Data/ProductTourProgress.cs
new file mode 100644
index 0000000000..fbcf95fd89
--- /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 ProductTourStatus Status { get; set; }
+    public DateTime UpdatedUtc { get; set; }
+    public int Version { get; set; }
+}
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum ProductTourStatus
+{
+    [JsonStringEnumMemberName("completed")]
+    [EnumMember(Value = "completed")]
+    Completed,
+    [JsonStringEnumMemberName("dismissed")]
+    [EnumMember(Value = "dismissed")]
+    Dismissed
+}
diff --git a/src/Exceptionless.Core/Models/Data/ProductTours.cs b/src/Exceptionless.Core/Models/Data/ProductTours.cs
new file mode 100644
index 0000000000..2ce860ec3b
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Data/ProductTours.cs
@@ -0,0 +1,88 @@
+using System.Collections.Frozen;
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+using Exceptionless.Core.Extensions;
+
+namespace Exceptionless.Core.Models.Data;
+
+public static class ProductTours
+{
+    public const string ConfigureProject = "configure-project";
+    public const string CreateSavedView = "create-saved-view";
+    public const string ExieAnnouncement = "exie-announcement";
+    public const string InvestigateError = "investigate-error";
+    public const string MeetExie = "meet-exie";
+    public const string UiOverview = "ui-overview";
+    public const string Welcome = "welcome";
+
+    public static IReadOnlyDictionary<string, int> Versions { get; } = new Dictionary<string, int>(StringComparer.Ordinal)
+    {
+        [ConfigureProject] = 1,
+        [CreateSavedView] = 1,
+        [ExieAnnouncement] = 1,
+        [InvestigateError] = 1,
+        [MeetExie] = 1,
+        [UiOverview] = 1,
+        [Welcome] = 1
+    }.ToFrozenDictionary(StringComparer.Ordinal);
+
+    public static IReadOnlyCollection<ProductTourTelemetryEvent> TelemetryEvents { get; } = Enum.GetValues<ProductTourTelemetryEvent>();
+    public static IReadOnlyCollection<ProductTourLaunchSource> LaunchSources { get; } = Enum.GetValues<ProductTourLaunchSource>();
+
+    public static bool IsKnown(string name) => Versions.ContainsKey(name);
+
+    public static bool IsValid(string name, int version)
+    {
+        return Versions.TryGetValue(name, out int currentVersion) && version > 0 && version <= currentVersion;
+    }
+
+    public static string CreateTelemetrySource(
+        ProductTourTelemetryEvent telemetryEvent,
+        string tourName,
+        int version,
+        ProductTourLaunchSource launchSource)
+    {
+        return $"product-tour.{GetTelemetryName(telemetryEvent)}.{tourName}.v{version}.{GetLaunchSourceName(launchSource)}";
+    }
+
+    public static string GetTelemetryName(ProductTourTelemetryEvent telemetryEvent) => telemetryEvent.ToString().ToLowerUnderscoredWords('-');
+
+    public static string GetLaunchSourceName(ProductTourLaunchSource launchSource) => launchSource.ToString().ToLowerUnderscoredWords('-');
+}
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum ProductTourTelemetryEvent
+{
+    [JsonStringEnumMemberName("completed")]
+    [EnumMember(Value = "completed")]
+    Completed,
+    [JsonStringEnumMemberName("dismissed")]
+    [EnumMember(Value = "dismissed")]
+    Dismissed,
+    [JsonStringEnumMemberName("shown")]
+    [EnumMember(Value = "shown")]
+    Shown,
+    [JsonStringEnumMemberName("started")]
+    [EnumMember(Value = "started")]
+    Started
+}
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum ProductTourLaunchSource
+{
+    [JsonStringEnumMemberName("automatic")]
+    [EnumMember(Value = "automatic")]
+    Automatic,
+    [JsonStringEnumMemberName("catalog")]
+    [EnumMember(Value = "catalog")]
+    Catalog,
+    [JsonStringEnumMemberName("command-palette")]
+    [EnumMember(Value = "command-palette")]
+    CommandPalette,
+    [JsonStringEnumMemberName("feature-announcement")]
+    [EnumMember(Value = "feature-announcement")]
+    FeatureAnnouncement,
+    [JsonStringEnumMemberName("help-menu")]
+    [EnumMember(Value = "help-menu")]
+    HelpMenu
+}
diff --git a/src/Exceptionless.Core/Models/User.cs b/src/Exceptionless.Core/Models/User.cs
index cb6e154e50..cd8146ace8 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;
@@ -24,6 +25,7 @@ public record User : IIdentity, IHaveDates, IValidatableObject
     public DateTime PasswordResetTokenExpiration { get; set; }
     public ICollection<OAuthAccount> OAuthAccounts { get; init; } = new Collection<OAuthAccount>();
     public ICollection<UserOrganizationPreference> OrganizationPreferences { get; init; } = new Collection<UserOrganizationPreference>();
+    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.Core/Repositories/EventRepository.cs b/src/Exceptionless.Core/Repositories/EventRepository.cs
index 3fba37a69d..264c90241c 100644
--- a/src/Exceptionless.Core/Repositories/EventRepository.cs
+++ b/src/Exceptionless.Core/Repositories/EventRepository.cs
@@ -1,10 +1,14 @@
-using Elastic.Clients.Elasticsearch.QueryDsl;
+using Elastic.Clients.Elasticsearch.Aggregations;
+using Elastic.Clients.Elasticsearch.QueryDsl;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Repositories.Configuration;
 using Exceptionless.Core.Repositories.Queries;
 using Exceptionless.Core.Validation;
 using Exceptionless.DateTimeExtensions;
 using Foundatio.Repositories;
+using Foundatio.Repositories.Elasticsearch.Extensions;
+using Foundatio.Repositories.Exceptions;
 using Foundatio.Repositories.Models;
 
 namespace Exceptionless.Core.Repositories;
@@ -82,6 +86,163 @@ public Task<FindResults<PersistentEvent>> GetByReferenceIdAsync(string projectId
         return FindAsync(q => q.Project(projectId).FieldEquals(e => e.ReferenceId, referenceId).SortDescending(e => e.Date), o => o.PageLimit(10));
     }
 
+    public async Task<ProductTourUsageResult> GetProductTourUsageAsync(string projectId, DateTime utcStart, DateTime utcEnd, int recentLimit = 500)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(projectId);
+        ArgumentOutOfRangeException.ThrowIfLessThan(recentLimit, 1);
+        if (utcEnd <= utcStart)
+            throw new ArgumentOutOfRangeException(nameof(utcEnd), "The end date must be later than the start date.");
+
+        var sourcesByTour = ProductTours.Versions.ToDictionary(
+            pair => pair.Key,
+            pair => CreateProductTourSources(pair.Key, pair.Value),
+            StringComparer.Ordinal);
+        var sourcesByName = sourcesByTour.Values
+            .SelectMany(sources => sources)
+            .ToDictionary(source => source.Raw, StringComparer.Ordinal);
+        string[] allSources = sourcesByName.Keys.ToArray();
+
+        var aggregationTask = GetProductTourUsageToursAsync(projectId, utcStart, utcEnd, sourcesByTour, allSources);
+        var recentTask = FindAsync(query => ApplyProductTourUsageFilter(query, projectId, utcStart, utcEnd, allSources)
+            .SortDescending(ev => ev.Date), options => options.PageLimit(recentLimit));
+
+        await Task.WhenAll(aggregationTask, recentTask);
+        var recentEvents = (await recentTask).Documents
+            .Select(ev => ev.Source is not null && sourcesByName.TryGetValue(ev.Source, out var source) ? new ProductTourUsageEvent(ev, source) : null)
+            .OfType<ProductTourUsageEvent>()
+            .ToArray();
+        return new ProductTourUsageResult(await aggregationTask, recentEvents);
+    }
+
+    private async Task<IReadOnlyCollection<ProductTourUsageTour>> GetProductTourUsageToursAsync(
+        string projectId,
+        DateTime utcStart,
+        DateTime utcEnd,
+        IReadOnlyDictionary<string, ProductTourUsageSource[]> sourcesByTour,
+        string[] allSources)
+    {
+        var query = ApplyProductTourUsageFilter(NewQuery(), projectId, utcStart, utcEnd, allSources);
+        var options = ConfigureOptions(null);
+        await OnBeforeQueryAsync(query, options, typeof(PersistentEvent));
+        await RefreshForConsistency(query, options);
+
+        var search = (await CreateSearchDescriptorAsync(query, options))
+            .Size(0)
+            .Aggregations(CreateProductTourAggregations(sourcesByTour));
+        var response = await _client.SearchAsync<PersistentEvent>(search);
+        _logger.LogRequest(response);
+
+        if (!response.IsValidResponse)
+            throw new DocumentException($"Error getting product tour usage: {response.ElasticsearchServerError?.Error?.Reason}", response.ApiCallDetails.OriginalException);
+
+        var tours = new List<ProductTourUsageTour>();
+        foreach ((string tourName, ProductTourUsageSource[] sources) in sourcesByTour)
+        {
+            if (response.Aggregations is null
+                || !response.Aggregations.TryGetValue(tourName, out var aggregate)
+                || aggregate is not FilterAggregate filterAggregate
+                || filterAggregate.Aggregations is null)
+                continue;
+
+            if (!filterAggregate.Aggregations.TryGetValue("sources", out var sourceAggregate) || sourceAggregate is not StringTermsAggregate sourceTerms)
+                continue;
+
+            var buckets = new List<ProductTourUsageBucket>();
+            foreach (var bucket in sourceTerms.Buckets)
+            {
+                if (!bucket.Key.TryGetString(out string? sourceValue))
+                    continue;
+
+                var source = sources.FirstOrDefault(source => String.Equals(source.Raw, sourceValue, StringComparison.Ordinal));
+                if (source is null)
+                    continue;
+
+                long count = bucket.Aggregations is { } bucketAggregations
+                    && bucketAggregations.TryGetValue("count", out var countAggregate)
+                    && countAggregate is SumAggregate sum
+                    ? Convert.ToInt64(sum.Value)
+                    : bucket.DocCount;
+                DateTime? lastUtc = bucket.Aggregations is { } lastAggregations
+                    && lastAggregations.TryGetValue("last", out var lastAggregate)
+                    && lastAggregate is MaxAggregate max
+                    ? max.ValueAsString is null ? null : DateTime.Parse(max.ValueAsString, null, System.Globalization.DateTimeStyles.RoundtripKind)
+                    : null;
+                buckets.Add(new ProductTourUsageBucket(source, count, lastUtc));
+            }
+
+            long uniqueUsers = filterAggregate.Aggregations.TryGetValue("users", out var usersAggregate) && usersAggregate is CardinalityAggregate cardinality
+                ? Convert.ToInt64(cardinality.Value)
+                : 0;
+            if (buckets.Count > 0)
+                tours.Add(new ProductTourUsageTour(tourName, uniqueUsers, buckets));
+        }
+
+        return tours;
+    }
+
+    private IDictionary<string, Aggregation> CreateProductTourAggregations(IReadOnlyDictionary<string, ProductTourUsageSource[]> sourcesByTour)
+    {
+        string sourceField = ElasticIndex.MappingResolver.GetNonAnalyzedFieldName(InferField(ev => ev.Source))!;
+        string userPath = EventIndexExtensions.DataPath<UserInfo>(Event.KnownDataKeys.UserInfo, user => user.Identity);
+        string userField = ElasticIndex.MappingResolver.GetNonAnalyzedFieldName(userPath) ?? userPath;
+        var aggregations = new Dictionary<string, Aggregation>(StringComparer.Ordinal);
+
+        foreach ((string tourName, ProductTourUsageSource[] sources) in sourcesByTour)
+        {
+            aggregations[tourName] = new Aggregation
+            {
+                Filter = new TermsQuery
+                {
+                    Field = sourceField,
+                    Terms = new TermsQueryField(sources.Select(source => (Elastic.Clients.Elasticsearch.FieldValue)source.Raw).ToArray())
+                },
+                Aggregations = new Dictionary<string, Aggregation>
+                {
+                    ["sources"] = new Aggregation
+                    {
+                        Terms = new TermsAggregation { Field = sourceField, Size = sources.Length },
+                        Aggregations = new Dictionary<string, Aggregation>
+                        {
+                            ["count"] = new SumAggregation { Field = InferField(ev => ev.Count), Missing = 1 },
+                            ["last"] = new MaxAggregation { Field = InferField(ev => ev.Date) }
+                        }
+                    },
+                    ["users"] = new CardinalityAggregation { Field = userField }
+                }
+            };
+        }
+
+        return aggregations;
+    }
+
+    private static IRepositoryQuery<PersistentEvent> ApplyProductTourUsageFilter(
+        IRepositoryQuery<PersistentEvent> query,
+        string projectId,
+        DateTime utcStart,
+        DateTime utcEnd,
+        string[] sources)
+    {
+        return query
+            .Project(projectId)
+            .FieldEquals(ev => ev.Type, Event.KnownTypes.FeatureUsage)
+            .FieldEquals(ev => ev.Source, sources)
+            .DateRange(utcStart, utcEnd, (PersistentEvent ev) => ev.Date)
+            .Index(utcStart, utcEnd);
+    }
+
+    private static ProductTourUsageSource[] CreateProductTourSources(string tourName, int currentVersion)
+    {
+        return Enumerable.Range(1, currentVersion)
+            .SelectMany(version => ProductTours.TelemetryEvents.SelectMany(telemetryEvent => ProductTours.LaunchSources.Select(launchSource =>
+                new ProductTourUsageSource(
+                    ProductTours.CreateTelemetrySource(telemetryEvent, tourName, version, launchSource),
+                    telemetryEvent,
+                    tourName,
+                    version,
+                    launchSource))))
+            .ToArray();
+    }
+
     public async Task<PreviousAndNextEventIdResult> GetPreviousAndNextEventIdsAsync(PersistentEvent ev, AppFilter? systemFilter = null, DateTime? utcStart = null, DateTime? utcEnd = null)
     {
         var previous = GetPreviousEventIdAsync(ev, systemFilter, utcStart, utcEnd);
diff --git a/src/Exceptionless.Core/Repositories/Interfaces/IEventRepository.cs b/src/Exceptionless.Core/Repositories/Interfaces/IEventRepository.cs
index c7c2272cbc..9545942087 100644
--- a/src/Exceptionless.Core/Repositories/Interfaces/IEventRepository.cs
+++ b/src/Exceptionless.Core/Repositories/Interfaces/IEventRepository.cs
@@ -13,6 +13,7 @@ public interface IEventRepository : IRepositoryOwnedByOrganizationAndProject<Per
     Task<bool> UpdateSessionStartLastActivityAsync(string id, DateTime lastActivityUtc, bool isSessionEnd = false, bool hasError = false, bool sendNotifications = true);
     Task<long> RemoveAllAsync(string organizationId, string? clientIpAddress, DateTime? utcStart, DateTime? utcEnd, CommandOptionsDescriptor<PersistentEvent>? options = null);
     Task<long> RemoveAllByStackIdsAsync(string[] stackIds);
+    Task<ProductTourUsageResult> GetProductTourUsageAsync(string projectId, DateTime utcStart, DateTime utcEnd, int recentLimit = 500);
 }
 
 public static class EventRepositoryExtensions
diff --git a/src/Exceptionless.Core/Repositories/ProductTourUsageResult.cs b/src/Exceptionless.Core/Repositories/ProductTourUsageResult.cs
new file mode 100644
index 0000000000..b6fbc20df6
--- /dev/null
+++ b/src/Exceptionless.Core/Repositories/ProductTourUsageResult.cs
@@ -0,0 +1,21 @@
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
+
+namespace Exceptionless.Core.Repositories;
+
+public sealed record ProductTourUsageResult(
+    IReadOnlyCollection<ProductTourUsageTour> Tours,
+    IReadOnlyCollection<ProductTourUsageEvent> RecentEvents);
+
+public sealed record ProductTourUsageTour(string Name, long UniqueUsers, IReadOnlyCollection<ProductTourUsageBucket> Buckets);
+
+public sealed record ProductTourUsageBucket(ProductTourUsageSource Source, long Count, DateTime? LastUtc);
+
+public sealed record ProductTourUsageEvent(PersistentEvent Event, ProductTourUsageSource Source);
+
+public sealed record ProductTourUsageSource(
+    string Raw,
+    ProductTourTelemetryEvent Event,
+    string TourName,
+    int Version,
+    ProductTourLaunchSource LaunchSource);
diff --git a/src/Exceptionless.Web/Api/Endpoints/AdminEndpoints.cs b/src/Exceptionless.Web/Api/Endpoints/AdminEndpoints.cs
index 7d6bbbbfe4..22bce2dc6e 100644
--- a/src/Exceptionless.Web/Api/Endpoints/AdminEndpoints.cs
+++ b/src/Exceptionless.Web/Api/Endpoints/AdminEndpoints.cs
@@ -87,6 +87,14 @@ public static IEndpointRouteBuilder MapAdminEndpoints(this IEndpointRouteBuilder
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden);
 
+        endpoints.MapGet("api/v2/admin/product-tour-usage", GetProductTourUsageAsync)
+            .RequireAuthorization(AuthorizationRoles.GlobalAdminPolicy)
+            .AddEndpointFilter<AutoValidationEndpointFilter>()
+            .Produces<AdminProductTourUsageResponse>(StatusCodes.Status200OK)
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces(StatusCodes.Status403Forbidden);
+
         group.MapPost("change-plan", async (HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, string organizationId, string planId)
             => (await mediator.InvokeAsync<Result<object>>(new AdminChangePlan(organizationId, planId, httpContext))).ToHttpResult(resultMapper));
 
@@ -130,4 +138,11 @@ private static EventSubmissionSettings CreateEventSubmissionSettings(bool? enabl
         bool configuredEnabled = !appOptions.EventSubmissionDisabled;
         return new EventSubmissionSettings(enabledOverride ?? configuredEnabled, configuredEnabled, enabledOverride.HasValue);
     }
+
+    private static async Task<HttpIResult> GetProductTourUsageAsync(
+        IMediator mediator,
+        IMediatorResultMapper<HttpIResult> resultMapper,
+        DateTime? month = null,
+        int limit = 100)
+        => (await mediator.InvokeAsync<Result<object>>(new GetAdminProductTourUsage(month, limit))).ToHttpResult(resultMapper);
 }
diff --git a/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs b/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
index 44ce3acd29..96f0464734 100644
--- a/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
+++ b/src/Exceptionless.Web/Api/Endpoints/UserEndpoints.cs
@@ -1,4 +1,5 @@
 using Exceptionless.Core.Authorization;
+using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Extensions;
 using Exceptionless.Web.Api.Filters;
 using Exceptionless.Web.Api.Infrastructure;
@@ -37,6 +38,27 @@ public static IEndpointRouteBuilder MapUserEndpoints(this IEndpointRouteBuilder
             }
         });
 
+        group.MapPut("users/me/product-tours/{tourName:regex(^[a-z0-9]+(?:-[a-z0-9]+)*$):maxlength(64)}", async (string tourName, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] UpdateProductTourProgress progress)
+            => (await mediator.InvokeAsync<Result<ProductTourProgress>>(new UserMessages.UpdateCurrentUserProductTour(tourName, progress))).ToHttpResult(resultMapper))
+        .Accepts<UpdateProductTourProgress>(false, "application/json")
+        .Produces<ProductTourProgress>()
+        .ProducesProblem(StatusCodes.Status400BadRequest)
+        .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() {
+                ["tourName"] = "The stable product tour name.",
+            },
+            ResponseDescriptions = new() {
+                ["400"] = "The request body is missing or malformed.",
+                ["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/AdminHandler.cs b/src/Exceptionless.Web/Api/Handlers/AdminHandler.cs
index 0fe5e82b12..f9b3b1e8e1 100644
--- a/src/Exceptionless.Web/Api/Handlers/AdminHandler.cs
+++ b/src/Exceptionless.Web/Api/Handlers/AdminHandler.cs
@@ -3,6 +3,7 @@
 using Exceptionless.Core.Extensions;
 using Exceptionless.Core.Messaging.Models;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Models.WorkItems;
 using Exceptionless.Core.Queues.Models;
 using Exceptionless.Core.Repositories;
@@ -17,6 +18,8 @@
 using Foundatio.Queues;
 using Foundatio.Repositories;
 using Foundatio.Repositories.Migrations;
+using Foundatio.Repositories.Models;
+using Foundatio.Serializer;
 using Foundatio.Storage;
 using Foundatio.Mediator;
 
@@ -38,6 +41,7 @@ public class AdminHandler(
     BillingPlans plans,
     IMigrationStateRepository migrationStateRepository,
     SampleDataService sampleDataService,
+    ITextSerializer serializer,
     TimeProvider timeProvider,
     ILoggerFactory loggerFactory)
 {
@@ -78,7 +82,7 @@ public async Task<Result<object>> Handle(GetAdminStats message)
     public async Task<Result<object>> Handle(GetAdminAssistantUsage message)
     {
         var requestedMonth = message.Month ?? timeProvider.GetUtcNow().UtcDateTime;
-        var month = new DateTime(requestedMonth.Year, requestedMonth.Month, 1, 0, 0, 0, DateTimeKind.Utc);
+        var month = requestedMonth.ToUniversalTime().StartOfMonth();
         var results = await organizationRepository.FindAsync(
             query => query.FieldEquals(organization => organization.AssistantUsage.First().Date, month),
             options => options.SearchAfterPaging().PageLimit(500));
@@ -134,6 +138,50 @@ public async Task<Result<object>> Handle(GetAdminAssistantUsage message)
             rows.Take(limit).ToArray());
     }
 
+    public async Task<Result<object>> Handle(GetAdminProductTourUsage message)
+    {
+        var requestedMonth = message.Month ?? timeProvider.GetUtcNow().UtcDateTime;
+        var month = requestedMonth.ToUniversalTime().StartOfMonth();
+        var nextMonth = month.AddMonths(1);
+        int limit = Math.Clamp(message.Limit, 1, 500);
+
+        var usage = await eventRepository.GetProductTourUsageAsync(appOptions.InternalProjectId, month, nextMonth, limit);
+        var tours = usage.Tours
+            .Select(tour =>
+            {
+                long shown = SumEvent(tour.Buckets, ProductTourTelemetryEvent.Shown);
+                long started = SumEvent(tour.Buckets, ProductTourTelemetryEvent.Started);
+                long completed = SumEvent(tour.Buckets, ProductTourTelemetryEvent.Completed);
+                long dismissed = SumEvent(tour.Buckets, ProductTourTelemetryEvent.Dismissed);
+                long decisionDenominator = started > 0 ? started : shown;
+                DateTime? lastRunUtc = tour.Buckets.Select(bucket => bucket.LastUtc).Max();
+
+                return new AdminProductTourSummary(
+                    tour.Name,
+                    shown,
+                    started,
+                    completed,
+                    dismissed,
+                    tour.UniqueUsers,
+                    lastRunUtc,
+                    CalculateRate(completed, decisionDenominator),
+                    CalculateRate(dismissed, decisionDenominator));
+            })
+            .OrderByDescending(tour => tour.Started)
+            .ThenBy(tour => tour.Name, StringComparer.Ordinal)
+            .ToArray();
+
+        var recentActivity = usage.RecentEvents
+            .Select(item => CreateActivity(item.Event, item.Source))
+            .Take(limit)
+            .ToArray();
+
+        return new AdminProductTourUsageResponse(
+            month,
+            tours,
+            recentActivity);
+    }
+
     [HandlerEndpoint(HandlerMethod.Get, "migrations", Group = "Admin")]
     public async Task<Result<object>> Handle(GetAdminMigrations message)
     {
@@ -172,6 +220,30 @@ public Task<Result<object>> Handle(GetAdminEcho message)
         });
     }
 
+    private AdminProductTourActivity CreateActivity(PersistentEvent ev, ProductTourUsageSource source)
+    {
+        var user = ev.GetUserIdentity(serializer, _logger);
+        return new AdminProductTourActivity(
+            ev.Date.UtcDateTime,
+            source.Event,
+            source.LaunchSource,
+            source.TourName,
+            user?.Identity,
+            user?.Name,
+            source.Version,
+            ev.Count ?? 1);
+    }
+
+    private static decimal? CalculateRate(long value, long denominator)
+    {
+        return denominator > 0 ? Decimal.Round(value / (decimal)denominator, 4) : null;
+    }
+
+    private static long SumEvent(IEnumerable<ProductTourUsageBucket> buckets, ProductTourTelemetryEvent telemetryEvent)
+    {
+        return buckets.Where(bucket => bucket.Source.Event == telemetryEvent).Sum(bucket => bucket.Count);
+    }
+
     [HandlerEndpoint(HandlerMethod.Get, "assemblies", Group = "Admin")]
     public Task<Result<object>> Handle(GetAdminAssemblies message)
     {
diff --git a/src/Exceptionless.Web/Api/Handlers/UserHandler.cs b/src/Exceptionless.Web/Api/Handlers/UserHandler.cs
index 92e9bd563e..2d0e4cdd60 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,9 @@
 using Exceptionless.Web.Models.OAuth;
 using Exceptionless.Web.Utility;
 using Foundatio.Caching;
-using Foundatio.Repositories;
 using Foundatio.Mediator;
+using Foundatio.Repositories;
+using Foundatio.Repositories.Models;
 
 namespace Exceptionless.Web.Api.Handlers;
 
@@ -49,6 +51,49 @@ public async Task<Result<ViewCurrentUser>> Handle(GetCurrentUser message)
         };
     }
 
+    public async Task<Result<ProductTourProgress>> Handle(UpdateCurrentUserProductTour message)
+    {
+        if (!ProductTours.IsKnown(message.TourName))
+            return Result.Invalid(ValidationError.Create("tour_name", "Unknown product tour."));
+
+        if (!ProductTours.IsValid(message.TourName, message.Progress.Version))
+            return Result.Invalid(ValidationError.Create("version", "The product tour version is not supported."));
+
+        ProductTourProgress? progress = null;
+        await repository.PatchAsync(
+            GetCurrentUserId(),
+            new ActionPatch<User>(user =>
+            {
+                user.ProductTours.TryGetValue(message.TourName, out var currentProgress);
+                if (!ShouldUpdateProductTourProgress(currentProgress, message.Progress))
+                {
+                    progress = currentProgress;
+                    return false;
+                }
+
+                progress = new ProductTourProgress
+                {
+                    Status = message.Progress.Status!.Value,
+                    UpdatedUtc = timeProvider.GetUtcNow().UtcDateTime,
+                    Version = message.Progress.Version
+                };
+                user.ProductTours[message.TourName] = progress;
+                return true;
+            }),
+            options => options.Cache());
+
+        return progress is null ? Result.NotFound("User not found.") : progress;
+    }
+
+    private static bool ShouldUpdateProductTourProgress(ProductTourProgress? current, UpdateProductTourProgress requested)
+    {
+        return current is null
+            || requested.Version > current.Version
+            || (requested.Version == current.Version
+                && current.Status is ProductTourStatus.Dismissed
+                && requested.Status is ProductTourStatus.Completed);
+    }
+
     public async Task<Result<IReadOnlyCollection<ViewOAuthGrant>>> Handle(GetCurrentUserOAuthGrants message)
     {
         var tokens = new List<OAuthToken>();
diff --git a/src/Exceptionless.Web/Api/Messages/AdminMessages.cs b/src/Exceptionless.Web/Api/Messages/AdminMessages.cs
index df738edd85..43f3144691 100644
--- a/src/Exceptionless.Web/Api/Messages/AdminMessages.cs
+++ b/src/Exceptionless.Web/Api/Messages/AdminMessages.cs
@@ -3,6 +3,7 @@ namespace Exceptionless.Web.Api.Messages;
 public record GetAdminSettings;
 public record GetAdminStats;
 public record GetAdminAssistantUsage(DateTime? Month, int Limit, HttpContext Context);
+public record GetAdminProductTourUsage(DateTime? Month, int Limit);
 public record GetAdminMigrations;
 public record GetAdminEcho(HttpContext Context);
 public record GetAdminAssemblies;
diff --git a/src/Exceptionless.Web/Api/Messages/UserMessages.cs b/src/Exceptionless.Web/Api/Messages/UserMessages.cs
index 7cc329710b..7973ceae86 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 TourName, 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 8b3f0f6eaf..1451c7f25c 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/fixtures/api-client.ts
@@ -309,6 +309,15 @@ export class E2EApiClient {
         await expectStatus(response, [202], 'submit event');
     }
 
+    async updateProductTour(token: string, tourName: string, version: number, status: 'completed' | 'dismissed'): Promise<void> {
+        const response = await this.request.put(this.url(`users/me/product-tours/${tourName}`), {
+            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..380578c279 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/fixtures/e2e-test.ts
@@ -43,6 +43,7 @@ export interface E2ESecondaryProject {
 interface E2EFixtures {
     e2eApi: E2EApiClient;
     e2eCleanupPassword: string;
+    e2eDismissProductTourWelcome: boolean;
     e2eScenario: E2EScenario;
     e2eSecondaryOrganization: E2ESecondaryOrganization;
     e2eSecondaryProject: E2ESecondaryProject;
@@ -57,7 +58,9 @@ export const test = base.extend<E2EFixtures>({
 
     e2eCleanupPassword: [E2E_TEST_PASSWORD, { option: true }],
 
-    e2eScenario: async ({ e2eApi, e2eCleanupPassword, e2eUseGeneratedUser, page }, use, testInfo) => {
+    e2eDismissProductTourWelcome: [true, { option: true }],
+
+    e2eScenario: async ({ e2eApi, e2eCleanupPassword, e2eDismissProductTourWelcome, e2eUseGeneratedUser, page }, use, testInfo) => {
         const run = createRunName(e2eApi.environment.runId, testInfo);
         const userName = `Playwright User ${run}`;
         const email = `playwright-${run}@exceptionless.test`.toLowerCase();
@@ -85,6 +88,9 @@ 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);
+            if (e2eDismissProductTourWelcome) {
+                await e2eApi.updateProductTour(userToken, 'welcome', 1, 'dismissed');
+            }
 
             await page.addInitScript(
                 ({ organizationId, token }) => {
diff --git a/src/Exceptionless.Web/ClientApp/e2e/tests/chart-refresh.e2e.ts b/src/Exceptionless.Web/ClientApp/e2e/tests/chart-refresh.e2e.ts
index 729f62728e..b192730f74 100644
--- a/src/Exceptionless.Web/ClientApp/e2e/tests/chart-refresh.e2e.ts
+++ b/src/Exceptionless.Web/ClientApp/e2e/tests/chart-refresh.e2e.ts
@@ -4,6 +4,7 @@ import { expect, test } from '../fixtures/e2e-test';
 
 test('dashboard charts stay mounted while list data refreshes', async ({ e2eApi, page }) => {
     const userToken = await e2eApi.login();
+    await e2eApi.updateProductTour(userToken, 'welcome', 1, 'dismissed');
     const organizations = await e2eApi.getOrganizations(userToken);
     const organizationId = organizations[0]?.id;
     expect(organizationId).toBeTruthy();
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..04496a2594
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/e2e/tests/product-tours.e2e.ts
@@ -0,0 +1,271 @@
+import type { Page, Request, Response } from '@playwright/test';
+
+import { E2E_TEST_PASSWORD, expect, test } from '../fixtures/e2e-test';
+import { seedRepresentativeEvent } from '../support/event-data';
+import { createRepresentativeEvent } from '../support/synthetic-event';
+
+test.use({ actionTimeout: 15_000, e2eUseGeneratedUser: true });
+
+test.describe('first-run welcome', () => {
+    test.use({ e2eDismissProductTourWelcome: false });
+
+    test('Browse Guides persists before the catalog opens', async ({ e2eScenario, page }) => {
+        await test.step(`show the first-run prompt for ${e2eScenario.email}`, async () => {
+            await page.goto('/next/stack');
+            await expect(page.getByRole('dialog', { name: 'Welcome to Exceptionless' })).toBeVisible();
+        });
+
+        const persisted = page.waitForResponse(isSuccessfulTourProgress('welcome'));
+        await page.getByRole('dialog', { name: 'Welcome to Exceptionless' }).getByRole('button', { name: 'Browse Guides' }).click();
+        await persisted;
+
+        const catalog = page.getByRole('dialog', { name: 'Guided Tours' });
+        await expect(catalog).toBeVisible();
+        await catalog.getByRole('button', { name: 'Close' }).click();
+        await page.reload();
+        await expect(page.getByRole('dialog', { name: 'Welcome to Exceptionless' })).toBeHidden();
+    });
+});
+
+test.describe('shell and identity checkpoints', () => {
+    test.use({ e2eDismissProductTourWelcome: false });
+
+    test('supports responsive resume and never carries checkpoints across identities', async ({ e2eApi, e2eScenario, e2eSecondaryOrganization, page }) => {
+        test.setTimeout(240_000);
+        const progressWrites: string[] = [];
+        page.on('request', (request) => {
+            if (request.method() === 'PUT' && request.url().includes('/api/v2/users/me/product-tours/')) {
+                progressWrites.push(new URL(request.url()).pathname);
+            }
+        });
+
+        await test.step('closing the welcome persists dismissal', async () => {
+            await page.goto('/next/stack');
+            await expect(page.getByRole('dialog', { name: 'Welcome to Exceptionless' })).toBeVisible();
+            const dismissed = page.waitForResponse(isSuccessfulTourProgress('welcome'));
+            await page.keyboard.press('Escape');
+            await dismissed;
+            await expect(page.getByRole('dialog', { name: 'Welcome to Exceptionless' })).toBeHidden();
+        });
+
+        await test.step('the shell tour renders on mobile and resumes on desktop with reduced motion', async () => {
+            await page.setViewportSize({ height: 844, width: 390 });
+            await startTourFromCommand(page, 'Explore Exceptionless');
+            const tour = page.locator('.driver-popover');
+            await expect(page.locator('[data-tour="app-navigation"]')).toBeVisible();
+            await expect(tour.getByText('Your workspace navigation')).toBeVisible();
+
+            await page.emulateMedia({ reducedMotion: 'reduce' });
+            await page.setViewportSize({ height: 900, width: 1440 });
+            await tour.getByRole('button', { name: 'Continue' }).click();
+            await expect(tour.getByText('Find anything quickly')).toBeVisible();
+            await page.reload();
+            await expect(tour.getByText('Find anything quickly')).toBeVisible();
+
+            const dismissed = page.waitForResponse(isSuccessfulTourProgress('ui-overview'));
+            await tour.getByRole('button', { name: 'Close' }).click();
+            await dismissed;
+            await expectProductTourSession(page, false);
+        });
+
+        await test.step('an organization change clears an active checkpoint without recording progress', async () => {
+            await mockAssistantAccess(page);
+            await page.reload();
+            await startTourFromCommand(page, 'Meet Exie');
+            await expectProductTourSession(page, true);
+            const writesBeforeSwitch = progressWrites.length;
+
+            const identityTab = await page.context().newPage();
+            await identityTab.goto('/next/stack');
+            await identityTab.evaluate((organizationId) => {
+                window.localStorage.setItem('organization', JSON.stringify(organizationId));
+            }, e2eSecondaryOrganization.organizationId);
+            await identityTab.close();
+            await expectProductTourSession(page, false);
+            expect(progressWrites).toHaveLength(writesBeforeSwitch);
+        });
+
+        await test.step('logout clears an active checkpoint without recording progress', async () => {
+            await startTourFromCommand(page, 'Meet Exie');
+            await expectProductTourSession(page, true);
+            const writesBeforeLogout = progressWrites.length;
+
+            await page.getByRole('button', { name: new RegExp(e2eScenario.userName) }).dispatchEvent('click');
+            await page.getByRole('menuitem', { name: 'Log Out' }).dispatchEvent('click');
+            await expect(page).toHaveURL(/\/next\/login/);
+            await expectProductTourSession(page, false);
+            expect(progressWrites).toHaveLength(writesBeforeLogout);
+
+            e2eScenario.userToken = await e2eApi.login(e2eScenario.email, E2E_TEST_PASSWORD);
+        });
+    });
+});
+
+test('domain workflows advance only on real success', async ({ e2eApi, e2eScenario, page }) => {
+    test.setTimeout(300_000);
+
+    await test.step('project configuration advances after creation and the first event', async () => {
+        await page.goto('/next/stack');
+        await startTourFromCommand(page, 'Configure a project');
+        await expect(page.getByRole('heading', { name: 'Add Project' })).toBeVisible();
+
+        const projectName = `Tour Project ${e2eScenario.run}`;
+        await page.getByLabel('Project Name', { exact: true }).fill(projectName);
+        await page.getByRole('button', { name: 'Continue to Client Setup' }).click();
+        await page.waitForURL(/\/next\/project\/[^/]+\/configure\?redirect=true/);
+        const projectId = page.url().match(/\/project\/([^/]+)\/configure/)?.[1];
+        expect(projectId).toBeTruthy();
+
+        await page.locator('[data-tour="project-configure-platform"]').click();
+        await page.getByRole('option', { name: 'Browser applications' }).click();
+        await page.locator('[data-product-tour-inline="configure-project"]').getByRole('button', { name: 'Continue' }).click();
+        await expect(page.getByText('Waiting for your first event')).toBeVisible();
+
+        try {
+            const token = await e2eApi.getProjectDefaultToken(e2eScenario.userToken, projectId!);
+            await e2eApi.submitEvent(
+                projectId!,
+                token.id,
+                createRepresentativeEvent({
+                    appUrl: e2eApi.environment.appUrl,
+                    message: e2eScenario.message,
+                    referenceId: e2eScenario.referenceId,
+                    runId: e2eApi.environment.runId
+                })
+            );
+            await expect(page).toHaveURL(/\/next\/event/);
+            await expectProductTourSession(page, false);
+        } finally {
+            await e2eApi.deleteProject(e2eScenario.userToken, projectId!);
+            await e2eApi.waitForProjectDeleted(e2eScenario.userToken, projectId!);
+        }
+    });
+
+    await test.step('saved-view progress retry never repeats the successful POST', async () => {
+        let createRequests = 0;
+        let progressRequests = 0;
+        const countSavedViewCreation = (request: Request) => {
+            const path = new URL(request.url()).pathname;
+            if (request.method() === 'POST' && /^\/api\/v2\/organizations\/[^/]+\/saved-views$/.test(path)) createRequests += 1;
+        };
+        const progressRoute = (url: URL) => url.pathname === '/api/v2/users/me/product-tours/create-saved-view';
+        page.on('request', countSavedViewCreation);
+        await page.route(progressRoute, async (route) => {
+            progressRequests += 1;
+            if (progressRequests === 1) {
+                await route.fulfill({ json: { title: 'Injected progress failure' }, status: 500 });
+                return;
+            }
+
+            await route.continue();
+        });
+
+        try {
+            await page.goto('/next/event');
+            await startTourFromCommand(page, 'Create a saved view');
+            await expectProductTourSession(page, true);
+            const tour = page.locator('.driver-popover');
+            await tour.getByRole('button', { name: 'Continue' }).click();
+            await tour.getByRole('button', { name: 'Continue' }).click();
+
+            await page.getByLabel('Name', { exact: true }).fill(`Tour View ${e2eScenario.run}`);
+            await page.getByRole('button', { name: 'Continue' }).click();
+            await page.getByRole('button', { name: 'Continue' }).click();
+            await page.getByRole('button', { exact: true, name: 'Save' }).click();
+            await expect(page.getByText('Retry guide completion')).toBeVisible();
+            expect(createRequests).toBe(1);
+
+            await page.reload();
+            await expect(page.getByRole('button', { name: 'Retry guide completion' })).toBeVisible();
+            const completed = page.waitForResponse(isSuccessfulTourProgress('create-saved-view'));
+            await page.getByRole('button', { name: 'Retry guide completion' }).click();
+            await completed;
+            await expect.poll(() => createRequests).toBe(1);
+            await expectProductTourSession(page, false);
+        } finally {
+            page.off('request', countSavedViewCreation);
+            await page.unroute(progressRoute);
+        }
+    });
+
+    await test.step('investigation advances when a real error opens', async () => {
+        await seedRepresentativeEvent(e2eApi, e2eScenario.userToken, {
+            message: e2eScenario.message,
+            projectId: e2eScenario.projectId,
+            projectToken: e2eScenario.projectToken,
+            referenceId: e2eScenario.referenceId
+        });
+        await page.goto('/next/event?time=all&type=error');
+        await expect(page.getByText(e2eScenario.message).first()).toBeVisible({ timeout: 30_000 });
+        await startTourFromCommand(page, 'Investigate an error');
+        await page.locator('.driver-popover').getByRole('button', { name: 'Continue' }).click();
+        await page.locator('tr').filter({ hasText: e2eScenario.message }).first().click();
+        const callout = page.locator('[data-product-tour-inline="investigate-error"]');
+        await expect(callout.getByText('Understand the grouped issue')).toBeVisible();
+        for (const title of ['Triage deliberately', 'Inspect the occurrence', 'Begin with the overview', 'Compare every occurrence']) {
+            await callout.getByRole('button', { name: 'Continue' }).click();
+            await expect(callout.getByText(title)).toBeVisible();
+        }
+
+        const completed = page.waitForResponse(isSuccessfulTourProgress('investigate-error'));
+        await callout.getByRole('button', { name: 'Finish guide' }).click();
+        await completed;
+        await expectProductTourSession(page, false);
+        await page.reload();
+        await expect(page.locator('[data-product-tour-inline="investigate-error"]')).toBeHidden();
+    });
+
+    await test.step('Exie opens context without provider submission', async () => {
+        await mockAssistantAccess(page);
+        let chatRequests = 0;
+        const countChatRequest = (request: Request) => {
+            if (new URL(request.url()).pathname === '/api/v2/assistant/chat') chatRequests += 1;
+        };
+        page.on('request', countChatRequest);
+
+        try {
+            await page.goto('/next/stack');
+            await startTourFromCommand(page, 'Meet Exie');
+            const tour = page.locator('.driver-popover');
+            await tour.getByRole('button', { name: 'Continue' }).click();
+            await expect(tour.getByText('You control every request')).toBeVisible();
+            expect(chatRequests).toBe(0);
+        } finally {
+            page.off('request', countChatRequest);
+        }
+    });
+});
+
+async function expectProductTourSession(page: Page, present: boolean): Promise<void> {
+    const assertion = expect.poll(() => page.evaluate(() => sessionStorage.getItem('exceptionless.product-tour')));
+    if (present) {
+        await assertion.not.toBeNull();
+    } else {
+        await assertion.toBeNull();
+    }
+}
+
+function isSuccessfulTourProgress(tourName: string) {
+    return (response: Response): boolean => {
+        const path = new URL(response.url()).pathname;
+        return response.request().method() === 'PUT' && path === `/api/v2/users/me/product-tours/${tourName}` && response.status() === 200;
+    };
+}
+
+async function mockAssistantAccess(page: Page): Promise<void> {
+    await page.route(
+        (url) => url.pathname === '/api/v2/assistant/access',
+        (route) => route.fulfill({ json: { enabled: true, has_access: true, message: null, upgrade_required: false } })
+    );
+}
+
+async function startTourFromCommand(page: Page, title: string): Promise<void> {
+    const announcementStart = page.getByRole('button', { name: 'See how it works' });
+    if (title === 'Meet Exie' && (await announcementStart.isVisible())) {
+        await announcementStart.click();
+        return;
+    }
+
+    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 23a4f6bd0e..483f1f2f02 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.14",
+                "driver.js": "^1.8.0",
                 "layerchart": "^2.3.0",
                 "mode-watcher": "^1.1.0",
                 "oidc-client-ts": "^3.5.0",
@@ -6069,6 +6070,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 f3fc1b0a20..f9d84a2dbd 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.14",
+        "driver.js": "^1.8.0",
         "layerchart": "^2.3.0",
         "mode-watcher": "^1.1.0",
         "oidc-client-ts": "^3.5.0",
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/admin/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/admin/api.svelte.ts
index 63f51aab4f..1d35d410b5 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/admin/api.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/admin/api.svelte.ts
@@ -6,6 +6,7 @@ import type {
     AdminAssistantSettings,
     AdminAssistantUsage,
     AdminEventSubmissionSettings,
+    AdminProductTourUsage,
     AdminStats,
     ElasticsearchInfo,
     ElasticsearchSnapshotsResponse,
@@ -32,6 +33,7 @@ export const queryKeys = {
     eventSubmissionSettings: ['admin', 'event-submission-settings'] as const,
     migrations: ['admin', 'migrations'] as const,
     oauthApplications: ['admin', 'oauth-applications'] as const,
+    productTourUsage: (month: string) => ['admin', 'product-tour-usage', month] as const,
     snapshots: ['admin', 'elasticsearch', 'snapshots'] as const,
     stats: ['admin', 'stats'] as const
 };
@@ -98,6 +100,29 @@ export function getAdminAssistantUsageQuery(month: () => string) {
     }));
 }
 
+export function getAdminProductTourUsageQuery(month: () => string) {
+    return createQuery<AdminProductTourUsage, ProblemDetails>(() => ({
+        queryFn: async ({ signal }: { signal: AbortSignal }) => {
+            const client = useFetchClient();
+            const response = await client.getJSON<AdminProductTourUsage>('admin/product-tour-usage', {
+                params: {
+                    limit: 100,
+                    month: `${month()}-01`
+                },
+                signal
+            });
+
+            if (!response.ok) {
+                throw response.problem;
+            }
+
+            return response.data!;
+        },
+        queryKey: queryKeys.productTourUsage(month()),
+        staleTime: 60 * 1000
+    }));
+}
+
 export function getAdminStatsQuery() {
     return createQuery<AdminStats, ProblemDetails>(() => ({
         queryFn: async ({ signal }: { signal: AbortSignal }) => {
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/admin/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/admin/models.ts
index e5bd45b444..568924dad6 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/admin/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/admin/models.ts
@@ -1,12 +1,13 @@
 import type {
     AssistantModelSettings,
     CountResult,
-    EventSubmissionSettings,
     UpdateAssistantEnabledSettings,
     UpdateAssistantSettings,
     UpdateEventSubmissionSettings
 } from '$generated/api';
 
+export type { EventSubmissionSettings as AdminEventSubmissionSettings, AdminProductTourUsageResponse as AdminProductTourUsage } from '$generated/api';
+
 export enum MigrationType {
     Versioned = 0,
     VersionedAndResumable = 1,
@@ -49,8 +50,6 @@ export type AdminAssistantUsage = {
     turns: number;
 };
 
-export type AdminEventSubmissionSettings = EventSubmissionSettings;
-
 export type AdminStats = {
     events: CountResult;
     organizations: CountResult;
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 8bd8a218c6..493cd91988 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
@@ -31,6 +31,7 @@
 
     import { getSessionId } from '../utils';
     import { shouldResetActiveEventTab } from './events-overview-tab-state';
+    import InvestigationDetailTour from './investigation-detail-tour.svelte';
     import Environment from './views/environment.svelte';
     import Error from './views/error.svelte';
     import ExtendedData from './views/extended-data.svelte';
@@ -331,7 +332,9 @@
     });
 </script>
 
-<section>
+<InvestigationDetailTour {event} placement="stack" />
+
+<section data-event-type={event ? (hasErrorOrSimpleError(event) ? 'error' : event.type) : undefined} data-tour={event ? 'event-details' : undefined}>
     <h4 class="text-muted-foreground mb-3 text-sm font-semibold tracking-wide uppercase">Stack</h4>
     {#if event?.stack_id}
         <StackCard
@@ -343,7 +346,9 @@
     {/if}
 </section>
 
-<section class="mt-2">
+<InvestigationDetailTour {event} placement="occurrence" />
+
+<section class="mt-2" data-tour={event ? 'event-occurrence' : 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">
@@ -355,6 +360,7 @@
             {#if event?.stack_id}
                 <Button
                     aria-label="Show all events"
+                    data-tour="event-stack-filter"
                     onclick={() => filterChanged(new EventsFacetedFilter.StringFilter('stack', event!.stack_id))}
                     size="icon-sm"
                     title="Show all events"
@@ -397,6 +403,7 @@
     </Table.Root>
 
     {#if event}
+        <InvestigationDetailTour {event} placement="overview" />
         <Tabs.Root class="mt-4 mb-4" bind:value={activeTab}>
             <div class="relative">
                 {#if canScrollTabsLeft}
@@ -424,6 +431,7 @@
                                 draggedPromotedTab === tab && 'bg-accent/70'
                             ]}
                             draggable={isPromotedTab(tab)}
+                            data-tour={tab === 'Overview' ? 'event-tab-overview' : undefined}
                             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/events/components/investigation-detail-tour.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/investigation-detail-tour.svelte
new file mode 100644
index 0000000000..8c7afe291d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/investigation-detail-tour.svelte
@@ -0,0 +1,114 @@
+<script lang="ts">
+    import { createProductTourActions } from '$features/product-tours/actions.svelte';
+    import ProductTourInlineCallout from '$features/product-tours/components/product-tour-inline-callout.svelte';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
+
+    import type { PersistentEvent } from '../models';
+
+    import { hasErrorOrSimpleError } from '../persistent-event';
+
+    interface Props {
+        event?: PersistentEvent;
+        placement: 'occurrence' | 'overview' | 'stack';
+    }
+
+    let { event, placement }: Props = $props();
+    let advancedEventId = $state('');
+
+    const actions = createProductTourActions();
+    const checkpoint = $derived(productTourCheckpoint.current?.tourName === 'investigate-error' ? productTourCheckpoint.current : undefined);
+    const copy = $derived.by(() => {
+        switch (checkpoint?.checkpointName) {
+            case 'event-occurrence':
+                return placement === 'occurrence'
+                    ? {
+                          description: 'This occurrence contains its timestamp, raw JSON, and navigation to nearby events.',
+                          title: 'Inspect the occurrence'
+                      }
+                    : undefined;
+            case 'filter-stack-events':
+                return placement === 'occurrence'
+                    ? {
+                          description: 'Show all events filters the list to this stack when you are ready to compare occurrences.',
+                          title: 'Compare every occurrence'
+                      }
+                    : undefined;
+            case 'stack-summary':
+                return placement === 'stack'
+                    ? {
+                          description: 'Use the grouped stack title, affected users, occurrence count, and trend to judge scope and impact.',
+                          title: 'Understand the grouped issue'
+                      }
+                    : undefined;
+            case 'stack-triage':
+                return placement === 'stack'
+                    ? {
+                          description: 'Status and options change shared issue state. Review them here; this guide will not invoke them.',
+                          title: 'Triage deliberately'
+                      }
+                    : undefined;
+            case 'tab-overview':
+                return placement === 'overview'
+                    ? {
+                          description: 'Overview summarizes the message and useful event fields. Choose other tabs when the evidence calls for them.',
+                          title: 'Begin with the overview'
+                      }
+                    : undefined;
+            default:
+                return undefined;
+        }
+    });
+
+    $effect(() => {
+        if (placement !== 'stack' || !event || event.id === advancedEventId) {
+            return;
+        }
+
+        advancedEventId = event.id;
+        const active = checkpoint;
+        if (active?.checkpointName === 'choose-error' && hasErrorOrSimpleError(event)) {
+            productTourCheckpoint.advance(active, 'stack-summary');
+        }
+    });
+
+    async function continueTour(): Promise<void> {
+        const active = checkpoint;
+        if (!active) {
+            return;
+        }
+
+        switch (active.checkpointName) {
+            case 'event-occurrence':
+                productTourCheckpoint.advance(active, 'tab-overview');
+                break;
+            case 'stack-summary':
+                productTourCheckpoint.advance(active, 'stack-triage');
+                break;
+            case 'stack-triage':
+                productTourCheckpoint.advance(active, 'event-occurrence');
+                break;
+            case 'tab-overview':
+                productTourCheckpoint.advance(active, 'filter-stack-events');
+                break;
+            default:
+                await actions.complete(active);
+        }
+    }
+
+    async function dismiss(): Promise<void> {
+        if (checkpoint) {
+            await actions.dismiss(checkpoint);
+        }
+    }
+</script>
+
+{#if event && checkpoint && copy}
+    <ProductTourInlineCallout
+        continueLabel={checkpoint.checkpointName === 'filter-stack-events' ? 'Finish guide' : 'Continue'}
+        description={copy.description}
+        onContinue={continueTour}
+        onDismiss={dismiss}
+        title={copy.title}
+        tourName="investigate-error"
+    />
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/investigation-list-tour.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/investigation-list-tour.svelte
new file mode 100644
index 0000000000..29f1dcb8de
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/events/components/investigation-list-tour.svelte
@@ -0,0 +1,29 @@
+<script lang="ts">
+    import { createProductTourActions } from '$features/product-tours/actions.svelte';
+    import ProductTourSpotlight from '$features/product-tours/components/product-tour-spotlight.svelte';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
+
+    const actions = createProductTourActions();
+    const checkpoint = $derived(productTourCheckpoint.current?.tourName === 'investigate-error' ? productTourCheckpoint.current : undefined);
+</script>
+
+{#if checkpoint?.checkpointName === 'filter-errors'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Errors are selected. Narrow the list by project, status, date, version, tags, or search terms when you need a specific incident."
+        onDismiss={actions.dismiss}
+        onNext={(current) => {
+            productTourCheckpoint.advance(current, 'choose-error');
+        }}
+        target="[data-tour='event-filters']"
+        title="Start with the right errors"
+    />
+{:else if checkpoint?.checkpointName === 'choose-error'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Choose a real error row. The guide continues only after its detail sheet loads."
+        onDismiss={actions.dismiss}
+        target="[data-tour='event-list']"
+        title="Open a real error"
+    />
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/actions.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/actions.svelte.ts
new file mode 100644
index 0000000000..e2e2951648
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/actions.svelte.ts
@@ -0,0 +1,56 @@
+import { submitFeatureUsage } from '$features/auth/exceptionless-session';
+import { putCurrentUserProductTour } from '$features/users/api.svelte';
+import { ProductTourStatus } from '$features/users/models';
+import { toast } from 'svelte-sonner';
+
+import type { ProductTourCheckpoint, ProductTourKey, ProductTourLaunchSource } from './types';
+
+import { productTourCheckpoint } from './state.svelte';
+import { buildProductTourTelemetryEvent, type ProductTourTelemetryEvent } from './telemetry';
+
+export function createProductTourActions() {
+    const progressMutation = putCurrentUserProductTour();
+
+    async function complete(checkpoint: ProductTourCheckpoint): Promise<boolean> {
+        return finish(checkpoint, ProductTourStatus.Completed);
+    }
+
+    async function dismiss(checkpoint: ProductTourCheckpoint): Promise<boolean> {
+        return finish(checkpoint, ProductTourStatus.Dismissed);
+    }
+
+    async function finish(checkpoint: ProductTourCheckpoint, status: ProductTourStatus): Promise<boolean> {
+        try {
+            await progressMutation.mutateAsync({
+                progress: {
+                    status,
+                    version: checkpoint.version
+                },
+                tourName: checkpoint.tourName
+            });
+        } catch {
+            toast.error('We could not save your guided-tour progress. Please try again.');
+            return false;
+        }
+
+        if (!productTourCheckpoint.clear(checkpoint)) {
+            return false;
+        }
+        await track(status === ProductTourStatus.Completed ? 'completed' : 'dismissed', checkpoint.tourName, checkpoint.version, checkpoint.source);
+        return true;
+    }
+
+    return {
+        complete,
+        dismiss,
+        progressMutation
+    };
+}
+
+export async function track(event: ProductTourTelemetryEvent, name: ProductTourKey, version: number, source: ProductTourLaunchSource): Promise<void> {
+    try {
+        await submitFeatureUsage(buildProductTourTelemetryEvent(event, name, version, source));
+    } catch (error) {
+        console.warn('Unable to submit product tour telemetry.', error);
+    }
+}
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..13f1c376f8
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ProductTourContext } from './types';
+
+import { getProductTourItems, getRecommendedProductTourName, productTourCatalog } from './catalog';
+
+function context(overrides: Partial<ProductTourContext> = {}): ProductTourContext {
+    return {
+        errorEventAvailability: 'available',
+        isSetupPage: false,
+        organizationId: 'organization-id',
+        pathname: '/next',
+        projects: [],
+        ...overrides
+    };
+}
+
+describe('product tour catalog', () => {
+    const versions = Object.fromEntries(productTourCatalog.map((tour) => [tour.name, 1]));
+
+    it('contains only durable metadata for the five named tours', () => {
+        expect(productTourCatalog.map((tour) => tour.name)).toEqual([
+            'ui-overview',
+            'configure-project',
+            'create-saved-view',
+            'investigate-error',
+            'meet-exie'
+        ]);
+        expect(productTourCatalog.every((tour) => tour.keywords.length > 0)).toBe(true);
+        expect(JSON.stringify(productTourCatalog)).not.toContain('data-tour');
+    });
+
+    it('recommends setup until an organization has configured projects', () => {
+        expect(getRecommendedProductTourName(context({ organizationId: undefined }))).toBe('configure-project');
+        expect(getRecommendedProductTourName(context({ projects: [{ is_configured: false }] }))).toBe('configure-project');
+        expect(getRecommendedProductTourName(context({ projects: [{ is_configured: true }] }))).toBe('ui-overview');
+    });
+
+    it('reports availability separately from catalog metadata', () => {
+        const items = getProductTourItems(
+            context({
+                assistantAccess: { enabled: false, has_access: false, upgrade_required: false },
+                errorEventAvailability: 'empty'
+            }),
+            versions
+        );
+        expect(items.find((item) => item.name === 'meet-exie')?.currentAvailability.available).toBe(false);
+        expect(items.find((item) => item.name === 'investigate-error')?.currentAvailability.available).toBe(false);
+    });
+
+    it('uses server versions as the availability boundary', () => {
+        const items = getProductTourItems(context(), {});
+        expect(items.every((item) => !item.currentAvailability.available && item.version === 0)).toBe(true);
+    });
+});
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..8b26d1f198
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/catalog.ts
@@ -0,0 +1,93 @@
+import type { ProductTourProgress } from '$features/users/models';
+
+import { resolve } from '$app/paths';
+
+import type { ProductTourContext, ProductTourDefinition, ProductTourListItem, ProductTourName } from './types';
+
+function requireApplicationShell(context: ProductTourContext) {
+    return context.isSetupPage || !context.organizationId
+        ? { available: false, reason: 'Finish organization setup to explore Exceptionless.' }
+        : { available: true };
+}
+
+function requireError(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. Try again shortly.' };
+    if (context.errorEventAvailability === 'empty') return { available: false, reason: 'Send 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[] = [
+    {
+        availability: requireApplicationShell,
+        description: 'Learn navigation, command search, saved views, Exie, and where to get help.',
+        initialCheckpoint: 'navigation',
+        keywords: ['navigation', 'ui', 'search', 'command', 'help', 'saved views'],
+        name: 'ui-overview',
+        startingRoute: () => resolve('/'),
+        title: 'Explore Exceptionless'
+    },
+    {
+        availability: () => ({ available: true }),
+        description: 'Create or resume a project, connect an SDK, and wait for its first real event.',
+        initialCheckpoint: 'project-name',
+        keywords: ['add project', 'configure', 'sdk', 'api key', 'first event'],
+        name: 'configure-project',
+        startingRoute: (context) => (context.organizationId ? resolve('/(app)/project/add') : resolve('/(app)/organization/add')),
+        title: 'Configure a project'
+    },
+    {
+        availability: requireOrganization,
+        description: 'Save the current Events configuration as a private view that only you can see.',
+        initialCheckpoint: 'open-view-menu',
+        keywords: ['saved view', 'filter', 'columns', 'private', 'dashboard'],
+        name: 'create-saved-view',
+        startingRoute: () => resolve('/(app)/event'),
+        title: 'Create a saved view'
+    },
+    {
+        availability: requireError,
+        description: 'Open a real error, assess its stack and status, then inspect the occurrence.',
+        initialCheckpoint: 'filter-errors',
+        keywords: ['error report', 'event details', 'exception', 'filter', 'stack', 'triage'],
+        name: 'investigate-error',
+        startingRoute: () => `${resolve('/(app)/event')}?time=all&type=error`,
+        title: 'Investigate an error'
+    },
+    {
+        availability: (context) =>
+            context.assistantAccess?.enabled ? { available: true } : { available: false, reason: 'Exie is not enabled by this Exceptionless installation.' },
+        description: 'See how Exie uses the current page as context without sending a prompt.',
+        initialCheckpoint: 'open-exie',
+        keywords: ['exie', 'assistant', 'ai', 'help', 'investigate'],
+        name: 'meet-exie',
+        startingRoute: () => resolve('/'),
+        title: 'Meet Exie'
+    }
+] as const;
+
+export function getProductTourItems(
+    context: ProductTourContext,
+    versions: Record<string, number>,
+    progress: Record<string, ProductTourProgress> = {}
+): ProductTourListItem[] {
+    return productTourCatalog.map((definition) => {
+        const version = versions[definition.name] ?? 0;
+        return {
+            ...definition,
+            currentAvailability:
+                version > 0 ? definition.availability(context) : { available: false, reason: 'This guided tour is not supported by the server.' },
+            progress: progress[definition.name],
+            version
+        };
+    });
+}
+
+export function getRecommendedProductTourName(context: ProductTourContext): ProductTourName {
+    return !context.organizationId || context.projects.some((project) => !project.is_configured) ? 'configure-project' : 'ui-overview';
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/create-saved-view-tour.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/create-saved-view-tour.svelte
new file mode 100644
index 0000000000..adc4c9d0a5
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/create-saved-view-tour.svelte
@@ -0,0 +1,179 @@
+<script lang="ts">
+    import type { SavedView } from '$features/saved-views/models';
+
+    import { toast } from 'svelte-sonner';
+
+    import type { ProductTourCheckpoint } from '../types';
+
+    import { createProductTourActions } from '../actions.svelte';
+    import { productTourCheckpoint } from '../state.svelte';
+    import ProductTourSpotlight from './product-tour-spotlight.svelte';
+
+    interface Props {
+        closeMenu: () => void;
+        onLoadView: (view: SavedView) => Promise<void> | void;
+        openMenu: () => void;
+        openSaveDialog: () => void;
+        savedViews: SavedView[];
+    }
+
+    let { closeMenu, onLoadView, openMenu, openSaveDialog, savedViews }: Props = $props();
+    const actions = createProductTourActions();
+    const checkpoint = $derived(productTourCheckpoint.current?.tourName === 'create-saved-view' ? productTourCheckpoint.current : undefined);
+    const pendingView = $derived.by(() => {
+        const phase = checkpoint?.phase;
+        return phase?.type === 'saved-view-created' || phase?.type === 'saved-view-loaded'
+            ? savedViews.find((savedView) => savedView.id === phase.viewId)
+            : undefined;
+    });
+
+    export function validateSave(isPrivate: boolean): boolean {
+        if (!checkpoint) {
+            return true;
+        }
+
+        if (checkpoint.checkpointName !== 'save-view') {
+            toast.error('Continue the guide before creating the practice view.');
+            return false;
+        }
+
+        if (isPrivate) {
+            return true;
+        }
+
+        toast.error('Enable Private before creating the guided practice view.');
+        return false;
+    }
+
+    export function shouldDefaultPrivate(): boolean {
+        return Boolean(checkpoint);
+    }
+
+    export async function created(view: SavedView): Promise<void> {
+        const active = checkpoint;
+        if (!active) {
+            await onLoadView(view);
+            return;
+        }
+
+        const createdCheckpoint = productTourCheckpoint.advance(active, 'view-created', {
+            type: 'saved-view-created',
+            viewId: view.id
+        });
+        if (createdCheckpoint) {
+            await loadAndComplete(createdCheckpoint, view);
+        }
+    }
+
+    export async function closed(): Promise<void> {
+        const active = checkpoint;
+        if (active?.phase.type === 'active' && ['name-view', 'private-view', 'save-view'].includes(active.checkpointName)) {
+            await actions.dismiss(active);
+        }
+    }
+
+    async function retry(): Promise<void> {
+        const active = checkpoint;
+        if (!active) {
+            return;
+        }
+
+        if (active.phase.type === 'saved-view-loaded') {
+            await actions.complete(active);
+            return;
+        }
+
+        if (active.phase.type === 'saved-view-created') {
+            if (!pendingView) {
+                toast.error('The created view could not be loaded. Refresh and try again.');
+                return;
+            }
+
+            await loadAndComplete(active, pendingView);
+        }
+    }
+
+    async function loadAndComplete(active: ProductTourCheckpoint<'create-saved-view'>, view: SavedView): Promise<void> {
+        try {
+            await onLoadView(view);
+            const loadedCheckpoint = productTourCheckpoint.advance(active, 'view-created', {
+                type: 'saved-view-loaded',
+                viewId: view.id
+            });
+            if (loadedCheckpoint) {
+                await actions.complete(loadedCheckpoint);
+            }
+        } catch {
+            toast.error('Failed to load the created view. Please try again.');
+        }
+    }
+</script>
+
+{#if checkpoint?.checkpointName === 'open-view-menu'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Open View settings to review what a reusable saved view can remember."
+        onDismiss={actions.dismiss}
+        onNext={(active) => {
+            openMenu();
+            productTourCheckpoint.advance(active, 'review-settings');
+        }}
+        target="[data-tour='saved-view-trigger']"
+        title="Open View settings"
+    />
+{:else if checkpoint?.checkpointName === 'review-settings'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Review the filters, date range, display choices, and columns. The guide will not change them for you."
+        onDismiss={actions.dismiss}
+        onNext={(active) => {
+            closeMenu();
+            openSaveDialog();
+            productTourCheckpoint.advance(active, 'name-view');
+        }}
+        target="[data-tour='saved-view-settings']"
+        title="Configure what the view remembers"
+    />
+{:else if checkpoint?.checkpointName === 'name-view'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Choose a meaningful name for the current filters, time range, display options, and columns."
+        onDismiss={actions.dismiss}
+        onNext={(active) => {
+            productTourCheckpoint.advance(active, 'private-view');
+        }}
+        target="[data-tour='saved-view-name']"
+        title="Name your view"
+    />
+{:else if checkpoint?.checkpointName === 'private-view'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Enable Private so this guided practice view is visible only to you."
+        onDismiss={actions.dismiss}
+        onNext={(active) => {
+            productTourCheckpoint.advance(active, 'save-view');
+        }}
+        target="[data-tour='saved-view-private']"
+        title="Keep it private"
+    />
+{:else if checkpoint?.checkpointName === 'save-view'}
+    <ProductTourSpotlight
+        {checkpoint}
+        description="Create the saved view when you are ready. The guide finishes after the view is successfully created and loaded."
+        onDismiss={actions.dismiss}
+        target="[data-tour='saved-view-submit']"
+        title="Create the saved view"
+    />
+{:else if checkpoint?.phase.type === 'saved-view-created' || checkpoint?.phase.type === 'saved-view-loaded'}
+    <ProductTourSpotlight
+        {checkpoint}
+        continueLabel="Retry guide completion"
+        description={checkpoint.phase.type === 'saved-view-created'
+            ? 'The view was created, but it could not be loaded. Continue to try loading it again.'
+            : 'The view was created and loaded, but guide progress could not be saved. Continue to retry.'}
+        onDismiss={actions.dismiss}
+        onNext={retry}
+        target="[data-tour='saved-view-trigger']"
+        title="Finish the saved-view guide"
+    />
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-catalog-dialog.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-catalog-dialog.svelte
new file mode 100644
index 0000000000..942730a992
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-catalog-dialog.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 { ProductTourListItem, ProductTourName } from '../../types';
+
+    interface Props {
+        items: ProductTourListItem[];
+        onStart: (name: ProductTourName) => Promise<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 Exceptionless with short guides that use your real data.</Dialog.Description>
+        </Dialog.Header>
+
+        <div class="grid gap-3 py-2 sm:grid-cols-2">
+            {#each items as item (item.name)}
+                <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.currentAvailability.available}
+                            <p class="text-muted-foreground mt-2 text-xs">{item.currentAvailability.reason}</p>
+                        {/if}
+                    </div>
+                    <Button disabled={!item.currentAvailability.available} onclick={() => onStart(item.name)} 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/dialogs/product-tour-welcome-dialog.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-welcome-dialog.svelte
new file mode 100644
index 0000000000..3fde333876
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-welcome-dialog.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: () => Promise<void>;
+        onDismiss: () => Promise<void>;
+        onStart: () => Promise<void>;
+        open?: boolean;
+        recommended: ProductTourListItem;
+    }
+
+    let { onBrowse, onDismiss, onStart, open = $bindable(false), recommended }: Props = $props();
+
+    async function onOpenChange(nextOpen: boolean): Promise<void> {
+        if (!nextOpen && open) {
+            await onDismiss();
+        }
+    }
+</script>
+
+<Dialog.Root {open} {onOpenChange}>
+    <Dialog.Content class="sm:max-w-lg" data-product-tour-overlay>
+        <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 Exceptionless</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={onDismiss} 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.name === 'configure-project' ? 'Continue setup' : 'Explore Exceptionless'}</Button>
+            </div>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-welcome-dialog.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-welcome-dialog.svelte.test.ts
new file mode 100644
index 0000000000..a3744dc382
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/dialogs/product-tour-welcome-dialog.svelte.test.ts
@@ -0,0 +1,41 @@
+import { fireEvent, render, screen } from '@testing-library/svelte';
+import { describe, expect, it, vi } from 'vitest';
+
+import ProductTourWelcomeDialog from './product-tour-welcome-dialog.svelte';
+
+const recommended = {
+    availability: vi.fn(() => ({ available: true })),
+    currentAvailability: { available: true },
+    description: 'Learn navigation and search.',
+    initialCheckpoint: 'navigation' as const,
+    keywords: ['navigation'],
+    name: 'ui-overview' as const,
+    startingRoute: vi.fn(() => '/next'),
+    title: 'Explore Exceptionless',
+    version: 1
+};
+
+describe('ProductTourWelcomeDialog', () => {
+    it('records dismissal from Escape', async () => {
+        const onBrowse = vi.fn();
+        const onDismiss = vi.fn();
+        const onStart = vi.fn();
+        render(ProductTourWelcomeDialog, { onBrowse, onDismiss, onStart, open: true, recommended });
+
+        await fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+        expect(onBrowse).not.toHaveBeenCalled();
+        expect(onDismiss).toHaveBeenCalledOnce();
+        expect(onStart).not.toHaveBeenCalled();
+    });
+
+    it('provides Browse Guides and Skip choices', async () => {
+        const onBrowse = vi.fn();
+        const onDismiss = vi.fn();
+        render(ProductTourWelcomeDialog, { onBrowse, onDismiss, 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(onDismiss).toHaveBeenCalledOnce();
+    });
+});
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-host.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-host.svelte
new file mode 100644
index 0000000000..735ee4de5b
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-host.svelte
@@ -0,0 +1,268 @@
+<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 { goto } from '$app/navigation';
+    import { resolve } from '$app/paths';
+    import { putCurrentUserProductTour } from '$features/users/api.svelte';
+    import { ProductTourStatus } from '$features/users/models';
+    import { toast } from 'svelte-sonner';
+
+    import type { ProductTourContext, ProductTourLaunchSource, ProductTourListItem, ProductTourName } from '../types';
+
+    import { createProductTourActions, track } from '../actions.svelte';
+    import { getProductTourItems, getRecommendedProductTourName } from '../catalog';
+    import { shouldOfferProductTourAnnouncement, shouldOfferProductTourWelcome } from '../eligibility';
+    import { productTourCheckpoint } from '../state.svelte';
+    import ProductTourCatalogDialog from './dialogs/product-tour-catalog-dialog.svelte';
+    import ProductTourWelcomeDialog from './dialogs/product-tour-welcome-dialog.svelte';
+    import ProductTourFeatureAnnouncement from './product-tour-feature-announcement.svelte';
+    import ProductTourShellSpotlight from './product-tour-shell-spotlight.svelte';
+
+    interface Props {
+        assistantAccess?: AssistantAccess;
+        closeOverlays: () => void;
+        currentUser?: ViewCurrentUser;
+        errorEventAvailability: ProductTourContext['errorEventAvailability'];
+        isAnyOverlayOpen: boolean;
+        isImpersonating: boolean;
+        isSetupPage: boolean;
+        openAssistant: () => Promise<void>;
+        organizationId?: string;
+        pathname: string;
+        projects: ViewProject[];
+        requestErrorAvailability: () => void;
+        setMobileNavigationOpen: (open: boolean) => void;
+        stateSettled: boolean;
+    }
+
+    const SYSTEM_PATH = resolve('/(app)/system');
+
+    let {
+        assistantAccess,
+        closeOverlays,
+        currentUser,
+        errorEventAvailability,
+        isAnyOverlayOpen,
+        isImpersonating,
+        isSetupPage,
+        openAssistant,
+        organizationId,
+        pathname,
+        projects,
+        requestErrorAvailability,
+        setMobileNavigationOpen,
+        stateSettled
+    }: Props = $props();
+
+    let catalogOpen = $state(false);
+    let catalogSource = $state<ProductTourLaunchSource>('catalog');
+    let lastTrackedAnnouncementImpression = $state('');
+    let lastTrackedWelcomeImpression = $state('');
+    let welcomeHandled = $state(false);
+
+    const actions = createProductTourActions();
+    const progressMutation = putCurrentUserProductTour();
+    const context = $derived<ProductTourContext>({
+        assistantAccess,
+        errorEventAvailability,
+        isSetupPage,
+        organizationId,
+        pathname,
+        projects
+    });
+    const items = $derived(getProductTourItems(context, currentUser?.product_tour_versions ?? {}, currentUser?.product_tours));
+    const recommended = $derived(items.find((item) => item.name === getRecommendedProductTourName(context)) ?? items[0]!);
+    const checkpoint = $derived(productTourCheckpoint.current);
+    const welcomeVersion = $derived(currentUser?.product_tour_versions.welcome ?? 0);
+    const exieAnnouncementVersion = $derived(currentUser?.product_tour_versions['exie-announcement'] ?? 0);
+    const welcomeOpen = $derived(
+        !!(
+            stateSettled &&
+            currentUser &&
+            !welcomeHandled &&
+            !catalogOpen &&
+            !isAnyOverlayOpen &&
+            !isImpersonating &&
+            !isSetupPage &&
+            !pathname.startsWith(SYSTEM_PATH) &&
+            welcomeVersion > 0 &&
+            shouldOfferProductTourWelcome(currentUser.product_tours?.welcome, welcomeVersion)
+        )
+    );
+    const exieAnnouncementOpen = $derived(
+        !!(
+            stateSettled &&
+            currentUser &&
+            assistantAccess?.enabled &&
+            (pathname.startsWith('/next/event') || pathname.startsWith('/next/stack')) &&
+            !isSetupPage &&
+            !isImpersonating &&
+            !checkpoint &&
+            !welcomeOpen &&
+            !catalogOpen &&
+            !isAnyOverlayOpen &&
+            !shouldOfferProductTourWelcome(currentUser.product_tours?.welcome, welcomeVersion) &&
+            exieAnnouncementVersion > 0 &&
+            shouldOfferProductTourAnnouncement(currentUser.product_tours?.['exie-announcement'], exieAnnouncementVersion)
+        )
+    );
+
+    $effect(() => {
+        if (!stateSettled) {
+            return;
+        }
+
+        if (!currentUser) {
+            productTourCheckpoint.clear();
+            return;
+        }
+
+        const active = productTourCheckpoint.current ?? productTourCheckpoint.restore(currentUser.id, organizationId);
+        if (active && (active.userId !== currentUser.id || active.organizationId !== organizationId)) {
+            productTourCheckpoint.clear(active);
+        }
+    });
+
+    $effect(() => {
+        if (!currentUser) {
+            return;
+        }
+
+        const impression = `${currentUser.id}:${welcomeVersion}`;
+        if (welcomeOpen && lastTrackedWelcomeImpression !== impression) {
+            lastTrackedWelcomeImpression = impression;
+            void track('shown', 'welcome', welcomeVersion, 'automatic');
+        }
+    });
+
+    $effect(() => {
+        if (!currentUser) {
+            return;
+        }
+
+        const impression = `${currentUser.id}:${exieAnnouncementVersion}`;
+        if (exieAnnouncementOpen && lastTrackedAnnouncementImpression !== impression) {
+            lastTrackedAnnouncementImpression = impression;
+            void track('shown', 'exie-announcement', exieAnnouncementVersion, 'feature-announcement');
+        }
+    });
+
+    export function openCatalog(source: ProductTourLaunchSource = 'catalog'): void {
+        closeOverlays();
+        requestErrorAvailability();
+        catalogSource = source;
+        catalogOpen = true;
+    }
+
+    export async function startTour<Name extends ProductTourName>(name: Name, source: ProductTourLaunchSource = 'catalog'): Promise<void> {
+        if (!currentUser) {
+            return;
+        }
+        const item = getItem(name);
+        if (!item.currentAvailability.available) {
+            openCatalog(source);
+            return;
+        }
+
+        const active = productTourCheckpoint.current;
+        if (active && !(await actions.dismiss(active))) {
+            return;
+        }
+
+        closeOverlays();
+        catalogOpen = false;
+        const next = productTourCheckpoint.start(name, item.initialCheckpoint, source, currentUser.id, item.version, organizationId);
+        await Promise.all([track('shown', name, item.version, source), track('started', name, item.version, source)]);
+
+        const destination = item.startingRoute(context);
+        if (`${pathname}${window.location.search}` !== destination) {
+            await goto(destination);
+        }
+
+        if (next.tourName === 'meet-exie' && next.checkpointName === 'open-exie') {
+            setMobileNavigationOpen(false);
+        }
+    }
+
+    async function recordPreference(name: 'exie-announcement' | 'welcome', version: number, status: ProductTourStatus): Promise<boolean> {
+        try {
+            await progressMutation.mutateAsync({
+                progress: {
+                    status,
+                    version
+                },
+                tourName: name
+            });
+            return true;
+        } catch {
+            toast.error('We could not save your guided-tour preference. Please try again.');
+            return false;
+        }
+    }
+
+    async function onWelcomeStart(): Promise<void> {
+        if (!(await recordPreference('welcome', welcomeVersion, ProductTourStatus.Completed))) {
+            return;
+        }
+        welcomeHandled = true;
+        await track('completed', 'welcome', welcomeVersion, 'automatic');
+        await startTour(recommended.name, 'automatic');
+    }
+
+    async function onWelcomeBrowse(): Promise<void> {
+        if (!(await recordPreference('welcome', welcomeVersion, ProductTourStatus.Completed))) {
+            return;
+        }
+        welcomeHandled = true;
+        await track('completed', 'welcome', welcomeVersion, 'automatic');
+        openCatalog('catalog');
+    }
+
+    async function onWelcomeSkip(): Promise<void> {
+        if (!(await recordPreference('welcome', welcomeVersion, ProductTourStatus.Dismissed))) {
+            return;
+        }
+        welcomeHandled = true;
+        await track('dismissed', 'welcome', welcomeVersion, 'automatic');
+    }
+
+    async function onExieAnnouncementStart(): Promise<void> {
+        if (!(await recordPreference('exie-announcement', exieAnnouncementVersion, ProductTourStatus.Completed))) {
+            return;
+        }
+        await track('completed', 'exie-announcement', exieAnnouncementVersion, 'feature-announcement');
+        await startTour('meet-exie', 'feature-announcement');
+    }
+
+    async function onExieAnnouncementDismiss(): Promise<void> {
+        if (!(await recordPreference('exie-announcement', exieAnnouncementVersion, ProductTourStatus.Dismissed))) {
+            return;
+        }
+        await track('dismissed', 'exie-announcement', exieAnnouncementVersion, 'feature-announcement');
+    }
+
+    function getItem<Name extends ProductTourName>(name: Name): ProductTourListItem<Name> {
+        return items.find((item) => item.name === name)! as ProductTourListItem<Name>;
+    }
+</script>
+
+<ProductTourWelcomeDialog open={welcomeOpen} onBrowse={onWelcomeBrowse} onDismiss={onWelcomeSkip} onStart={onWelcomeStart} {recommended} />
+
+{#if exieAnnouncementOpen && assistantAccess}
+    <ProductTourFeatureAnnouncement
+        hasAccess={assistantAccess.has_access}
+        message={assistantAccess.message}
+        onDismiss={onExieAnnouncementDismiss}
+        onStart={onExieAnnouncementStart}
+    />
+{/if}
+
+<ProductTourCatalogDialog bind:open={catalogOpen} {items} onStart={(name) => startTour(name, catalogSource)} />
+
+{#if checkpoint && (checkpoint.tourName === 'meet-exie' || checkpoint.tourName === 'ui-overview')}
+    {#key checkpoint}
+        <ProductTourShellSpotlight {assistantAccess} {checkpoint} {isAnyOverlayOpen} {openAssistant} {setMobileNavigationOpen} />
+    {/key}
+{/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..325b931d75
--- /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?: () => Promise<void> | void;
+        onDismiss: () => Promise<void> | void;
+        title: string;
+        tourName: string;
+    }
+
+    let { continueLabel = 'Continue', description, onContinue, onDismiss, title, tourName }: Props = $props();
+</script>
+
+<Alert.Root data-product-tour-inline={tourName}>
+    <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-shell-spotlight.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-shell-spotlight.svelte
new file mode 100644
index 0000000000..cc38a9ab01
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-shell-spotlight.svelte
@@ -0,0 +1,119 @@
+<script lang="ts">
+    import type { AssistantAccess } from '$features/assistant/models';
+
+    import { onDestroy, onMount, untrack } from 'svelte';
+
+    import type { ProductTourCheckpoint, ProductTourCheckpointName } from '../types';
+
+    import { createProductTourActions } from '../actions.svelte';
+    import { productTourCheckpoint } from '../state.svelte';
+    import ProductTourSpotlight from './product-tour-spotlight.svelte';
+
+    interface Props {
+        assistantAccess?: AssistantAccess;
+        checkpoint: ProductTourCheckpoint;
+        isAnyOverlayOpen: boolean;
+        openAssistant: () => Promise<void>;
+        setMobileNavigationOpen: (open: boolean) => void;
+    }
+
+    interface ShellStep {
+        checkpointName: ProductTourCheckpointName;
+        description: string;
+        target: string;
+        title: string;
+    }
+
+    let { assistantAccess, checkpoint, isAnyOverlayOpen, openAssistant, setMobileNavigationOpen }: Props = $props();
+    const currentAssistantAccess = untrack(() => assistantAccess);
+    const currentCheckpoint = untrack(() => checkpoint);
+    const actions = createProductTourActions();
+    const meetExieSteps: ShellStep[] = [
+        {
+            checkpointName: 'open-exie',
+            description: 'Open Exie to see the page context available for your next question.',
+            target: '[data-tour="exie-trigger"]',
+            title: 'Open Exie'
+        },
+        {
+            checkpointName: 'exie-context',
+            description: 'Nothing is sent until you choose a prompt. Submitted requests use metered provider usage.',
+            target: '[data-tour="exie-panel"]',
+            title: 'You control every request'
+        }
+    ];
+    const uiOverviewSteps: ShellStep[] = [
+        {
+            checkpointName: 'navigation',
+            description: 'Move between dashboards, saved views, and settings from the application navigation.',
+            target: '[data-tour="app-navigation"]',
+            title: 'Your workspace navigation'
+        },
+        {
+            checkpointName: 'command-search',
+            description: 'Open search or press / to jump to pages, projects, events, stacks, and actions.',
+            target: '[data-tour="command-search"]',
+            title: 'Find anything quickly'
+        },
+        {
+            checkpointName: 'saved-views',
+            description: 'Saved views preserve filters, time, sorting, charts, stats, and columns for quick reuse.',
+            target: '[data-tour="saved-view-navigation"]',
+            title: 'Reuse configured views'
+        },
+        ...(currentAssistantAccess?.enabled
+            ? [
+                  {
+                      checkpointName: 'exie' as const,
+                      description: 'Exie can investigate the page or error you are viewing. You decide whether to send a prompt.',
+                      target: '[data-tour="exie-trigger"]',
+                      title: 'Ask Exie with context'
+                  }
+              ]
+            : []),
+        {
+            checkpointName: 'help',
+            description: 'Open Help for documentation, support, keyboard shortcuts, and guided tours.',
+            target: '[data-tour="help-menu"]',
+            title: 'Help is always nearby'
+        }
+    ];
+    const steps = currentCheckpoint.tourName === 'ui-overview' ? uiOverviewSteps : meetExieSteps;
+    const spotlight = steps.find((step) => step.checkpointName === currentCheckpoint.checkpointName);
+
+    onMount(() => {
+        setMobileNavigationOpen(currentCheckpoint.checkpointName === 'navigation');
+    });
+
+    onDestroy(() => {
+        setMobileNavigationOpen(false);
+    });
+
+    async function advance(): Promise<void> {
+        if (currentCheckpoint.tourName === 'meet-exie' && currentCheckpoint.checkpointName === 'open-exie') {
+            await openAssistant();
+            productTourCheckpoint.advance(currentCheckpoint, 'exie-context');
+            return;
+        }
+
+        const index = steps.findIndex((step) => step.checkpointName === currentCheckpoint.checkpointName);
+        const next = steps[index + 1];
+        if (next) {
+            productTourCheckpoint.advance(currentCheckpoint, next.checkpointName);
+            return;
+        }
+
+        await actions.complete(currentCheckpoint);
+    }
+</script>
+
+{#if spotlight && (!isAnyOverlayOpen || checkpoint.tourName === 'meet-exie')}
+    <ProductTourSpotlight
+        checkpoint={currentCheckpoint}
+        description={spotlight.description}
+        onDismiss={actions.dismiss}
+        onNext={advance}
+        target={spotlight.target}
+        title={spotlight.title}
+    />
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-spotlight.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-spotlight.svelte
new file mode 100644
index 0000000000..a00e3de4e7
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/components/product-tour-spotlight.svelte
@@ -0,0 +1,75 @@
+<script lang="ts">
+    import { driver, type Driver } from 'driver.js';
+    import { onMount } from 'svelte';
+
+    import type { ProductTourCheckpoint } from '../types';
+
+    import 'driver.js/dist/driver.css';
+
+    interface Props {
+        checkpoint: ProductTourCheckpoint;
+        continueLabel?: string;
+        description: string;
+        onDismiss: (checkpoint: ProductTourCheckpoint) => Promise<boolean>;
+        onNext?: (checkpoint: ProductTourCheckpoint) => Promise<void> | void;
+        side?: 'bottom' | 'left' | 'right' | 'top';
+        target: Element | string;
+        title: string;
+    }
+
+    let { checkpoint, continueLabel = 'Continue', description, onDismiss, onNext, side, target, title }: Props = $props();
+    let activeDriver: Driver | undefined;
+
+    onMount(() => {
+        const instance = driver({
+            allowClose: true,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+            disableActiveInteraction: false,
+            onDestroyStarted: async () => {
+                if (activeDriver === instance && (await onDismiss(checkpoint))) {
+                    destroy();
+                }
+            },
+            popoverClass:
+                'max-w-sm rounded-lg border border-border bg-popover text-popover-foreground shadow-lg [&_.driver-popover-title]:text-base [&_.driver-popover-title]:font-semibold',
+            showProgress: false,
+            smoothScroll: !window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+            steps: [
+                {
+                    element: target,
+                    popover: {
+                        description,
+                        doneBtnText: continueLabel,
+                        onNextClick: onNext
+                            ? async () => {
+                                  await onNext(checkpoint);
+                              }
+                            : undefined,
+                        showButtons: onNext ? ['close', 'next'] : ['close'],
+                        side,
+                        title
+                    },
+                    waitForElement: 5000
+                }
+            ]
+        });
+        activeDriver = instance;
+        instance.drive();
+
+        return destroyImmediately;
+    });
+
+    function destroy(): void {
+        const instance = activeDriver;
+        activeDriver = undefined;
+        instance?.setConfig({
+            ...instance.getConfig(),
+            onDestroyStarted: undefined
+        });
+        instance?.destroy();
+    }
+
+    function destroyImmediately(): void {
+        destroy();
+    }
+</script>
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..65b7d7b3f1
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.test.ts
@@ -0,0 +1,35 @@
+import { ProductTourStatus } from '$generated/api';
+import { describe, expect, it } from 'vitest';
+
+import { isProductTourSetupRoute, shouldOfferProductTourAnnouncement, shouldOfferProductTourWelcome } from './eligibility';
+
+describe('product tour setup routes', () => {
+    it.each(['/(app)/organization/add', '/(app)/project/add', '/(app)/project/[projectId]/configure'])('suppresses automatic tours on %s', (routeId) => {
+        expect(isProductTourSetupRoute(routeId)).toBe(true);
+    });
+
+    it('allows automatic tours after setup', () => {
+        expect(isProductTourSetupRoute('/(app)/stack')).toBe(false);
+        expect(isProductTourSetupRoute(null)).toBe(false);
+    });
+});
+
+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..882d52d3f8
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/eligibility.ts
@@ -0,0 +1,15 @@
+import type { ProductTourProgress } from '$features/users/models';
+
+const SETUP_ROUTE_IDS = new Set(['/(app)/organization/add', '/(app)/project/[projectId]/configure', '/(app)/project/add']);
+
+export function isProductTourSetupRoute(routeId: null | string): boolean {
+    return !!routeId && SETUP_ROUTE_IDS.has(routeId);
+}
+
+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/session.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.svelte.test.ts
new file mode 100644
index 0000000000..a14662905a
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.svelte.test.ts
@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import type { ProductTourCheckpoint } from './types';
+
+import { clearProductTourSession, readProductTourSession, writeProductTourSession } from './session';
+
+const checkpoint: ProductTourCheckpoint = {
+    checkpointName: 'choose-error',
+    organizationId: 'organization-id',
+    phase: { type: 'active' },
+    source: 'command-palette',
+    tourName: 'investigate-error',
+    userId: 'user-id',
+    version: 1
+};
+
+describe('product tour session', () => {
+    beforeEach(() => {
+        sessionStorage.clear();
+    });
+
+    it('round-trips an explicit checkpoint', () => {
+        writeProductTourSession(checkpoint);
+        expect(readProductTourSession()).toEqual(checkpoint);
+        clearProductTourSession();
+        expect(sessionStorage).toHaveLength(0);
+    });
+
+    it.each([
+        '{not-json',
+        JSON.stringify({ ...checkpoint, tourName: 'unknown-tour' }),
+        JSON.stringify({ ...checkpoint, checkpointName: 'unknown-step' }),
+        JSON.stringify({ ...checkpoint, source: 'unknown-source' }),
+        JSON.stringify({ ...checkpoint, version: 0 }),
+        JSON.stringify({ ...checkpoint, phase: { type: 'saved-view-created' } }),
+        JSON.stringify({ ...checkpoint, phase: { type: 'saved-view-created', viewId: 'view-id' } }),
+        JSON.stringify({ ...checkpoint, phase: { type: 'saved-view-loaded', viewId: 'view-id' } }),
+        JSON.stringify({ ...checkpoint, userId: 42 })
+    ])('clears malformed or unknown stored state: %s', (value) => {
+        sessionStorage.setItem('exceptionless.product-tour', value);
+        expect(readProductTourSession()).toBeUndefined();
+        expect(sessionStorage).toHaveLength(0);
+    });
+});
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..0b52603cc7
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/session.ts
@@ -0,0 +1,77 @@
+import { ProductTourLaunchSource as ProductTourLaunchSourceContract } from '$generated/api';
+
+import type { ProductTourCheckpoint, ProductTourLaunchSource, ProductTourName, ProductTourPhase } from './types';
+
+import { PRODUCT_TOUR_CHECKPOINTS } from './types';
+
+const SESSION_KEY = 'exceptionless.product-tour';
+const SOURCES = new Set<string>(Object.values(ProductTourLaunchSourceContract));
+
+export function clearProductTourSession(storage: Pick<Storage, 'removeItem'> = sessionStorage): void {
+    storage.removeItem(SESSION_KEY);
+}
+
+export function readProductTourSession(storage: Pick<Storage, 'getItem' | 'removeItem'> = sessionStorage): ProductTourCheckpoint | undefined {
+    try {
+        const value = storage.getItem(SESSION_KEY);
+        if (!value) return undefined;
+
+        const candidate: unknown = JSON.parse(value);
+        if (!isProductTourCheckpoint(candidate)) {
+            clearProductTourSession(storage);
+            return undefined;
+        }
+
+        return candidate;
+    } catch {
+        clearProductTourSession(storage);
+        return undefined;
+    }
+}
+
+export function writeProductTourSession(checkpoint: ProductTourCheckpoint, storage: Pick<Storage, 'setItem'> = sessionStorage): void {
+    storage.setItem(SESSION_KEY, JSON.stringify(checkpoint));
+}
+
+function isPhase(value: unknown, tourName: string, checkpointName: unknown): value is ProductTourPhase {
+    if (!isRecord(value) || typeof value.type !== 'string') return false;
+    if (value.type === 'active') return true;
+    return (
+        tourName === 'create-saved-view' &&
+        checkpointName === 'view-created' &&
+        (value.type === 'saved-view-created' || value.type === 'saved-view-loaded') &&
+        typeof value.viewId === 'string' &&
+        !!value.viewId
+    );
+}
+
+function isProductTourCheckpoint(value: unknown): value is ProductTourCheckpoint {
+    if (
+        !isRecord(value) ||
+        typeof value.userId !== 'string' ||
+        !value.userId ||
+        typeof value.tourName !== 'string' ||
+        typeof value.version !== 'number' ||
+        !Number.isSafeInteger(value.version) ||
+        value.version < 1
+    )
+        return false;
+    if (value.organizationId !== undefined && typeof value.organizationId !== 'string') return false;
+    if (!isProductTourLaunchSource(value.source) || !isProductTourName(value.tourName)) return false;
+
+    const checkpoints: readonly string[] = PRODUCT_TOUR_CHECKPOINTS[value.tourName];
+    if (typeof value.checkpointName !== 'string' || !checkpoints.includes(value.checkpointName)) return false;
+    return isPhase(value.phase, value.tourName, value.checkpointName);
+}
+
+function isProductTourLaunchSource(value: unknown): value is ProductTourLaunchSource {
+    return typeof value === 'string' && SOURCES.has(value);
+}
+
+function isProductTourName(value: string): value is ProductTourName {
+    return Object.hasOwn(PRODUCT_TOUR_CHECKPOINTS, value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
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..d1d4d2f6f7
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.test.ts
@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import type { ProductTourCheckpoint } from './types';
+
+import { productTourCheckpoint } from './state.svelte';
+
+const checkpoint: ProductTourCheckpoint = {
+    checkpointName: 'navigation',
+    organizationId: 'organization-id',
+    phase: { type: 'active' },
+    source: 'catalog',
+    tourName: 'ui-overview',
+    userId: 'user-id',
+    version: 1
+};
+
+describe('product tour checkpoint store', () => {
+    beforeEach(() => productTourCheckpoint.clear());
+
+    it('does not let stale work advance or clear a newer tour', () => {
+        const first = productTourCheckpoint.start(
+            checkpoint.tourName,
+            checkpoint.checkpointName,
+            checkpoint.source,
+            checkpoint.userId,
+            checkpoint.version,
+            checkpoint.organizationId
+        );
+        const second = productTourCheckpoint.start(
+            checkpoint.tourName,
+            checkpoint.checkpointName,
+            'help-menu',
+            checkpoint.userId,
+            checkpoint.version,
+            checkpoint.organizationId
+        );
+
+        expect(productTourCheckpoint.advance(first, 'command-search')).toBeUndefined();
+        expect(productTourCheckpoint.clear(first)).toBe(false);
+        expect(productTourCheckpoint.current).toBe(second);
+    });
+
+    it('clears a checkpoint restored for another identity', () => {
+        productTourCheckpoint.start(
+            checkpoint.tourName,
+            checkpoint.checkpointName,
+            checkpoint.source,
+            checkpoint.userId,
+            checkpoint.version,
+            checkpoint.organizationId
+        );
+        productTourCheckpoint.clear();
+        sessionStorage.setItem('exceptionless.product-tour', JSON.stringify(checkpoint));
+
+        expect(productTourCheckpoint.restore('another-user', 'organization-id')).toBeUndefined();
+        expect(sessionStorage.getItem('exceptionless.product-tour')).toBeNull();
+    });
+});
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..7ba2fcb1d4
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/state.svelte.ts
@@ -0,0 +1,85 @@
+import type { ProductTourCheckpoint, ProductTourCheckpointName, ProductTourLaunchSource, ProductTourName, ProductTourPhase } from './types';
+
+import { clearProductTourSession, readProductTourSession, writeProductTourSession } from './session';
+
+class ProductTourCheckpointStore {
+    current = $state.raw<ProductTourCheckpoint>();
+
+    advance<Name extends ProductTourCheckpoint['tourName']>(
+        expected: ProductTourCheckpoint<Name>,
+        checkpointName: ProductTourCheckpointName<Name>,
+        phase: ProductTourPhase<Name> = {
+            type: 'active'
+        },
+        organizationId = expected.organizationId
+    ): ProductTourCheckpoint<Name> | undefined {
+        if (this.current !== expected) {
+            return undefined;
+        }
+        const next = {
+            ...expected,
+            checkpointName,
+            organizationId,
+            phase
+        } as ProductTourCheckpoint<Name>;
+        return this.save(next);
+    }
+
+    clear(expected?: ProductTourCheckpoint): boolean {
+        if (expected && this.current !== expected) {
+            return false;
+        }
+        this.current = undefined;
+        clearProductTourSession();
+        return true;
+    }
+
+    restore(userId: string, organizationId?: string): ProductTourCheckpoint | undefined {
+        if (this.current) {
+            return this.current;
+        }
+
+        const stored = readProductTourSession();
+        if (!stored) {
+            return undefined;
+        }
+
+        if (stored.userId !== userId || stored.organizationId !== organizationId) {
+            clearProductTourSession();
+            return undefined;
+        }
+
+        this.current = stored;
+        return stored;
+    }
+
+    start<Name extends ProductTourName>(
+        tourName: Name,
+        checkpointName: ProductTourCheckpointName<Name>,
+        source: ProductTourLaunchSource,
+        userId: string,
+        version: number,
+        organizationId?: string
+    ): ProductTourCheckpoint<Name> {
+        const checkpoint = {
+            checkpointName,
+            organizationId,
+            phase: {
+                type: 'active'
+            },
+            source,
+            tourName,
+            userId,
+            version
+        } as ProductTourCheckpoint<Name>;
+        return this.save(checkpoint);
+    }
+
+    private save<Name extends ProductTourCheckpoint['tourName']>(checkpoint: ProductTourCheckpoint<Name>): ProductTourCheckpoint<Name> {
+        this.current = checkpoint;
+        writeProductTourSession(checkpoint);
+        return checkpoint;
+    }
+}
+
+export const productTourCheckpoint = new ProductTourCheckpointStore();
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..a7ff2b5165
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.test.ts
@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildProductTourTelemetryEvent } from './telemetry';
+
+describe('product tour telemetry', () => {
+    it('records stable lifecycle events without resource data', () => {
+        expect(buildProductTourTelemetryEvent('started', 'ui-overview', 1, 'command-palette')).toBe('product-tour.started.ui-overview.v1.command-palette');
+    });
+
+    it('rejects invalid versions', () => {
+        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..8eeb6df23d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/telemetry.ts
@@ -0,0 +1,18 @@
+import type { ProductTourTelemetryEvent as ProductTourTelemetryEventContract } from '$generated/api';
+
+import type { ProductTourKey, ProductTourLaunchSource } from './types';
+
+export type ProductTourTelemetryEvent = `${ProductTourTelemetryEventContract}`;
+
+export function buildProductTourTelemetryEvent(
+    event: ProductTourTelemetryEvent,
+    name: ProductTourKey,
+    version: number,
+    source: ProductTourLaunchSource
+): string {
+    if (!Number.isSafeInteger(version) || version < 1) {
+        throw new Error('Product tour telemetry requires a positive version.');
+    }
+
+    return ['product-tour', event, name, `v${version}`, source].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..87d794902b
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/product-tours/types.ts
@@ -0,0 +1,61 @@
+import type { AssistantAccess } from '$features/assistant/models';
+import type { ViewProject } from '$features/projects/models';
+import type { ProductTourProgress } from '$features/users/models';
+import type { ProductTourLaunchSource as ProductTourLaunchSourceContract } from '$generated/api';
+
+export const PRODUCT_TOUR_CHECKPOINTS = {
+    'configure-project': ['organization-name', 'project-name', 'choose-platform', 'sdk-instructions', 'wait-for-event'],
+    'create-saved-view': ['open-view-menu', 'review-settings', 'name-view', 'private-view', 'save-view', 'view-created'],
+    'investigate-error': ['filter-errors', 'choose-error', 'stack-summary', 'stack-triage', 'event-occurrence', 'tab-overview', 'filter-stack-events'],
+    'meet-exie': ['open-exie', 'exie-context'],
+    'ui-overview': ['navigation', 'command-search', 'saved-views', 'exie', 'help']
+} as const;
+
+export interface ProductTourAvailability {
+    available: boolean;
+    reason?: string;
+}
+export type ProductTourCheckpoint<Name extends ProductTourName = ProductTourName> = Name extends ProductTourName
+    ? {
+          checkpointName: ProductTourCheckpointName<Name>;
+          organizationId?: string;
+          phase: ProductTourPhase<Name>;
+          source: ProductTourLaunchSource;
+          tourName: Name;
+          userId: string;
+          version: number;
+      }
+    : never;
+export type ProductTourCheckpointName<Name extends ProductTourName = ProductTourName> = (typeof PRODUCT_TOUR_CHECKPOINTS)[Name][number];
+export interface ProductTourContext {
+    assistantAccess?: AssistantAccess;
+    errorEventAvailability: 'available' | 'empty' | 'error' | 'loading';
+    isSetupPage: boolean;
+    organizationId?: string;
+    pathname: string;
+    projects: Pick<ViewProject, 'is_configured'>[];
+}
+export interface ProductTourDefinition<Name extends ProductTourName = ProductTourName> {
+    availability: (context: ProductTourContext) => ProductTourAvailability;
+    description: string;
+    initialCheckpoint: ProductTourCheckpointName<Name>;
+    keywords: readonly string[];
+    name: Name;
+    startingRoute: (context: ProductTourContext) => string;
+    title: string;
+}
+
+export type ProductTourKey = 'exie-announcement' | 'welcome' | ProductTourName;
+
+export type ProductTourLaunchSource = `${ProductTourLaunchSourceContract}`;
+
+export interface ProductTourListItem<Name extends ProductTourName = ProductTourName> extends ProductTourDefinition<Name> {
+    currentAvailability: ProductTourAvailability;
+    progress?: ProductTourProgress;
+    version: number;
+}
+
+export type ProductTourName = keyof typeof PRODUCT_TOUR_CHECKPOINTS;
+
+export type ProductTourPhase<Name extends ProductTourName = ProductTourName> =
+    (Name extends 'create-saved-view' ? { type: 'saved-view-created' | 'saved-view-loaded'; viewId: string } : never) | { type: 'active' };
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..4c5d0cb627 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
@@ -19,6 +19,7 @@
     } from '../slugs';
 
     interface Props {
+        defaultPrivate?: boolean;
         duplicateView?: SavedView;
         onClose: () => void;
         onLoadView: (view: SavedView) => void;
@@ -28,7 +29,7 @@
         saving: boolean;
     }
 
-    let { duplicateView, onClose, onLoadView, onSave, open = $bindable(), savedViews, saving }: Props = $props();
+    let { defaultPrivate = false, duplicateView, onClose, onLoadView, onSave, open = $bindable(), savedViews, saving }: Props = $props();
 
     let saveName = $state('');
     let saveSlug = $state('');
@@ -87,7 +88,7 @@
             saveName = '';
             saveSlug = '';
             isSlugDirty = false;
-            isPrivate = false;
+            isPrivate = defaultPrivate;
             attemptedSubmit = false;
         }
     });
@@ -115,8 +116,15 @@
     }
 </script>
 
-<Dialog.Root bind:open>
-    <Dialog.Content class="sm:max-w-100">
+<Dialog.Root
+    bind:open
+    onOpenChange={(nextOpen) => {
+        if (!nextOpen) {
+            onClose();
+        }
+    }}
+>
+    <Dialog.Content class="sm:max-w-100" data-tour="saved-view-dialog">
         <Dialog.Header>
             <Dialog.Title>Save View</Dialog.Title>
             <Dialog.Description>Save the current view configuration for quick access.</Dialog.Description>
@@ -146,6 +154,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"
@@ -177,7 +186,7 @@
                     <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>
@@ -185,8 +194,8 @@
                 <Switch id="view-private" bind:checked={isPrivate} />
             </div>
             <Dialog.Footer>
-                <Button variant="outline" onclick={onClose}>Cancel</Button>
-                <Button type="submit" disabled={!canSave}>
+                <Button variant="outline" onclick={() => (open = false)}>Cancel</Button>
+                <Button data-tour="saved-view-submit" type="submit" disabled={!canSave}>
                     {saving ? 'Saving...' : 'Save'}
                 </Button>
             </Dialog.Footer>
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 2cee06835d..74ad57afcf 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
@@ -15,6 +15,7 @@
     import { serializeFilters } from '$features/events/components/filters/helpers.svelte';
     import { getOrganizationQuery, getOrganizationsQuery } from '$features/organizations/api.svelte';
     import { organization } from '$features/organizations/context.svelte';
+    import CreateSavedViewTour from '$features/product-tours/components/create-saved-view-tour.svelte';
     import { supportsColumnWrapping } from '$features/shared/components/data-table/column-meta';
     import { getMeQuery } from '$features/users/api.svelte';
     import Building2 from '@lucide/svelte/icons/building-2';
@@ -69,7 +70,7 @@
         filters: IFilter[];
         isModified: boolean;
         onClearSavedView: () => Promise<void>;
-        onLoadView: (view: SavedView) => void;
+        onLoadView: (view: SavedView) => Promise<void> | void;
         onResetToSaved: () => void;
         onSavedViewUpdated: (view: SavedView) => void;
         savedViews: SavedView[];
@@ -120,6 +121,7 @@
     let isColumnDialogOpen = $state(false);
     let isMenuOpen = $state(false);
     let viewToDelete = $state<null | SavedView>(null);
+    let createSavedViewTour = $state<CreateSavedViewTour>();
 
     const organizationId = $derived(organization.current);
     const activeView = $derived(activeSavedView);
@@ -259,6 +261,11 @@
             return;
         }
 
+        const tour = createSavedViewTour;
+        if (tour && !tour.validateSave(isPrivate)) {
+            return;
+        }
+
         const filterDefinitions = serializeFilters(filters);
         const body: NewSavedView = {
             columns: getSavedColumnSettings(),
@@ -277,8 +284,9 @@
 
         try {
             const result = await createMutation.mutateAsync(body);
+            const tourCompletion = tour ? tour.created(result) : onLoadView(result);
             isSaveDialogOpen = false;
-            onLoadView(result);
+            await tourCompletion;
             toast.success(`Saved view "${result.name}" created.`);
         } catch (error) {
             toast.error(getErrorMessage(error, 'Failed to save view. Please try again.'));
@@ -393,7 +401,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}
@@ -402,7 +410,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}
@@ -494,15 +502,25 @@
 {#if isSaveDialogOpen}
     <SaveViewDialog
         bind:open={isSaveDialogOpen}
+        defaultPrivate={createSavedViewTour?.shouldDefaultPrivate()}
         {duplicateView}
         {savedViews}
         {saving}
         onSave={handleSave}
-        onClose={() => (isSaveDialogOpen = false)}
+        onClose={() => createSavedViewTour?.closed()}
         {onLoadView}
     />
 {/if}
 
+<CreateSavedViewTour
+    bind:this={createSavedViewTour}
+    closeMenu={() => (isMenuOpen = false)}
+    openMenu={() => (isMenuOpen = true)}
+    openSaveDialog={() => (isSaveDialogOpen = true)}
+    {onLoadView}
+    {savedViews}
+/>
+
 {#if isRenameDialogOpen && activeView}
     <RenameViewDialog
         bind:open={isRenameDialogOpen}
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 4c3a0a6601..f0e404b244 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
@@ -98,7 +98,7 @@ export interface UseSavedViewsReturn {
     autoFillColumnId: AutoFillColumnSelection;
     canModifySavedView: boolean;
     handleClearSavedView: () => Promise<void>;
-    handleLoadView: (view: SavedView) => void;
+    handleLoadView: (view: SavedView) => Promise<void>;
     handleResetToSaved: () => void;
     handleSavedViewUpdated: (view: SavedView) => void;
     hydratedSavedViewId: string | undefined;
@@ -1199,9 +1199,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 d28effe22b..a5dce7ded1 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
@@ -173,6 +173,7 @@
 {#if stack}
     <Card.Root
         class="bg-background relative overflow-hidden ring-[color-mix(in_oklab,var(--chart-1)_42%,transparent)] before:absolute before:inset-x-0 before:top-0 before:h-1 before:bg-[linear-gradient(90deg,var(--chart-1),var(--chart-2))] before:content-['']"
+        data-tour="event-stack"
     >
         <Card.Header>
             <Card.Title class="flex flex-row items-center justify-between text-lg font-semibold">
@@ -184,10 +185,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 4747a521fa..e4feb3e218 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,16 @@ 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,
+    ProductTourProgress,
+    UpdateEmailAddressResult,
+    UpdateProductTourProgress,
+    UpdateUser,
+    UpdateUserEmailAddress,
+    ViewCurrentUser,
+    ViewUser
+} from './models';
 
 export async function invalidateUserQueries(queryClient: QueryClient, message: WebSocketMessageValue<'UserChanged'>) {
     const { id } = message;
@@ -41,6 +50,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: (tourName: string | undefined) => [...queryKeys.me(), 'product-tours', tourName] as const,
     type: ['User'] as const
 };
 
@@ -68,6 +78,11 @@ export interface PostEmailAddressRequest {
     };
 }
 
+export interface PutCurrentUserProductTourRequest {
+    progress: UpdateProductTourProgress;
+    tourName: string;
+}
+
 export interface ResendVerificationEmailRequest {
     route: {
         id: string | undefined;
@@ -260,6 +275,40 @@ export function postEmailAddress(request: PostEmailAddressRequest) {
     }));
 }
 
+export function putCurrentUserProductTour() {
+    const queryClient = useQueryClient();
+    return createMutation<ProductTourProgress, ProblemDetails, PutCurrentUserProductTourRequest>(() => ({
+        enabled: () => !!accessToken.current,
+        mutationFn: async ({ progress, tourName }) => {
+            const client = useFetchClient();
+            const response = await client.putJSON<ProductTourProgress>(`users/me/product-tours/${tourName}`, progress);
+
+            if (!response.ok) {
+                throw response.problem;
+            }
+
+            return response.data!;
+        },
+        mutationKey: queryKeys.productTour(undefined),
+        onSuccess: (progress, { tourName }) => {
+            const currentUser = queryClient.getQueryData<ViewCurrentUser>(queryKeys.me());
+            if (!currentUser) {
+                return;
+            }
+
+            const updatedUser = {
+                ...currentUser,
+                product_tours: {
+                    ...currentUser.product_tours,
+                    [tourName]: progress
+                }
+            };
+            queryClient.setQueryData(queryKeys.me(), updatedUser);
+            queryClient.setQueryData(queryKeys.id(currentUser.id), updatedUser);
+        }
+    }));
+}
+
 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..67d005712d 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/users/models.ts
@@ -1,4 +1,12 @@
-export type { ViewOAuthGrant as OAuthGrant, UpdateEmailAddressResult, ViewCurrentUser, ViewUser } from '$generated/api';
+export { ProductTourStatus } from '$generated/api';
+export type {
+    ViewOAuthGrant as OAuthGrant,
+    ProductTourProgress,
+    UpdateEmailAddressResult,
+    UpdateProductTourProgress,
+    ViewCurrentUser,
+    ViewUser
+} from '$generated/api';
 
 export interface InviteUserForm {
     email: string;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
index d009f96c39..197143e908 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
@@ -7,6 +7,26 @@ export enum StackStatus {
   Discarded = "discarded",
 }
 
+export enum ProductTourTelemetryEvent {
+  Completed = "completed",
+  Dismissed = "dismissed",
+  Shown = "shown",
+  Started = "started",
+}
+
+export enum ProductTourStatus {
+  Completed = "completed",
+  Dismissed = "dismissed",
+}
+
+export enum ProductTourLaunchSource {
+  Automatic = "automatic",
+  Catalog = "catalog",
+  CommandPalette = "command-palette",
+  FeatureAnnouncement = "feature-announcement",
+  HelpMenu = "help-menu",
+}
+
 export enum BillingStatus {
   Trialing = 0,
   Active = 1,
@@ -73,6 +93,47 @@ export interface AdminAssistantUsageResponse {
   organizations: AdminAssistantOrganizationUsage[];
 }
 
+export interface AdminProductTourActivity {
+  /** @format date-time */
+  date_utc: string;
+  event: ProductTourTelemetryEvent;
+  launch_source: ProductTourLaunchSource;
+  tour_name: string;
+  user_identity?: null | string;
+  user_name?: null | string;
+  /** @format int32 */
+  version: number;
+  /** @format int64 */
+  count: number;
+}
+
+export interface AdminProductTourSummary {
+  name: string;
+  /** @format int64 */
+  shown: number;
+  /** @format int64 */
+  started: number;
+  /** @format int64 */
+  completed: number;
+  /** @format int64 */
+  dismissed: number;
+  /** @format int64 */
+  unique_users: number;
+  /** @format date-time */
+  last_run_utc?: null | string;
+  /** @format double */
+  completion_rate?: null | number;
+  /** @format double */
+  dismissal_rate?: null | number;
+}
+
+export interface AdminProductTourUsageResponse {
+  /** @format date-time */
+  month: string;
+  tours: AdminProductTourSummary[];
+  recent_activity: AdminProductTourActivity[];
+}
+
 export interface AssistantAccessResponse {
   enabled: boolean;
   has_access: boolean;
@@ -494,6 +555,14 @@ export interface ProblemDetails {
   instance?: null | string;
 }
 
+export interface ProductTourProgress {
+  status: ProductTourStatus;
+  /** @format date-time */
+  updated_utc: string;
+  /** @format int32 */
+  version: number;
+}
+
 export interface ResetPasswordModel {
   password_reset_token: string;
   password: string;
@@ -648,6 +717,16 @@ export interface UpdateEventSubmissionSettings {
   enabled?: null | boolean;
 }
 
+export interface UpdateProductTourProgress {
+  status?: null | ProductTourStatus;
+  /**
+   * @format int32
+   * @min 1
+   * @max 2147483647
+   */
+  version: number;
+}
+
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
 export interface UpdateProject {
   name: string;
@@ -732,6 +811,7 @@ export interface User {
   password_reset_token_expiration: string;
   o_auth_accounts: OAuthAccount[];
   organization_preferences: UserOrganizationPreference[];
+  product_tours: Record<string, ProductTourProgress>;
   /** Gets or sets the users Full Name. */
   full_name: string;
   /** @format email */
@@ -771,6 +851,8 @@ export interface ViewCurrentUser {
   has_local_account: boolean;
   o_auth_accounts: OAuthAccount[];
   organization_preferences: UserOrganizationPreference[];
+  product_tours: Record<string, ProductTourProgress>;
+  product_tour_versions: Record<string, number>;
   /** @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 f7e0970212..1d64508108 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
@@ -27,6 +27,20 @@ export const StackStatusSchema = zodEnum([
   "ignored",
   "discarded",
 ]);
+export const ProductTourTelemetryEventSchema = zodEnum([
+  "completed",
+  "dismissed",
+  "shown",
+  "started",
+]);
+export const ProductTourStatusSchema = zodEnum(["completed", "dismissed"]);
+export const ProductTourLaunchSourceSchema = zodEnum([
+  "automatic",
+  "catalog",
+  "command-palette",
+  "feature-announcement",
+  "help-menu",
+]);
 export const BillingStatusSchema = union([
   literal(0),
   literal(1),
@@ -75,6 +89,44 @@ export type AdminAssistantUsageResponseFormData = Infer<
   typeof AdminAssistantUsageResponseSchema
 >;
 
+export const AdminProductTourActivitySchema = object({
+  date_utc: iso.datetime(),
+  event: ProductTourTelemetryEventSchema,
+  launch_source: ProductTourLaunchSourceSchema,
+  tour_name: string().min(1, "Tour name is required"),
+  user_identity: string().min(1, "User identity is required").nullable(),
+  user_name: string().min(1, "User name is required").nullable(),
+  version: int32(),
+  count: int(),
+});
+export type AdminProductTourActivityFormData = Infer<
+  typeof AdminProductTourActivitySchema
+>;
+
+export const AdminProductTourSummarySchema = object({
+  name: string().min(1, "Name is required"),
+  shown: int(),
+  started: int(),
+  completed: int(),
+  dismissed: int(),
+  unique_users: int(),
+  last_run_utc: iso.datetime().nullable(),
+  completion_rate: number().nullable(),
+  dismissal_rate: number().nullable(),
+});
+export type AdminProductTourSummaryFormData = Infer<
+  typeof AdminProductTourSummarySchema
+>;
+
+export const AdminProductTourUsageResponseSchema = object({
+  month: iso.datetime(),
+  tours: array(lazy(() => AdminProductTourSummarySchema)),
+  recent_activity: array(lazy(() => AdminProductTourActivitySchema)),
+});
+export type AdminProductTourUsageResponseFormData = Infer<
+  typeof AdminProductTourUsageResponseSchema
+>;
+
 export const AssistantAccessResponseSchema = object({
   enabled: boolean(),
   has_access: boolean(),
@@ -626,6 +678,15 @@ export const ProblemDetailsSchema = object({
 });
 export type ProblemDetailsFormData = Infer<typeof ProblemDetailsSchema>;
 
+export const ProductTourProgressSchema = object({
+  status: ProductTourStatusSchema,
+  updated_utc: iso.datetime(),
+  version: int32(),
+});
+export type ProductTourProgressFormData = Infer<
+  typeof ProductTourProgressSchema
+>;
+
 export const ResetPasswordModelSchema = object({
   password_reset_token: string().length(
     40,
@@ -768,6 +829,16 @@ export type UpdateEventSubmissionSettingsFormData = Infer<
   typeof UpdateEventSubmissionSettingsSchema
 >;
 
+export const UpdateProductTourProgressSchema = object({
+  status: ProductTourStatusSchema,
+  version: int32()
+    .min(1, "Version must be at least 1")
+    .max(2147483647, "Version must be at most 2147483647"),
+});
+export type UpdateProductTourProgressFormData = Infer<
+  typeof UpdateProductTourProgressSchema
+>;
+
 export const UpdateProjectSchema = object({
   name: string().min(1, "Name is required").optional(),
   delete_bot_data_enabled: boolean().optional(),
@@ -854,6 +925,10 @@ export const UserSchema = object({
   password_reset_token_expiration: iso.datetime(),
   o_auth_accounts: array(lazy(() => OAuthAccountSchema)),
   organization_preferences: array(lazy(() => UserOrganizationPreferenceSchema)),
+  product_tours: record(
+    string(),
+    lazy(() => ProductTourProgressSchema),
+  ),
   full_name: string().min(1, "Full name is required"),
   email_address: email(),
   avatar_file_name: string()
@@ -899,6 +974,11 @@ export const ViewCurrentUserSchema = object({
   has_local_account: boolean(),
   o_auth_accounts: array(lazy(() => OAuthAccountSchema)),
   organization_preferences: array(lazy(() => UserOrganizationPreferenceSchema)),
+  product_tours: record(
+    string(),
+    lazy(() => ProductTourProgressSchema),
+  ),
+  product_tour_versions: record(string(), number()).optional(),
   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 039baf20f5..6084aeef2c 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('/')}>
                     {#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 d1cbdcbe14..2a19d607a3 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 { ProductTourListItem, ProductTourName } 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: (name: ProductTourName) => Promise<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();
+    }
+
+    async function launchGuidedTour(name: ProductTourName): Promise<void> {
+        closeCommandWindow();
+        await startGuidedTour(name);
+    }
+
     function toggleTheme(): void {
         closeCommandWindow();
         toggleMode();
@@ -556,6 +574,19 @@
                 bind:selectedActionId={selectedProjectActionId}
             />
             {#if !selectingProject}
+                <Command.Group heading="Guided Tours">
+                    {#each guidedTours.filter((tour) => tour.currentAvailability.available) as tour (tour.name)}
+                        <Command.Item keywords={[...tour.keywords]} value={`Guided Tour ${tour.title}`} onSelect={() => launchGuidedTour(tour.name)}>
+                            <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..035504f0a6 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?: (name: ProductTourListItem['name']) => Promise<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()
     });
 }
@@ -274,7 +282,7 @@ describe('NavigationCommand project actions', () => {
         await fireEvent.click(screen.getByText('Switch to Other Organization'));
 
         expect(organizationState.current).toBe('other-organization-id');
-        await waitFor(() => expect(goto).toHaveBeenCalledWith('/next/stack'));
+        await waitFor(() => expect(goto).toHaveBeenCalledWith('/next/'));
     });
 
     it('opens support chat', async () => {
@@ -319,3 +327,43 @@ describe('NavigationCommand project actions', () => {
         expect(goto).toHaveBeenCalledWith('/next/login');
     });
 });
+
+describe('NavigationCommand guided tours', () => {
+    it('launches available tours directly and opens the full catalog', async () => {
+        vi.useFakeTimers();
+        const openGuidedTours = vi.fn();
+        const startGuidedTour = vi.fn();
+        try {
+            const tourPalette = renderCommandPalette([], {
+                guidedTours: [
+                    {
+                        availability: vi.fn(() => ({ available: true })),
+                        currentAvailability: { available: true },
+                        description: 'Learn the UI.',
+                        initialCheckpoint: 'navigation',
+                        keywords: ['tour'],
+                        name: 'ui-overview',
+                        startingRoute: vi.fn(() => '/next'),
+                        title: 'Explore Exceptionless',
+                        version: 1
+                    }
+                ],
+                openGuidedTours,
+                startGuidedTour
+            });
+
+            await fireEvent.click(screen.getByText('Explore Exceptionless'));
+            expect(startGuidedTour).toHaveBeenCalledWith('ui-overview');
+            tourPalette.unmount();
+            await vi.runAllTimersAsync();
+
+            const catalogPalette = renderCommandPalette([], { openGuidedTours });
+            await fireEvent.click(screen.getByText('Browse Guided Tours…'));
+            expect(openGuidedTours).toHaveBeenCalled();
+            catalogPalette.unmount();
+            await vi.runAllTimersAsync();
+        } finally {
+            vi.useRealTimers();
+        }
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
index e1d5fa562b..106a3964c9 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 { ProductTourLaunchSource, ProductTourName } 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,11 @@
     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 ProductTourHost from '$features/product-tours/components/product-tour-host.svelte';
+    import { isProductTourSetupRoute } from '$features/product-tours/eligibility';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
+    import { getOrganizationProjectsQuery, 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 +98,8 @@
     let isOrganizationSwitcherOpen = $state(false);
     let isImpersonateOrganizationOpen = $state(false);
     let isUserMenuOpen = $state(false);
+    let productToursComponent = $state<ProductTourHost>();
+    let productTourErrorCheckEnabled = $state(false);
 
     // Auto-reset premium page state on navigation so pages don't need cleanup
     beforeNavigate(() => {
@@ -100,6 +108,7 @@
 
     function openCommandPalette(): void {
         commandResetKey += 1;
+        productTourErrorCheckEnabled = true;
         isCommandOpen = true;
     }
 
@@ -228,6 +237,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);
+    }
+
+    async function startGuidedTour(name: ProductTourName, source: ProductTourLaunchSource): Promise<void> {
+        await productToursComponent?.startTour(name, source);
+    }
+
     async function stopImpersonating(): Promise<void> {
         isCommandOpen = false;
         organization.current = organizations[0]?.id;
@@ -374,6 +401,7 @@
         void page.url.pathname;
 
         if (!currentToken) {
+            productTourCheckpoint.clear();
             queryClient.cancelQueries();
             queryClient.invalidateQueries();
             gotoLogin();
@@ -484,6 +512,42 @@
 
     const organizationsQuery = getOrganizationsQuery({});
     const organizations = $derived(organizationsQuery.data?.data ?? []);
+    const projectsQuery = getOrganizationProjectsQuery({
+        params: {
+            limit: 1000
+        },
+        route: {
+            get organizationId() {
+                return organization.current;
+            }
+        }
+    });
+    const projects = $derived(projectsQuery.data?.data ?? []);
+    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 +707,26 @@
 
     const setupPath = resolve('/(app)/organization/add');
     const isSetupPage = $derived(page.url.pathname === setupPath);
+    const suppressAutomaticProductTours = $derived(isProductTourSetupRoute(page.route.id));
+    const productTourItems = $derived(
+        meQuery.isSuccess
+            ? getProductTourItems(
+                  {
+                      assistantAccess,
+                      errorEventAvailability: productTourErrorEventAvailability,
+                      isSetupPage: suppressAutomaticProductTours,
+                      organizationId: organization.current,
+                      pathname: page.url.pathname,
+                      projects
+                  },
+                  meQuery.data?.product_tour_versions ?? {},
+                  meQuery.data?.product_tours
+              )
+            : []
+    );
+    const isAnyProductTourOverlayOpen = $derived(
+        isAssistantOpen || isCommandOpen || isImpersonateOrganizationOpen || isKeyboardShortcutsOpen || isOrganizationSwitcherOpen || isUserMenuOpen
+    );
 
     $effect(() => {
         if (assistantAccessQuery.isSuccess && !isAssistantEnabled) {
@@ -704,6 +788,7 @@
                 {organizations}
                 {openChat}
                 {openKeyboardShortcuts}
+                openGuidedTours={() => openGuidedTours('help-menu')}
                 {intercomUnreadCount}
                 bind:open={isUserMenuOpen}
             />
@@ -724,16 +809,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 +875,26 @@
 {/snippet}
 
 {#if isAuthenticated}
+    <ProductTourHost
+        {assistantAccess}
+        bind:this={productToursComponent}
+        closeOverlays={closeProductTourOverlays}
+        currentUser={meQuery.data}
+        errorEventAvailability={productTourErrorEventAvailability}
+        isAnyOverlayOpen={isAnyProductTourOverlayOpen}
+        {isImpersonating}
+        isSetupPage={suppressAutomaticProductTours}
+        openAssistant={openAssistantPanel}
+        organizationId={organization.current}
+        pathname={page.url.pathname}
+        {projects}
+        requestErrorAvailability={() => (productTourErrorCheckEnabled = true)}
+        setMobileNavigationOpen={(open) => (sidebar.isMobile ? sidebar.setOpenMobile(open) : sidebar.setOpen(open))}
+        stateSettled={meQuery.isSuccess &&
+            organizationsQuery.isSuccess &&
+            (!organization.current || 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 f74ef8aec2..5d41eb6981 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/+page.svelte
@@ -42,6 +42,7 @@
         updateFilterCache
     } from '$features/events/components/filters/helpers.svelte';
     import OrganizationDefaultsFacetedFilterBuilder from '$features/events/components/filters/organization-defaults-faceted-filter-builder.svelte';
+    import InvestigationListTour from '$features/events/components/investigation-list-tour.svelte';
     import { buildEventDetailsHref, type EventSummaryModel, type SummaryTemplateKeys } from '$features/events/components/summary/index';
     import EventsBulkActionsDropdownMenu from '$features/events/components/table/events-bulk-actions-dropdown-menu.svelte';
     import EventsDataTable from '$features/events/components/table/events-data-table.svelte';
@@ -49,6 +50,7 @@
     import { filterUsesPremiumFeatures } from '$features/events/premium-filter';
     import { organization } from '$features/organizations/context.svelte';
     import { premiumPage } from '$features/organizations/premium-page.svelte';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
     import SavedViewPicker from '$features/saved-views/components/saved-view-picker.svelte';
     import { isSavedViewHydrationPending, isSavedViewUnavailable, useSavedViews } from '$features/saved-views/use-saved-views.svelte';
     import * as agg from '$features/shared/api/aggregations';
@@ -77,8 +79,10 @@
         redirectToEventsWithFilter,
         serializeTimeQueryParam
     } from '../redirect-to-events.svelte';
+    import { getEventQueryFilters } from './query-filters';
 
     let selectedEventId: null | string = $state(null);
+    const investigationCheckpoint = $derived(productTourCheckpoint.current?.tourName === 'investigate-error' ? productTourCheckpoint.current : undefined);
 
     function handleEventError(problem: ProblemDetails) {
         showBillingDialogOnUpgradeProblem(problem, organization.current);
@@ -87,6 +91,10 @@
 
     function rowClick(row: EventSummaryModel<SummaryTemplateKeys>) {
         selectedEventId = row.id;
+        const checkpoint = investigationCheckpoint;
+        if (checkpoint?.checkpointName === 'choose-error') {
+            productTourCheckpoint.advance(checkpoint, 'stack-summary');
+        }
     }
 
     function rowHref(row: EventSummaryModel<SummaryTemplateKeys>): string {
@@ -140,77 +148,6 @@
         return filter || null;
     }
 
-    function getQueryFilters(params: ListFilterQueryParams = queryParams): FacetedFilter.IFilter[] | null {
-        const filters: FacetedFilter.IFilter[] = [];
-
-        if (params.project) {
-            filters.push(new ProjectFilter(splitQueryParam(params.project)));
-        }
-
-        if (params.stack) {
-            filters.push(new StringFilter('stack', params.stack));
-        }
-
-        const bot = parseBooleanQueryParam(params.bot);
-        if (bot !== undefined) {
-            filters.push(new BooleanFilter('bot', bot));
-        }
-
-        const first = parseBooleanQueryParam(params.first);
-        if (first !== undefined) {
-            filters.push(new BooleanFilter('first', first));
-        }
-
-        if (params.level) {
-            filters.push(new LevelFilter(splitQueryParam(params.level) as never[]));
-        }
-
-        if (params.reference) {
-            filters.push(new ReferenceFilter(params.reference));
-        }
-
-        if (params.session) {
-            filters.push(new SessionFilter(params.session));
-        }
-
-        if (params.status) {
-            filters.push(new StatusFilter(splitQueryParam(params.status) as never[]));
-        }
-
-        if (params.tag) {
-            filters.push(new TagFilter(splitQueryParam(params.tag) as never[]));
-        }
-
-        if (params.type) {
-            filters.push(new TypeFilter(splitQueryParam(params.type) as never[]));
-        }
-
-        if (params.version) {
-            filters.push(new VersionFilter('version', params.version));
-        }
-
-        return filters.length > 0 ? filters : null;
-    }
-
-    function parseBooleanQueryParam(value: null | string | undefined): boolean | undefined {
-        if (value === 'true') {
-            return true;
-        }
-
-        if (value === 'false') {
-            return false;
-        }
-
-        return undefined;
-    }
-
-    function splitQueryParam(value: string): string[] {
-        return value
-            .split(',')
-            .map((item) => item.trim())
-            .filter((item) => item);
-    }
-
     function getEffectiveSort(): null | string | undefined {
         if (queryParams.sort != null) {
             return queryParams.sort || undefined;
@@ -331,7 +268,7 @@
 
     function getCurrentFiltersWithoutTime(params: ListFilterQueryParams = queryParams): FacetedFilter.IFilter[] {
         const savedViewFilters = getSavedViewFilters();
-        const queryFilters = getQueryFilters(params) ?? [];
+        const queryFilters = getEventQueryFilters(params) ?? [];
         const expressionFilters =
             params.filter != null ? getFiltersFromCache(filterCacheKey(params.filter), params.filter).filter((filter) => filter.type !== 'date') : [];
 
@@ -960,7 +897,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="order-3 flex w-full flex-wrap items-start gap-1.5 md:order-none md:w-auto md:min-w-0 md:flex-1">
+        <div class="order-3 flex w-full flex-wrap items-start gap-1.5 md:order-none md:w-auto md:min-w-0 md:flex-1" data-tour="event-filters">
             <FacetedFilter.Root changed={onFilterChanged} {filters} remove={onFilterRemoved}>
                 <OrganizationDefaultsFacetedFilterBuilder />
             </FacetedFilter.Root>
@@ -1018,25 +955,27 @@
             />
         {/if}
 
-        <EventsDataTable
-            autoFillColumnId={savedViewsState.autoFillColumnId}
-            bind:limit={eventsQueryParameters.limit!}
-            isLoading={isSavedViewRoutePending || eventsQuery.isFetching}
-            onAutoFillColumnResized={() => savedViewsState.setAutoFillColumnId(null)}
-            {rowClick}
-            {rowHref}
-            {table}
-            wrappedColumnIds={savedViewsState.wrappedColumnIds}
-        >
-            {#snippet footerChildren()}
-                <div class="flex min-w-0 items-center gap-3">
-                    <EventsBulkActionsDropdownMenu {table} />
-                    <DataTable.Selection {table} />
-                </div>
-
-                <DataTable.Pager bind:value={eventsQueryParameters.limit!} {table} variant="floating" />
-            {/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}
+                wrappedColumnIds={savedViewsState.wrappedColumnIds}
+            >
+                {#snippet footerChildren()}
+                    <div class="flex min-w-0 items-center gap-3">
+                        <EventsBulkActionsDropdownMenu {table} />
+                        <DataTable.Selection {table} />
+                    </div>
+
+                    <DataTable.Pager bind:value={eventsQueryParameters.limit!} {table} variant="floating" />
+                {/snippet}
+            </EventsDataTable>
+        </div>
     </div>
 </div>
 
@@ -1048,3 +987,5 @@
     }}
     onError={handleEventError}
 />
+
+<InvestigationListTour />
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/query-filters.ts b/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/query-filters.ts
new file mode 100644
index 0000000000..99b0685152
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/event/query-filters.ts
@@ -0,0 +1,70 @@
+import type { PersistentEventKnownTypes } from '$features/events/models';
+import type { LogLevel } from '$features/events/models/event-data';
+
+import * as FacetedFilter from '$comp/faceted-filter';
+import {
+    BooleanFilter,
+    LevelFilter,
+    ProjectFilter,
+    ReferenceFilter,
+    SessionFilter,
+    StatusFilter,
+    StringFilter,
+    TagFilter,
+    TypeFilter,
+    VersionFilter
+} from '$features/events/components/filters';
+import { StackStatus } from '$features/stacks/models';
+
+import type { ListFilterQueryParams } from '../redirect-to-events.svelte';
+
+export function getEventQueryFilters(params: ListFilterQueryParams): FacetedFilter.IFilter[] | null {
+    const filters: FacetedFilter.IFilter[] = [];
+
+    if (params.project) {
+        filters.push(new ProjectFilter(splitQueryParam(params.project)));
+    }
+    if (params.stack) {
+        filters.push(new StringFilter('stack', params.stack));
+    }
+
+    addBooleanFilter(filters, 'bot', params.bot);
+    addBooleanFilter(filters, 'first', params.first);
+
+    if (params.level) {
+        filters.push(new LevelFilter(splitQueryParam(params.level) as LogLevel[]));
+    }
+    if (params.reference) {
+        filters.push(new ReferenceFilter(params.reference));
+    }
+    if (params.session) {
+        filters.push(new SessionFilter(params.session));
+    }
+    if (params.status) {
+        filters.push(new StatusFilter(splitQueryParam(params.status) as StackStatus[]));
+    }
+    if (params.tag) {
+        filters.push(new TagFilter(splitQueryParam(params.tag) as PersistentEventKnownTypes[]));
+    }
+    if (params.type) {
+        filters.push(new TypeFilter(splitQueryParam(params.type) as PersistentEventKnownTypes[]));
+    }
+    if (params.version) {
+        filters.push(new VersionFilter('version', params.version));
+    }
+
+    return filters.length > 0 ? filters : null;
+}
+
+function addBooleanFilter(filters: FacetedFilter.IFilter[], field: 'bot' | 'first', value: null | string | undefined): void {
+    if (value === 'true' || value === 'false') {
+        filters.push(new BooleanFilter(field, value === 'true'));
+    }
+}
+
+function splitQueryParam(value: string): string[] {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
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..d966b7898a 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
@@ -15,6 +15,9 @@
     import { postOrganization } from '$features/organizations/api.svelte';
     import { organization } from '$features/organizations/context.svelte';
     import { useHideOrganizationNotifications } from '$features/organizations/hooks/use-hide-organization-notifications.svelte';
+    import { createProductTourActions } from '$features/product-tours/actions.svelte';
+    import ProductTourSpotlight from '$features/product-tours/components/product-tour-spotlight.svelte';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
     import { postProject } from '$features/projects/api.svelte';
     import { ariaInvalid, getFormErrorMessages, mapFieldErrors, problemDetailsToFormErrors } from '$features/shared/validation';
     import { ProblemDetails } from '@foundatiofx/fetchclient';
@@ -32,6 +35,8 @@
     let toastId = $state<number | string>();
     const createOrganization = postOrganization();
     const createProject = postProject();
+    const tourActions = createProductTourActions();
+    const configureCheckpoint = $derived(productTourCheckpoint.current?.tourName === 'configure-project' ? productTourCheckpoint.current : undefined);
     const CREATE_ERROR_MESSAGE = 'Error creating setup. Please try again.';
 
     useHideOrganizationNotifications();
@@ -57,6 +62,18 @@
                         organization_id: createdOrganization.id
                     } as NewProject);
 
+                    const checkpoint = configureCheckpoint;
+                    if (checkpoint) {
+                        productTourCheckpoint.advance(
+                            checkpoint,
+                            'choose-platform',
+                            {
+                                type: 'active'
+                            },
+                            createdOrganization.id
+                        );
+                    }
+
                     toastId = toast.success('Project added successfully');
                     await goto(
                         resolve('/(app)/project/[projectId]/configure', {
@@ -92,6 +109,7 @@
     </Card.Header>
     <Card.Content>
         <form
+            data-tour="project-setup-form"
             onsubmit={(e) => {
                 e.preventDefault();
                 e.stopPropagation();
@@ -108,6 +126,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 +144,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 +159,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}
@@ -151,3 +171,21 @@
         </form>
     </Card.Content>
 </Card.Root>
+
+{#if configureCheckpoint}
+    <ProductTourSpotlight
+        checkpoint={configureCheckpoint}
+        description={configureCheckpoint.checkpointName === 'organization-name'
+            ? 'Name the organization that will own your projects and error data.'
+            : 'Name the application or service that will send events. The guide advances only after setup succeeds.'}
+        onDismiss={tourActions.dismiss}
+        onNext={configureCheckpoint.checkpointName === 'organization-name'
+            ? (checkpoint) => {
+                  productTourCheckpoint.advance(checkpoint, 'project-name');
+              }
+            : undefined}
+        side="top"
+        target={configureCheckpoint.checkpointName === 'organization-name' ? "[data-tour='setup-organization-name']" : "[data-tour='project-setup-form']"}
+        title={configureCheckpoint.checkpointName === 'organization-name' ? 'Name your organization' : 'Name your first project'}
+    />
+{/if}
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..6a0458f4ff 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,11 @@
     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 { createProductTourActions } from '$features/product-tours/actions.svelte';
+    import ProductTourInlineCallout from '$features/product-tours/components/product-tour-inline-callout.svelte';
+    import ProductTourSpotlight from '$features/product-tours/components/product-tour-spotlight.svelte';
+    import { productTourCheckpoint } 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 +42,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();
@@ -47,7 +59,10 @@
     const isTokenSuspended = $derived(defaultTokenQuery.data?.is_suspended ?? false);
 
     let toastId = $state<number | string>();
+    let isProjectTypeOpen = $state(false);
     let openEnableTokenDialog = $state(false);
+    const tourActions = createProductTourActions();
+    const configureCheckpoint = $derived(productTourCheckpoint.current?.tourName === 'configure-project' ? productTourCheckpoint.current : undefined);
 
     const enableTokenMutation = patchToken({
         route: {
@@ -419,11 +434,40 @@ 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 (configureCheckpoint && !(await tourActions.complete(configureCheckpoint))) {
+                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 (configureCheckpoint && !(await tourActions.complete(configureCheckpoint))) {
+            return;
+        }
+
+        toast.success('First event received. Opening Events...');
+        await redirectToEventsWithFilter(organization.current, new ProjectFilter([projectId]));
+    }
+
+    useEventListener(window, 'focus', async () => {
+        await refreshConfiguredProject();
+    });
+    useEventListener(document, 'refresh', async () => {
+        await refreshConfiguredProject();
+    });
+
     // Use Intercom from parent provider context
     const intercom = getIntercom();
 
@@ -462,10 +506,21 @@ 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 configureCheckpoint}
+                    <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={async () => {
+                            await tourActions.dismiss(configureCheckpoint);
+                        }}
+                        size="sm"
+                        variant="outline">End guide</Button
+                    >
+                {/if}
             </NotificationDescription>
         </Notification>
     {/if}
@@ -476,12 +531,16 @@ public partial class App : Application {
             <Select.Root
                 type="single"
                 bind:value={queryParams.type as string | undefined}
+                onOpenChange={(open) => (isProjectTypeOpen = open)}
                 onValueChange={(value) => {
                     selectedProjectType = projectTypes.find((P) => P.id === value) || null;
                     queryParams.type = value;
+                    if (configureCheckpoint?.checkpointName === 'choose-platform') {
+                        productTourCheckpoint.advance(configureCheckpoint, 'sdk-instructions');
+                    }
                 }}
             >
-                <Select.Trigger class="w-full">
+                <Select.Trigger class="w-full" data-tour="project-configure-platform">
                     <span
                         >{#if selectedProjectType}
                             {selectedProjectType.platform}: {selectedProjectType.label}
@@ -768,6 +827,30 @@ public partial class App : Application {
         {/if}
     </ol>
 
+    {#if configureCheckpoint?.checkpointName === '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={() => {
+                productTourCheckpoint.advance(configureCheckpoint, 'wait-for-event');
+            }}
+            onDismiss={async () => {
+                await tourActions.dismiss(configureCheckpoint);
+            }}
+            title="Connect your application"
+            tourName="configure-project"
+        />
+    {/if}
+
+    {#if configureCheckpoint?.checkpointName === 'choose-platform' && !isProjectTypeOpen}
+        <ProductTourSpotlight
+            checkpoint={configureCheckpoint}
+            description="Choose the SDK platform that matches the application you are connecting."
+            onDismiss={tourActions.dismiss}
+            target="[data-tour='project-configure-platform']"
+            title="Choose your SDK"
+        />
+    {/if}
+
     {#if selectedProjectType}
         <P
             ><strong>That's it!</strong>
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..20a724a4f4 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
@@ -11,6 +11,9 @@
     import { Spinner } from '$comp/ui/spinner';
     import { showBillingDialogOnUpgradeProblem } from '$features/billing';
     import { organization } from '$features/organizations/context.svelte';
+    import { createProductTourActions } from '$features/product-tours/actions.svelte';
+    import ProductTourSpotlight from '$features/product-tours/components/product-tour-spotlight.svelte';
+    import { productTourCheckpoint } from '$features/product-tours/state.svelte';
     import { postProject } from '$features/projects/api.svelte';
     import { type NewProjectFormData, NewProjectSchema } from '$features/projects/schemas';
     import { ariaInvalid, getFormErrorMessages, mapFieldErrors, problemDetailsToFormErrors } from '$features/shared/validation';
@@ -21,6 +24,8 @@
 
     let toastId = $state<number | string>();
     const createProject = postProject();
+    const tourActions = createProductTourActions();
+    const configureCheckpoint = $derived(productTourCheckpoint.current?.tourName === 'configure-project' ? productTourCheckpoint.current : undefined);
 
     const form = createForm(() => ({
         defaultValues: {
@@ -37,6 +42,10 @@
                         ...value,
                         organization_id: organization.current ?? value.organization_id
                     } as NewProject);
+                    const checkpoint = configureCheckpoint;
+                    if (checkpoint) {
+                        productTourCheckpoint.advance(checkpoint, 'choose-platform');
+                    }
                     toastId = toast.success('Project added successfully');
                     await goto(
                         resolve('/(app)/project/[projectId]/configure', {
@@ -75,6 +84,7 @@
         <Muted>Create a project, then configure a client to send your first event.</Muted>
     </div>
     <form
+        data-tour="project-setup-form"
         onsubmit={(e) => {
             e.preventDefault();
             e.stopPropagation();
@@ -91,6 +101,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 +116,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}
@@ -116,3 +127,14 @@
         </form.Subscribe>
     </form>
 </div>
+
+{#if configureCheckpoint?.checkpointName === 'project-name'}
+    <ProductTourSpotlight
+        checkpoint={configureCheckpoint}
+        description="Name the application or service that will send events. Continue by submitting this form; the guide advances only after creation succeeds."
+        onDismiss={tourActions.dismiss}
+        side="top"
+        target="[data-tour='project-setup-form']"
+        title="Name your project"
+    />
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/product-tours/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/product-tours/+page.svelte
new file mode 100644
index 0000000000..d20d291eb6
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/product-tours/+page.svelte
@@ -0,0 +1,147 @@
+<script lang="ts">
+    import Number from '$comp/formatters/number.svelte';
+    import Percentage from '$comp/formatters/percentage.svelte';
+    import TimeAgo from '$comp/formatters/time-ago.svelte';
+    import { Muted } from '$comp/typography';
+    import { Badge } from '$comp/ui/badge';
+    import * as Card from '$comp/ui/card';
+    import { Input } from '$comp/ui/input';
+    import { Skeleton } from '$comp/ui/skeleton';
+    import * as Table from '$comp/ui/table';
+    import { getAdminProductTourUsageQuery } from '$features/admin/api.svelte';
+    import { getUtcMonthKey } from '$features/admin/assistant-usage';
+
+    const currentMonth = getUtcMonthKey();
+    let selectedMonth = $state(currentMonth);
+    const usageQuery = getAdminProductTourUsageQuery(() => selectedMonth);
+    const usage = $derived(usageQuery.data);
+
+    function title(value: string): string {
+        return value
+            .split('-')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+</script>
+
+<div class="space-y-6">
+    <div class="flex flex-wrap items-end justify-between gap-4">
+        <Muted>Tour starts, outcomes, and recent user activity recorded by Exceptionless Feature Usage events</Muted>
+        <label class="flex flex-col gap-1 text-sm font-medium">
+            Month
+            <Input class="w-40" type="month" max={currentMonth} bind:value={selectedMonth} />
+        </label>
+    </div>
+
+    {#if usageQuery.isError}
+        <Card.Root>
+            <Card.Content class="pt-6">
+                <p class="text-destructive text-sm">Failed to load guided-tour usage. Please try again.</p>
+            </Card.Content>
+        </Card.Root>
+    {:else}
+        <Card.Root>
+            <Card.Header>
+                <Card.Title>Tour Outcomes</Card.Title>
+                <Card.Description>
+                    Tour rates use starts as the denominator. Welcome and announcement decision rates use shown prompts because they do not have a separate
+                    start event.
+                </Card.Description>
+            </Card.Header>
+            <Card.Content class="px-0">
+                {#if usageQuery.isPending}
+                    <div class="space-y-3 px-4 pb-2">
+                        {#each [0, 1, 2, 3, 4] as row (row)}
+                            <Skeleton class="h-12 w-full rounded" aria-label={`Loading tour ${row + 1}`} />
+                        {/each}
+                    </div>
+                {:else if usage?.tours.length === 0}
+                    <p class="text-muted-foreground px-4 py-10 text-center text-sm">No guided-tour activity was recorded for this month.</p>
+                {:else}
+                    <Table.Root>
+                        <Table.Header>
+                            <Table.Row>
+                                <Table.Head class="pl-4">Tour</Table.Head>
+                                <Table.Head class="text-right">Shown</Table.Head>
+                                <Table.Head class="text-right">Started</Table.Head>
+                                <Table.Head class="text-right">Users</Table.Head>
+                                <Table.Head class="text-right">Completed</Table.Head>
+                                <Table.Head class="text-right">Dismissed</Table.Head>
+                                <Table.Head>Last Run</Table.Head>
+                            </Table.Row>
+                        </Table.Header>
+                        <Table.Body>
+                            {#each usage?.tours ?? [] as tour (tour.name)}
+                                <Table.Row>
+                                    <Table.Cell class="pl-4 font-medium">{title(tour.name)}</Table.Cell>
+                                    <Table.Cell class="text-right"><Number value={tour.shown} /></Table.Cell>
+                                    <Table.Cell class="text-right"><Number value={tour.started} /></Table.Cell>
+                                    <Table.Cell class="text-right"><Number value={tour.unique_users} /></Table.Cell>
+                                    <Table.Cell class="text-right">
+                                        <Number value={tour.completed} />
+                                        <span class="text-muted-foreground ml-1 text-xs">
+                                            ({#if tour.completion_rate == null}—{:else}<Percentage percent={tour.completion_rate * 100} />{/if})
+                                        </span>
+                                    </Table.Cell>
+                                    <Table.Cell class="text-right">
+                                        <Number value={tour.dismissed} />
+                                        <span class="text-muted-foreground ml-1 text-xs">
+                                            ({#if tour.dismissal_rate == null}—{:else}<Percentage percent={tour.dismissal_rate * 100} />{/if})
+                                        </span>
+                                    </Table.Cell>
+                                    <Table.Cell>
+                                        {#if tour.last_run_utc}
+                                            <TimeAgo value={tour.last_run_utc} />
+                                        {:else}
+                                            <span class="text-muted-foreground">Never</span>
+                                        {/if}
+                                    </Table.Cell>
+                                </Table.Row>
+                            {/each}
+                        </Table.Body>
+                    </Table.Root>
+                {/if}
+            </Card.Content>
+        </Card.Root>
+
+        <Card.Root>
+            <Card.Header>
+                <Card.Title>Recent Activity</Card.Title>
+                <Card.Description>Latest identified-user tour events for investigating support and onboarding patterns.</Card.Description>
+            </Card.Header>
+            <Card.Content class="px-0">
+                {#if usage?.recent_activity.length === 0}
+                    <p class="text-muted-foreground px-4 py-10 text-center text-sm">No recent tour activity was recorded.</p>
+                {:else}
+                    <Table.Root>
+                        <Table.Header>
+                            <Table.Row>
+                                <Table.Head class="pl-4">User</Table.Head>
+                                <Table.Head>Tour</Table.Head>
+                                <Table.Head>Event</Table.Head>
+                                <Table.Head>Source</Table.Head>
+                                <Table.Head>When</Table.Head>
+                            </Table.Row>
+                        </Table.Header>
+                        <Table.Body>
+                            {#each usage?.recent_activity ?? [] as activity (`${activity.date_utc}-${activity.user_identity}-${activity.event}-${activity.tour_name}`)}
+                                <Table.Row>
+                                    <Table.Cell class="pl-4">
+                                        <div class="font-medium">{activity.user_name || activity.user_identity || 'Unknown user'}</div>
+                                        {#if activity.user_name && activity.user_identity}
+                                            <div class="text-muted-foreground font-mono text-xs">{activity.user_identity}</div>
+                                        {/if}
+                                    </Table.Cell>
+                                    <Table.Cell>{title(activity.tour_name)} <span class="text-muted-foreground">v{activity.version}</span></Table.Cell>
+                                    <Table.Cell><Badge variant="secondary">{title(activity.event)}</Badge></Table.Cell>
+                                    <Table.Cell>{title(activity.launch_source)}</Table.Cell>
+                                    <Table.Cell><TimeAgo value={activity.date_utc} /></Table.Cell>
+                                </Table.Row>
+                            {/each}
+                        </Table.Body>
+                    </Table.Root>
+                {/if}
+            </Card.Content>
+        </Card.Root>
+    {/if}
+</div>
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
index 1b41f9a74a..c9ca0b4a11 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
@@ -6,6 +6,7 @@ import Database from '@lucide/svelte/icons/database';
 import DatabaseZap from '@lucide/svelte/icons/database-zap';
 import KeyRound from '@lucide/svelte/icons/key-round';
 import LayoutDashboard from '@lucide/svelte/icons/layout-dashboard';
+import Map from '@lucide/svelte/icons/map';
 import Play from '@lucide/svelte/icons/play';
 import Settings from '@lucide/svelte/icons/settings';
 
@@ -62,6 +63,13 @@ export function routes(): NavigationItem[] {
             show: (context) => context.user?.roles?.includes('global') ?? false,
             title: 'Saved Views'
         },
+        {
+            group: 'System',
+            href: resolve('/(app)/system/product-tours'),
+            icon: Map,
+            show: (context) => context.user?.roles?.includes('global') ?? false,
+            title: 'Guided Tours'
+        },
         {
             group: 'System',
             href: resolve('/(app)/system/oauth-applications'),
diff --git a/src/Exceptionless.Web/Models/Admin/AdminProductTourUsageResponse.cs b/src/Exceptionless.Web/Models/Admin/AdminProductTourUsageResponse.cs
new file mode 100644
index 0000000000..475360e1ed
--- /dev/null
+++ b/src/Exceptionless.Web/Models/Admin/AdminProductTourUsageResponse.cs
@@ -0,0 +1,29 @@
+using Exceptionless.Core.Models.Data;
+
+namespace Exceptionless.Web.Models.Admin;
+
+public sealed record AdminProductTourUsageResponse(
+    DateTime Month,
+    IReadOnlyCollection<AdminProductTourSummary> Tours,
+    IReadOnlyCollection<AdminProductTourActivity> RecentActivity);
+
+public sealed record AdminProductTourSummary(
+    string Name,
+    long Shown,
+    long Started,
+    long Completed,
+    long Dismissed,
+    long UniqueUsers,
+    DateTime? LastRunUtc,
+    decimal? CompletionRate,
+    decimal? DismissalRate);
+
+public sealed record AdminProductTourActivity(
+    DateTime DateUtc,
+    ProductTourTelemetryEvent Event,
+    ProductTourLaunchSource LaunchSource,
+    string TourName,
+    string? UserIdentity,
+    string? UserName,
+    int Version,
+    long Count);
diff --git a/src/Exceptionless.Web/Models/User/UpdateProductTourProgress.cs b/src/Exceptionless.Web/Models/User/UpdateProductTourProgress.cs
new file mode 100644
index 0000000000..249d265eb3
--- /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
+{
+    [Required]
+    [EnumDataType(typeof(ProductTourStatus))]
+    public ProductTourStatus? Status { get; init; }
+
+    [Range(1, Int32.MaxValue)]
+    public int Version { get; init; }
+}
diff --git a/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs b/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
index 18f8827830..59b483518a 100644
--- a/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
+++ b/src/Exceptionless.Web/Models/User/ViewCurrentUser.cs
@@ -2,6 +2,7 @@
 using System.Text;
 using Exceptionless.Core.Configuration;
 using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
 
 namespace Exceptionless.Web.Models;
 
@@ -23,12 +24,15 @@ 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 ICollection<UserOrganizationPreference> OrganizationPreferences { get; set; }
+    public IDictionary<string, ProductTourProgress> ProductTours { get; set; } = new Dictionary<string, ProductTourProgress>(StringComparer.Ordinal);
+    public IReadOnlyDictionary<string, int> ProductTourVersions { get; } = Exceptionless.Core.Models.Data.ProductTours.Versions;
 
     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 6b50907fb9..9ec6787132 100644
--- a/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json
+++ b/tests/Exceptionless.Tests/Api/Data/endpoint-manifest.json
@@ -511,6 +511,18 @@
     "authorizationRoles": [],
     "authenticationSchemes": []
   },
+  {
+    "method": "GET",
+    "route": "/api/v2/admin/product-tour-usage",
+    "displayName": "HTTP: GET api/v2/admin/product-tour-usage =\u003E GetProductTourUsageAsync",
+    "tags": [],
+    "allowAnonymous": false,
+    "authorizationPolicies": [
+      "GlobalAdminPolicy"
+    ],
+    "authorizationRoles": [],
+    "authenticationSchemes": []
+  },
   {
     "method": "GET",
     "route": "/api/v2/admin/requeue",
@@ -2686,6 +2698,20 @@
     "authorizationRoles": [],
     "authenticationSchemes": []
   },
+  {
+    "method": "PUT",
+    "route": "/api/v2/users/me/product-tours/{tourName:regex(^[a-z0-9]\u002B(?:-[a-z0-9]\u002B)*$):maxlength(64)}",
+    "displayName": "HTTP: PUT api/v2/users/me/product-tours/{tourName:regex(^[a-z0-9]\u002B(?:-[a-z0-9]\u002B)*$):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 f1f2e22b16..d9feb4e4ff 100644
--- a/tests/Exceptionless.Tests/Api/Data/openapi.json
+++ b/tests/Exceptionless.Tests/Api/Data/openapi.json
@@ -428,6 +428,60 @@
         }
       }
     },
+    "/api/v2/admin/product-tour-usage": {
+      "get": {
+        "tags": [
+          "AdminEndpoints"
+        ],
+        "parameters": [
+          {
+            "name": "month",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "format": "int32",
+              "default": 100
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/AdminProductTourUsageResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "403": {
+            "description": "Forbidden"
+          }
+        }
+      }
+    },
     "/.well-known/oauth-authorization-server": {
       "get": {
         "tags": [
@@ -3847,6 +3901,80 @@
         }
       }
     },
+    "/api/v2/users/me/product-tours/{tourName}": {
+      "put": {
+        "tags": [
+          "User"
+        ],
+        "summary": "Update current user product tour progress",
+        "parameters": [
+          {
+            "name": "tourName",
+            "in": "path",
+            "description": "The stable product tour name.",
+            "required": true,
+            "schema": {
+              "maxLength": 64,
+              "pattern": "^[a-z0-9]\u002B(?:-[a-z0-9]\u002B)*$",
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "description": "The versioned product tour outcome.",
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateProductTourProgress"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProductTourProgress"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "The request body is missing or malformed.",
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "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": [
@@ -11590,6 +11718,140 @@
           }
         }
       },
+      "AdminProductTourActivity": {
+        "required": [
+          "date_utc",
+          "event",
+          "launch_source",
+          "tour_name",
+          "user_identity",
+          "user_name",
+          "version",
+          "count"
+        ],
+        "type": "object",
+        "properties": {
+          "date_utc": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "event": {
+            "$ref": "#/components/schemas/ProductTourTelemetryEvent"
+          },
+          "launch_source": {
+            "$ref": "#/components/schemas/ProductTourLaunchSource"
+          },
+          "tour_name": {
+            "type": "string"
+          },
+          "user_identity": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "user_name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "version": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "count": {
+            "type": "integer",
+            "format": "int64"
+          }
+        }
+      },
+      "AdminProductTourSummary": {
+        "required": [
+          "name",
+          "shown",
+          "started",
+          "completed",
+          "dismissed",
+          "unique_users",
+          "last_run_utc",
+          "completion_rate",
+          "dismissal_rate"
+        ],
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "shown": {
+            "type": "integer",
+            "format": "int64"
+          },
+          "started": {
+            "type": "integer",
+            "format": "int64"
+          },
+          "completed": {
+            "type": "integer",
+            "format": "int64"
+          },
+          "dismissed": {
+            "type": "integer",
+            "format": "int64"
+          },
+          "unique_users": {
+            "type": "integer",
+            "format": "int64"
+          },
+          "last_run_utc": {
+            "type": [
+              "null",
+              "string"
+            ],
+            "format": "date-time"
+          },
+          "completion_rate": {
+            "type": [
+              "null",
+              "number"
+            ],
+            "format": "double"
+          },
+          "dismissal_rate": {
+            "type": [
+              "null",
+              "number"
+            ],
+            "format": "double"
+          }
+        }
+      },
+      "AdminProductTourUsageResponse": {
+        "required": [
+          "month",
+          "tours",
+          "recent_activity"
+        ],
+        "type": "object",
+        "properties": {
+          "month": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "tours": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/AdminProductTourSummary"
+            }
+          },
+          "recent_activity": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/AdminProductTourActivity"
+            }
+          }
+        }
+      },
       "AssistantAccessResponse": {
         "required": [
           "enabled",
@@ -13122,6 +13384,67 @@
           }
         }
       },
+      "ProductTourLaunchSource": {
+        "enum": [
+          "automatic",
+          "catalog",
+          "command-palette",
+          "feature-announcement",
+          "help-menu"
+        ],
+        "x-enumNames": [
+          "Automatic",
+          "Catalog",
+          "CommandPalette",
+          "FeatureAnnouncement",
+          "HelpMenu"
+        ]
+      },
+      "ProductTourProgress": {
+        "required": [
+          "status",
+          "updated_utc",
+          "version"
+        ],
+        "type": "object",
+        "properties": {
+          "status": {
+            "$ref": "#/components/schemas/ProductTourStatus"
+          },
+          "updated_utc": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "version": {
+            "type": "integer",
+            "format": "int32"
+          }
+        }
+      },
+      "ProductTourStatus": {
+        "enum": [
+          "completed",
+          "dismissed"
+        ],
+        "x-enumNames": [
+          "Completed",
+          "Dismissed"
+        ]
+      },
+      "ProductTourTelemetryEvent": {
+        "enum": [
+          "completed",
+          "dismissed",
+          "shown",
+          "started"
+        ],
+        "x-enumNames": [
+          "Completed",
+          "Dismissed",
+          "Shown",
+          "Started"
+        ]
+      },
       "ResetPasswordModel": {
         "required": [
           "password_reset_token",
@@ -13530,6 +13853,31 @@
           }
         }
       },
+      "UpdateProductTourProgress": {
+        "required": [
+          "status",
+          "version"
+        ],
+        "type": "object",
+        "properties": {
+          "status": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProductTourStatus"
+              }
+            ]
+          },
+          "version": {
+            "maximum": 2147483647,
+            "minimum": 1,
+            "type": "integer",
+            "format": "int32"
+          }
+        }
+      },
       "UpdateProject": {
         "type": "object",
         "properties": {
@@ -13743,6 +14091,7 @@
           "password_reset_token_expiration",
           "o_auth_accounts",
           "organization_preferences",
+          "product_tours",
           "email_notifications_enabled",
           "is_email_address_verified",
           "verify_email_address_token_expiration",
@@ -13802,6 +14151,12 @@
               "$ref": "#/components/schemas/UserOrganizationPreference"
             }
           },
+          "product_tours": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/components/schemas/ProductTourProgress"
+            }
+          },
           "full_name": {
             "type": "string",
             "description": "Gets or sets the users Full Name."
@@ -13907,6 +14262,7 @@
           "has_local_account",
           "o_auth_accounts",
           "organization_preferences",
+          "product_tours",
           "id",
           "organization_ids",
           "full_name",
@@ -13940,6 +14296,20 @@
               "$ref": "#/components/schemas/UserOrganizationPreference"
             }
           },
+          "product_tours": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/components/schemas/ProductTourProgress"
+            }
+          },
+          "product_tour_versions": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "integer",
+              "format": "int32"
+            },
+            "readOnly": true
+          },
           "id": {
             "maxLength": 24,
             "minLength": 24,
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/AdminProductTourUsageEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/AdminProductTourUsageEndpointTests.cs
new file mode 100644
index 0000000000..7367b4f277
--- /dev/null
+++ b/tests/Exceptionless.Tests/Api/Endpoints/AdminProductTourUsageEndpointTests.cs
@@ -0,0 +1,134 @@
+using Exceptionless.Core;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Utility;
+using Exceptionless.Tests.Extensions;
+using Exceptionless.Tests.Utility;
+using Exceptionless.Web.Models.Admin;
+using Xunit;
+
+namespace Exceptionless.Tests.Api.Endpoints;
+
+public sealed class AdminProductTourUsageEndpointTests : IntegrationTestsBase
+{
+    private readonly AppOptions _appOptions;
+
+    public AdminProductTourUsageEndpointTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
+    {
+        _appOptions = GetService<AppOptions>();
+    }
+
+    protected override async Task ResetDataAsync()
+    {
+        await base.ResetDataAsync();
+        await GetService<SampleDataService>().CreateDataAsync();
+    }
+
+    [Fact]
+    public async Task GetProductTourUsageAsync_AsGlobalAdmin_ReturnsInternalMonthlyUsage()
+    {
+        var month = new DateTime(2026, 8, 1, 0, 0, 0, DateTimeKind.Utc);
+        TimeProvider.SetUtcNow(month.AddDays(20));
+
+        await CreateDataAsync(builder =>
+        {
+            AddUsage(builder, "product-tour.shown.ui-overview.v1.automatic", month.AddDays(1), "user-1", 2);
+            AddUsage(builder, "product-tour.started.ui-overview.v1.catalog", month.AddDays(2), "user-1");
+            AddUsage(builder, "product-tour.started.ui-overview.v1.help-menu", month.AddDays(3), "user-1");
+            AddUsage(builder, "product-tour.started.ui-overview.v1.catalog", month.AddDays(4), "user-2");
+            AddUsage(builder, "product-tour.completed.ui-overview.v1.catalog", month.AddDays(5), "user-1");
+            AddUsage(builder, "product-tour.dismissed.ui-overview.v1.catalog", month.AddDays(6), "user-2");
+            AddUsage(builder, "product-tour.started.meet-exie.v1.command-palette", month.AddDays(7), "user-3");
+            AddUsage(builder, "product-tour.shown.welcome.v1.automatic", month.AddDays(1), "user-1", 2);
+            AddUsage(builder, "product-tour.dismissed.welcome.v1.automatic", month.AddDays(2), "user-1");
+            AddUsage(builder, "product-tour.started.unknown.v1.unknown-source", month.AddDays(8), "user-4");
+
+            builder.Event()
+                .TestProject()
+                .Type(Event.KnownTypes.FeatureUsage)
+                .Source("product-tour.started.ignored-tour.v1.catalog")
+                .Date(month.AddDays(9))
+                .UserIdentity("user-5");
+            AddUsage(builder, "product-tour.started.old-tour.v1.catalog", month.AddMonths(-1), "user-6");
+        });
+
+        var response = await SendRequestAsAsync<AdminProductTourUsageResponse>(request => request
+            .AsGlobalAdminUser()
+            .AppendPaths("admin", "product-tour-usage")
+            .QueryString("month", "2026-08-01")
+            .QueryString("limit", "3")
+            .StatusCodeShouldBeOk());
+
+        Assert.NotNull(response);
+        Assert.Equal(month, response.Month);
+        Assert.Equal(3, response.Tours.Count);
+
+        var overview = Assert.Single(response.Tours, tour => String.Equals(tour.Name, "ui-overview", StringComparison.Ordinal));
+        Assert.Equal(2, overview.Shown);
+        Assert.Equal(3, overview.Started);
+        Assert.Equal(1, overview.Completed);
+        Assert.Equal(1, overview.Dismissed);
+        Assert.Equal(2, overview.UniqueUsers);
+        Assert.Equal(month.AddDays(6), overview.LastRunUtc);
+        Assert.Equal(0.3333m, overview.CompletionRate);
+        Assert.Equal(0.3333m, overview.DismissalRate);
+
+        var exie = Assert.Single(response.Tours, tour => String.Equals(tour.Name, "meet-exie", StringComparison.Ordinal));
+        Assert.Equal(1, exie.Started);
+        Assert.Equal(1, exie.UniqueUsers);
+        Assert.Equal(month.AddDays(7), exie.LastRunUtc);
+        Assert.Equal(0m, exie.CompletionRate);
+        Assert.Equal(0m, exie.DismissalRate);
+
+        var welcome = Assert.Single(response.Tours, tour => String.Equals(tour.Name, "welcome", StringComparison.Ordinal));
+        Assert.Equal(2, welcome.Shown);
+        Assert.Equal(1, welcome.Dismissed);
+        Assert.Equal(month.AddDays(2), welcome.LastRunUtc);
+        Assert.Equal(0.5m, welcome.DismissalRate);
+
+        Assert.Equal(3, response.RecentActivity.Count);
+        Assert.Equal(month.AddDays(7), response.RecentActivity.First().DateUtc);
+        Assert.All(response.RecentActivity, activity => Assert.StartsWith("user-", activity.UserIdentity));
+    }
+
+    [Fact]
+    public async Task GetProductTourUsageAsync_WithoutMonth_UsesCurrentUtcMonth()
+    {
+        TimeProvider.SetUtcNow(new DateTime(2026, 9, 17, 12, 0, 0, DateTimeKind.Utc));
+
+        var response = await SendRequestAsAsync<AdminProductTourUsageResponse>(request => request
+            .AsGlobalAdminUser()
+            .AppendPaths("admin", "product-tour-usage")
+            .StatusCodeShouldBeOk());
+
+        Assert.NotNull(response);
+        Assert.Equal(new DateTime(2026, 9, 1, 0, 0, 0, DateTimeKind.Utc), response.Month);
+        Assert.Empty(response.Tours);
+        Assert.Empty(response.RecentActivity);
+    }
+
+    [Fact]
+    public Task GetProductTourUsageAsync_AsOrganizationUser_ReturnsForbidden()
+    {
+        return SendRequestAsync(request => request
+            .AsTestOrganizationUser()
+            .AppendPaths("admin", "product-tour-usage")
+            .StatusCodeShouldBeForbidden());
+    }
+
+    private void AddUsage(
+        DataBuilder builder,
+        string source,
+        DateTime dateUtc,
+        string userIdentity,
+        int count = 1)
+    {
+        builder.Event()
+            .Organization(SampleDataService.TEST_ORG_ID)
+            .Project(_appOptions.InternalProjectId)
+            .Type(Event.KnownTypes.FeatureUsage)
+            .Source(source)
+            .Date(dateUtc)
+            .UserIdentity(userIdentity, $"Name {userIdentity}")
+            .Mutate(ev => ev.Count = count);
+    }
+}
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/OAuthGrantEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/OAuthGrantEndpointTests.cs
new file mode 100644
index 0000000000..e125d7ff0f
--- /dev/null
+++ b/tests/Exceptionless.Tests/Api/Endpoints/OAuthGrantEndpointTests.cs
@@ -0,0 +1,280 @@
+using Exceptionless.Core.Authorization;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.Core.Utility;
+using Exceptionless.Tests.Extensions;
+using Exceptionless.Web.Models.OAuth;
+using Foundatio.Repositories;
+using Foundatio.Repositories.Utility;
+using Xunit;
+
+namespace Exceptionless.Tests.Api.Endpoints;
+
+public sealed class OAuthGrantEndpointTests : IntegrationTestsBase
+{
+    private readonly IOAuthApplicationRepository _oauthApplicationRepository;
+    private readonly IOAuthTokenRepository _oauthTokenRepository;
+    private readonly IUserRepository _userRepository;
+
+    public OAuthGrantEndpointTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
+    {
+        _oauthApplicationRepository = GetService<IOAuthApplicationRepository>();
+        _oauthTokenRepository = GetService<IOAuthTokenRepository>();
+        _userRepository = GetService<IUserRepository>();
+    }
+
+    protected override async Task ResetDataAsync()
+    {
+        await base.ResetDataAsync();
+        await GetService<SampleDataService>().CreateDataAsync();
+    }
+
+    [Fact]
+    public async Task GetOAuthGrantsAsync_WithActiveOAuthTokens_ReturnsGroupedApplications()
+    {
+        // Arrange
+        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
+        Assert.NotNull(user);
+
+        const string clientId = "test-oauth-grant-client";
+        await CreateOAuthApplicationAsync(clientId, "Test AI Client");
+        string grantId = StringExtensions.GetNewToken();
+        await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess], grantId: grantId);
+        await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.StacksRead], grantId: grantId);
+        await CreateOAuthGrantTokenAsync(user.Id, "disabled-oauth-grant-client", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead], isDisabled: true);
+
+        // Act
+        var grants = await SendRequestAsAsync<IReadOnlyCollection<ViewOAuthGrant>>(r => r
+            .AsTestOrganizationUser()
+            .AppendPath("users/me/oauth-grants")
+            .StatusCodeShouldBeOk()
+        );
+
+        // Assert
+        Assert.NotNull(grants);
+        var grant = Assert.Single(grants);
+        Assert.Equal(clientId, grant.ClientId);
+        Assert.Equal("Test AI Client", grant.ApplicationName);
+        Assert.Contains(SampleDataService.TEST_ORG_ID, grant.OrganizationIds);
+        Assert.Contains(AuthorizationRoles.McpRead, grant.Scopes);
+        Assert.Contains(AuthorizationRoles.StacksRead, grant.Scopes);
+        Assert.Equal(2, grant.Resources.Count);
+        Assert.Contains(grant.Resources, resource => String.Equals(resource.Resource, "http://localhost:7110/mcp", StringComparison.Ordinal) && resource.Scopes.Contains(AuthorizationRoles.McpRead));
+        Assert.Contains(grant.Resources, resource => String.Equals(resource.Resource, "http://localhost:7110/api/v2", StringComparison.Ordinal) && resource.Scopes.Contains(AuthorizationRoles.StacksRead));
+    }
+
+    [Fact]
+    public async Task GetOAuthGrantsAsync_WhenDisabledTokensExceedPageLimit_ReturnsActiveGrant()
+    {
+        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
+        Assert.NotNull(user);
+        const string clientId = "paged-oauth-grant-client";
+        await CreateOAuthApplicationAsync(clientId, "Paged OAuth Grant Client");
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var disabledTokens = Enumerable.Range(0, 1005)
+            .Select(i => CreateOAuthGrantToken(user.Id, $"disabled-paged-client-{i}", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead], utcNow.AddMinutes(1), isDisabled: true))
+            .ToArray();
+        await _oauthTokenRepository.AddAsync(disabledTokens, o => o.ImmediateConsistency());
+        string grantId = StringExtensions.GetNewToken();
+        await _oauthTokenRepository.AddAsync(CreateOAuthGrantToken(
+            user.Id,
+            clientId,
+            "http://localhost:7110/mcp",
+            [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess],
+            utcNow,
+            grantId: grantId), o => o.ImmediateConsistency());
+
+        var grants = await SendRequestAsAsync<IReadOnlyCollection<ViewOAuthGrant>>(r => r
+            .AsTestOrganizationUser()
+            .AppendPath("users/me/oauth-grants")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(grants);
+        var grant = Assert.Single(grants);
+        Assert.Equal(clientId, grant.ClientId);
+        Assert.Equal("Paged OAuth Grant Client", grant.ApplicationName);
+        Assert.Contains(AuthorizationRoles.McpRead, grant.Scopes);
+    }
+
+    [Fact]
+    public async Task RevokeOAuthGrantAsync_WithCurrentUserGrant_DisablesAllClientTokens()
+    {
+        // Arrange
+        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
+        Assert.NotNull(user);
+
+        const string clientId = "test-revoke-client";
+        await CreateOAuthApplicationAsync(clientId, "Revoked AI Client");
+        await CreateOAuthApplicationAsync("unrelated-revoke-client", "Unrelated AI Client");
+        var firstToken = await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess]);
+        var secondToken = await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess]);
+        var unrelatedToken = await CreateOAuthGrantTokenAsync(user.Id, "unrelated-revoke-client", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess]);
+
+        // Act
+        await SendRequestAsync(r => r
+            .Delete()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "oauth-grants", firstToken.GrantId!)
+            .StatusCodeShouldBeNoContent()
+        );
+
+        // Assert
+        var revokedFirstToken = await _oauthTokenRepository.GetByIdAsync(firstToken.Id, o => o.ImmediateConsistency());
+        var revokedSecondToken = await _oauthTokenRepository.GetByIdAsync(secondToken.Id, o => o.ImmediateConsistency());
+        var stillActiveToken = await _oauthTokenRepository.GetByIdAsync(unrelatedToken.Id, o => o.ImmediateConsistency());
+        Assert.NotNull(revokedFirstToken);
+        Assert.NotNull(revokedSecondToken);
+        Assert.NotNull(stillActiveToken);
+        Assert.True(revokedFirstToken.IsDisabled);
+        Assert.True(revokedSecondToken.IsDisabled);
+        Assert.Null(revokedFirstToken.RefreshTokenHash);
+        Assert.Null(revokedSecondToken.RefreshTokenHash);
+        Assert.False(stillActiveToken.IsDisabled);
+        Assert.NotNull(stillActiveToken.RefreshTokenHash);
+    }
+
+    [Fact]
+    public async Task RevokeOAuthGrantAsync_WhenClientTokensExceedPageLimit_DisablesAllClientTokens()
+    {
+        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
+        Assert.NotNull(user);
+        const string clientId = "paged-revoke-client";
+        await CreateOAuthApplicationAsync(clientId, "Paged Revoke Client");
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var tokens = Enumerable.Range(0, 1005)
+            .Select(i => CreateOAuthGrantToken(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess], utcNow))
+            .ToList();
+        string targetGrantId = StringExtensions.GetNewToken();
+        var targetToken = CreateOAuthGrantToken(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess], utcNow, grantId: targetGrantId);
+        tokens.Add(targetToken);
+        await _oauthTokenRepository.AddAsync(tokens, o => o.ImmediateConsistency());
+
+        await SendRequestAsync(r => r
+            .Delete()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "oauth-grants", targetGrantId)
+            .StatusCodeShouldBeNoContent()
+        );
+
+        var results = await _oauthTokenRepository.GetByUserIdAndClientIdForUpdateAsync(user.Id, clientId, o => o.ImmediateConsistency().SearchAfterPaging().PageLimit(1000));
+        int tokenCount = 0;
+        do
+        {
+            foreach (var token in results.Documents)
+            {
+                tokenCount++;
+                Assert.True(token.IsDisabled);
+                Assert.Null(token.RefreshTokenHash);
+            }
+        } while (await results.NextPageAsync());
+
+        Assert.Equal(tokens.Count, tokenCount);
+    }
+
+    [Fact]
+    public async Task RevokeOAuthGrantAsync_ForAnotherUserGrant_ReturnsNotFound()
+    {
+        // Arrange
+        var freeUser = await _userRepository.GetByEmailAddressAsync(SampleDataService.FREE_USER_EMAIL);
+        Assert.NotNull(freeUser);
+
+        const string clientId = "other-user-revoke-client";
+        await CreateOAuthApplicationAsync(clientId, "Other User AI Client");
+        var token = await CreateOAuthGrantTokenAsync(freeUser.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess], organizationIds: [SampleDataService.FREE_ORG_ID]);
+
+        // Act
+        await SendRequestAsync(r => r
+            .Delete()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "oauth-grants", token.GrantId!)
+            .StatusCodeShouldBeNotFound()
+        );
+
+        // Assert
+        var storedToken = await _oauthTokenRepository.GetByIdAsync(token.Id, o => o.ImmediateConsistency());
+        Assert.NotNull(storedToken);
+        Assert.False(storedToken.IsDisabled);
+        Assert.NotNull(storedToken.RefreshTokenHash);
+    }
+    private Task<OAuthApplication> CreateOAuthApplicationAsync(string clientId, string name)
+    {
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var application = new OAuthApplication
+        {
+            Id = ObjectId.GenerateNewId().ToString(),
+            ClientId = clientId,
+            Name = name,
+            RedirectUris = ["http://localhost/callback"],
+            Scopes =
+            [
+                AuthorizationRoles.McpRead,
+                AuthorizationRoles.ProjectsRead,
+                AuthorizationRoles.StacksRead,
+                AuthorizationRoles.StacksWrite,
+                AuthorizationRoles.EventsRead,
+                AuthorizationRoles.OfflineAccess
+            ],
+            CreatedByUserId = OAuthApplication.SystemUserId,
+            UpdatedByUserId = OAuthApplication.SystemUserId,
+            CreatedUtc = utcNow,
+            UpdatedUtc = utcNow
+        };
+
+        return _oauthApplicationRepository.AddAsync(application, o => o.ImmediateConsistency());
+    }
+
+    private async Task<OAuthToken> CreateOAuthGrantTokenAsync(string userId, string clientId, string resource, string[] scopes, bool isDisabled = false, string[]? organizationIds = null, string? grantId = null)
+    {
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var accessToken = StringExtensions.GetRandomString(OAuthService.OAuthTokenLength);
+        var refreshToken = scopes.Contains(AuthorizationRoles.OfflineAccess, StringComparer.Ordinal) ? StringExtensions.GetRandomString(OAuthService.OAuthTokenLength) : null;
+        var token = new OAuthToken
+        {
+            Id = ObjectId.GenerateNewId().ToString(),
+            UserId = userId,
+            ClientId = clientId,
+            GrantId = String.IsNullOrWhiteSpace(grantId) ? StringExtensions.GetNewToken() : grantId,
+            Resource = resource,
+            AccessTokenHash = OAuthService.CreateTokenHash(accessToken),
+            RefreshTokenHash = refreshToken is null ? null : OAuthService.CreateTokenHash(refreshToken),
+            Scopes = scopes.ToHashSet(StringComparer.Ordinal),
+            OrganizationIds = (organizationIds ?? [SampleDataService.TEST_ORG_ID]).ToHashSet(StringComparer.Ordinal),
+            ExpiresUtc = utcNow.AddHours(1),
+            RefreshExpiresUtc = refreshToken is not null ? utcNow.AddDays(30) : null,
+            IsDisabled = isDisabled,
+            CreatedBy = userId,
+            CreatedUtc = utcNow,
+            UpdatedUtc = utcNow
+        };
+
+        await _oauthTokenRepository.AddAsync(token, o => o.ImmediateConsistency());
+        return token;
+    }
+
+    private static OAuthToken CreateOAuthGrantToken(string userId, string clientId, string resource, string[] scopes, DateTime utcNow, bool isDisabled = false, string[]? organizationIds = null, string? grantId = null)
+    {
+        var accessToken = StringExtensions.GetRandomString(OAuthService.OAuthTokenLength);
+        var refreshToken = scopes.Contains(AuthorizationRoles.OfflineAccess, StringComparer.Ordinal) ? StringExtensions.GetRandomString(OAuthService.OAuthTokenLength) : null;
+        return new OAuthToken
+        {
+            Id = ObjectId.GenerateNewId().ToString(),
+            UserId = userId,
+            ClientId = clientId,
+            GrantId = String.IsNullOrWhiteSpace(grantId) ? StringExtensions.GetNewToken() : grantId,
+            Resource = resource,
+            AccessTokenHash = OAuthService.CreateTokenHash(accessToken),
+            RefreshTokenHash = refreshToken is null ? null : OAuthService.CreateTokenHash(refreshToken),
+            Scopes = scopes.ToHashSet(StringComparer.Ordinal),
+            OrganizationIds = (organizationIds ?? [SampleDataService.TEST_ORG_ID]).ToHashSet(StringComparer.Ordinal),
+            ExpiresUtc = utcNow.AddHours(1),
+            RefreshExpiresUtc = refreshToken is not null ? utcNow.AddDays(30) : null,
+            IsDisabled = isDisabled,
+            CreatedBy = userId,
+            CreatedUtc = utcNow,
+            UpdatedUtc = utcNow
+        };
+    }
+}
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/ProductTourEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/ProductTourEndpointTests.cs
new file mode 100644
index 0000000000..4b579de86a
--- /dev/null
+++ b/tests/Exceptionless.Tests/Api/Endpoints/ProductTourEndpointTests.cs
@@ -0,0 +1,189 @@
+using System.Text.Json;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.Data;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Utility;
+using Exceptionless.Tests.Extensions;
+using Exceptionless.Web.Models;
+using Foundatio.Repositories;
+using Xunit;
+
+namespace Exceptionless.Tests.Api.Endpoints;
+
+public sealed class ProductTourEndpointTests : IntegrationTestsBase
+{
+    private readonly IUserRepository _userRepository;
+
+    public ProductTourEndpointTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
+    {
+        _userRepository = GetService<IUserRepository>();
+    }
+
+    protected override async Task ResetDataAsync()
+    {
+        await base.ResetDataAsync();
+        await GetService<SampleDataService>().CreateDataAsync();
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_NewProgress_PersistsAndReturnsProgress()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+
+        var progress = await SendRequestAsAsync<ProductTourProgress>(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "ui-overview")
+            .Content(new UpdateProductTourProgress { Status = ProductTourStatus.Dismissed, Version = 1 })
+            .StatusCodeShouldBeOk());
+
+        Assert.NotNull(progress);
+        Assert.Equal(ProductTourStatus.Dismissed, progress.Status);
+        Assert.Equal(1, progress.Version);
+
+        var persistedUser = await _userRepository.GetByIdAsync(currentUser.Id, options => options.Cache(false));
+        Assert.NotNull(persistedUser);
+        Assert.Equal(progress, persistedUser.ProductTours["ui-overview"]);
+    }
+
+    [Fact]
+    public async Task GetCurrentUserAsync_ReturnsAuthoritativeProductTourVersions()
+    {
+        var currentUser = await SendRequestAsAsync<JsonElement>(request => request
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me")
+            .StatusCodeShouldBeOk());
+
+        var versions = currentUser.GetProperty("product_tour_versions")
+            .Deserialize<Dictionary<string, int>>();
+
+        Assert.Equal(ProductTours.Versions, versions);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_OlderProgress_PreservesStoredValue()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+        currentUser.ProductTours[ProductTours.MeetExie] = new ProductTourProgress
+        {
+            Status = ProductTourStatus.Completed,
+            UpdatedUtc = TimeProvider.GetUtcNow().UtcDateTime,
+            Version = 3
+        };
+        await _userRepository.SaveAsync(currentUser, options => options.Cache().ImmediateConsistency());
+
+        var replacement = await UpdateProgressAsync(ProductTours.MeetExie, ProductTourStatus.Dismissed, 1);
+
+        Assert.Equal(ProductTourStatus.Completed, replacement.Status);
+        Assert.Equal(3, replacement.Version);
+        var persistedUser = await _userRepository.GetByIdAsync(currentUser.Id, options => options.Cache(false));
+        Assert.NotNull(persistedUser);
+        Assert.Equal(replacement, persistedUser.ProductTours["meet-exie"]);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_CompletedProgress_ReplacesDismissedProgressForSameVersion()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+        await UpdateProgressAsync(ProductTours.MeetExie, ProductTourStatus.Dismissed, 1);
+
+        var replacement = await UpdateProgressAsync(ProductTours.MeetExie, ProductTourStatus.Completed, 1);
+
+        Assert.Equal(ProductTourStatus.Completed, replacement.Status);
+        Assert.Equal(1, replacement.Version);
+        var persistedUser = await _userRepository.GetByIdAsync(currentUser.Id, options => options.Cache(false));
+        Assert.NotNull(persistedUser);
+        Assert.Equal(replacement, persistedUser.ProductTours["meet-exie"]);
+    }
+
+    [Fact]
+    public async Task UpdateCurrentUserProductTourAsync_UnknownTourName_ReturnsUnprocessableEntity()
+    {
+        var currentUser = await GetTestOrganizationUserAsync();
+
+        await SendRequestAsync(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "unknown-tour")
+            .Content(new UpdateProductTourProgress { Status = ProductTourStatus.Completed, Version = 1 })
+            .StatusCodeShouldBeUnprocessableEntity());
+
+        var persistedUser = await _userRepository.GetByIdAsync(currentUser.Id, options => options.Cache(false));
+        Assert.NotNull(persistedUser);
+        Assert.DoesNotContain("unknown-tour", persistedUser.ProductTours);
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_InvalidTourName_DoesNotMatchRoute()
+    {
+        return SendRequestAsync(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "Invalid--Tour")
+            .Content(new UpdateProductTourProgress { Status = ProductTourStatus.Completed, Version = 1 })
+            .StatusCodeShouldBeNotFound());
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_AnonymousUser_ReturnsUnauthorized()
+    {
+        return SendRequestAsync(request => request
+            .Put()
+            .AppendPaths("users", "me", "product-tours", "welcome")
+            .Content(new UpdateProductTourProgress { Status = ProductTourStatus.Dismissed, Version = 1 })
+            .StatusCodeShouldBeUnauthorized());
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_MissingBody_ReturnsBadRequest()
+    {
+        return SendRequestAsync(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "ui-overview")
+            .StatusCodeShouldBeBadRequest());
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    [InlineData(2)]
+    public Task UpdateCurrentUserProductTourAsync_UnsupportedVersion_ReturnsUnprocessableEntity(int version)
+    {
+        return SendRequestAsync(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "ui-overview")
+            .Content(new UpdateProductTourProgress { Status = ProductTourStatus.Completed, Version = version })
+            .StatusCodeShouldBeUnprocessableEntity());
+    }
+
+    [Fact]
+    public Task UpdateCurrentUserProductTourAsync_UndefinedStatus_ReturnsUnprocessableEntity()
+    {
+        return SendRequestAsync(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", "ui-overview")
+            .Content(new { Status = 999, Version = 1 })
+            .StatusCodeShouldBeUnprocessableEntity());
+    }
+
+    private async Task<ProductTourProgress> UpdateProgressAsync(string tourName, ProductTourStatus status, int version)
+    {
+        var progress = await SendRequestAsAsync<ProductTourProgress>(request => request
+            .Put()
+            .AsTestOrganizationUser()
+            .AppendPaths("users", "me", "product-tours", tourName)
+            .Content(new UpdateProductTourProgress { Status = status, Version = version })
+            .StatusCodeShouldBeOk());
+
+        return Assert.IsType<ProductTourProgress>(progress);
+    }
+
+    private async Task<User> GetTestOrganizationUserAsync()
+    {
+        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
+        return Assert.IsType<User>(user);
+    }
+}
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
index 2bcd528a36..f05a690a5b 100644
--- a/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
+++ b/tests/Exceptionless.Tests/Api/Endpoints/UserEndpointTests.cs
@@ -8,7 +8,6 @@
 using Exceptionless.Tests.Extensions;
 using Exceptionless.Web.Api.Results;
 using Exceptionless.Web.Models;
-using Exceptionless.Web.Models.OAuth;
 using Exceptionless.Web.Utility;
 using FluentRest;
 using Foundatio.Repositories;
@@ -20,14 +19,10 @@ namespace Exceptionless.Tests.Api.Endpoints;
 public sealed class UserEndpointTests : IntegrationTestsBase
 {
     private readonly IUserRepository _userRepository;
-    private readonly IOAuthApplicationRepository _oauthApplicationRepository;
-    private readonly IOAuthTokenRepository _oauthTokenRepository;
 
     public UserEndpointTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
     {
         _userRepository = GetService<IUserRepository>();
-        _oauthApplicationRepository = GetService<IOAuthApplicationRepository>();
-        _oauthTokenRepository = GetService<IOAuthTokenRepository>();
     }
 
     protected override async Task ResetDataAsync()
@@ -432,174 +427,6 @@ public async Task GetCurrentUserAsync_WithAvatar_ReturnsRoutableAvatarUrl()
         Assert.Equal($"/api/v2/users/{currentUser.Id}/avatar/avatar.png", user.AvatarUrl);
     }
 
-    [Fact]
-    public async Task GetOAuthGrantsAsync_WithActiveOAuthTokens_ReturnsGroupedApplications()
-    {
-        // Arrange
-        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
-        Assert.NotNull(user);
-
-        const string clientId = "test-oauth-grant-client";
-        await CreateOAuthApplicationAsync(clientId, "Test AI Client");
-        string grantId = StringExtensions.GetNewToken();
-        await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess], grantId: grantId);
-        await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.StacksRead], grantId: grantId);
-        await CreateOAuthGrantTokenAsync(user.Id, "disabled-oauth-grant-client", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead], isDisabled: true);
-
-        // Act
-        var grants = await SendRequestAsAsync<IReadOnlyCollection<ViewOAuthGrant>>(r => r
-            .AsTestOrganizationUser()
-            .AppendPath("users/me/oauth-grants")
-            .StatusCodeShouldBeOk()
-        );
-
-        // Assert
-        Assert.NotNull(grants);
-        var grant = Assert.Single(grants);
-        Assert.Equal(clientId, grant.ClientId);
-        Assert.Equal("Test AI Client", grant.ApplicationName);
-        Assert.Contains(SampleDataService.TEST_ORG_ID, grant.OrganizationIds);
-        Assert.Contains(AuthorizationRoles.McpRead, grant.Scopes);
-        Assert.Contains(AuthorizationRoles.StacksRead, grant.Scopes);
-        Assert.Equal(2, grant.Resources.Count);
-        Assert.Contains(grant.Resources, r => r.Resource == "http://localhost:7110/mcp" && r.Scopes.Contains(AuthorizationRoles.McpRead));
-        Assert.Contains(grant.Resources, r => r.Resource == "http://localhost:7110/api/v2" && r.Scopes.Contains(AuthorizationRoles.StacksRead));
-    }
-
-    [Fact]
-    public async Task GetOAuthGrantsAsync_WhenDisabledTokensExceedPageLimit_ReturnsActiveGrant()
-    {
-        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
-        Assert.NotNull(user);
-        const string clientId = "paged-oauth-grant-client";
-        await CreateOAuthApplicationAsync(clientId, "Paged OAuth Grant Client");
-        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
-        var disabledTokens = Enumerable.Range(0, 1005)
-            .Select(i => CreateOAuthGrantToken(user.Id, $"disabled-paged-client-{i}", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead], utcNow.AddMinutes(1), isDisabled: true))
-            .ToArray();
-        await _oauthTokenRepository.AddAsync(disabledTokens, o => o.ImmediateConsistency());
-        string grantId = StringExtensions.GetNewToken();
-        await _oauthTokenRepository.AddAsync(CreateOAuthGrantToken(
-            user.Id,
-            clientId,
-            "http://localhost:7110/mcp",
-            [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess],
-            utcNow,
-            grantId: grantId), o => o.ImmediateConsistency());
-
-        var grants = await SendRequestAsAsync<IReadOnlyCollection<ViewOAuthGrant>>(r => r
-            .AsTestOrganizationUser()
-            .AppendPath("users/me/oauth-grants")
-            .StatusCodeShouldBeOk()
-        );
-
-        Assert.NotNull(grants);
-        var grant = Assert.Single(grants);
-        Assert.Equal(clientId, grant.ClientId);
-        Assert.Equal("Paged OAuth Grant Client", grant.ApplicationName);
-        Assert.Contains(AuthorizationRoles.McpRead, grant.Scopes);
-    }
-
-    [Fact]
-    public async Task RevokeOAuthGrantAsync_WithCurrentUserGrant_DisablesAllClientTokens()
-    {
-        // Arrange
-        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
-        Assert.NotNull(user);
-
-        const string clientId = "test-revoke-client";
-        await CreateOAuthApplicationAsync(clientId, "Revoked AI Client");
-        await CreateOAuthApplicationAsync("unrelated-revoke-client", "Unrelated AI Client");
-        var firstToken = await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess]);
-        var secondToken = await CreateOAuthGrantTokenAsync(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess]);
-        var unrelatedToken = await CreateOAuthGrantTokenAsync(user.Id, "unrelated-revoke-client", "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess]);
-
-        // Act
-        await SendRequestAsync(r => r
-            .Delete()
-            .AsTestOrganizationUser()
-            .AppendPaths("users", "me", "oauth-grants", firstToken.GrantId!)
-            .StatusCodeShouldBeNoContent()
-        );
-
-        // Assert
-        var revokedFirstToken = await _oauthTokenRepository.GetByIdAsync(firstToken.Id, o => o.ImmediateConsistency());
-        var revokedSecondToken = await _oauthTokenRepository.GetByIdAsync(secondToken.Id, o => o.ImmediateConsistency());
-        var stillActiveToken = await _oauthTokenRepository.GetByIdAsync(unrelatedToken.Id, o => o.ImmediateConsistency());
-        Assert.NotNull(revokedFirstToken);
-        Assert.NotNull(revokedSecondToken);
-        Assert.NotNull(stillActiveToken);
-        Assert.True(revokedFirstToken.IsDisabled);
-        Assert.True(revokedSecondToken.IsDisabled);
-        Assert.Null(revokedFirstToken.RefreshTokenHash);
-        Assert.Null(revokedSecondToken.RefreshTokenHash);
-        Assert.False(stillActiveToken.IsDisabled);
-        Assert.NotNull(stillActiveToken.RefreshTokenHash);
-    }
-
-    [Fact]
-    public async Task RevokeOAuthGrantAsync_WhenClientTokensExceedPageLimit_DisablesAllClientTokens()
-    {
-        var user = await _userRepository.GetByEmailAddressAsync(SampleDataService.TEST_ORG_USER_EMAIL);
-        Assert.NotNull(user);
-        const string clientId = "paged-revoke-client";
-        await CreateOAuthApplicationAsync(clientId, "Paged Revoke Client");
-        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
-        var tokens = Enumerable.Range(0, 1005)
-            .Select(i => CreateOAuthGrantToken(user.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess], utcNow))
-            .ToList();
-        string targetGrantId = StringExtensions.GetNewToken();
-        var targetToken = CreateOAuthGrantToken(user.Id, clientId, "http://localhost:7110/api/v2", [AuthorizationRoles.ProjectsRead, AuthorizationRoles.OfflineAccess], utcNow, grantId: targetGrantId);
-        tokens.Add(targetToken);
-        await _oauthTokenRepository.AddAsync(tokens, o => o.ImmediateConsistency());
-
-        await SendRequestAsync(r => r
-            .Delete()
-            .AsTestOrganizationUser()
-            .AppendPaths("users", "me", "oauth-grants", targetGrantId)
-            .StatusCodeShouldBeNoContent()
-        );
-
-        var results = await _oauthTokenRepository.GetByUserIdAndClientIdForUpdateAsync(user.Id, clientId, o => o.ImmediateConsistency().SearchAfterPaging().PageLimit(1000));
-        int tokenCount = 0;
-        do
-        {
-            foreach (var token in results.Documents)
-            {
-                tokenCount++;
-                Assert.True(token.IsDisabled);
-                Assert.Null(token.RefreshTokenHash);
-            }
-        } while (await results.NextPageAsync());
-
-        Assert.Equal(tokens.Count, tokenCount);
-    }
-
-    [Fact]
-    public async Task RevokeOAuthGrantAsync_ForAnotherUserGrant_ReturnsNotFound()
-    {
-        // Arrange
-        var freeUser = await _userRepository.GetByEmailAddressAsync(SampleDataService.FREE_USER_EMAIL);
-        Assert.NotNull(freeUser);
-
-        const string clientId = "other-user-revoke-client";
-        await CreateOAuthApplicationAsync(clientId, "Other User AI Client");
-        var token = await CreateOAuthGrantTokenAsync(freeUser.Id, clientId, "http://localhost:7110/mcp", [AuthorizationRoles.McpRead, AuthorizationRoles.OfflineAccess], organizationIds: [SampleDataService.FREE_ORG_ID]);
-
-        // Act
-        await SendRequestAsync(r => r
-            .Delete()
-            .AsTestOrganizationUser()
-            .AppendPaths("users", "me", "oauth-grants", token.GrantId!)
-            .StatusCodeShouldBeNotFound()
-        );
-
-        // Assert
-        var storedToken = await _oauthTokenRepository.GetByIdAsync(token.Id, o => o.ImmediateConsistency());
-        Assert.NotNull(storedToken);
-        Assert.False(storedToken.IsDisabled);
-        Assert.NotNull(storedToken.RefreshTokenHash);
-    }
 
     [Fact]
     public async Task UploadAvatarAsync_ImageOverGlobalRequestLimit_ReturnsUpdatedUser()
@@ -962,84 +789,6 @@ await SendRequestAsync(r => r
         Assert.Null(updatedUser.VerifyEmailAddressToken);
     }
 
-    private Task<OAuthApplication> CreateOAuthApplicationAsync(string clientId, string name)
-    {
-        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
-        var application = new OAuthApplication
-        {
-            Id = ObjectId.GenerateNewId().ToString(),
-            ClientId = clientId,
-            Name = name,
-            RedirectUris = ["http://localhost/callback"],
-            Scopes =
-            [
-                AuthorizationRoles.McpRead,
-                AuthorizationRoles.ProjectsRead,
-                AuthorizationRoles.StacksRead,
-                AuthorizationRoles.StacksWrite,
-                AuthorizationRoles.EventsRead,
-                AuthorizationRoles.OfflineAccess
-            ],
-            CreatedByUserId = OAuthApplication.SystemUserId,
-            UpdatedByUserId = OAuthApplication.SystemUserId,
-            CreatedUtc = utcNow,
-            UpdatedUtc = utcNow
-        };
-
-        return _oauthApplicationRepository.AddAsync(application, o => o.ImmediateConsistency());
-    }
-
-    private async Task<OAuthToken> CreateOAuthGrantTokenAsync(string userId, string clientId, string resource, string[] scopes, bool isDisabled = false, string[]? organizationIds = null, string? grantId = null)
-    {
-        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
-        var accessToken = StringExtensions.GetRandomString(OAuthService.OAuthTokenLength);
-        var refreshToken = scopes.Contains(AuthorizationRoles.OfflineAccess, StringComparer.Ordinal) ? StringExtensions.GetRandomString(OAuthService.OAuthTokenLength) : null;
-        var token = new OAuthToken
-        {
-            Id = ObjectId.GenerateNewId().ToString(),
-            UserId = userId,
-            ClientId = clientId,
-            GrantId = String.IsNullOrWhiteSpace(grantId) ? StringExtensions.GetNewToken() : grantId,
-            Resource = resource,
-            AccessTokenHash = OAuthService.CreateTokenHash(accessToken),
-            RefreshTokenHash = refreshToken is null ? null : OAuthService.CreateTokenHash(refreshToken),
-            Scopes = scopes.ToHashSet(StringComparer.Ordinal),
-            OrganizationIds = (organizationIds ?? [SampleDataService.TEST_ORG_ID]).ToHashSet(StringComparer.Ordinal),
-            ExpiresUtc = utcNow.AddHours(1),
-            RefreshExpiresUtc = refreshToken is not null ? utcNow.AddDays(30) : null,
-            IsDisabled = isDisabled,
-            CreatedBy = userId,
-            CreatedUtc = utcNow,
-            UpdatedUtc = utcNow
-        };
-
-        await _oauthTokenRepository.AddAsync(token, o => o.ImmediateConsistency());
-        return token;
-    }
-
-    private static OAuthToken CreateOAuthGrantToken(string userId, string clientId, string resource, string[] scopes, DateTime utcNow, bool isDisabled = false, string[]? organizationIds = null, string? grantId = null)
-    {
-        var accessToken = StringExtensions.GetRandomString(OAuthService.OAuthTokenLength);
-        var refreshToken = scopes.Contains(AuthorizationRoles.OfflineAccess, StringComparer.Ordinal) ? StringExtensions.GetRandomString(OAuthService.OAuthTokenLength) : null;
-        return new OAuthToken
-        {
-            Id = ObjectId.GenerateNewId().ToString(),
-            UserId = userId,
-            ClientId = clientId,
-            GrantId = String.IsNullOrWhiteSpace(grantId) ? StringExtensions.GetNewToken() : grantId,
-            Resource = resource,
-            AccessTokenHash = OAuthService.CreateTokenHash(accessToken),
-            RefreshTokenHash = refreshToken is null ? null : OAuthService.CreateTokenHash(refreshToken),
-            Scopes = scopes.ToHashSet(StringComparer.Ordinal),
-            OrganizationIds = (organizationIds ?? [SampleDataService.TEST_ORG_ID]).ToHashSet(StringComparer.Ordinal),
-            ExpiresUtc = utcNow.AddHours(1),
-            RefreshExpiresUtc = refreshToken is not null ? utcNow.AddDays(30) : null,
-            IsDisabled = isDisabled,
-            CreatedBy = userId,
-            CreatedUtc = utcNow,
-            UpdatedUtc = utcNow
-        };
-    }
 
     private async Task<ViewUser> GetTestOrganizationUserAsync()
     {
diff --git a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
index 9d85fa6956..f0e22b33ad 100644
--- a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
+++ b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
@@ -61,6 +61,17 @@ 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/{tourName}", out var productTourPath));
+        Assert.True(productTourPath.TryGetProperty("put", out var productTourPut));
+        Assert.True(productTourPut.TryGetProperty("requestBody", out _));
+        AssertResponseCodes(productTourPut, "200", "404", "422");
+        AssertResponseSchema(productTourPut, "200", "ProductTourProgress");
+
+        Assert.True(paths.TryGetProperty("/api/v2/admin/product-tour-usage", out var productTourUsagePath));
+        Assert.True(productTourUsagePath.TryGetProperty("get", out var productTourUsageGet));
+        AssertResponseCodes(productTourUsageGet, "200", "400", "401", "403");
+        AssertResponseSchema(productTourUsageGet, "200", "AdminProductTourUsageResponse");
+
         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 +111,11 @@ 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("AdminProductTourActivity", out _));
+        Assert.True(schemas.TryGetProperty("AdminProductTourSummary", out _));
+        Assert.True(schemas.TryGetProperty("AdminProductTourUsageResponse", out _));
         Assert.True(schemas.TryGetProperty("ViewOrganization", out _));
 
         var savedViewColumnProperties = savedViewColumnSettings.GetProperty("properties");
@@ -167,6 +183,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/{tourName}", "put", "UpdateProductTourProgress", "application/json");
 
         AssertRequestContentTypes(paths, "/api/v1/error", "post", "application/json", "text/plain");
         AssertRequestContentTypes(paths, "/api/v1/events", "post", "application/json", "text/plain");
@@ -290,6 +307,20 @@ private static void AssertResponseCodes(JsonElement operation, params string[] e
             Assert.True(responses.TryGetProperty(statusCode, out _), $"Expected response status code '{statusCode}'.");
     }
 
+    private static void AssertResponseSchema(JsonElement operation, string statusCode, string expectedSchema)
+    {
+        string? schema = operation
+            .GetProperty("responses")
+            .GetProperty(statusCode)
+            .GetProperty("content")
+            .GetProperty("application/json")
+            .GetProperty("schema")
+            .GetProperty("$ref")
+            .GetString();
+
+        Assert.Equal($"#/components/schemas/{expectedSchema}", schema);
+    }
+
     private static void AssertPathResponseCodes(JsonElement paths, string path, string method, params string[] expectedStatusCodes)
     {
         var operation = paths.GetProperty(path).GetProperty(method);
@@ -364,13 +395,14 @@ private static void AssertRequestContentTypes(JsonElement paths, string path, st
         Assert.Equal(expectedContentTypes.Order(), content.EnumerateObject().Select(property => property.Name).Order());
     }
 
-    private static void AssertRequiredJsonRequestBody(JsonElement paths, string path, string method, string expectedSchema)
+    private static void AssertRequiredJsonRequestBody(JsonElement paths, string path, string method, string expectedSchema, params string[] expectedContentTypes)
     {
         var requestBody = paths.GetProperty(path).GetProperty(method).GetProperty("requestBody");
         Assert.True(requestBody.GetProperty("required").GetBoolean());
 
         var content = requestBody.GetProperty("content");
-        Assert.Equal(["application/*+json", "application/json"], content.EnumerateObject().Select(property => property.Name).Order());
+        string[] contentTypes = expectedContentTypes.Length > 0 ? expectedContentTypes : ["application/*+json", "application/json"];
+        Assert.Equal(contentTypes.Order(), content.EnumerateObject().Select(property => property.Name).Order());
 
         foreach (var mediaType in content.EnumerateObject())
             Assert.Equal($"#/components/schemas/{expectedSchema}", mediaType.Value.GetProperty("schema").GetProperty("$ref").GetString());
diff --git a/tests/Exceptionless.Tests/Repositories/EventRepositoryTests.cs b/tests/Exceptionless.Tests/Repositories/EventRepositoryTests.cs
index 95c5d2b628..196877c9d5 100644
--- a/tests/Exceptionless.Tests/Repositories/EventRepositoryTests.cs
+++ b/tests/Exceptionless.Tests/Repositories/EventRepositoryTests.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using Exceptionless.Core;
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Models.Data;
 using Exceptionless.Core.Repositories;
@@ -16,6 +17,7 @@ namespace Exceptionless.Tests.Repositories;
 public sealed class EventRepositoryTests : IntegrationTestsBase
 {
     private readonly List<Tuple<string, DateTime>> _ids = new();
+    private readonly AppOptions _appOptions;
     private readonly Exceptionless.Helpers.RandomEventGenerator _randomEventGenerator;
     private readonly EventData _eventData;
     private readonly IEventRepository _repository;
@@ -25,6 +27,7 @@ public sealed class EventRepositoryTests : IntegrationTestsBase
 
     public EventRepositoryTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
     {
+        _appOptions = GetService<AppOptions>();
         _randomEventGenerator = GetService<Exceptionless.Helpers.RandomEventGenerator>();
         _eventData = GetService<EventData>();
         _repository = GetService<IEventRepository>();
@@ -33,6 +36,52 @@ public EventRepositoryTests(ITestOutputHelper output, AppWebHostFactory factory)
         _serializer = GetService<ITextSerializer>();
     }
 
+    [Fact]
+    public async Task GetProductTourUsageAsync_KnownSources_ReturnsPerTourAggregations()
+    {
+        var month = new DateTime(2026, 8, 1, 0, 0, 0, DateTimeKind.Utc);
+        await CreateDataAsync(builder =>
+        {
+            AddProductTourUsage(builder, "product-tour.started.ui-overview.v1.catalog", month.AddDays(1), "user-1", 2);
+            AddProductTourUsage(builder, "product-tour.started.ui-overview.v1.help-menu", month.AddDays(2), "user-1");
+            AddProductTourUsage(builder, "product-tour.completed.ui-overview.v1.catalog", month.AddDays(3), "user-2");
+            AddProductTourUsage(builder, "product-tour.shown.welcome.v1.automatic", month.AddDays(4), "user-3");
+            AddProductTourUsage(builder, "product-tour.started.ui-overview.v2.catalog", month.AddDays(5), "user-4");
+            AddProductTourUsage(builder, "product-tour.started.unknown-tour.v1.catalog", month.AddDays(6), "user-5");
+            AddProductTourUsage(builder, "product-tour.started.ui-overview.v1.catalog", month.AddMonths(-1), "user-6");
+            builder.Event()
+                .Organization(TestConstants.OrganizationId)
+                .Project(_appOptions.InternalProjectId)
+                .Type(Event.KnownTypes.FeatureUsage)
+                .Source("product-tour.started.ui-overview.v1.catalog")
+                .Date(month.AddDays(8))
+                .UserIdentity("user-8");
+            builder.Event()
+                .TestProject()
+                .Type(Event.KnownTypes.FeatureUsage)
+                .Source("product-tour.started.ui-overview.v1.catalog")
+                .Date(month.AddDays(7))
+                .UserIdentity("user-7");
+        });
+
+        var result = await _repository.GetProductTourUsageAsync(_appOptions.InternalProjectId, month, month.AddMonths(1), recentLimit: 3);
+
+        Assert.Equal(3, result.RecentEvents.Count);
+        Assert.Equal(2, result.Tours.Count);
+        var overview = Assert.Single(result.Tours, tour => String.Equals(tour.Name, ProductTours.UiOverview, StringComparison.Ordinal));
+        Assert.Equal(3, overview.UniqueUsers);
+        Assert.Equal(4, overview.Buckets.Where(bucket => bucket.Source.Event == ProductTourTelemetryEvent.Started).Sum(bucket => bucket.Count));
+        Assert.Equal(1, overview.Buckets.Where(bucket => bucket.Source.Event == ProductTourTelemetryEvent.Completed).Sum(bucket => bucket.Count));
+        Assert.Equal(month.AddDays(8), overview.Buckets.Max(bucket => bucket.LastUtc));
+
+        var welcome = Assert.Single(result.Tours, tour => String.Equals(tour.Name, ProductTours.Welcome, StringComparison.Ordinal));
+        Assert.Equal(1, welcome.UniqueUsers);
+        Assert.Equal(1, Assert.Single(welcome.Buckets).Count);
+
+        Assert.Equal(month.AddDays(8), result.RecentEvents.First().Event.Date);
+        Assert.All(result.RecentEvents, item => Assert.True(ProductTours.IsValid(item.Source.TourName, item.Source.Version)));
+    }
+
     [Fact]
     public async Task GetAsync()
     {
@@ -245,6 +294,18 @@ public async Task RemoveAllByClientIpAndDateAsync()
         Assert.Empty(events);
     }
 
+    private void AddProductTourUsage(DataBuilder builder, string source, DateTime dateUtc, string userIdentity, int count = 1)
+    {
+        builder.Event()
+            .Organization(TestConstants.OrganizationId)
+            .Project(_appOptions.InternalProjectId)
+            .Type(Event.KnownTypes.FeatureUsage)
+            .Source(source)
+            .Date(dateUtc)
+            .UserIdentity(userIdentity)
+            .Mutate(ev => ev.Count = count);
+    }
+
     private async Task CreateDataAsync()
     {
         var baseDate = DateTime.UtcNow.SubtractHours(1);
diff --git a/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs b/tests/Exceptionless.Tests/Serializer/Models/UserSerializerTests.cs
index 9766e07805..ea47f10f7a 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
+                },
+                ["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["ui-overview"].Version);
+        Assert.Equal(ProductTourStatus.Completed, deserialized.ProductTours["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/admin.http b/tests/http/admin.http
index ca66456788..e887ce5045 100644
--- a/tests/http/admin.http
+++ b/tests/http/admin.http
@@ -116,6 +116,10 @@ Content-Type: application/json
     "enabled": null
 }
 
+### Product Tour Usage
+GET {{apiUrl}}/admin/product-tour-usage?month=2026-08-01&limit=100
+Authorization: Bearer {{token}}
+
 ### Suspend
 POST {{apiUrl}}/organizations/{{organizationId}}/suspend?code=1
 Authorization: Bearer {{token}}
diff --git a/tests/http/users.http b/tests/http/users.http
index 38b9d2cee5..2fc983c203 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/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}}