chore: temp commit

2026-02-09 19:22:21 +00:00 · 2026-02-08 11:03:17 +05:30
168 changed files with 10336 additions and 6528 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -133,8 +133,5 @@
 /frontend/src/pages/PublicDashboard/ @SigNoz/pulse-frontend
 /frontend/src/container/PublicDashboardContainer/ @SigNoz/pulse-frontend

-## Dashboard Libs + Components
-/frontend/src/lib/uPlotV2/ @SigNoz/pulse-frontend
-/frontend/src/lib/dashboard/ @SigNoz/pulse-frontend
-/frontend/src/lib/dashboardVariables/ @SigNoz/pulse-frontend
-/frontend/src/components/NewSelect/ @SigNoz/pulse-frontend
+## UplotV2 
+/frontend/src/lib/uPlotV2/ @SigNoz/pulse-frontend
--- a/cmd/community/server.go
+++ b/cmd/community/server.go
@@ -18,6 +18,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	"github.com/SigNoz/signoz/pkg/modules/role/implrole"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/queryparser"
@@ -76,15 +78,18 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error) {
 			return signoz.NewAuthNs(ctx, providerSettings, store, licensing)
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, _ licensing.Licensing, _ dashboard.Module) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+		func(ctx context.Context, sqlstore sqlstore.SQLStore) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx))
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, _ role.Setter, _ role.Granter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
 			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()
 		},
+		func(store sqlstore.SQLStore, authz authz.AuthZ, licensing licensing.Licensing, _ []role.RegisterTypeable) role.Setter {
+			return implrole.NewSetter(implrole.NewStore(store), authz)
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", "error", err)
--- a/cmd/enterprise/server.go
+++ b/cmd/enterprise/server.go
@@ -14,6 +14,7 @@ import (
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
+	"github.com/SigNoz/signoz/ee/modules/role/implrole"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
 	"github.com/SigNoz/signoz/ee/sqlschema/postgressqlschema"
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
@@ -28,6 +29,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	pkgimplrole "github.com/SigNoz/signoz/pkg/modules/role/implrole"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
@@ -115,15 +118,18 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e

 			return authNs, nil
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, licensing licensing.Licensing, dashboardModule dashboard.Module) factory.ProviderFactory[authz.AuthZ, authz.Config] {
-			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), licensing, dashboardModule)
+		func(ctx context.Context, sqlstore sqlstore.SQLStore) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx))
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, roleSetter role.Setter, granter role.Granter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, roleSetter, granter, queryParser, querier, licensing)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)
 		},
+		func(store sqlstore.SQLStore, authz authz.AuthZ, licensing licensing.Licensing, registry []role.RegisterTypeable) role.Setter {
+			return implrole.NewSetter(pkgimplrole.NewStore(store), authz, licensing, registry)
+		},
 	)

 	if err != nil {
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -607,178 +607,6 @@ paths:
      summary: Update auth domain
      tags:
      - authdomains
-  /api/v1/fields/keys:
-    get:
-      deprecated: false
-      description: This endpoint returns field keys
-      operationId: GetFieldsKeys
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          type: string
-      - in: query
-        name: source
-        schema:
-          type: string
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          type: string
-      - in: query
-        name: fieldDataType
-        schema:
-          type: string
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldKeys'
-                  status:
-                    type: string
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get field keys
-      tags:
-      - fields
-  /api/v1/fields/values:
-    get:
-      deprecated: false
-      description: This endpoint returns field values
-      operationId: GetFieldsValues
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          type: string
-      - in: query
-        name: source
-        schema:
-          type: string
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          type: string
-      - in: query
-        name: fieldDataType
-        schema:
-          type: string
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      - in: query
-        name: name
-        schema:
-          type: string
-      - in: query
-        name: existingQuery
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldValues'
-                  status:
-                    type: string
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get field values
-      tags:
-      - fields
  /api/v1/getResetPasswordToken/{id}:
    get:
      deprecated: false
@@ -2398,12 +2226,6 @@ paths:
              schema:
                $ref: '#/components/schemas/RenderErrorResponse'
          description: Bad Request
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unprocessable Entity
        "500":
          content:
            application/json:
@@ -2843,7 +2665,6 @@ paths:
      parameters:
      - in: query
        name: metricName
-        required: true
        schema:
          type: string
      responses:
@@ -2898,7 +2719,6 @@ paths:
      parameters:
      - in: query
        name: metricName
-        required: true
        schema:
          type: string
      responses:
@@ -2954,7 +2774,6 @@ paths:
      parameters:
      - in: query
        name: metricName
-        required: true
        schema:
          type: string
      responses:
@@ -3121,7 +2940,6 @@ paths:
      parameters:
      - in: query
        name: metricName
-        required: true
        schema:
          type: string
      responses:
@@ -3989,9 +3807,6 @@ components:
          type: string
        alertName:
          type: string
-      required:
-      - alertName
-      - alertId
      type: object
    MetricsexplorertypesMetricAlertsResponse:
      properties:
@@ -4000,8 +3815,6 @@ components:
            $ref: '#/components/schemas/MetricsexplorertypesMetricAlert'
          nullable: true
          type: array
-      required:
-      - alerts
      type: object
    MetricsexplorertypesMetricAttribute:
      properties:
@@ -4015,10 +3828,6 @@ components:
            type: string
          nullable: true
          type: array
-      required:
-      - key
-      - values
-      - valueCount
      type: object
    MetricsexplorertypesMetricAttributesRequest:
      properties:
@@ -4030,8 +3839,6 @@ components:
        start:
          nullable: true
          type: integer
-      required:
-      - metricName
      type: object
    MetricsexplorertypesMetricAttributesResponse:
      properties:
@@ -4043,9 +3850,6 @@ components:
        totalKeys:
          format: int64
          type: integer
-      required:
-      - attributes
-      - totalKeys
      type: object
    MetricsexplorertypesMetricDashboard:
      properties:
@@ -4057,11 +3861,6 @@ components:
          type: string
        widgetName:
          type: string
-      required:
-      - dashboardName
-      - dashboardId
-      - widgetId
-      - widgetName
      type: object
    MetricsexplorertypesMetricDashboardsResponse:
      properties:
@@ -4070,8 +3869,6 @@ components:
            $ref: '#/components/schemas/MetricsexplorertypesMetricDashboard'
          nullable: true
          type: array
-      required:
-      - dashboards
      type: object
    MetricsexplorertypesMetricHighlightsResponse:
      properties:
@@ -4087,11 +3884,6 @@ components:
        totalTimeSeries:
          minimum: 0
          type: integer
-      required:
-      - dataPoints
-      - lastReceived
-      - totalTimeSeries
-      - activeTimeSeries
      type: object
    MetricsexplorertypesMetricMetadata:
      properties:
@@ -4100,17 +3892,11 @@ components:
        isMonotonic:
          type: boolean
        temporality:
-          $ref: '#/components/schemas/MetrictypesTemporality'
+          type: string
        type:
-          $ref: '#/components/schemas/MetrictypesType'
+          type: string
        unit:
          type: string
-      required:
-      - description
-      - type
-      - unit
-      - temporality
-      - isMonotonic
      type: object
    MetricsexplorertypesStat:
      properties:
@@ -4125,16 +3911,9 @@ components:
          minimum: 0
          type: integer
        type:
-          $ref: '#/components/schemas/MetrictypesType'
+          type: string
        unit:
          type: string
-      required:
-      - metricName
-      - description
-      - type
-      - unit
-      - timeseries
-      - samples
      type: object
    MetricsexplorertypesStatsRequest:
      properties:
@@ -4152,10 +3931,6 @@ components:
        start:
          format: int64
          type: integer
-      required:
-      - start
-      - end
-      - limit
      type: object
    MetricsexplorertypesStatsResponse:
      properties:
@@ -4167,9 +3942,6 @@ components:
        total:
          minimum: 0
          type: integer
-      required:
-      - metrics
-      - total
      type: object
    MetricsexplorertypesTreemapEntry:
      properties:
@@ -4181,16 +3953,7 @@ components:
        totalValue:
          minimum: 0
          type: integer
-      required:
-      - metricName
-      - percentage
-      - totalValue
      type: object
-    MetricsexplorertypesTreemapMode:
-      enum:
-      - timeseries
-      - samples
-      type: string
    MetricsexplorertypesTreemapRequest:
      properties:
        end:
@@ -4201,15 +3964,10 @@ components:
        limit:
          type: integer
        mode:
-          $ref: '#/components/schemas/MetricsexplorertypesTreemapMode'
+          type: string
        start:
          format: int64
          type: integer
-      required:
-      - start
-      - end
-      - limit
-      - mode
      type: object
    MetricsexplorertypesTreemapResponse:
      properties:
@@ -4223,9 +3981,6 @@ components:
            $ref: '#/components/schemas/MetricsexplorertypesTreemapEntry'
          nullable: true
          type: array
-      required:
-      - timeseries
-      - samples
      type: object
    MetricsexplorertypesUpdateMetricMetadataRequest:
      properties:
@@ -4236,33 +3991,12 @@ components:
        metricName:
          type: string
        temporality:
-          $ref: '#/components/schemas/MetrictypesTemporality'
+          type: string
        type:
-          $ref: '#/components/schemas/MetrictypesType'
+          type: string
        unit:
          type: string
-      required:
-      - metricName
-      - type
-      - description
-      - unit
-      - temporality
-      - isMonotonic
      type: object
-    MetrictypesTemporality:
-      enum:
-      - delta
-      - cumulative
-      - unspecified
-      type: string
-    MetrictypesType:
-      enum:
-      - gauge
-      - sum
-      - histogram
-      - summary
-      - exponentialhistogram
-      type: string
    PreferencetypesPreference:
      properties:
        allowedScopes:
@@ -4416,60 +4150,6 @@ components:
          format: date-time
          type: string
      type: object
-    TelemetrytypesGettableFieldKeys:
-      properties:
-        complete:
-          type: boolean
-        keys:
-          additionalProperties:
-            items:
-              $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
-            type: array
-          nullable: true
-          type: object
-      type: object
-    TelemetrytypesGettableFieldValues:
-      properties:
-        complete:
-          type: boolean
-        values:
-          $ref: '#/components/schemas/TelemetrytypesTelemetryFieldValues'
-      type: object
-    TelemetrytypesTelemetryFieldKey:
-      properties:
-        description:
-          type: string
-        fieldContext:
-          type: string
-        fieldDataType:
-          type: string
-        name:
-          type: string
-        signal:
-          type: string
-        unit:
-          type: string
-      type: object
-    TelemetrytypesTelemetryFieldValues:
-      properties:
-        boolValues:
-          items:
-            type: boolean
-          type: array
-        numberValues:
-          items:
-            format: double
-            type: number
-          type: array
-        relatedValues:
-          items:
-            type: string
-          type: array
-        stringValues:
-          items:
-            type: string
-          type: array
-      type: object
    TypesChangePasswordRequest:
      properties:
        newPassword:
@@ -4598,9 +4278,6 @@ components:
          type: string
        orgId:
          type: string
-      required:
-      - orgId
-      - email
      type: object
    TypesPostableInvite:
      properties:
--- a/ee/authz/openfgaauthz/provider.go
+++ b/ee/authz/openfgaauthz/provider.go
@@ -2,18 +2,12 @@ package openfgaauthz

 import (
 	"context"
-	"slices"

-	"github.com/SigNoz/signoz/ee/authz/openfgaserver"
 	"github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/authz/authzstore/sqlauthzstore"
 	pkgopenfgaauthz "github.com/SigNoz/signoz/pkg/authz/openfgaauthz"
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/roletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
@@ -21,224 +15,50 @@ import (

 type provider struct {
 	pkgAuthzService authz.AuthZ
-	openfgaServer   *openfgaserver.Server
-	licensing       licensing.Licensing
-	store           roletypes.Store
-	registry        []authz.RegisterTypeable
 }

-func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, licensing licensing.Licensing, registry ...authz.RegisterTypeable) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("openfga"), func(ctx context.Context, ps factory.ProviderSettings, config authz.Config) (authz.AuthZ, error) {
-		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema, licensing, registry)
+		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema)
 	})
 }

-func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, licensing licensing.Licensing, registry []authz.RegisterTypeable) (authz.AuthZ, error) {
+func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) (authz.AuthZ, error) {
 	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema)
 	pkgAuthzService, err := pkgOpenfgaAuthzProvider.New(ctx, settings, config)
 	if err != nil {
 		return nil, err
 	}

-	openfgaServer, err := openfgaserver.NewOpenfgaServer(ctx, pkgAuthzService)
-	if err != nil {
-		return nil, err
-	}
-
 	return &provider{
 		pkgAuthzService: pkgAuthzService,
-		openfgaServer:   openfgaServer,
-		licensing:       licensing,
-		store:           sqlauthzstore.NewSqlAuthzStore(sqlstore),
-		registry:        registry,
 	}, nil
 }

 func (provider *provider) Start(ctx context.Context) error {
-	return provider.openfgaServer.Start(ctx)
+	return provider.pkgAuthzService.Start(ctx)
 }

 func (provider *provider) Stop(ctx context.Context) error {
-	return provider.openfgaServer.Stop(ctx)
+	return provider.pkgAuthzService.Stop(ctx)
 }

 func (provider *provider) Check(ctx context.Context, tuple *openfgav1.TupleKey) error {
-	return provider.openfgaServer.Check(ctx, tuple)
+	return provider.pkgAuthzService.Check(ctx, tuple)
 }

-func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	return provider.openfgaServer.CheckWithTupleCreation(ctx, claims, orgID, relation, typeable, selectors, roleSelectors)
-}
-
-func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	return provider.openfgaServer.CheckWithTupleCreationWithoutClaims(ctx, orgID, relation, typeable, selectors, roleSelectors)
-}
-
-func (provider *provider) BatchCheck(ctx context.Context, tuples []*openfgav1.TupleKey) error {
-	return provider.openfgaServer.BatchCheck(ctx, tuples)
-}
-
-func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
-	return provider.openfgaServer.ListObjects(ctx, subject, relation, typeable)
-}
-
-func (provider *provider) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
-	return provider.openfgaServer.Write(ctx, additions, deletions)
-}
-
-func (provider *provider) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*roletypes.Role, error) {
-	return provider.pkgAuthzService.Get(ctx, orgID, id)
-}
-
-func (provider *provider) GetByOrgIDAndName(ctx context.Context, orgID valuer.UUID, name string) (*roletypes.Role, error) {
-	return provider.pkgAuthzService.GetByOrgIDAndName(ctx, orgID, name)
-}
-
-func (provider *provider) List(ctx context.Context, orgID valuer.UUID) ([]*roletypes.Role, error) {
-	return provider.pkgAuthzService.List(ctx, orgID)
-}
-
-func (provider *provider) ListByOrgIDAndNames(ctx context.Context, orgID valuer.UUID, names []string) ([]*roletypes.Role, error) {
-	return provider.pkgAuthzService.ListByOrgIDAndNames(ctx, orgID, names)
-}
-
-func (provider *provider) Grant(ctx context.Context, orgID valuer.UUID, name string, subject string) error {
-	return provider.pkgAuthzService.Grant(ctx, orgID, name, subject)
-}
-
-func (provider *provider) ModifyGrant(ctx context.Context, orgID valuer.UUID, existingRoleName string, updatedRoleName string, subject string) error {
-	return provider.pkgAuthzService.ModifyGrant(ctx, orgID, existingRoleName, updatedRoleName, subject)
-}
-
-func (provider *provider) Revoke(ctx context.Context, orgID valuer.UUID, name string, subject string) error {
-	return provider.pkgAuthzService.Revoke(ctx, orgID, name, subject)
-}
-
-func (provider *provider) CreateManagedRoles(ctx context.Context, orgID valuer.UUID, managedRoles []*roletypes.Role) error {
-	return provider.pkgAuthzService.CreateManagedRoles(ctx, orgID, managedRoles)
-}
-
-func (provider *provider) CreateManagedUserRoleTransactions(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
-	tuples := make([]*openfgav1.TupleKey, 0)
-
-	grantTuples, err := provider.getManagedRoleGrantTuples(orgID, userID)
-	if err != nil {
-		return err
-	}
-	tuples = append(tuples, grantTuples...)
-
-	managedRoleTuples, err := provider.getManagedRoleTransactionTuples(orgID)
-	if err != nil {
-		return err
-	}
-	tuples = append(tuples, managedRoleTuples...)
-
-	return provider.Write(ctx, tuples, nil)
-}
-
-func (provider *provider) Create(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) error {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	return provider.store.Create(ctx, roletypes.NewStorableRoleFromRole(role))
-}
-
-func (provider *provider) GetOrCreate(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) (*roletypes.Role, error) {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	existingRole, err := provider.store.GetByOrgIDAndName(ctx, role.OrgID, role.Name)
-	if err != nil {
-		if !errors.Ast(err, errors.TypeNotFound) {
-			return nil, err
-		}
-	}
-
-	if existingRole != nil {
-		return roletypes.NewRoleFromStorableRole(existingRole), nil
-	}
-
-	err = provider.store.Create(ctx, roletypes.NewStorableRoleFromRole(role))
-	if err != nil {
-		return nil, err
-	}
-
-	return role, nil
-}
-
-func (provider *provider) GetResources(_ context.Context) []*authtypes.Resource {
-	typeables := make([]authtypes.Typeable, 0)
-	for _, register := range provider.registry {
-		typeables = append(typeables, register.MustGetTypeables()...)
-	}
-	// role module cannot self register itself!
-	typeables = append(typeables, provider.MustGetTypeables()...)
-
-	resources := make([]*authtypes.Resource, 0)
-	for _, typeable := range typeables {
-		resources = append(resources, &authtypes.Resource{Name: typeable.Name(), Type: typeable.Type()})
-	}
-
-	return resources
-}
-
-func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*authtypes.Object, error) {
-	storableRole, err := provider.store.Get(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	objects := make([]*authtypes.Object, 0)
-	for _, resource := range provider.GetResources(ctx) {
-		if slices.Contains(authtypes.TypeableRelations[resource.Type], relation) {
-			resourceObjects, err := provider.
-				ListObjects(
-					ctx,
-					authtypes.MustNewSubject(authtypes.TypeableRole, storableRole.ID.String(), orgID, &authtypes.RelationAssignee),
-					relation,
-					authtypes.MustNewTypeableFromType(resource.Type, resource.Name),
-				)
-			if err != nil {
-				return nil, err
-			}
-
-			objects = append(objects, resourceObjects...)
-		}
-	}
-
-	return objects, nil
-}
-
-func (provider *provider) Patch(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) error {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	return provider.store.Update(ctx, orgID, roletypes.NewStorableRoleFromRole(role))
-}
-
-func (provider *provider) PatchObjects(ctx context.Context, orgID valuer.UUID, name string, relation authtypes.Relation, additions, deletions []*authtypes.Object) error {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	additionTuples, err := roletypes.GetAdditionTuples(name, orgID, relation, additions)
+func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
+	subject, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
 	if err != nil {
 		return err
 	}

-	deletionTuples, err := roletypes.GetDeletionTuples(name, orgID, relation, deletions)
+	tuples, err := typeable.Tuples(subject, relation, selectors, orgID)
 	if err != nil {
 		return err
 	}

-	err = provider.Write(ctx, additionTuples, deletionTuples)
+	err = provider.BatchCheck(ctx, tuples)
 	if err != nil {
 		return err
 	}
@@ -246,95 +66,33 @@ func (provider *provider) PatchObjects(ctx context.Context, orgID valuer.UUID, n
 	return nil
 }

-func (provider *provider) Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	_, err := provider.licensing.GetActive(ctx, orgID)
-	if err != nil {
-		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
-	}
-
-	storableRole, err := provider.store.Get(ctx, orgID, id)
+func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
+	subject, err := authtypes.NewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
 	if err != nil {
 		return err
 	}

-	role := roletypes.NewRoleFromStorableRole(storableRole)
-	err = role.CanEditDelete()
+	tuples, err := typeable.Tuples(subject, relation, selectors, orgID)
 	if err != nil {
 		return err
 	}

-	return provider.store.Delete(ctx, orgID, id)
-}
-
-func (provider *provider) MustGetTypeables() []authtypes.Typeable {
-	return []authtypes.Typeable{authtypes.TypeableRole, roletypes.TypeableResourcesRoles}
-}
-
-func (provider *provider) getManagedRoleGrantTuples(orgID valuer.UUID, userID valuer.UUID) ([]*openfgav1.TupleKey, error) {
-	tuples := []*openfgav1.TupleKey{}
-
-	// Grant the admin role to the user
-	adminSubject := authtypes.MustNewSubject(authtypes.TypeableUser, userID.String(), orgID, nil)
-	adminTuple, err := authtypes.TypeableRole.Tuples(
-		adminSubject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, roletypes.SigNozAdminRoleName),
-		},
-		orgID,
-	)
+	err = provider.BatchCheck(ctx, tuples)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	tuples = append(tuples, adminTuple...)

-	// Grant the admin role to the anonymous user
-	anonymousSubject := authtypes.MustNewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
-	anonymousTuple, err := authtypes.TypeableRole.Tuples(
-		anonymousSubject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, roletypes.SigNozAnonymousRoleName),
-		},
-		orgID,
-	)
-	if err != nil {
-		return nil, err
-	}
-	tuples = append(tuples, anonymousTuple...)
-
-	return tuples, nil
+	return nil
 }

-func (provider *provider) getManagedRoleTransactionTuples(orgID valuer.UUID) ([]*openfgav1.TupleKey, error) {
-	transactionsByRole := make(map[string][]*authtypes.Transaction)
-	for _, register := range provider.registry {
-		for roleName, txns := range register.MustGetManagedRoleTransactions() {
-			transactionsByRole[roleName] = append(transactionsByRole[roleName], txns...)
-		}
-	}
-
-	tuples := make([]*openfgav1.TupleKey, 0)
-	for roleName, transactions := range transactionsByRole {
-		for _, txn := range transactions {
-			typeable := authtypes.MustNewTypeableFromType(txn.Object.Resource.Type, txn.Object.Resource.Name)
-			txnTuples, err := typeable.Tuples(
-				authtypes.MustNewSubject(
-					authtypes.TypeableRole,
-					roleName,
-					orgID,
-					&authtypes.RelationAssignee,
-				),
-				txn.Relation,
-				[]authtypes.Selector{txn.Object.Selector},
-				orgID,
-			)
-			if err != nil {
-				return nil, err
-			}
-			tuples = append(tuples, txnTuples...)
-		}
-	}
-
-	return tuples, nil
+func (provider *provider) BatchCheck(ctx context.Context, tuples []*openfgav1.TupleKey) error {
+	return provider.pkgAuthzService.BatchCheck(ctx, tuples)
+}
+
+func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
+	return provider.pkgAuthzService.ListObjects(ctx, subject, relation, typeable)
+}
+
+func (provider *provider) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
+	return provider.pkgAuthzService.Write(ctx, additions, deletions)
 }
--- a/ee/authz/openfgaserver/server.go
+++ b/ee/authz/openfgaserver/server.go
@@ -1,83 +0,0 @@
-package openfgaserver
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	openfgav1 "github.com/openfga/api/proto/openfga/v1"
-)
-
-type Server struct {
-	pkgAuthzService authz.AuthZ
-}
-
-func NewOpenfgaServer(ctx context.Context, pkgAuthzService authz.AuthZ) (*Server, error) {
-
-	return &Server{
-		pkgAuthzService: pkgAuthzService,
-	}, nil
-}
-
-func (server *Server) Start(ctx context.Context) error {
-	return server.pkgAuthzService.Start(ctx)
-}
-
-func (server *Server) Stop(ctx context.Context) error {
-	return server.pkgAuthzService.Stop(ctx)
-}
-
-func (server *Server) Check(ctx context.Context, tuple *openfgav1.TupleKey) error {
-	return server.pkgAuthzService.Check(ctx, tuple)
-}
-
-func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
-	subject, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
-	if err != nil {
-		return err
-	}
-
-	tuples, err := typeable.Tuples(subject, relation, selectors, orgID)
-	if err != nil {
-		return err
-	}
-
-	err = server.BatchCheck(ctx, tuples)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (server *Server) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
-	subject, err := authtypes.NewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
-	if err != nil {
-		return err
-	}
-
-	tuples, err := typeable.Tuples(subject, relation, selectors, orgID)
-	if err != nil {
-		return err
-	}
-
-	err = server.BatchCheck(ctx, tuples)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (server *Server) BatchCheck(ctx context.Context, tuples []*openfgav1.TupleKey) error {
-	return server.pkgAuthzService.BatchCheck(ctx, tuples)
-}
-
-func (server *Server) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
-	return server.pkgAuthzService.ListObjects(ctx, subject, relation, typeable)
-}
-
-func (server *Server) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
-	return server.pkgAuthzService.Write(ctx, additions, deletions)
-}
--- a/ee/modules/dashboard/impldashboard/module.go
+++ b/ee/modules/dashboard/impldashboard/module.go
@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -25,11 +26,13 @@ type module struct {
 	pkgDashboardModule dashboard.Module
 	store              dashboardtypes.Store
 	settings           factory.ScopedProviderSettings
+	roleSetter         role.Setter
+	granter            role.Granter
 	querier            querier.Querier
 	licensing          licensing.Licensing
 }

-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, roleSetter role.Setter, granter role.Granter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
 	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser)

@@ -37,6 +40,8 @@ func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, an
 		pkgDashboardModule: pkgDashboardModule,
 		store:              store,
 		settings:           scopedProviderSettings,
+		roleSetter:         roleSetter,
+		granter:            granter,
 		querier:            querier,
 		licensing:          licensing,
 	}
@@ -56,6 +61,29 @@ func (module *module) CreatePublic(ctx context.Context, orgID valuer.UUID, publi
 		return errors.Newf(errors.TypeAlreadyExists, dashboardtypes.ErrCodePublicDashboardAlreadyExists, "dashboard with id %s is already public", storablePublicDashboard.DashboardID)
 	}

+	role, err := module.roleSetter.GetOrCreate(ctx, orgID, roletypes.NewRole(roletypes.SigNozAnonymousRoleName, roletypes.SigNozAnonymousRoleDescription, roletypes.RoleTypeManaged, orgID))
+	if err != nil {
+		return err
+	}
+
+	err = module.granter.Grant(ctx, orgID, roletypes.SigNozAnonymousRoleName, authtypes.MustNewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.StringValue(), orgID, nil))
+	if err != nil {
+		return err
+	}
+
+	additionObject := authtypes.MustNewObject(
+		authtypes.Resource{
+			Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
+			Type: authtypes.TypeMetaResource,
+		},
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, publicDashboard.ID.String()),
+	)
+
+	err = module.roleSetter.PatchObjects(ctx, orgID, role.Name, authtypes.RelationRead, []*authtypes.Object{additionObject}, nil)
+	if err != nil {
+		return err
+	}
+
 	err = module.store.CreatePublic(ctx, dashboardtypes.NewStorablePublicDashboardFromPublicDashboard(publicDashboard))
 	if err != nil {
 		return err
@@ -100,7 +128,6 @@ func (module *module) GetPublicDashboardSelectorsAndOrg(ctx context.Context, id

 	return []authtypes.Selector{
 		authtypes.MustNewSelector(authtypes.TypeMetaResource, id.StringValue()),
-		authtypes.MustNewSelector(authtypes.TypeMetaResource, authtypes.WildCardSelectorString),
 	}, storableDashboard.OrgID, nil
 }

@@ -163,6 +190,29 @@ func (module *module) DeletePublic(ctx context.Context, orgID valuer.UUID, dashb
 		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
 	}

+	publicDashboard, err := module.GetPublic(ctx, orgID, dashboardID)
+	if err != nil {
+		return err
+	}
+
+	role, err := module.roleSetter.GetOrCreate(ctx, orgID, roletypes.NewRole(roletypes.SigNozAnonymousRoleName, roletypes.SigNozAnonymousRoleDescription, roletypes.RoleTypeManaged, orgID))
+	if err != nil {
+		return err
+	}
+
+	deletionObject := authtypes.MustNewObject(
+		authtypes.Resource{
+			Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
+			Type: authtypes.TypeMetaResource,
+		},
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, publicDashboard.ID.String()),
+	)
+
+	err = module.roleSetter.PatchObjects(ctx, orgID, role.Name, authtypes.RelationRead, nil, []*authtypes.Object{deletionObject})
+	if err != nil {
+		return err
+	}
+
 	err = module.store.DeletePublic(ctx, dashboardID.StringValue())
 	if err != nil {
 		return err
@@ -200,6 +250,10 @@ func (module *module) GetByMetricNames(ctx context.Context, orgID valuer.UUID, m
 	return module.pkgDashboardModule.GetByMetricNames(ctx, orgID, metricNames)
 }

+func (module *module) MustGetTypeables() []authtypes.Typeable {
+	return module.pkgDashboardModule.MustGetTypeables()
+}
+
 func (module *module) List(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.List(ctx, orgID)
 }
@@ -212,27 +266,34 @@ func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valu
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, role, lock)
 }

-func (module *module) MustGetTypeables() []authtypes.Typeable {
-	return module.pkgDashboardModule.MustGetTypeables()
-}
-
-func (module *module) MustGetManagedRoleTransactions() map[string][]*authtypes.Transaction {
-	return map[string][]*authtypes.Transaction{
-		roletypes.SigNozAnonymousRoleName: {
-			{
-				Relation: authtypes.RelationRead,
-				Object: *authtypes.MustNewObject(
-					authtypes.Resource{
-						Type: authtypes.TypeMetaResource,
-						Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
-					},
-					authtypes.MustNewSelector(authtypes.TypeMetaResource, "*"),
-				),
-			},
-		},
+func (module *module) deletePublic(ctx context.Context, orgID valuer.UUID, dashboardID valuer.UUID) error {
+	publicDashboard, err := module.store.GetPublic(ctx, dashboardID.String())
+	if err != nil {
+		return err
 	}
-}

-func (module *module) deletePublic(ctx context.Context, _ valuer.UUID, dashboardID valuer.UUID) error {
-	return module.store.DeletePublic(ctx, dashboardID.StringValue())
+	role, err := module.roleSetter.GetOrCreate(ctx, orgID, roletypes.NewRole(roletypes.SigNozAnonymousRoleName, roletypes.SigNozAnonymousRoleDescription, roletypes.RoleTypeManaged, orgID))
+	if err != nil {
+		return err
+	}
+
+	deletionObject := authtypes.MustNewObject(
+		authtypes.Resource{
+			Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
+			Type: authtypes.TypeMetaResource,
+		},
+		authtypes.MustNewSelector(authtypes.TypeMetaResource, publicDashboard.ID.String()),
+	)
+
+	err = module.roleSetter.PatchObjects(ctx, orgID, role.Name, authtypes.RelationRead, nil, []*authtypes.Object{deletionObject})
+	if err != nil {
+		return err
+	}
+
+	err = module.store.DeletePublic(ctx, dashboardID.StringValue())
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
--- a/ee/modules/role/implrole/setter.go
+++ b/ee/modules/role/implrole/setter.go
@@ -0,0 +1,165 @@
+package implrole
+
+import (
+	"context"
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/authz"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/role"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/roletypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type setter struct {
+	store     roletypes.Store
+	authz     authz.AuthZ
+	licensing licensing.Licensing
+	registry  []role.RegisterTypeable
+}
+
+func NewSetter(store roletypes.Store, authz authz.AuthZ, licensing licensing.Licensing, registry []role.RegisterTypeable) role.Setter {
+	return &setter{
+		store:     store,
+		authz:     authz,
+		licensing: licensing,
+		registry:  registry,
+	}
+}
+
+func (setter *setter) Create(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) error {
+	_, err := setter.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	return setter.store.Create(ctx, roletypes.NewStorableRoleFromRole(role))
+}
+
+func (setter *setter) GetOrCreate(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) (*roletypes.Role, error) {
+	_, err := setter.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	existingRole, err := setter.store.GetByOrgIDAndName(ctx, role.OrgID, role.Name)
+	if err != nil {
+		if !errors.Ast(err, errors.TypeNotFound) {
+			return nil, err
+		}
+	}
+
+	if existingRole != nil {
+		return roletypes.NewRoleFromStorableRole(existingRole), nil
+	}
+
+	err = setter.store.Create(ctx, roletypes.NewStorableRoleFromRole(role))
+	if err != nil {
+		return nil, err
+	}
+
+	return role, nil
+}
+
+func (setter *setter) GetResources(_ context.Context) []*authtypes.Resource {
+	typeables := make([]authtypes.Typeable, 0)
+	for _, register := range setter.registry {
+		typeables = append(typeables, register.MustGetTypeables()...)
+	}
+	// role module cannot self register itself!
+	typeables = append(typeables, setter.MustGetTypeables()...)
+
+	resources := make([]*authtypes.Resource, 0)
+	for _, typeable := range typeables {
+		resources = append(resources, &authtypes.Resource{Name: typeable.Name(), Type: typeable.Type()})
+	}
+
+	return resources
+}
+
+func (setter *setter) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*authtypes.Object, error) {
+	storableRole, err := setter.store.Get(ctx, orgID, id)
+	if err != nil {
+		return nil, err
+	}
+
+	objects := make([]*authtypes.Object, 0)
+	for _, resource := range setter.GetResources(ctx) {
+		if slices.Contains(authtypes.TypeableRelations[resource.Type], relation) {
+			resourceObjects, err := setter.
+				authz.
+				ListObjects(
+					ctx,
+					authtypes.MustNewSubject(authtypes.TypeableRole, storableRole.ID.String(), orgID, &authtypes.RelationAssignee),
+					relation,
+					authtypes.MustNewTypeableFromType(resource.Type, resource.Name),
+				)
+			if err != nil {
+				return nil, err
+			}
+
+			objects = append(objects, resourceObjects...)
+		}
+	}
+
+	return objects, nil
+}
+
+func (setter *setter) Patch(ctx context.Context, orgID valuer.UUID, role *roletypes.Role) error {
+	_, err := setter.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	return setter.store.Update(ctx, orgID, roletypes.NewStorableRoleFromRole(role))
+}
+
+func (setter *setter) PatchObjects(ctx context.Context, orgID valuer.UUID, name string, relation authtypes.Relation, additions, deletions []*authtypes.Object) error {
+	_, err := setter.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	additionTuples, err := roletypes.GetAdditionTuples(name, orgID, relation, additions)
+	if err != nil {
+		return err
+	}
+
+	deletionTuples, err := roletypes.GetDeletionTuples(name, orgID, relation, deletions)
+	if err != nil {
+		return err
+	}
+
+	err = setter.authz.Write(ctx, additionTuples, deletionTuples)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (setter *setter) Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
+	_, err := setter.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storableRole, err := setter.store.Get(ctx, orgID, id)
+	if err != nil {
+		return err
+	}
+
+	role := roletypes.NewRoleFromStorableRole(storableRole)
+	err = role.CanEditDelete()
+	if err != nil {
+		return err
+	}
+
+	return setter.store.Delete(ctx, orgID, id)
+}
+
+func (setter *setter) MustGetTypeables() []authtypes.Typeable {
+	return []authtypes.Typeable{authtypes.TypeableRole, roletypes.TypeableResourcesRoles}
+}
--- a/ee/query-service/app/api/api.go
+++ b/ee/query-service/app/api/api.go
@@ -9,6 +9,7 @@ import (
 	"github.com/SigNoz/signoz/ee/query-service/integrations/gateway"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/apis/fields"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	querierAPI "github.com/SigNoz/signoz/pkg/querier"
@@ -55,6 +56,7 @@ func NewAPIHandler(opts APIHandlerOptions, signoz *signoz.SigNoz) (*APIHandler,
 		FluxInterval:                  opts.FluxInterval,
 		AlertmanagerAPI:               alertmanager.NewAPI(signoz.Alertmanager),
 		LicensingAPI:                  httplicensing.NewLicensingAPI(signoz.Licensing),
+		FieldsAPI:                     fields.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.TelemetryStore),
 		Signoz:                        signoz,
 		QuerierAPI:                    querierAPI.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.Querier, signoz.Analytics),
 		QueryParserAPI:                queryparser.NewAPI(signoz.Instrumentation.ToProviderSettings(), signoz.QueryParser),
--- a/ee/query-service/app/server.go
+++ b/ee/query-service/app/server.go
@@ -211,7 +211,7 @@ func (s Server) HealthCheckStatus() chan healthcheck.Status {

 func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*http.Server, error) {
 	r := baseapp.NewRouter()
-	am := middleware.NewAuthZ(s.signoz.Instrumentation.Logger(), s.signoz.Modules.OrgGetter, s.signoz.Authz)
+	am := middleware.NewAuthZ(s.signoz.Instrumentation.Logger(), s.signoz.Modules.OrgGetter, s.signoz.Authz, s.signoz.Modules.RoleGetter)

 	r.Use(otelmux.Middleware(
 		"apiserver",
@@ -237,6 +237,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterLogsRoutes(r, am)
 	apiHandler.RegisterIntegrationRoutes(r, am)
 	apiHandler.RegisterCloudIntegrationsRoutes(r, am)
+	apiHandler.RegisterFieldsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV3Routes(r, am)
 	apiHandler.RegisterInfraMetricsRoutes(r, am)
 	apiHandler.RegisterQueryRangeV4Routes(r, am)
--- a/ee/query-service/rules/anomaly.go
+++ b/ee/query-service/rules/anomaly.go
@@ -15,7 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/common"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/transition"
-	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"

 	querierV2 "github.com/SigNoz/signoz/pkg/query-service/app/querier/v2"
@@ -63,8 +63,6 @@ type AnomalyRule struct {
 	seasonality anomaly.Seasonality
 }

-var _ baserules.Rule = (*AnomalyRule)(nil)
-
 func NewAnomalyRule(
 	id string,
 	orgID valuer.UUID,
@@ -492,7 +490,7 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 			continue
 		}

-		if a.State == model.StatePending && ts.Sub(a.ActiveAt) >= r.HoldDuration().Duration() {
+		if a.State == model.StatePending && ts.Sub(a.ActiveAt) >= r.HoldDuration() {
 			a.State = model.StateFiring
 			a.FiredAt = ts
 			state := model.StateFiring
@@ -555,7 +553,7 @@ func (r *AnomalyRule) String() string {
 	ar := ruletypes.PostableRule{
 		AlertName:         r.Name(),
 		RuleCondition:     r.Condition(),
-		EvalWindow:        r.EvalWindow(),
+		EvalWindow:        ruletypes.Duration(r.EvalWindow()),
 		Labels:            r.Labels().Map(),
 		Annotations:       r.Annotations().Map(),
 		PreferredChannels: r.PreferredChannels(),
--- a/ee/query-service/rules/anomaly_test.go
+++ b/ee/query-service/rules/anomaly_test.go
@@ -40,7 +40,7 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 	// Test basic AlertOnAbsent functionality (without AbsentFor grace period)

 	baseTime := time.Unix(1700000000, 0)
-	evalWindow := valuer.MustParseTextDuration("5m")
+	evalWindow := 5 * time.Minute
 	evalTime := baseTime.Add(5 * time.Minute)

 	target := 500.0
@@ -50,8 +50,8 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 		AlertType: ruletypes.AlertTypeMetric,
 		RuleType:  RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-			EvalWindow: evalWindow,
-			Frequency:  valuer.MustParseTextDuration("1m"),
+			EvalWindow: ruletypes.Duration(evalWindow),
+			Frequency:  ruletypes.Duration(1 * time.Minute),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
 			CompareOp: ruletypes.ValueIsAbove,
@@ -147,7 +147,7 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 	// 3. Alert fires only if t2 - t1 > AbsentFor

 	baseTime := time.Unix(1700000000, 0)
-	evalWindow := valuer.MustParseTextDuration("5m")
+	evalWindow := 5 * time.Minute

 	// Set target higher than test data so regular threshold alerts don't fire
 	target := 500.0
@@ -157,8 +157,8 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 		AlertType: ruletypes.AlertTypeMetric,
 		RuleType:  RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-			EvalWindow: evalWindow,
-			Frequency:  valuer.MustParseTextDuration("1m"),
+			EvalWindow: ruletypes.Duration(evalWindow),
+			Frequency:  ruletypes.Duration(time.Minute),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
 			CompareOp:     ruletypes.ValueIsAbove,
--- a/ee/query-service/rules/manager.go
+++ b/ee/query-service/rules/manager.go
@@ -26,6 +26,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 	if err != nil {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "evaluation is invalid: %v", err)
 	}
+
 	if opts.Rule.RuleType == ruletypes.RuleTypeThreshold {
 		// create a threshold rule
 		tr, err := baserules.NewThresholdRule(
@@ -48,7 +49,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, tr)

 		// create ch rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, time.Duration(evaluation.GetFrequency()), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)

 	} else if opts.Rule.RuleType == ruletypes.RuleTypeProm {

@@ -72,7 +73,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, pr)

 		// create promql rule task for evaluation
-		task = newTask(baserules.TaskTypeProm, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeProm, opts.TaskName, time.Duration(evaluation.GetFrequency()), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)

 	} else if opts.Rule.RuleType == ruletypes.RuleTypeAnomaly {
 		// create anomaly rule
@@ -96,7 +97,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		rules = append(rules, ar)

 		// create anomaly rule task for evaluation
-		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
+		task = newTask(baserules.TaskTypeCh, opts.TaskName, time.Duration(evaluation.GetFrequency()), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)

 	} else {
 		return nil, fmt.Errorf("unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
@@ -213,7 +214,8 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.Ap
 	return alertsFound, nil
 }

-// newTask returns an appropriate group for the rule type
+// newTask returns an appropriate group for
+// rule type
 func newTask(taskType baserules.TaskType, name string, frequency time.Duration, rules []baserules.Rule, opts *baserules.ManagerOptions, notify baserules.NotifyFunc, maintenanceStore ruletypes.MaintenanceStore, orgID valuer.UUID) baserules.Task {
 	if taskType == baserules.TaskTypeCh {
 		return baserules.NewRuleTask(name, "", frequency, rules, opts, notify, maintenanceStore, orgID)
--- a/frontend/.eslintrc.js
+++ b/frontend/.eslintrc.js
@@ -61,8 +61,6 @@ module.exports = {
 		curly: 'error', // Requires curly braces for all control statements
 		eqeqeq: ['error', 'always', { null: 'ignore' }], // Enforces === and !== (allows == null for null/undefined check)
 		'no-console': ['error', { allow: ['warn', 'error'] }], // Warns on console.log, allows console.warn/error
-		// TODO: Change this to error in May 2026
-		'max-params': ['warn', 3], // a function can have max 3 params after which it should become an object

 		// TypeScript rules
 		'@typescript-eslint/explicit-function-return-type': 'error', // Requires explicit return types on functions
@@ -118,7 +116,7 @@ module.exports = {
 			},
 		],
 		'import/no-extraneous-dependencies': ['error', { devDependencies: true }], // Prevents importing packages not in package.json
-		'import/no-cycle': 'warn', // Warns about circular dependencies
+		// 'import/no-cycle': 'warn', // TODO: Enable later to detect circular dependencies

 		// Import sorting rules
 		'simple-import-sort/imports': [
@@ -148,19 +146,6 @@ module.exports = {
 		'sonarjs/no-duplicate-string': 'off', // Disabled - can be noisy (enable periodically to check)
 	},
 	overrides: [
-		{
-			files: [
-				'**/*.test.{js,jsx,ts,tsx}',
-				'**/*.spec.{js,jsx,ts,tsx}',
-				'**/__tests__/**/*.{js,jsx,ts,tsx}',
-			],
-			rules: {
-				// Tests often have intentional duplication and complexity - disable SonarJS rules
-				'sonarjs/cognitive-complexity': 'off', // Tests can be complex
-				'sonarjs/no-identical-functions': 'off', // Similar test patterns are OK
-				'sonarjs/no-small-switch': 'off', // Small switches are OK in tests
-			},
-		},
 		{
 			files: ['src/api/generated/**/*.ts'],
 			rules: {
@@ -168,6 +153,7 @@ module.exports = {
 				'@typescript-eslint/explicit-module-boundary-types': 'off',
 				'no-nested-ternary': 'off',
 				'@typescript-eslint/no-unused-vars': 'warn',
+				'sonarjs/no-duplicate-string': 'off',
 			},
 		},
 	],
--- a/frontend/CONTRIBUTIONS.md
+++ b/frontend/CONTRIBUTIONS.md
@@ -2,11 +2,6 @@

 Embrace the spirit of collaboration and contribute to the success of our open-source project by adhering to these frontend development guidelines with precision and passion.

-### Export Style
-
- **React components** (`src/components/`, `src/container/`, `src/pages/`): Prefer **default exports** for the main component in each file
- **Utilities, hooks, APIs, types, constants** (`src/utils/`, `src/hooks/`, `src/api/`, `src/lib/`, `src/types/`, `src/constants/`): Prefer **named exports** for better tree-shaking and explicit imports
-
 ### React and Components

 - Strive to create small and modular components, ensuring they are divided into individual pieces for improved maintainability and reusability.
--- a/frontend/src/api/generated/services/gateway/index.ts
+++ b/frontend/src/api/generated/services/gateway/index.ts
@@ -28,10 +28,8 @@ import type {
 	GatewaytypesPostableIngestionKeyLimitDTO,
 	GatewaytypesUpdatableIngestionKeyLimitDTO,
 	GetIngestionKeys200,
-	GetIngestionKeysParams,
 	RenderErrorResponseDTO,
 	SearchIngestionKeys200,
-	SearchIngestionKeysParams,
 	UpdateIngestionKeyLimitPathParameters,
 	UpdateIngestionKeyPathParameters,
 } from '../sigNoz.schemas';
@@ -44,44 +42,35 @@ type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
 * This endpoint returns the ingestion keys for a workspace
 * @summary Get ingestion keys for workspace
 */
-export const getIngestionKeys = (
-	params?: GetIngestionKeysParams,
-	signal?: AbortSignal,
-) => {
+export const getIngestionKeys = (signal?: AbortSignal) => {
 	return GeneratedAPIInstance<GetIngestionKeys200>({
 		url: `/api/v2/gateway/ingestion_keys`,
 		method: 'GET',
-		params,
 		signal,
 	});
 };

-export const getGetIngestionKeysQueryKey = (
-	params?: GetIngestionKeysParams,
-) => {
-	return ['getIngestionKeys', ...(params ? [params] : [])] as const;
+export const getGetIngestionKeysQueryKey = () => {
+	return ['getIngestionKeys'] as const;
 };

 export const getGetIngestionKeysQueryOptions = <
 	TData = Awaited<ReturnType<typeof getIngestionKeys>>,
 	TError = RenderErrorResponseDTO
->(
-	params?: GetIngestionKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getIngestionKeys>>,
-			TError,
-			TData
-		>;
-	},
-) => {
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof getIngestionKeys>>,
+		TError,
+		TData
+	>;
+}) => {
 	const { query: queryOptions } = options ?? {};

-	const queryKey = queryOptions?.queryKey ?? getGetIngestionKeysQueryKey(params);
+	const queryKey = queryOptions?.queryKey ?? getGetIngestionKeysQueryKey();

 	const queryFn: QueryFunction<Awaited<ReturnType<typeof getIngestionKeys>>> = ({
 		signal,
-	}) => getIngestionKeys(params, signal);
+	}) => getIngestionKeys(signal);

 	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
 		Awaited<ReturnType<typeof getIngestionKeys>>,
@@ -102,17 +91,14 @@ export type GetIngestionKeysQueryError = RenderErrorResponseDTO;
 export function useGetIngestionKeys<
 	TData = Awaited<ReturnType<typeof getIngestionKeys>>,
 	TError = RenderErrorResponseDTO
->(
-	params?: GetIngestionKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getIngestionKeys>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetIngestionKeysQueryOptions(params, options);
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof getIngestionKeys>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetIngestionKeysQueryOptions(options);

 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
@@ -128,11 +114,10 @@ export function useGetIngestionKeys<
 */
 export const invalidateGetIngestionKeys = async (
 	queryClient: QueryClient,
-	params?: GetIngestionKeysParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getGetIngestionKeysQueryKey(params) },
+		{ queryKey: getGetIngestionKeysQueryKey() },
 		options,
 	);

@@ -677,45 +662,35 @@ export const useUpdateIngestionKeyLimit = <
 * This endpoint returns the ingestion keys for a workspace
 * @summary Search ingestion keys for workspace
 */
-export const searchIngestionKeys = (
-	params?: SearchIngestionKeysParams,
-	signal?: AbortSignal,
-) => {
+export const searchIngestionKeys = (signal?: AbortSignal) => {
 	return GeneratedAPIInstance<SearchIngestionKeys200>({
 		url: `/api/v2/gateway/ingestion_keys/search`,
 		method: 'GET',
-		params,
 		signal,
 	});
 };

-export const getSearchIngestionKeysQueryKey = (
-	params?: SearchIngestionKeysParams,
-) => {
-	return ['searchIngestionKeys', ...(params ? [params] : [])] as const;
+export const getSearchIngestionKeysQueryKey = () => {
+	return ['searchIngestionKeys'] as const;
 };

 export const getSearchIngestionKeysQueryOptions = <
 	TData = Awaited<ReturnType<typeof searchIngestionKeys>>,
 	TError = RenderErrorResponseDTO
->(
-	params?: SearchIngestionKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof searchIngestionKeys>>,
-			TError,
-			TData
-		>;
-	},
-) => {
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof searchIngestionKeys>>,
+		TError,
+		TData
+	>;
+}) => {
 	const { query: queryOptions } = options ?? {};

-	const queryKey =
-		queryOptions?.queryKey ?? getSearchIngestionKeysQueryKey(params);
+	const queryKey = queryOptions?.queryKey ?? getSearchIngestionKeysQueryKey();

 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof searchIngestionKeys>>
-	> = ({ signal }) => searchIngestionKeys(params, signal);
+	> = ({ signal }) => searchIngestionKeys(signal);

 	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
 		Awaited<ReturnType<typeof searchIngestionKeys>>,
@@ -736,17 +711,14 @@ export type SearchIngestionKeysQueryError = RenderErrorResponseDTO;
 export function useSearchIngestionKeys<
 	TData = Awaited<ReturnType<typeof searchIngestionKeys>>,
 	TError = RenderErrorResponseDTO
->(
-	params?: SearchIngestionKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof searchIngestionKeys>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getSearchIngestionKeysQueryOptions(params, options);
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof searchIngestionKeys>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getSearchIngestionKeysQueryOptions(options);

 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
@@ -762,11 +734,10 @@ export function useSearchIngestionKeys<
 */
 export const invalidateSearchIngestionKeys = async (
 	queryClient: QueryClient,
-	params?: SearchIngestionKeysParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getSearchIngestionKeysQueryKey(params) },
+		{ queryKey: getSearchIngestionKeysQueryKey() },
 		options,
 	);

--- a/frontend/src/api/generated/services/metrics/index.ts
+++ b/frontend/src/api/generated/services/metrics/index.ts
@@ -47,7 +47,7 @@ type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
 * @summary Get metric alerts
 */
 export const getMetricAlerts = (
-	params: GetMetricAlertsParams,
+	params?: GetMetricAlertsParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricAlerts200>({
@@ -66,7 +66,7 @@ export const getGetMetricAlertsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricAlerts>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricAlertsParams,
+	params?: GetMetricAlertsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricAlerts>>,
@@ -103,7 +103,7 @@ export function useGetMetricAlerts<
 	TData = Awaited<ReturnType<typeof getMetricAlerts>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricAlertsParams,
+	params?: GetMetricAlertsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricAlerts>>,
@@ -128,7 +128,7 @@ export function useGetMetricAlerts<
 */
 export const invalidateGetMetricAlerts = async (
 	queryClient: QueryClient,
-	params: GetMetricAlertsParams,
+	params?: GetMetricAlertsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
@@ -144,7 +144,7 @@ export const invalidateGetMetricAlerts = async (
 * @summary Get metric dashboards
 */
 export const getMetricDashboards = (
-	params: GetMetricDashboardsParams,
+	params?: GetMetricDashboardsParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricDashboards200>({
@@ -165,7 +165,7 @@ export const getGetMetricDashboardsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricDashboards>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricDashboardsParams,
+	params?: GetMetricDashboardsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricDashboards>>,
@@ -203,7 +203,7 @@ export function useGetMetricDashboards<
 	TData = Awaited<ReturnType<typeof getMetricDashboards>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricDashboardsParams,
+	params?: GetMetricDashboardsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricDashboards>>,
@@ -228,7 +228,7 @@ export function useGetMetricDashboards<
 */
 export const invalidateGetMetricDashboards = async (
 	queryClient: QueryClient,
-	params: GetMetricDashboardsParams,
+	params?: GetMetricDashboardsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
@@ -244,7 +244,7 @@ export const invalidateGetMetricDashboards = async (
 * @summary Get metric highlights
 */
 export const getMetricHighlights = (
-	params: GetMetricHighlightsParams,
+	params?: GetMetricHighlightsParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricHighlights200>({
@@ -265,7 +265,7 @@ export const getGetMetricHighlightsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricHighlights>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricHighlightsParams,
+	params?: GetMetricHighlightsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricHighlights>>,
@@ -303,7 +303,7 @@ export function useGetMetricHighlights<
 	TData = Awaited<ReturnType<typeof getMetricHighlights>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricHighlightsParams,
+	params?: GetMetricHighlightsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricHighlights>>,
@@ -328,7 +328,7 @@ export function useGetMetricHighlights<
 */
 export const invalidateGetMetricHighlights = async (
 	queryClient: QueryClient,
-	params: GetMetricHighlightsParams,
+	params?: GetMetricHighlightsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
@@ -526,7 +526,7 @@ export const useGetMetricAttributes = <
 * @summary Get metric metadata
 */
 export const getMetricMetadata = (
-	params: GetMetricMetadataParams,
+	params?: GetMetricMetadataParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricMetadata200>({
@@ -547,7 +547,7 @@ export const getGetMetricMetadataQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricMetadataParams,
+	params?: GetMetricMetadataParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricMetadata>>,
@@ -585,7 +585,7 @@ export function useGetMetricMetadata<
 	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
 	TError = RenderErrorResponseDTO
 >(
-	params: GetMetricMetadataParams,
+	params?: GetMetricMetadataParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricMetadata>>,
@@ -610,7 +610,7 @@ export function useGetMetricMetadata<
 */
 export const invalidateGetMetricMetadata = async (
 	queryClient: QueryClient,
-	params: GetMetricMetadataParams,
+	params?: GetMetricMetadataParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -650,11 +650,11 @@ export interface MetricsexplorertypesMetricAlertDTO {
 	/**
 	 * @type string
 	 */
-	alertId: string;
+	alertId?: string;
 	/**
 	 * @type string
 	 */
-	alertName: string;
+	alertName?: string;
 }

 export interface MetricsexplorertypesMetricAlertsResponseDTO {
@@ -662,24 +662,24 @@ export interface MetricsexplorertypesMetricAlertsResponseDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	alerts: MetricsexplorertypesMetricAlertDTO[] | null;
+	alerts?: MetricsexplorertypesMetricAlertDTO[] | null;
 }

 export interface MetricsexplorertypesMetricAttributeDTO {
 	/**
 	 * @type string
 	 */
-	key: string;
+	key?: string;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	valueCount: number;
+	valueCount?: number;
 	/**
 	 * @type array
 	 * @nullable true
 	 */
-	values: string[] | null;
+	values?: string[] | null;
 }

 export interface MetricsexplorertypesMetricAttributesRequestDTO {
@@ -691,7 +691,7 @@ export interface MetricsexplorertypesMetricAttributesRequestDTO {
 	/**
 	 * @type string
 	 */
-	metricName: string;
+	metricName?: string;
 	/**
 	 * @type integer
 	 * @nullable true
@@ -704,31 +704,31 @@ export interface MetricsexplorertypesMetricAttributesResponseDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	attributes: MetricsexplorertypesMetricAttributeDTO[] | null;
+	attributes?: MetricsexplorertypesMetricAttributeDTO[] | null;
 	/**
 	 * @type integer
 	 * @format int64
 	 */
-	totalKeys: number;
+	totalKeys?: number;
 }

 export interface MetricsexplorertypesMetricDashboardDTO {
 	/**
 	 * @type string
 	 */
-	dashboardId: string;
+	dashboardId?: string;
 	/**
 	 * @type string
 	 */
-	dashboardName: string;
+	dashboardName?: string;
 	/**
 	 * @type string
 	 */
-	widgetId: string;
+	widgetId?: string;
 	/**
 	 * @type string
 	 */
-	widgetName: string;
+	widgetName?: string;
 }

 export interface MetricsexplorertypesMetricDashboardsResponseDTO {
@@ -736,7 +736,7 @@ export interface MetricsexplorertypesMetricDashboardsResponseDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	dashboards: MetricsexplorertypesMetricDashboardDTO[] | null;
+	dashboards?: MetricsexplorertypesMetricDashboardDTO[] | null;
 }

 export interface MetricsexplorertypesMetricHighlightsResponseDTO {
@@ -744,65 +744,74 @@ export interface MetricsexplorertypesMetricHighlightsResponseDTO {
 	 * @type integer
 	 * @minimum 0
 	 */
-	activeTimeSeries: number;
+	activeTimeSeries?: number;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	dataPoints: number;
+	dataPoints?: number;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	lastReceived: number;
+	lastReceived?: number;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	totalTimeSeries: number;
+	totalTimeSeries?: number;
 }

 export interface MetricsexplorertypesMetricMetadataDTO {
 	/**
 	 * @type string
 	 */
-	description: string;
+	description?: string;
 	/**
 	 * @type boolean
 	 */
-	isMonotonic: boolean;
-	temporality: MetrictypesTemporalityDTO;
-	type: MetrictypesTypeDTO;
+	isMonotonic?: boolean;
 	/**
 	 * @type string
 	 */
-	unit: string;
+	temporality?: string;
+	/**
+	 * @type string
+	 */
+	type?: string;
+	/**
+	 * @type string
+	 */
+	unit?: string;
 }

 export interface MetricsexplorertypesStatDTO {
 	/**
 	 * @type string
 	 */
-	description: string;
+	description?: string;
 	/**
 	 * @type string
 	 */
-	metricName: string;
+	metricName?: string;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	samples: number;
+	samples?: number;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	timeseries: number;
-	type: MetrictypesTypeDTO;
+	timeseries?: number;
 	/**
 	 * @type string
 	 */
-	unit: string;
+	type?: string;
+	/**
+	 * @type string
+	 */
+	unit?: string;
 }

 export interface MetricsexplorertypesStatsRequestDTO {
@@ -810,12 +819,12 @@ export interface MetricsexplorertypesStatsRequestDTO {
 	 * @type integer
 	 * @format int64
 	 */
-	end: number;
+	end?: number;
 	filter?: Querybuildertypesv5FilterDTO;
 	/**
 	 * @type integer
 	 */
-	limit: number;
+	limit?: number;
 	/**
 	 * @type integer
 	 */
@@ -825,7 +834,7 @@ export interface MetricsexplorertypesStatsRequestDTO {
 	 * @type integer
 	 * @format int64
 	 */
-	start: number;
+	start?: number;
 }

 export interface MetricsexplorertypesStatsResponseDTO {
@@ -833,52 +842,51 @@ export interface MetricsexplorertypesStatsResponseDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	metrics: MetricsexplorertypesStatDTO[] | null;
+	metrics?: MetricsexplorertypesStatDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	total: number;
+	total?: number;
 }

 export interface MetricsexplorertypesTreemapEntryDTO {
 	/**
 	 * @type string
 	 */
-	metricName: string;
+	metricName?: string;
 	/**
 	 * @type number
 	 * @format double
 	 */
-	percentage: number;
+	percentage?: number;
 	/**
 	 * @type integer
 	 * @minimum 0
 	 */
-	totalValue: number;
+	totalValue?: number;
 }

-export enum MetricsexplorertypesTreemapModeDTO {
-	timeseries = 'timeseries',
-	samples = 'samples',
-}
 export interface MetricsexplorertypesTreemapRequestDTO {
 	/**
 	 * @type integer
 	 * @format int64
 	 */
-	end: number;
+	end?: number;
 	filter?: Querybuildertypesv5FilterDTO;
 	/**
 	 * @type integer
 	 */
-	limit: number;
-	mode: MetricsexplorertypesTreemapModeDTO;
+	limit?: number;
+	/**
+	 * @type string
+	 */
+	mode?: string;
 	/**
 	 * @type integer
 	 * @format int64
 	 */
-	start: number;
+	start?: number;
 }

 export interface MetricsexplorertypesTreemapResponseDTO {
@@ -886,47 +894,41 @@ export interface MetricsexplorertypesTreemapResponseDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	samples: MetricsexplorertypesTreemapEntryDTO[] | null;
+	samples?: MetricsexplorertypesTreemapEntryDTO[] | null;
 	/**
 	 * @type array
 	 * @nullable true
 	 */
-	timeseries: MetricsexplorertypesTreemapEntryDTO[] | null;
+	timeseries?: MetricsexplorertypesTreemapEntryDTO[] | null;
 }

 export interface MetricsexplorertypesUpdateMetricMetadataRequestDTO {
 	/**
 	 * @type string
 	 */
-	description: string;
+	description?: string;
 	/**
 	 * @type boolean
 	 */
-	isMonotonic: boolean;
+	isMonotonic?: boolean;
 	/**
 	 * @type string
 	 */
-	metricName: string;
-	temporality: MetrictypesTemporalityDTO;
-	type: MetrictypesTypeDTO;
+	metricName?: string;
 	/**
 	 * @type string
 	 */
-	unit: string;
+	temporality?: string;
+	/**
+	 * @type string
+	 */
+	type?: string;
+	/**
+	 * @type string
+	 */
+	unit?: string;
 }

-export enum MetrictypesTemporalityDTO {
-	delta = 'delta',
-	cumulative = 'cumulative',
-	unspecified = 'unspecified',
-}
-export enum MetrictypesTypeDTO {
-	gauge = 'gauge',
-	sum = 'sum',
-	histogram = 'histogram',
-	summary = 'summary',
-	exponentialhistogram = 'exponentialhistogram',
-}
 export interface PreferencetypesPreferenceDTO {
 	/**
 	 * @type array
@@ -1345,7 +1347,7 @@ export interface TypesPostableForgotPasswordDTO {
 	/**
 	 * @type string
 	 */
-	email: string;
+	email?: string;
 	/**
 	 * @type string
 	 */
@@ -1353,7 +1355,7 @@ export interface TypesPostableForgotPasswordDTO {
 	/**
 	 * @type string
 	 */
-	orgId: string;
+	orgId?: string;
 }

 export interface TypesPostableInviteDTO {
@@ -1849,19 +1851,6 @@ export type GetFeatures200 = {
 	status?: string;
 };

-export type GetIngestionKeysParams = {
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	page?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	per_page?: number;
-};
-
 export type GetIngestionKeys200 = {
 	data?: GatewaytypesGettableIngestionKeysDTO;
 	/**
@@ -1901,24 +1890,6 @@ export type DeleteIngestionKeyLimitPathParameters = {
 export type UpdateIngestionKeyLimitPathParameters = {
 	limitId: string;
 };
-export type SearchIngestionKeysParams = {
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	name?: string;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	page?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	per_page?: number;
-};
-
 export type SearchIngestionKeys200 = {
 	data?: GatewaytypesGettableIngestionKeysDTO;
 	/**
@@ -1932,7 +1903,7 @@ export type GetMetricAlertsParams = {
 	 * @type string
 	 * @description undefined
 	 */
-	metricName: string;
+	metricName?: string;
 };

 export type GetMetricAlerts200 = {
@@ -1948,7 +1919,7 @@ export type GetMetricDashboardsParams = {
 	 * @type string
 	 * @description undefined
 	 */
-	metricName: string;
+	metricName?: string;
 };

 export type GetMetricDashboards200 = {
@@ -1964,7 +1935,7 @@ export type GetMetricHighlightsParams = {
 	 * @type string
 	 * @description undefined
 	 */
-	metricName: string;
+	metricName?: string;
 };

 export type GetMetricHighlights200 = {
@@ -1991,7 +1962,7 @@ export type GetMetricMetadataParams = {
 	 * @type string
 	 * @description undefined
 	 */
-	metricName: string;
+	metricName?: string;
 };

 export type GetMetricMetadata200 = {
--- a/frontend/src/components/NewSelect/CustomMultiSelect.tsx
+++ b/frontend/src/components/NewSelect/CustomMultiSelect.tsx
@@ -140,7 +140,10 @@ const CustomMultiSelect: React.FC<CustomMultiSelectProps> = ({
 	}, [selectedValues, allAvailableValues, enableAllSelection]);

 	// Define allOptionShown earlier in the code
-	const allOptionShown = value === ALL_SELECTED_VALUE;
+	const allOptionShown = useMemo(
+		() => value === ALL_SELECTED_VALUE || value === 'ALL',
+		[value],
+	);

 	// Value passed to the underlying Ant Select component
 	const displayValue = useMemo(
--- a/frontend/src/constants/theme.ts
+++ b/frontend/src/constants/theme.ts
@@ -34,230 +34,159 @@ const themeColors = {
 		cyan: '#00FFFF',
 	},
 	chartcolors: {
-		// Blues (3)
-		dodgerBlue: '#2F80ED',
-		royalBlue: '#3366E6',
-		steelBlue: '#4682B4',
-
-		// Teals / Cyans (3)
-		turquoise: '#00CEC9',
-		lagoon: '#1ABC9C',
-		cyanBright: '#22A6F2',
-
-		// Greens (3)
-		emeraldGreen: '#27AE60',
-		mediumSeaGreen: '#3CB371',
-		limeGreen: '#A3E635',
-
-		// Yellows / Golds (3)
-		festivalYellow: '#F2C94C',
-		sunflower: '#FFD93D',
-		warmAmber: '#FFCA28',
-
-		// Oranges (3)
-		festivalOrange: '#F2994A',
-		coralOrange: '#E17055',
-		pumpkin: '#FF7F50',
-
-		// Reds (3)
 		radicalRed: '#FF1A66',
-		crimsonRed: '#EB5757',
-		fireRed: '#E10600',
-
-		// Pinks (3)
-		hotPink: '#E84393',
-		rosePink: '#FD79A8',
-		blush: '#FF7EB6',
-
-		// Purples / Violets (3)
-		mediumPurple: '#BB6BD9',
-		royalPurple: '#9B51E0',
-		orchid: '#DA77F2',
-
-		// Accent / Neon / Unique Colors (3)
-		neonViolet: '#C77DFF',
-		electricPurple: '#6C5CE7',
-		arcticBlue: '#48DBFB',
-
-		// Extended palette — systematic variations to reach 100 colors
-		blue1: '#1F63E0',
-		blue2: '#3A7AED',
-		blue3: '#5A9DF5',
-		cyan1: '#00B0AA',
-		cyan2: '#33D6C2',
-		cyan3: '#66E9DA',
-		green1: '#1E8449',
-		green2: '#2ECC71',
-		green3: '#58D68D',
-		yellow1: '#F1C40F',
-		yellow2: '#F7DC6F',
-		yellow3: '#F9E79F',
-		orange1: '#D35400',
-		orange2: '#E67E22',
-		orange3: '#F5B041',
-		red1: '#C0392B',
-		red2: '#E74C3C',
-		red3: '#EC7063',
-		pink1: '#D81B60',
-		pink2: '#E91E63',
-		pink3: '#F06292',
-		purple1: '#8E44AD',
-		purple2: '#9B59B6',
-		purple3: '#BB8FCE',
-		teal1: '#009688',
-		teal2: '#1ABC9C',
-		teal3: '#48C9B0',
-		lime1: '#A3E635',
-		lime2: '#B9F18D',
-		lime3: '#D4FFB0',
-		gold1: '#F39C12',
-		gold2: '#F1C40F',
-		gold3: '#F7DC6F',
-		coral1: '#E67E22',
-		coral2: '#F39C12',
-		coral3: '#F5B041',
-		crimson1: '#C0392B',
-		crimson2: '#E74C3C',
-		crimson3: '#EC7063',
-		violet1: '#8E44AD',
-		violet2: '#9B59B6',
-		violet3: '#BB8FCE',
-		aqua1: '#00BFFF',
-		aqua2: '#1E90FF',
-		aqua3: '#63B8FF',
-		forest1: '#27AE60',
-		forest2: '#2ECC71',
-		forest3: '#58D68D',
-		blush1: '#FF6F91',
-		blush2: '#FF85A2',
-		blush3: '#FFA0B3',
-		lavender1: '#9B59B6',
-		lavender2: '#AF7AC5',
-		lavender3: '#C39BD3',
-		tomato1: '#E74C3C',
-		tomato2: '#EC7063',
-		tomato3: '#F1948A',
-		salmon1: '#FF6B6B',
-		salmon2: '#FF8787',
-		salmon3: '#FFA1A1',
-		mustard1: '#F1C40F',
-		mustard2: '#F7DC6F',
-		mustard3: '#F9E79F',
-		teal4: '#1ABC9C',
-		teal5: '#48C9B0',
-		teal6: '#76D7C4',
-		magenta1: '#D6336C',
-		magenta2: '#E84393',
-		magenta3: '#F06292',
-		violet4: '#7D3C98',
-		violet5: '#8E44AD',
-		violet6: '#9B59B6',
-		green4: '#229954',
-		green5: '#27AE60',
-		green6: '#52BE80',
-		blue4: '#2874A6',
-		blue5: '#2E86C1',
-		blue6: '#3498DB',
-		red4: '#C0392B',
-		red5: '#E74C3C',
-		red6: '#EC7063',
-		orange4: '#D35400',
-		orange5: '#E67E22',
-		orange6: '#EB984E',
-		pink4: '#C2185B',
-		pink5: '#D81B60',
-		pink6: '#E91E63',
-		gold4: '#B7950B',
-		gold5: '#F1C40F',
-		gold6: '#F4D03F',
+		dodgerBlue: '#2F80ED',
+		mediumOrchid: '#BB6BD9',
+		seaBuckthorn: '#F2994A',
+		seaGreen: '#219653',
+		turquoiseBlue: '#56CCF2',
+		festivalOrange: '#F2C94C',
+		silver: '#BDBDBD',
+		outrageousOrange: '#FF6633',
+		roseBud: '#FFB399',
+		canary: '#FFFF99',
+		deepSkyBlue: '#00B3E6',
+		goldTips: '#E6B333',
+		royalBlue: '#3366E6',
+		avocado: '#999966',
+		mintGreen: '#99FF99',
+		chestnut: '#B34D4D',
+		lima: '#80B300',
+		olive: '#809900',
+		beautyBush: '#E6B3B3',
+		danube: '#6680B3',
+		oliveDrab: '#66991A',
+		lavenderRose: '#FF99E6',
+		electricLime: '#CCFF1A',
+		robin: '#3F5ECC',
+		harleyOrange: '#E6331A',
+		turquoise: '#33FFCC',
+		gladeGreen: '#66994D',
+		hemlock: '#66664D',
+		vidaLoca: '#4D8000',
+		rust: '#B33300',
+		red: '#FF0000', // Adding more colors, we need to get better colors from design team
+		blue: '#0000FF',
+		green: '#00FF00',
+		yellow: '#FFFF00',
+		purple: '#800080',
+		cyan: '#00FFFF',
+		magenta: '#FF00FF',
+		orange: '#FFA500',
+		pink: '#FFC0CB',
+		brown: '#A52A2A',
+		teal: '#008080',
+		lime: '#00FF00',
+		maroon: '#800000',
+		navy: '#000080',
+		aquamarine: '#7FFFD4',
+		darkSeaGreen: '#8FBC8F',
+		gray: '#808080',
+		skyBlue: '#87CEEB',
+		indigo: '#4B0082',
+		slateGray: '#708090',
+		chocolate: '#D2691E',
+		tomato: '#FF6347',
+		steelBlue: '#4682B4',
+		peru: '#CD853F',
+		darkOliveGreen: '#556B2F',
+		indianRed: '#CD5C5C',
+		mediumSlateBlue: '#7B68EE',
+		rosyBrown: '#BC8F8F',
+		darkSlateGray: '#2F4F4F',
+		mediumAquamarine: '#66CDAA',
+		lavender: '#E6E6FA',
+		thistle: '#D8BFD8',
+		salmon: '#FA8072',
+		darkSalmon: '#E9967A',
+		paleVioletRed: '#DB7093',
+		mediumPurple: '#9370DB',
+		darkOrchid: '#9932CC',
+		lawnGreen: '#7CFC00',
+		mediumSeaGreen: '#3CB371',
+		lightCoral: '#F08080',
+		gold: '#FFD700',
+		sandyBrown: '#F4A460',
+		darkKhaki: '#BDB76B',
+		cornflowerBlue: '#6495ED',
+		mediumVioletRed: '#C71585',
+		paleGreen: '#98FB98',
 	},
 	lightModeColor: {
-		radicalRed: '#D81B60',
-
-		dodgerBlueDark: '#1E5BD9',
-		steelgrey: '#344B6B',
-		steelpurple: '#5E548E',
-		steelindigo: '#8E4A7C',
-		steelpink: '#B63A6F',
-		steelcoral: '#E14B5A',
-		steelorange: '#E76F2F',
-		steelgold: '#E09B00',
-		steelrust: '#C93A50',
-		steelgreen: '#2F7D69',
-
-		mediumOrchidDark: '#8E24AA',
-		seaBuckthornDark: '#C75A00',
-		seaGreen: '#1E7F5A',
-		turquoiseBlueDark: '#007EA7',
-		silverDark: '#5F5F5F',
-		outrageousOrangeDark: '#E64A19',
-		roseBudDark: '#D84315',
-		deepSkyBlueDark: '#0277BD',
-		royalBlue: '#2A4FDB',
-
-		avocadoDark: '#6B6B1E',
-		mintGreenDark: '#2E9E55',
-		chestnut: '#8B3A3A',
-		limaDark: '#5C7F00',
-		olive: '#6E7F00',
-		beautyBushDark: '#C93C3C',
-
-		danube: '#4F6FB3',
-		oliveDrab: '#4F7F1A',
-		lavenderRoseDark: '#B0178F',
-		electricLimeDark: '#6B8F00',
-		robin: '#2F4FCC',
-
-		harleyOrange: '#CC2E12',
-		gladeGreen: '#4F7F46',
-		hemlock: '#5C5C45',
-		vidaLoca: '#3D6B00',
-		rust: '#993300',
-
-		red: '#C62828',
-		blue: '#1A237E',
-		green: '#1B7F3A',
-		purple: '#6A1B9A',
-		magentaDark: '#B000B5',
-		pinkDark: '#C2185B',
-
-		brown: '#7A3A1E',
-		teal: '#006D6F',
-		limeDark: '#4C8C2B',
-		maroon: '#6D1B1B',
-		navy: '#0D1B5E',
-		gray: '#616161',
-
-		skyBlueDark: '#0288D1',
-		indigo: '#303F9F',
-		slateGray: '#556B7C',
-		chocolate: '#9C4A1A',
-		tomato: '#E53935',
-		steelBlue: '#3A6EA5',
-
-		peruDark: '#B35E00',
-		darkOliveGreen: '#445B1F',
-		indianRed: '#B04040',
-		mediumSlateBlue: '#5C6BC0',
-		rosyBrownDark: '#A94444',
-		darkSlateGray: '#2E4A4A',
-
-		fuchsia: '#C511C5',
-		salmonDark: '#E64A3C',
-		darkSalmonDark: '#C85A3A',
-		paleVioletRedDark: '#C2186A',
-
-		mediumPurple: '#7E57C2',
-		darkOrchid: '#7B1FA2',
-		mediumSeaGreenDark: '#2E8B57',
-		lightCoralDark: '#E57373',
-
-		gold: '#D4AF37',
-		sandyBrownDark: '#C76A15',
-		darkKhakiDark: '#8A7F00',
-		cornflowerBlueDark: '#355FCC',
-		mediumVioletRed: '#AD1457',
-		paleGreenDark: '#2E7D32',
+		radicalRed: '#FF1A66',
+		dodgerBlueDark: '#0C6EED',
+		steelgrey: '#2f4b7c',
+		steelpurple: '#665191',
+		steelindigo: '#a05195',
+		steelpink: '#d45087',
+		steelcoral: '#f95d6a',
+		steelorange: '#ff7c43',
+		steelgold: '#ffa600',
+		steelrust: '#de425b',
+		steelgreen: '#41967e',
+		mediumOrchidDark: '#C326FD',
+		seaBuckthornDark: '#E66E05',
+		seaGreen: '#219653',
+		turquoiseBlueDark: '#0099CC',
+		silverDark: '#757575',
+		outrageousOrangeDark: '#F9521A',
+		roseBudDark: '#EB6437',
+		deepSkyBlueDark: '#0595BD',
+		royalBlue: '#3366E6',
+		avocadoDark: '#8E8E29',
+		mintGreenDark: '#00C700',
+		chestnut: '#B34D4D',
+		limaDark: '#6E9900',
+		olive: '#809900',
+		beautyBushDark: '#E25555',
+		danube: '#6680B3',
+		oliveDrab: '#66991A',
+		lavenderRoseDark: '#F024BD',
+		electricLimeDark: '#84A800',
+		robin: '#3F5ECC',
+		harleyOrange: '#E6331A',
+		gladeGreen: '#66994D',
+		hemlock: '#66664D',
+		vidaLoca: '#4D8000',
+		rust: '#B33300',
+		red: '#FF0000', // Adding more colors, we need to get better colors from design team
+		blue: '#0000FF',
+		green: '#00FF00',
+		purple: '#800080',
+		magentaDark: '#EB00EB',
+		pinkDark: '#FF3D5E',
+		brown: '#A52A2A',
+		teal: '#008080',
+		limeDark: '#07A207',
+		maroon: '#800000',
+		navy: '#000080',
+		gray: '#808080',
+		skyBlueDark: '#0CA7E4',
+		indigo: '#4B0082',
+		slateGray: '#708090',
+		chocolate: '#D2691E',
+		tomato: '#FF6347',
+		steelBlue: '#4682B4',
+		peruDark: '#D16E0A',
+		darkOliveGreen: '#556B2F',
+		indianRed: '#CD5C5C',
+		mediumSlateBlue: '#7B68EE',
+		rosyBrownDark: '#CB4848',
+		darkSlateGray: '#2F4F4F',
+		fuchsia: '#FF0AFF',
+		salmonDark: '#FF432E',
+		darkSalmonDark: '#D26541',
+		paleVioletRedDark: '#E83089',
+		mediumPurple: '#9370DB',
+		darkOrchid: '#9932CC',
+		mediumSeaGreenDark: '#109E50',
+		lightCoralDark: '#F85959',
+		gold: '#FFD700',
+		sandyBrownDark: '#D97117',
+		darkKhakiDark: '#99900A',
+		cornflowerBlueDark: '#3371E6',
+		mediumVioletRed: '#C71585',
+		paleGreenDark: '#0D910D',
 	},
 	errorColor: '#d32f2f',
 	royalGrey: '#888888',
--- a/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/VariableItem.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/VariableItem.tsx
@@ -18,8 +18,8 @@ import { useWidgetsByDynamicVariableId } from 'hooks/dashboard/useWidgetsByDynam
 import { getWidgetsHavingDynamicVariableAttribute } from 'hooks/dashboard/utils';
 import { useGetFieldValues } from 'hooks/dynamicVariables/useGetFieldValues';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
-import sortValues from 'lib/dashboardVariables/sortVariableValues';
+import { commaValuesParser } from 'lib/dashbaordVariables/customCommaValuesParser';
+import sortValues from 'lib/dashbaordVariables/sortVariableValues';
 import { isEmpty, map } from 'lodash-es';
 import {
 	ArrowLeft,
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/CustomVariableInput.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/CustomVariableInput.tsx
@@ -1,69 +0,0 @@
-import { memo, useEffect, useMemo } from 'react';
-import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
-import sortValues from 'lib/dashboardVariables/sortVariableValues';
-
-import SelectVariableInput from './SelectVariableInput';
-import { useDashboardVariableSelectHelper } from './useDashboardVariableSelectHelper';
-import { VariableItemProps } from './VariableItem';
-import { customVariableSelectStrategy } from './variableSelectStrategy/customVariableSelectStrategy';
-
-type CustomVariableInputProps = Pick<
-	VariableItemProps,
-	'variableData' | 'onValueUpdate'
->;
-
-function CustomVariableInput({
-	variableData,
-	onValueUpdate,
-}: CustomVariableInputProps): JSX.Element {
-	const optionsData: (string | number | boolean)[] = useMemo(() => {
-		return sortValues(
-			commaValuesParser(variableData.customValue || ''),
-			variableData.sort,
-		) as (string | number | boolean)[];
-	}, [variableData.customValue, variableData.sort]);
-
-	const {
-		value,
-		defaultValue,
-		enableSelectAll,
-		onChange,
-		onDropdownVisibleChange,
-		handleClear,
-		applyDefaultIfNeeded,
-	} = useDashboardVariableSelectHelper({
-		variableData,
-		optionsData,
-		onValueUpdate,
-		strategy: customVariableSelectStrategy,
-	});
-
-	// Apply default on mount — options are available synchronously for custom variables
-	// eslint-disable-next-line react-hooks/exhaustive-deps
-	useEffect(applyDefaultIfNeeded, []);
-
-	const selectOptions = useMemo(
-		() =>
-			optionsData.map((option) => ({
-				label: option.toString(),
-				value: option.toString(),
-			})),
-		[optionsData],
-	);
-
-	return (
-		<SelectVariableInput
-			variableId={variableData.id}
-			options={selectOptions}
-			value={value}
-			onChange={onChange}
-			onDropdownVisibleChange={onDropdownVisibleChange}
-			onClear={handleClear}
-			enableSelectAll={enableSelectAll}
-			defaultValue={defaultValue}
-			isMultiSelect={variableData.multiSelect}
-		/>
-	);
-}
-
-export default memo(CustomVariableInput);
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.styles.scss
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.styles.scss
@@ -25,6 +25,12 @@
 		}
 	}

+	&.focused {
+		.variable-value {
+			outline: 1px solid var(--bg-robin-400);
+		}
+	}
+
 	.variable-value {
 		display: flex;
 		min-width: 120px;
@@ -42,11 +48,6 @@
 		font-style: normal;
 		font-weight: 400;
 		line-height: 16px; /* 133.333% */
-
-		&:hover,
-		&:focus-within {
-			outline: 1px solid var(--bg-robin-400);
-		}
 	}

 	.variable-select {
@@ -98,6 +99,12 @@

 .lightMode {
 	.variable-item {
+		&.focused {
+			.variable-value {
+				border: 1px solid var(--bg-robin-400);
+			}
+		}
+
 		.variable-name {
 			border: 1px solid var(--bg-vanilla-300);
 			background: var(--bg-vanilla-100);
@@ -108,11 +115,6 @@
 			border: 1px solid var(--bg-vanilla-300);
 			background: var(--bg-vanilla-100);
 			color: var(--bg-ink-400);
-
-			&:hover,
-			&:focus-within {
-				outline: 1px solid var(--bg-robin-400);
-			}
 		}
 	}
 }
@@ -122,9 +124,3 @@
 	padding: 4px 12px;
 	font-size: 12px;
 }
-
-.dashboard-variables-selection-container {
-	display: flex;
-	flex-wrap: wrap;
-	gap: 12px;
-}
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx
@@ -1,4 +1,4 @@
-import { memo, useCallback, useEffect, useMemo } from 'react';
+import { memo, useEffect } from 'react';
 import { useSelector } from 'react-redux';
 import { Row } from 'antd';
 import { ALL_SELECTED_VALUE } from 'components/NewSelect/utils';
@@ -7,12 +7,14 @@ import {
 	useDashboardVariablesSelector,
 } from 'hooks/dashboard/useDashboardVariables';
 import useVariablesFromUrl from 'hooks/dashboard/useVariablesFromUrl';
+import { isEmpty } from 'lodash-es';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { initializeDefaultVariables } from 'providers/Dashboard/initializeDefaultVariables';
 import { AppState } from 'store/reducers';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
 import { GlobalReducer } from 'types/reducer/globalTime';

+import DynamicVariableSelection from './DynamicVariableSelection';
 import { onUpdateVariableNode } from './util';
 import VariableItem from './VariableItem';

@@ -20,6 +22,7 @@ import './DashboardVariableSelection.styles.scss';

 function DashboardVariableSelection(): JSX.Element | null {
 	const {
+		selectedDashboard,
 		setSelectedDashboard,
 		updateLocalStorageDashboardVariables,
 		variablesToGetUpdated,
@@ -49,36 +52,34 @@ function DashboardVariableSelection(): JSX.Element | null {
 		);
 	}, [getUrlVariables, updateUrlVariable, dashboardVariables]);

-	// Memoize the order key to avoid unnecessary triggers
-	const dependencyOrderKey = useMemo(
-		() => dependencyData?.order?.join(',') ?? '',
-		[dependencyData?.order],
-	);
-
-	// Trigger refetch when dependency order changes or global time changes
-	useEffect(() => {
-		if (dependencyData?.order && dependencyData.order.length > 0) {
-			setVariablesToGetUpdated(dependencyData?.order || []);
-		}
+	// this handles the case where the dependency order changes i.e. variable list updated via creation or deletion etc. and we need to refetch the variables
+	// also trigger when the global time changes
+	useEffect(
+		() => {
+			if (!isEmpty(dependencyData?.order)) {
+				setVariablesToGetUpdated(dependencyData?.order || []);
+			}
+		},
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [dependencyOrderKey, minTime, maxTime]);
+		[JSON.stringify(dependencyData?.order), minTime, maxTime],
+	);

 	// Performance optimization: For dynamic variables with allSelected=true, we don't store
 	// individual values in localStorage since we can always derive them from available options.
 	// This makes localStorage much lighter and more efficient.
-	const onValueUpdate = useCallback(
-		(
-			name: string,
-			id: string,
-			value: IDashboardVariable['selectedValue'],
-			allSelected: boolean,
-			haveCustomValuesSelected?: boolean,
-			// eslint-disable-next-line sonarjs/cognitive-complexity
-		): void => {
+	const onValueUpdate = (
+		name: string,
+		id: string,
+		value: IDashboardVariable['selectedValue'],
+		allSelected: boolean,
+		haveCustomValuesSelected?: boolean,
+		// eslint-disable-next-line sonarjs/cognitive-complexity
+	): void => {
+		if (id) {
 			// For dynamic variables, only store in localStorage when NOT allSelected
 			// This makes localStorage much lighter by avoiding storing all individual values
-			const variable = dashboardVariables[id] || dashboardVariables[name];
-			const isDynamic = variable.type === 'DYNAMIC';
+			const variable = dashboardVariables?.[id] || dashboardVariables?.[name];
+			const isDynamic = variable?.type === 'DYNAMIC';
 			updateLocalStorageDashboardVariables(name, value, allSelected, isDynamic);

 			if (allSelected) {
@@ -87,39 +88,41 @@ function DashboardVariableSelection(): JSX.Element | null {
 				updateUrlVariable(name || id, value);
 			}

-			setSelectedDashboard((prev) => {
-				if (prev) {
-					const oldVariables = { ...prev?.data.variables };
-					// this is added to handle case where we have two different
-					// schemas for variable response
-					if (oldVariables?.[id]) {
-						oldVariables[id] = {
-							...oldVariables[id],
-							selectedValue: value,
-							allSelected,
-							haveCustomValuesSelected,
-						};
-					}
-					if (oldVariables?.[name]) {
-						oldVariables[name] = {
-							...oldVariables[name],
-							selectedValue: value,
-							allSelected,
-							haveCustomValuesSelected,
-						};
-					}
-					return {
-						...prev,
-						data: {
-							...prev?.data,
-							variables: {
-								...oldVariables,
+			if (selectedDashboard) {
+				setSelectedDashboard((prev) => {
+					if (prev) {
+						const oldVariables = prev?.data.variables;
+						// this is added to handle case where we have two different
+						// schemas for variable response
+						if (oldVariables?.[id]) {
+							oldVariables[id] = {
+								...oldVariables[id],
+								selectedValue: value,
+								allSelected,
+								haveCustomValuesSelected,
+							};
+						}
+						if (oldVariables?.[name]) {
+							oldVariables[name] = {
+								...oldVariables[name],
+								selectedValue: value,
+								allSelected,
+								haveCustomValuesSelected,
+							};
+						}
+						return {
+							...prev,
+							data: {
+								...prev?.data,
+								variables: {
+									...oldVariables,
+								},
 							},
-						},
-					};
-				}
-				return prev;
-			});
+						};
+					}
+					return prev;
+				});
+			}

 			if (dependencyData) {
 				const updatedVariables: string[] = [];
@@ -135,24 +138,22 @@ function DashboardVariableSelection(): JSX.Element | null {
 			} else {
 				setVariablesToGetUpdated((prev) => prev.filter((v) => v !== name));
 			}
-		},
-		[
-			// This can be removed
-			dashboardVariables,
-			updateLocalStorageDashboardVariables,
-			dependencyData,
-			updateUrlVariable,
-			setSelectedDashboard,
-			setVariablesToGetUpdated,
-		],
-	);
+		}
+	};

 	return (
-		<Row className="dashboard-variables-selection-container">
+		<Row style={{ display: 'flex', gap: '12px' }}>
 			{sortedVariablesArray.map((variable) => {
 				const key = `${variable.name}${variable.id}${variable.order}`;

-				return (
+				return variable.type === 'DYNAMIC' ? (
+					<DynamicVariableSelection
+						key={key}
+						existingVariables={dashboardVariables}
+						variableData={variable}
+						onValueUpdate={onValueUpdate}
+					/>
+				) : (
 					<VariableItem
 						key={key}
 						existingVariables={dashboardVariables}
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DynamicVariableInput.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DynamicVariableInput.tsx
@@ -1,343 +0,0 @@
-import { memo, useCallback, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import { useSelector } from 'react-redux';
-import { getFieldValues } from 'api/dynamicVariables/getFieldValues';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
-import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import useDebounce from 'hooks/useDebounce';
-import { isEmpty } from 'lodash-es';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { isRetryableError as checkIfRetryableError } from 'utils/errorUtils';
-
-import SelectVariableInput from './SelectVariableInput';
-import { useDashboardVariableSelectHelper } from './useDashboardVariableSelectHelper';
-import { getOptionsForDynamicVariable } from './util';
-import { VariableItemProps } from './VariableItem';
-import { dynamicVariableSelectStrategy } from './variableSelectStrategy/dynamicVariableSelectStrategy';
-
-import './DashboardVariableSelection.styles.scss';
-
-type DynamicVariableInputProps = Pick<
-	VariableItemProps,
-	'variableData' | 'onValueUpdate' | 'existingVariables'
->;
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-function DynamicVariableInput({
-	variableData,
-	onValueUpdate,
-	existingVariables,
-}: DynamicVariableInputProps): JSX.Element {
-	const [optionsData, setOptionsData] = useState<(string | number | boolean)[]>(
-		[],
-	);
-
-	const [errorMessage, setErrorMessage] = useState<null | string>(null);
-	const [isRetryableError, setIsRetryableError] = useState<boolean>(true);
-
-	const [isComplete, setIsComplete] = useState<boolean>(false);
-
-	const [filteredOptionsData, setFilteredOptionsData] = useState<
-		(string | number | boolean)[]
-	>([]);
-
-	const [relatedValues, setRelatedValues] = useState<string[]>([]);
-	const [originalRelatedValues, setOriginalRelatedValues] = useState<string[]>(
-		[],
-	);
-
-	// Track dropdown open state for auto-checking new values
-	const [isDropdownOpen, setIsDropdownOpen] = useState<boolean>(false);
-
-	const [apiSearchText, setApiSearchText] = useState<string>('');
-
-	const debouncedApiSearchText = useDebounce(apiSearchText, DEBOUNCE_DELAY);
-
-	// Build a memoized list of all currently available option strings (normalized + related)
-	const allAvailableOptionStrings = useMemo(
-		() => [
-			...new Set([
-				...optionsData.map((v) => v.toString()),
-				...relatedValues.map((v) => v.toString()),
-			]),
-		],
-		[optionsData, relatedValues],
-	);
-
-	const {
-		value,
-		tempSelection,
-		setTempSelection,
-		handleClear,
-		enableSelectAll,
-		defaultValue,
-		applyDefaultIfNeeded,
-		onChange,
-		onDropdownVisibleChange,
-	} = useDashboardVariableSelectHelper({
-		variableData,
-		optionsData,
-		onValueUpdate,
-		strategy: dynamicVariableSelectStrategy,
-		allAvailableOptionStrings,
-	});
-
-	// Create a dependency key from all dynamic variables
-	const dynamicVariablesKey = useMemo(() => {
-		if (!existingVariables) {
-			return 'no_variables';
-		}
-
-		const dynamicVars = Object.values(existingVariables)
-			.filter((v) => v.type === 'DYNAMIC')
-			.map(
-				(v) => `${v.name || 'unnamed'}:${JSON.stringify(v.selectedValue || null)}`,
-			)
-			.join('|');
-
-		return dynamicVars || 'no_dynamic_variables';
-	}, [existingVariables]);
-
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	// existing query is the query made from the other dynamic variables around this one with there current values
-	// for e.g. k8s.namespace.name IN ["zeus", "gene"] AND doc_op_type IN ["test"]
-	// eslint-disable-next-line sonarjs/cognitive-complexity
-	const existingQuery = useMemo(() => {
-		if (!existingVariables || !variableData.dynamicVariablesAttribute) {
-			return '';
-		}
-
-		const queryParts: string[] = [];
-
-		Object.entries(existingVariables).forEach(([, variable]) => {
-			// Skip the current variable being processed
-			if (variable.id === variableData.id) {
-				return;
-			}
-
-			// Only include dynamic variables that have selected values and are not selected as ALL
-			if (
-				variable.type === 'DYNAMIC' &&
-				variable.dynamicVariablesAttribute &&
-				variable.selectedValue &&
-				!isEmpty(variable.selectedValue) &&
-				(variable.showALLOption ? !variable.allSelected : true)
-			) {
-				const attribute = variable.dynamicVariablesAttribute;
-				const values = Array.isArray(variable.selectedValue)
-					? variable.selectedValue
-					: [variable.selectedValue];
-
-				// Filter out empty values and convert to strings
-				const validValues = values
-					.filter((val) => val !== null && val !== undefined && val !== '')
-					.map((val) => val.toString());
-
-				if (validValues.length > 0) {
-					// Format values for query - wrap strings in quotes, keep numbers as is
-					const formattedValues = validValues.map((val) => {
-						// Check if value is a number
-						const numValue = Number(val);
-						if (!Number.isNaN(numValue) && Number.isFinite(numValue)) {
-							return val; // Keep as number
-						}
-						// Escape single quotes and wrap in quotes
-						return `'${val.replace(/'/g, "\\'")}'`;
-					});
-
-					if (formattedValues.length === 1) {
-						queryParts.push(`${attribute} = ${formattedValues[0]}`);
-					} else {
-						queryParts.push(`${attribute} IN [${formattedValues.join(', ')}]`);
-					}
-				}
-			}
-		});
-
-		return queryParts.join(' AND ');
-	}, [
-		existingVariables,
-		variableData.id,
-		variableData.dynamicVariablesAttribute,
-	]);
-
-	// Wrap the hook's onDropdownVisibleChange to also track isDropdownOpen and handle cleanup
-	const handleSelectDropdownVisibilityChange = useCallback(
-		(visible: boolean): void => {
-			setIsDropdownOpen(visible);
-
-			onDropdownVisibleChange(visible);
-
-			if (!visible) {
-				setFilteredOptionsData(optionsData);
-				setRelatedValues(originalRelatedValues);
-				setApiSearchText('');
-			}
-		},
-		[onDropdownVisibleChange, optionsData, originalRelatedValues],
-	);
-
-	const { isLoading, refetch } = useQuery(
-		[
-			REACT_QUERY_KEY.DASHBOARD_BY_ID,
-			variableData.name || `variable_${variableData.id}`,
-			dynamicVariablesKey,
-			minTime,
-			maxTime,
-			debouncedApiSearchText,
-			variableData.dynamicVariablesSource,
-			variableData.dynamicVariablesAttribute,
-		],
-		{
-			enabled:
-				variableData.type === 'DYNAMIC' &&
-				!!variableData.dynamicVariablesSource &&
-				!!variableData.dynamicVariablesAttribute,
-			queryFn: () =>
-				getFieldValues(
-					variableData.dynamicVariablesSource?.toLowerCase() === 'all telemetry'
-						? undefined
-						: (variableData.dynamicVariablesSource?.toLowerCase() as
-								| 'traces'
-								| 'logs'
-								| 'metrics'),
-					variableData.dynamicVariablesAttribute,
-					debouncedApiSearchText,
-					minTime,
-					maxTime,
-					existingQuery,
-				),
-			onSuccess: (data) => {
-				const newNormalizedValues = data.data?.normalizedValues || [];
-				const newRelatedValues = data.data?.relatedValues || [];
-
-				if (!debouncedApiSearchText) {
-					setOptionsData(newNormalizedValues);
-					setIsComplete(data.data?.complete || false);
-				}
-				setFilteredOptionsData(newNormalizedValues);
-				setRelatedValues(newRelatedValues);
-				setOriginalRelatedValues(newRelatedValues);
-
-				// Only run auto-check logic when necessary to avoid performance issues
-				if (variableData.allSelected && isDropdownOpen) {
-					// Build the latest full list from API (normalized + related)
-					const latestValues = [
-						...new Set([
-							...newNormalizedValues.map((v) => v.toString()),
-							...newRelatedValues.map((v) => v.toString()),
-						]),
-					];
-
-					// Update temp selection to exactly reflect latest API values when ALL is active
-					const currentStrings = Array.isArray(tempSelection)
-						? tempSelection.map((v) => v.toString())
-						: tempSelection
-						? [tempSelection.toString()]
-						: [];
-					const areSame =
-						currentStrings.length === latestValues.length &&
-						latestValues.every((v) => currentStrings.includes(v));
-					if (!areSame) {
-						setTempSelection(latestValues);
-					}
-				}
-
-				// Apply default if no value is selected (e.g., new variable, first load)
-				if (!debouncedApiSearchText) {
-					const allNewOptions = [
-						...new Set([
-							...newNormalizedValues.map((v) => v.toString()),
-							...newRelatedValues.map((v) => v.toString()),
-						]),
-					];
-					applyDefaultIfNeeded(allNewOptions);
-				}
-			},
-			onError: (error: any) => {
-				if (error) {
-					let message = SOMETHING_WENT_WRONG;
-					if (error?.message) {
-						message = error?.message;
-					} else {
-						message =
-							'Please make sure configuration is valid and you have required setup and permissions';
-					}
-					setErrorMessage(message);
-
-					// Check if error is retryable (5xx) or not (4xx)
-					const isRetryable = checkIfRetryableError(error);
-					setIsRetryableError(isRetryable);
-				}
-			},
-		},
-	);
-
-	const handleRetry = useCallback((): void => {
-		setErrorMessage(null);
-		setIsRetryableError(true);
-		refetch();
-	}, [refetch]);
-
-	const handleSearch = useCallback(
-		(text: string) => {
-			if (isComplete) {
-				if (!text) {
-					setFilteredOptionsData(optionsData);
-					setRelatedValues(originalRelatedValues);
-					return;
-				}
-
-				const lowerText = text.toLowerCase();
-				setFilteredOptionsData(
-					optionsData.filter((option) =>
-						option.toString().toLowerCase().includes(lowerText),
-					),
-				);
-				setRelatedValues(
-					originalRelatedValues.filter((val) =>
-						val.toLowerCase().includes(lowerText),
-					),
-				);
-			} else {
-				setApiSearchText(text);
-			}
-		},
-		[isComplete, optionsData, originalRelatedValues],
-	);
-
-	const selectOptions = useMemo(
-		() =>
-			getOptionsForDynamicVariable(filteredOptionsData || [], relatedValues || []),
-		[filteredOptionsData, relatedValues],
-	);
-
-	return (
-		<SelectVariableInput
-			variableId={variableData.id}
-			options={selectOptions}
-			value={value}
-			onChange={onChange}
-			onDropdownVisibleChange={handleSelectDropdownVisibilityChange}
-			onClear={handleClear}
-			enableSelectAll={enableSelectAll}
-			defaultValue={defaultValue}
-			isMultiSelect={variableData.multiSelect}
-			// dynamic variable specific + API related props
-			loading={isLoading}
-			errorMessage={errorMessage}
-			onRetry={handleRetry}
-			isDynamicVariable
-			showRetryButton={isRetryableError}
-			showIncompleteDataMessage={!isComplete && filteredOptionsData.length > 0}
-			onSearch={handleSearch}
-		/>
-	);
-}
-
-export default memo(DynamicVariableInput);
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DynamicVariableSelection.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DynamicVariableSelection.tsx
@@ -0,0 +1,602 @@
+/* eslint-disable sonarjs/cognitive-complexity */
+/* eslint-disable no-nested-ternary */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+import { useSelector } from 'react-redux';
+import { InfoCircleOutlined } from '@ant-design/icons';
+import { Tooltip, Typography } from 'antd';
+import { getFieldValues } from 'api/dynamicVariables/getFieldValues';
+import { CustomMultiSelect, CustomSelect } from 'components/NewSelect';
+import { SOMETHING_WENT_WRONG } from 'constants/api';
+import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import useDebounce from 'hooks/useDebounce';
+import { isEmpty, isUndefined } from 'lodash-es';
+import { AppState } from 'store/reducers';
+import { IDashboardVariable } from 'types/api/dashboard/getAll';
+import { GlobalReducer } from 'types/reducer/globalTime';
+import { isRetryableError as checkIfRetryableError } from 'utils/errorUtils';
+import { popupContainer } from 'utils/selectPopupContainer';
+
+import { ALL_SELECT_VALUE } from '../utils';
+import { SelectItemStyle } from './styles';
+import {
+	areArraysEqual,
+	getOptionsForDynamicVariable,
+	uniqueValues,
+} from './util';
+import { getSelectValue } from './VariableItem';
+
+import './DashboardVariableSelection.styles.scss';
+
+interface DynamicVariableSelectionProps {
+	variableData: IDashboardVariable;
+	existingVariables: Record<string, IDashboardVariable>;
+	onValueUpdate: (
+		name: string,
+		id: string,
+		arg1: IDashboardVariable['selectedValue'],
+		allSelected: boolean,
+		haveCustomValuesSelected?: boolean,
+	) => void;
+}
+
+function DynamicVariableSelection({
+	variableData,
+	onValueUpdate,
+	existingVariables,
+}: DynamicVariableSelectionProps): JSX.Element {
+	const [optionsData, setOptionsData] = useState<(string | number | boolean)[]>(
+		[],
+	);
+
+	const [errorMessage, setErrorMessage] = useState<null | string>(null);
+	const [isRetryableError, setIsRetryableError] = useState<boolean>(true);
+
+	const [isComplete, setIsComplete] = useState<boolean>(false);
+
+	const [filteredOptionsData, setFilteredOptionsData] = useState<
+		(string | number | boolean)[]
+	>([]);
+
+	const [relatedValues, setRelatedValues] = useState<string[]>([]);
+	const [originalRelatedValues, setOriginalRelatedValues] = useState<string[]>(
+		[],
+	);
+
+	const [tempSelection, setTempSelection] = useState<
+		string | string[] | undefined
+	>(undefined);
+
+	// Track dropdown open state for auto-checking new values
+	const [isDropdownOpen, setIsDropdownOpen] = useState<boolean>(false);
+
+	// Create a dependency key from all dynamic variables
+	const dynamicVariablesKey = useMemo(() => {
+		if (!existingVariables) {
+			return 'no_variables';
+		}
+
+		const dynamicVars = Object.values(existingVariables)
+			.filter((v) => v.type === 'DYNAMIC')
+			.map(
+				(v) => `${v.name || 'unnamed'}:${JSON.stringify(v.selectedValue || null)}`,
+			)
+			.join('|');
+
+		return dynamicVars || 'no_dynamic_variables';
+	}, [existingVariables]);
+
+	const [apiSearchText, setApiSearchText] = useState<string>('');
+
+	const debouncedApiSearchText = useDebounce(apiSearchText, DEBOUNCE_DELAY);
+
+	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	// existing query is the query made from the other dynamic variables around this one with there current values
+	// for e.g. k8s.namespace.name IN ["zeus", "gene"] AND doc_op_type IN ["test"]
+	const existingQuery = useMemo(() => {
+		if (!existingVariables || !variableData.dynamicVariablesAttribute) {
+			return '';
+		}
+
+		const queryParts: string[] = [];
+
+		Object.entries(existingVariables).forEach(([, variable]) => {
+			// Skip the current variable being processed
+			if (variable.id === variableData.id) {
+				return;
+			}
+
+			// Only include dynamic variables that have selected values and are not selected as ALL
+			if (
+				variable.type === 'DYNAMIC' &&
+				variable.dynamicVariablesAttribute &&
+				variable.selectedValue &&
+				!isEmpty(variable.selectedValue) &&
+				(variable.showALLOption ? !variable.allSelected : true)
+			) {
+				const attribute = variable.dynamicVariablesAttribute;
+				const values = Array.isArray(variable.selectedValue)
+					? variable.selectedValue
+					: [variable.selectedValue];
+
+				// Filter out empty values and convert to strings
+				const validValues = values
+					.filter((value) => value !== null && value !== undefined && value !== '')
+					.map((value) => value.toString());
+
+				if (validValues.length > 0) {
+					// Format values for query - wrap strings in quotes, keep numbers as is
+					const formattedValues = validValues.map((value) => {
+						// Check if value is a number
+						const numValue = Number(value);
+						if (!Number.isNaN(numValue) && Number.isFinite(numValue)) {
+							return value; // Keep as number
+						}
+						// Escape single quotes and wrap in quotes
+						return `'${value.replace(/'/g, "\\'")}'`;
+					});
+
+					if (formattedValues.length === 1) {
+						queryParts.push(`${attribute} = ${formattedValues[0]}`);
+					} else {
+						queryParts.push(`${attribute} IN [${formattedValues.join(', ')}]`);
+					}
+				}
+			}
+		});
+
+		return queryParts.join(' AND ');
+	}, [
+		existingVariables,
+		variableData.id,
+		variableData.dynamicVariablesAttribute,
+	]);
+
+	const { isLoading, refetch } = useQuery(
+		[
+			REACT_QUERY_KEY.DASHBOARD_BY_ID,
+			variableData.name || `variable_${variableData.id}`,
+			dynamicVariablesKey,
+			minTime,
+			maxTime,
+			debouncedApiSearchText,
+		],
+		{
+			enabled: variableData.type === 'DYNAMIC',
+			queryFn: () =>
+				getFieldValues(
+					variableData.dynamicVariablesSource?.toLowerCase() === 'all telemetry'
+						? undefined
+						: (variableData.dynamicVariablesSource?.toLowerCase() as
+								| 'traces'
+								| 'logs'
+								| 'metrics'),
+					variableData.dynamicVariablesAttribute,
+					debouncedApiSearchText,
+					minTime,
+					maxTime,
+					existingQuery,
+				),
+			onSuccess: (data) => {
+				const newNormalizedValues = data.data?.normalizedValues || [];
+				const newRelatedValues = data.data?.relatedValues || [];
+
+				if (!debouncedApiSearchText) {
+					setOptionsData(newNormalizedValues);
+					setIsComplete(data.data?.complete || false);
+				}
+				setFilteredOptionsData(newNormalizedValues);
+				setRelatedValues(newRelatedValues);
+				setOriginalRelatedValues(newRelatedValues);
+
+				// Only run auto-check logic when necessary to avoid performance issues
+				if (variableData.allSelected && isDropdownOpen) {
+					// Build the latest full list from API (normalized + related)
+					const latestValues = [
+						...new Set([
+							...newNormalizedValues.map((v) => v.toString()),
+							...newRelatedValues.map((v) => v.toString()),
+						]),
+					];
+
+					// Update temp selection to exactly reflect latest API values when ALL is active
+					const currentStrings = Array.isArray(tempSelection)
+						? tempSelection.map((v) => v.toString())
+						: tempSelection
+						? [tempSelection.toString()]
+						: [];
+					const areSame =
+						currentStrings.length === latestValues.length &&
+						latestValues.every((v) => currentStrings.includes(v));
+					if (!areSame) {
+						setTempSelection(latestValues);
+					}
+				}
+			},
+			onError: (error: any) => {
+				if (error) {
+					let message = SOMETHING_WENT_WRONG;
+					if (error?.message) {
+						message = error?.message;
+					} else {
+						message =
+							'Please make sure configuration is valid and you have required setup and permissions';
+					}
+					setErrorMessage(message);
+
+					// Check if error is retryable (5xx) or not (4xx)
+					const isRetryable = checkIfRetryableError(error);
+					setIsRetryableError(isRetryable);
+				}
+			},
+		},
+	);
+
+	const handleChange = useCallback(
+		(inputValue: string | string[]): void => {
+			const value = variableData.multiSelect && !inputValue ? [] : inputValue;
+
+			if (
+				value === variableData.selectedValue ||
+				(Array.isArray(value) &&
+					Array.isArray(variableData.selectedValue) &&
+					areArraysEqual(value, variableData.selectedValue))
+			) {
+				return;
+			}
+
+			if (variableData.name) {
+				if (
+					value === ALL_SELECT_VALUE ||
+					(Array.isArray(value) && value.includes(ALL_SELECT_VALUE))
+				) {
+					// For ALL selection in dynamic variables, pass null to avoid storing values
+					// The parent component will handle this appropriately
+					onValueUpdate(variableData.name, variableData.id, null, true);
+				} else {
+					// Build union of available options shown in dropdown (normalized + related)
+					const allAvailableOptionStrings = [
+						...new Set([
+							...optionsData.map((v) => v.toString()),
+							...relatedValues.map((v) => v.toString()),
+						]),
+					];
+
+					const haveCustomValuesSelected =
+						Array.isArray(value) &&
+						!value.every((v) => allAvailableOptionStrings.includes(v.toString()));
+
+					onValueUpdate(
+						variableData.name,
+						variableData.id,
+						value,
+						allAvailableOptionStrings.every((v) => value.includes(v.toString())),
+						haveCustomValuesSelected,
+					);
+				}
+			}
+		},
+		[variableData, onValueUpdate, optionsData, relatedValues],
+	);
+
+	useEffect(() => {
+		if (
+			variableData.dynamicVariablesSource &&
+			variableData.dynamicVariablesAttribute
+		) {
+			refetch();
+		}
+	}, [
+		refetch,
+		variableData.dynamicVariablesSource,
+		variableData.dynamicVariablesAttribute,
+		debouncedApiSearchText,
+	]);
+
+	// Build a memoized list of all currently available option strings (normalized + related)
+	const allAvailableOptionStrings = useMemo(
+		() => [
+			...new Set([
+				...optionsData.map((v) => v.toString()),
+				...relatedValues.map((v) => v.toString()),
+			]),
+		],
+		[optionsData, relatedValues],
+	);
+
+	const handleSearch = useCallback(
+		(text: string) => {
+			if (isComplete) {
+				if (!text) {
+					setFilteredOptionsData(optionsData);
+					setRelatedValues(originalRelatedValues);
+					return;
+				}
+
+				const localFilteredOptionsData: (string | number | boolean)[] = [];
+				optionsData.forEach((option) => {
+					if (option.toString().toLowerCase().includes(text.toLowerCase())) {
+						localFilteredOptionsData.push(option);
+					}
+				});
+				setFilteredOptionsData(localFilteredOptionsData);
+				setRelatedValues(
+					originalRelatedValues.filter((value) =>
+						value.toLowerCase().includes(text.toLowerCase()),
+					),
+				);
+			} else {
+				setApiSearchText(text);
+			}
+		},
+		[isComplete, optionsData, originalRelatedValues],
+	);
+
+	const { selectedValue } = variableData;
+	const selectedValueStringified = useMemo(
+		() => getSelectValue(selectedValue, variableData),
+		[selectedValue, variableData],
+	);
+
+	const enableSelectAll = variableData.multiSelect && variableData.showALLOption;
+
+	const selectValue =
+		variableData.allSelected && enableSelectAll
+			? ALL_SELECT_VALUE
+			: selectedValueStringified;
+
+	// Add a handler for tracking temporary selection changes
+	const handleTempChange = useCallback(
+		(inputValue: string | string[]): void => {
+			// Store the selection in temporary state while dropdown is open
+			const value = variableData.multiSelect && !inputValue ? [] : inputValue;
+			const sanitizedValue = uniqueValues(value);
+			setTempSelection(sanitizedValue);
+		},
+		[variableData.multiSelect],
+	);
+
+	// Handle dropdown visibility changes
+	const handleDropdownVisibleChange = (visible: boolean): void => {
+		// Update dropdown open state for auto-checking
+		setIsDropdownOpen(visible);
+
+		// Initialize temp selection when opening dropdown
+		if (visible) {
+			if (isUndefined(tempSelection) && selectValue === ALL_SELECT_VALUE) {
+				// When ALL is selected, set selection to exactly the latest available values
+				const latestAll = [...allAvailableOptionStrings];
+				setTempSelection(latestAll);
+			} else {
+				setTempSelection(getSelectValue(variableData.selectedValue, variableData));
+			}
+		}
+		// Apply changes when closing dropdown
+		else if (!visible && tempSelection !== undefined) {
+			// Only call handleChange if there's actually a change in the selection
+			const currentValue = variableData.selectedValue;
+
+			// Helper function to check if arrays have the same elements regardless of order
+			const areArraysEqualIgnoreOrder = (a: any[], b: any[]): boolean => {
+				if (a.length !== b.length) {
+					return false;
+				}
+				const sortedA = [...a].sort();
+				const sortedB = [...b].sort();
+				return areArraysEqual(sortedA, sortedB);
+			};
+
+			// If ALL was selected before and remains ALL after, skip updating
+			const wasAllSelected = enableSelectAll && variableData.allSelected;
+			const isAllSelectedAfter =
+				enableSelectAll &&
+				Array.isArray(tempSelection) &&
+				tempSelection.length === allAvailableOptionStrings.length &&
+				allAvailableOptionStrings.every((v) => tempSelection.includes(v));
+
+			if (wasAllSelected && isAllSelectedAfter) {
+				setTempSelection(undefined);
+				return;
+			}
+
+			const hasChanged =
+				tempSelection !== currentValue &&
+				!(
+					Array.isArray(tempSelection) &&
+					Array.isArray(currentValue) &&
+					areArraysEqualIgnoreOrder(tempSelection, currentValue)
+				);
+
+			if (hasChanged) {
+				handleChange(tempSelection);
+			}
+			setTempSelection(undefined);
+		}
+
+		// Always reset filtered data when dropdown closes, regardless of tempSelection state
+		if (!visible) {
+			setFilteredOptionsData(optionsData);
+			setRelatedValues(originalRelatedValues);
+			setApiSearchText('');
+		}
+	};
+
+	useEffect(
+		() => (): void => {
+			// Cleanup on unmount
+			setTempSelection(undefined);
+			setFilteredOptionsData([]);
+			setRelatedValues([]);
+			setApiSearchText('');
+		},
+		[],
+	);
+
+	// eslint-disable-next-line sonarjs/cognitive-complexity
+	const finalSelectedValues = useMemo(() => {
+		if (variableData.multiSelect) {
+			let value = tempSelection || selectedValue;
+			if (isEmpty(value)) {
+				if (variableData.showALLOption) {
+					if (variableData.defaultValue) {
+						value = variableData.defaultValue;
+					} else if (variableData.allSelected) {
+						// If ALL is selected but no stored values, derive from available options
+						// This handles the case where we don't store values in localStorage for ALL
+						value = allAvailableOptionStrings;
+					} else {
+						value = optionsData;
+					}
+				} else if (variableData.defaultValue) {
+					value = variableData.defaultValue;
+				} else {
+					value = optionsData?.[0];
+				}
+			}
+
+			return value;
+		}
+		if (isEmpty(selectedValue)) {
+			if (variableData.defaultValue) {
+				return variableData.defaultValue;
+			}
+			return optionsData[0]?.toString();
+		}
+
+		return selectedValue;
+	}, [
+		variableData.multiSelect,
+		variableData.showALLOption,
+		variableData.defaultValue,
+		variableData.allSelected,
+		selectedValue,
+		tempSelection,
+		optionsData,
+		allAvailableOptionStrings,
+	]);
+
+	useEffect(() => {
+		if (
+			(variableData.multiSelect && !(tempSelection || selectValue)) ||
+			isEmpty(selectValue)
+		) {
+			handleChange(finalSelectedValues as string[] | string);
+		}
+	}, [
+		finalSelectedValues,
+		handleChange,
+		selectValue,
+		tempSelection,
+		variableData.multiSelect,
+	]);
+
+	return (
+		<div className="variable-item">
+			<Typography.Text className="variable-name" ellipsis>
+				${variableData.name}
+				{variableData.description && (
+					<Tooltip title={variableData.description}>
+						<InfoCircleOutlined className="info-icon" />
+					</Tooltip>
+				)}
+			</Typography.Text>
+			<div className="variable-value">
+				{variableData.multiSelect ? (
+					<CustomMultiSelect
+						key={variableData.id}
+						options={getOptionsForDynamicVariable(
+							filteredOptionsData || [],
+							relatedValues || [],
+						)}
+						defaultValue={variableData.defaultValue}
+						onChange={handleTempChange}
+						bordered={false}
+						placeholder="Select value"
+						placement="bottomLeft"
+						style={SelectItemStyle}
+						loading={isLoading}
+						showSearch
+						data-testid="variable-select"
+						className="variable-select"
+						popupClassName="dropdown-styles"
+						maxTagCount={2}
+						getPopupContainer={popupContainer}
+						value={
+							(tempSelection || selectValue) === ALL_SELECT_VALUE
+								? 'ALL'
+								: tempSelection || selectValue
+						}
+						onDropdownVisibleChange={handleDropdownVisibleChange}
+						errorMessage={errorMessage}
+						// eslint-disable-next-line react/no-unstable-nested-components
+						maxTagPlaceholder={(omittedValues): JSX.Element => {
+							const maxDisplayValues = 10;
+							const valuesToShow = omittedValues.slice(0, maxDisplayValues);
+							const hasMore = omittedValues.length > maxDisplayValues;
+							const tooltipText =
+								valuesToShow.map(({ value }) => value).join(', ') +
+								(hasMore ? ` + ${omittedValues.length - maxDisplayValues} more` : '');
+
+							return (
+								<Tooltip title={tooltipText}>
+									<span>+ {omittedValues.length} </span>
+								</Tooltip>
+							);
+						}}
+						onClear={(): void => {
+							handleChange([]);
+						}}
+						enableAllSelection={enableSelectAll}
+						maxTagTextLength={30}
+						onSearch={handleSearch}
+						onRetry={(): void => {
+							setErrorMessage(null);
+							setIsRetryableError(true);
+							refetch();
+						}}
+						showIncompleteDataMessage={!isComplete && filteredOptionsData.length > 0}
+						isDynamicVariable
+						showRetryButton={isRetryableError}
+					/>
+				) : (
+					<CustomSelect
+						key={variableData.id}
+						onChange={handleChange}
+						bordered={false}
+						placeholder="Select value"
+						style={SelectItemStyle}
+						loading={isLoading}
+						showSearch
+						data-testid="variable-select"
+						className="variable-select"
+						popupClassName="dropdown-styles"
+						getPopupContainer={popupContainer}
+						options={getOptionsForDynamicVariable(
+							filteredOptionsData || [],
+							relatedValues || [],
+						)}
+						value={selectValue}
+						defaultValue={variableData.defaultValue}
+						errorMessage={errorMessage}
+						onSearch={handleSearch}
+						// eslint-disable-next-line sonarjs/no-identical-functions
+						onRetry={(): void => {
+							setErrorMessage(null);
+							setIsRetryableError(true);
+							refetch();
+						}}
+						showIncompleteDataMessage={!isComplete && filteredOptionsData.length > 0}
+						isDynamicVariable
+						showRetryButton={isRetryableError}
+					/>
+				)}
+			</div>
+		</div>
+	);
+}
+
+export default DynamicVariableSelection;
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/QueryVariableInput.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/QueryVariableInput.tsx
@@ -1,249 +0,0 @@
-import { memo, useCallback, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import { useSelector } from 'react-redux';
-import dashboardVariablesQuery from 'api/dashboard/variables/dashboardVariablesQuery';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import sortValues from 'lib/dashboardVariables/sortVariableValues';
-import { isArray, isString } from 'lodash-es';
-import { AppState } from 'store/reducers';
-import { VariableResponseProps } from 'types/api/dashboard/variables/query';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import { variablePropsToPayloadVariables } from '../utils';
-import SelectVariableInput from './SelectVariableInput';
-import { useDashboardVariableSelectHelper } from './useDashboardVariableSelectHelper';
-import { areArraysEqual, checkAPIInvocation } from './util';
-import { VariableItemProps } from './VariableItem';
-import { queryVariableSelectStrategy } from './variableSelectStrategy/queryVariableSelectStrategy';
-
-type QueryVariableInputProps = Pick<
-	VariableItemProps,
-	| 'variableData'
-	| 'existingVariables'
-	| 'onValueUpdate'
-	| 'variablesToGetUpdated'
-	| 'setVariablesToGetUpdated'
-	| 'dependencyData'
->;
-
-function QueryVariableInput({
-	variableData,
-	existingVariables,
-	variablesToGetUpdated,
-	setVariablesToGetUpdated,
-	dependencyData,
-	onValueUpdate,
-}: QueryVariableInputProps): JSX.Element {
-	const [optionsData, setOptionsData] = useState<(string | number | boolean)[]>(
-		[],
-	);
-	const [errorMessage, setErrorMessage] = useState<null | string>(null);
-
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const {
-		tempSelection,
-		setTempSelection,
-		value,
-		defaultValue,
-		enableSelectAll,
-		onChange,
-		onDropdownVisibleChange,
-		handleClear,
-		applyDefaultIfNeeded,
-	} = useDashboardVariableSelectHelper({
-		variableData,
-		optionsData,
-		onValueUpdate,
-		strategy: queryVariableSelectStrategy,
-	});
-
-	const validVariableUpdate = useCallback((): boolean => {
-		if (!variableData.name) {
-			return false;
-		}
-		return Boolean(
-			variablesToGetUpdated.length &&
-				variablesToGetUpdated[0] === variableData.name,
-		);
-	}, [variableData.name, variablesToGetUpdated]);
-
-	const getOptions = useCallback(
-		// eslint-disable-next-line sonarjs/cognitive-complexity
-		(variablesRes: VariableResponseProps | null): void => {
-			try {
-				setErrorMessage(null);
-
-				if (
-					variablesRes?.variableValues &&
-					Array.isArray(variablesRes?.variableValues)
-				) {
-					const newOptionsData = sortValues(
-						variablesRes?.variableValues,
-						variableData.sort,
-					);
-
-					const oldOptionsData = sortValues(optionsData, variableData.sort) as never;
-
-					if (!areArraysEqual(newOptionsData, oldOptionsData)) {
-						let valueNotInList = false;
-
-						if (isArray(variableData.selectedValue)) {
-							variableData.selectedValue.forEach((val) => {
-								if (!newOptionsData.includes(val)) {
-									valueNotInList = true;
-								}
-							});
-						} else if (
-							isString(variableData.selectedValue) &&
-							!newOptionsData.includes(variableData.selectedValue)
-						) {
-							valueNotInList = true;
-						}
-
-						// variablesData.allSelected is added for the case where on change of options we need to update the
-						// local storage
-						if (
-							variableData.name &&
-							(validVariableUpdate() || valueNotInList || variableData.allSelected)
-						) {
-							if (
-								variableData.allSelected &&
-								variableData.multiSelect &&
-								variableData.showALLOption
-							) {
-								onValueUpdate(variableData.name, variableData.id, newOptionsData, true);
-
-								// Update tempSelection to maintain ALL state when dropdown is open
-								if (tempSelection !== undefined) {
-									setTempSelection(newOptionsData.map((option) => option.toString()));
-								}
-							} else {
-								const value = variableData.selectedValue;
-								let allSelected = false;
-
-								if (variableData.multiSelect) {
-									const { selectedValue } = variableData;
-									allSelected =
-										newOptionsData.length > 0 &&
-										Array.isArray(selectedValue) &&
-										newOptionsData.every((option) => selectedValue.includes(option));
-								}
-
-								if (variableData.name && variableData.id) {
-									onValueUpdate(variableData.name, variableData.id, value, allSelected);
-								}
-							}
-						}
-
-						setOptionsData(newOptionsData);
-						// Apply default if no value is selected (e.g., new variable, first load)
-						applyDefaultIfNeeded(newOptionsData);
-					} else {
-						setVariablesToGetUpdated((prev) =>
-							prev.filter((name) => name !== variableData.name),
-						);
-					}
-				}
-			} catch (e) {
-				console.error(e);
-			}
-		},
-		[
-			variableData,
-			optionsData,
-			onValueUpdate,
-			tempSelection,
-			setTempSelection,
-			validVariableUpdate,
-			setVariablesToGetUpdated,
-			applyDefaultIfNeeded,
-		],
-	);
-
-	const { isLoading, refetch } = useQuery(
-		[
-			REACT_QUERY_KEY.DASHBOARD_BY_ID,
-			variableData.name || '',
-			`${minTime}`,
-			`${maxTime}`,
-			JSON.stringify(dependencyData?.order),
-		],
-		{
-			enabled:
-				variableData &&
-				checkAPIInvocation(
-					variablesToGetUpdated,
-					variableData,
-					dependencyData?.parentDependencyGraph,
-				),
-			queryFn: () =>
-				dashboardVariablesQuery({
-					query: variableData.queryValue || '',
-					variables: variablePropsToPayloadVariables(existingVariables),
-				}),
-			refetchOnWindowFocus: false,
-			onSuccess: (response) => {
-				getOptions(response.payload);
-				setVariablesToGetUpdated((prev) =>
-					prev.filter((v) => v !== variableData.name),
-				);
-			},
-			onError: (error: {
-				details: {
-					error: string;
-				};
-			}) => {
-				const { details } = error;
-
-				if (details.error) {
-					let message = details.error;
-					if ((details.error ?? '').toString().includes('Syntax error:')) {
-						message =
-							'Please make sure query is valid and dependent variables are selected';
-					}
-					setErrorMessage(message);
-				}
-				setVariablesToGetUpdated((prev) =>
-					prev.filter((v) => v !== variableData.name),
-				);
-			},
-		},
-	);
-
-	const handleRetry = useCallback((): void => {
-		setErrorMessage(null);
-		refetch();
-	}, [refetch]);
-
-	const selectOptions = useMemo(
-		() =>
-			optionsData.map((option) => ({
-				label: option.toString(),
-				value: option.toString(),
-			})),
-		[optionsData],
-	);
-
-	return (
-		<SelectVariableInput
-			variableId={variableData.id}
-			options={selectOptions}
-			value={value}
-			onChange={onChange}
-			onDropdownVisibleChange={onDropdownVisibleChange}
-			onClear={handleClear}
-			enableSelectAll={enableSelectAll}
-			defaultValue={defaultValue}
-			isMultiSelect={variableData.multiSelect}
-			// query variable specific, API related props
-			loading={isLoading}
-			errorMessage={errorMessage}
-			onRetry={handleRetry}
-		/>
-	);
-}
-
-export default memo(QueryVariableInput);
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/SelectVariableInput.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/SelectVariableInput.tsx
@@ -1,144 +0,0 @@
-import { memo, useMemo } from 'react';
-import { orange } from '@ant-design/colors';
-import { WarningOutlined } from '@ant-design/icons';
-import { Popover, Tooltip, Typography } from 'antd';
-import { CustomMultiSelect, CustomSelect } from 'components/NewSelect';
-import { OptionData } from 'components/NewSelect/types';
-import { popupContainer } from 'utils/selectPopupContainer';
-
-import { ALL_SELECT_VALUE } from '../utils';
-import { SelectItemStyle } from './styles';
-
-const errorIconStyle = { margin: '0 0.5rem' };
-
-interface SelectVariableInputProps {
-	variableId: string;
-	options: OptionData[];
-	value: string | string[] | undefined;
-	enableSelectAll: boolean;
-	isMultiSelect: boolean;
-	onChange: (value: string | string[]) => void;
-	onClear: () => void;
-	defaultValue?: string | string[];
-	onDropdownVisibleChange?: (visible: boolean) => void;
-	loading?: boolean;
-	errorMessage?: string | null;
-	onRetry?: () => void;
-	isDynamicVariable?: boolean;
-	showRetryButton?: boolean;
-	showIncompleteDataMessage?: boolean;
-	onSearch?: (searchTerm: string) => void;
-}
-
-const MAX_TAG_DISPLAY_VALUES = 10;
-
-export const renderMaxTagPlaceholder = (
-	omittedValues: { label?: React.ReactNode; value?: string | number }[],
-): JSX.Element => {
-	const valuesToShow = omittedValues.slice(0, MAX_TAG_DISPLAY_VALUES);
-	const hasMore = omittedValues.length > MAX_TAG_DISPLAY_VALUES;
-	const tooltipText =
-		valuesToShow.map(({ value: v }) => v ?? '').join(', ') +
-		(hasMore ? ` + ${omittedValues.length - MAX_TAG_DISPLAY_VALUES} more` : '');
-
-	return (
-		<Tooltip title={tooltipText}>
-			<span>+ {omittedValues.length} </span>
-		</Tooltip>
-	);
-};
-
-function SelectVariableInput({
-	variableId,
-	options,
-	value,
-	onChange,
-	onDropdownVisibleChange,
-	onClear,
-	loading,
-	errorMessage,
-	onRetry,
-	enableSelectAll,
-	isMultiSelect,
-	defaultValue,
-	isDynamicVariable,
-	showRetryButton,
-	showIncompleteDataMessage,
-	onSearch,
-}: SelectVariableInputProps): JSX.Element {
-	const commonProps = useMemo(
-		() => ({
-			// main props
-			key: variableId,
-			value,
-			defaultValue,
-
-			// setup props
-			placeholder: 'Select value',
-			className: 'variable-select',
-			popupClassName: 'dropdown-styles',
-			getPopupContainer: popupContainer,
-			style: SelectItemStyle,
-			showSearch: true,
-			bordered: false,
-
-			// changing props
-			'data-testid': 'variable-select',
-			onChange,
-			loading,
-			options,
-			errorMessage,
-			onRetry,
-
-			// dynamic variable only props
-			isDynamicVariable,
-			showRetryButton,
-			showIncompleteDataMessage,
-			onSearch,
-		}),
-		[
-			variableId,
-			defaultValue,
-			onChange,
-			loading,
-			options,
-			value,
-			errorMessage,
-			onRetry,
-			isDynamicVariable,
-			showRetryButton,
-			showIncompleteDataMessage,
-			onSearch,
-		],
-	);
-
-	return (
-		<>
-			{isMultiSelect ? (
-				<CustomMultiSelect
-					{...commonProps}
-					placement="bottomLeft"
-					maxTagCount={2}
-					onDropdownVisibleChange={onDropdownVisibleChange}
-					maxTagPlaceholder={renderMaxTagPlaceholder}
-					onClear={onClear}
-					enableAllSelection={enableSelectAll}
-					maxTagTextLength={30}
-					allowClear={value !== ALL_SELECT_VALUE}
-				/>
-			) : (
-				<CustomSelect {...commonProps} />
-			)}
-
-			{errorMessage && (
-				<span style={errorIconStyle}>
-					<Popover placement="top" content={<Typography>{errorMessage}</Typography>}>
-						<WarningOutlined style={{ color: orange[5] }} />
-					</Popover>
-				</span>
-			)}
-		</>
-	);
-}
-
-export default memo(SelectVariableInput);
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/TextboxVariableInput.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/TextboxVariableInput.tsx
@@ -1,85 +0,0 @@
-import { memo, useCallback, useRef, useState } from 'react';
-import { Input, InputRef } from 'antd';
-
-import { VariableItemProps } from './VariableItem';
-
-type TextboxVariableInputProps = Pick<
-	VariableItemProps,
-	'variableData' | 'onValueUpdate'
->;
-
-function TextboxVariableInput({
-	variableData,
-	onValueUpdate,
-}: TextboxVariableInputProps): JSX.Element {
-	const handleChange = useCallback(
-		(inputValue: string | string[]): void => {
-			if (inputValue === variableData.selectedValue) {
-				return;
-			}
-			if (variableData.name) {
-				onValueUpdate(variableData.name, variableData.id, inputValue, false);
-			}
-		},
-		[
-			onValueUpdate,
-			variableData.id,
-			variableData.name,
-			variableData.selectedValue,
-		],
-	);
-
-	const textboxInputRef = useRef<InputRef>(null);
-	const [textboxInputValue, setTextboxInputValue] = useState<string>(
-		(variableData.selectedValue?.toString() ||
-			variableData.defaultValue?.toString()) ??
-			'',
-	);
-
-	const handleInputOnChange = useCallback(
-		(event: React.ChangeEvent<HTMLInputElement>) => {
-			setTextboxInputValue(event.target.value);
-		},
-		[setTextboxInputValue],
-	);
-
-	const handleInputOnBlur = useCallback(
-		(event: React.FocusEvent<HTMLInputElement>): void => {
-			const value = event.target.value.trim();
-			// If empty, reset to default value
-			if (!value && variableData.defaultValue) {
-				setTextboxInputValue(variableData.defaultValue.toString());
-				handleChange(variableData.defaultValue.toString());
-			} else {
-				handleChange(value);
-			}
-		},
-		[handleChange, variableData.defaultValue],
-	);
-
-	const handleInputOnKeyDown = useCallback(
-		(event: React.KeyboardEvent<HTMLInputElement>): void => {
-			if (event.key === 'Enter') {
-				textboxInputRef.current?.blur();
-			}
-		},
-		[],
-	);
-
-	return (
-		<Input
-			key={variableData.id}
-			ref={textboxInputRef}
-			placeholder="Enter value"
-			data-testid={`variable-textbox-${variableData.id}`}
-			bordered={false}
-			value={textboxInputValue}
-			title={textboxInputValue}
-			onChange={handleInputOnChange}
-			onBlur={handleInputOnBlur}
-			onKeyDown={handleInputOnKeyDown}
-		/>
-	);
-}
-
-export default memo(TextboxVariableInput);
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/VariableItem.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/VariableItem.tsx
@@ -1,81 +1,530 @@
-import { memo } from 'react';
-import { InfoCircleOutlined } from '@ant-design/icons';
-import { Tooltip, Typography } from 'antd';
+/* eslint-disable sonarjs/cognitive-complexity */
+/* eslint-disable jsx-a11y/click-events-have-key-events */
+/* eslint-disable jsx-a11y/no-static-element-interactions */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable no-nested-ternary */
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useQuery } from 'react-query';
+import { useSelector } from 'react-redux';
+import { orange } from '@ant-design/colors';
+import { InfoCircleOutlined, WarningOutlined } from '@ant-design/icons';
+import { Input, InputRef, Popover, Tooltip, Typography } from 'antd';
+import dashboardVariablesQuery from 'api/dashboard/variables/dashboardVariablesQuery';
+import { CustomMultiSelect, CustomSelect } from 'components/NewSelect';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { commaValuesParser } from 'lib/dashbaordVariables/customCommaValuesParser';
+import sortValues from 'lib/dashbaordVariables/sortVariableValues';
+import { debounce, isArray, isEmpty, isString } from 'lodash-es';
 import { IDependencyData } from 'providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreTypes';
+import { AppState } from 'store/reducers';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';
+import { VariableResponseProps } from 'types/api/dashboard/variables/query';
+import { GlobalReducer } from 'types/reducer/globalTime';
+import { popupContainer } from 'utils/selectPopupContainer';

-import CustomVariableInput from './CustomVariableInput';
-import DynamicVariableInput from './DynamicVariableInput';
-import QueryVariableInput from './QueryVariableInput';
-import TextboxVariableInput from './TextboxVariableInput';
+import { ALL_SELECT_VALUE, variablePropsToPayloadVariables } from '../utils';
+import { SelectItemStyle } from './styles';
+import { areArraysEqual, checkAPIInvocation } from './util';

 import './DashboardVariableSelection.styles.scss';

-export interface VariableItemProps {
+interface VariableItemProps {
 	variableData: IDashboardVariable;
 	existingVariables: Record<string, IDashboardVariable>;
 	onValueUpdate: (
 		name: string,
 		id: string,
-		value: IDashboardVariable['selectedValue'],
+		arg1: IDashboardVariable['selectedValue'],
 		allSelected: boolean,
-		haveCustomValuesSelected?: boolean,
 	) => void;
 	variablesToGetUpdated: string[];
 	setVariablesToGetUpdated: React.Dispatch<React.SetStateAction<string[]>>;
 	dependencyData: IDependencyData | null;
 }

+export const getSelectValue = (
+	selectedValue: IDashboardVariable['selectedValue'],
+	variableData: IDashboardVariable,
+): string | string[] | undefined => {
+	if (Array.isArray(selectedValue)) {
+		if (!variableData.multiSelect && selectedValue.length === 1) {
+			return selectedValue[0]?.toString();
+		}
+		return selectedValue.map((item) => item.toString());
+	}
+	return selectedValue?.toString();
+};
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
 function VariableItem({
 	variableData,
-	onValueUpdate,
 	existingVariables,
+	onValueUpdate,
 	variablesToGetUpdated,
 	setVariablesToGetUpdated,
 	dependencyData,
 }: VariableItemProps): JSX.Element {
-	const { name, description, type: variableType } = variableData;
+	const [optionsData, setOptionsData] = useState<(string | number | boolean)[]>(
+		[],
+	);
+	const [tempSelection, setTempSelection] = useState<
+		string | string[] | undefined
+	>(undefined);
+
+	// Local state for textbox input to ensure smooth editing experience
+	const [textboxInputValue, setTextboxInputValue] = useState<string>(
+		(variableData.selectedValue?.toString() ||
+			variableData.defaultValue?.toString()) ??
+			'',
+	);
+	const [isTextboxFocused, setIsTextboxFocused] = useState<boolean>(false);
+	const textboxInputRef = useRef<InputRef>(null);
+
+	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	const validVariableUpdate = (): boolean => {
+		if (!variableData.name) {
+			return false;
+		}
+
+		// variableData.name is present as the top element or next in the queue - variablesToGetUpdated
+		return Boolean(
+			variablesToGetUpdated.length &&
+				variablesToGetUpdated[0] === variableData.name,
+		);
+	};
+
+	const [errorMessage, setErrorMessage] = useState<null | string>(null);
+
+	// eslint-disable-next-line sonarjs/cognitive-complexity
+	const getOptions = (variablesRes: VariableResponseProps | null): void => {
+		if (variablesRes && variableData.type === 'QUERY') {
+			try {
+				setErrorMessage(null);
+
+				if (
+					variablesRes?.variableValues &&
+					Array.isArray(variablesRes?.variableValues)
+				) {
+					const newOptionsData = sortValues(
+						variablesRes?.variableValues,
+						variableData.sort,
+					);
+
+					const oldOptionsData = sortValues(optionsData, variableData.sort) as never;
+
+					if (!areArraysEqual(newOptionsData, oldOptionsData)) {
+						/* eslint-disable no-useless-escape */
+
+						let valueNotInList = false;
+
+						if (isArray(variableData.selectedValue)) {
+							variableData.selectedValue.forEach((val) => {
+								const isUsed = newOptionsData.includes(val);
+
+								if (!isUsed) {
+									valueNotInList = true;
+								}
+							});
+						} else if (isString(variableData.selectedValue)) {
+							const isUsed = newOptionsData.includes(variableData.selectedValue);
+
+							if (!isUsed) {
+								valueNotInList = true;
+							}
+						}
+
+						// variablesData.allSelected is added for the case where on change of options we need to update the
+						// local storage
+						if (
+							variableData.type === 'QUERY' &&
+							variableData.name &&
+							(validVariableUpdate() || valueNotInList || variableData.allSelected)
+						) {
+							if (
+								variableData.allSelected &&
+								variableData.multiSelect &&
+								variableData.showALLOption
+							) {
+								onValueUpdate(variableData.name, variableData.id, newOptionsData, true);
+
+								// Update tempSelection to maintain ALL state when dropdown is open
+								if (tempSelection !== undefined) {
+									setTempSelection(newOptionsData.map((option) => option.toString()));
+								}
+							} else {
+								const value = variableData.selectedValue;
+								let allSelected = false;
+
+								if (variableData.multiSelect) {
+									const { selectedValue } = variableData;
+									allSelected =
+										newOptionsData.length > 0 &&
+										Array.isArray(selectedValue) &&
+										newOptionsData.every((option) => selectedValue.includes(option));
+								}
+
+								if (variableData && variableData?.name && variableData?.id) {
+									onValueUpdate(variableData.name, variableData.id, value, allSelected);
+								}
+							}
+						}
+
+						setOptionsData(newOptionsData);
+					} else {
+						setVariablesToGetUpdated((prev) =>
+							prev.filter((name) => name !== variableData.name),
+						);
+					}
+				}
+			} catch (e) {
+				console.error(e);
+			}
+		} else if (variableData.type === 'CUSTOM') {
+			const optionsData = sortValues(
+				commaValuesParser(variableData.customValue || ''),
+				variableData.sort,
+			) as never;
+
+			setOptionsData(optionsData);
+		}
+	};
+
+	const { isLoading, refetch } = useQuery(
+		[
+			REACT_QUERY_KEY.DASHBOARD_BY_ID,
+			variableData.name || '',
+			`${minTime}`,
+			`${maxTime}`,
+			JSON.stringify(dependencyData?.order),
+		],
+		{
+			enabled:
+				variableData &&
+				variableData.type === 'QUERY' &&
+				checkAPIInvocation(
+					variablesToGetUpdated,
+					variableData,
+					dependencyData?.parentDependencyGraph,
+				),
+			queryFn: () =>
+				dashboardVariablesQuery({
+					query: variableData.queryValue || '',
+					variables: variablePropsToPayloadVariables(existingVariables),
+				}),
+			refetchOnWindowFocus: false,
+			onSuccess: (response) => {
+				getOptions(response.payload);
+				setVariablesToGetUpdated((prev) =>
+					prev.filter((v) => v !== variableData.name),
+				);
+			},
+			onError: (error: {
+				details: {
+					error: string;
+				};
+			}) => {
+				const { details } = error;
+
+				if (details.error) {
+					let message = details.error;
+					if ((details.error ?? '').toString().includes('Syntax error:')) {
+						message =
+							'Please make sure query is valid and dependent variables are selected';
+					}
+					setErrorMessage(message);
+				}
+				setVariablesToGetUpdated((prev) =>
+					prev.filter((v) => v !== variableData.name),
+				);
+			},
+		},
+	);
+
+	const handleChange = useCallback(
+		(inputValue: string | string[]): void => {
+			const value = variableData.multiSelect && !inputValue ? [] : inputValue;
+
+			if (
+				value === variableData.selectedValue ||
+				(Array.isArray(value) &&
+					Array.isArray(variableData.selectedValue) &&
+					areArraysEqual(value, variableData.selectedValue))
+			) {
+				return;
+			}
+			if (variableData.name) {
+				// Check if ALL is effectively selected by comparing with available options
+				const isAllSelected =
+					Array.isArray(value) &&
+					value.length > 0 &&
+					optionsData.every((option) => value.includes(option.toString()));
+
+				if (isAllSelected && variableData.showALLOption) {
+					// For ALL selection, pass null to avoid storing values
+					onValueUpdate(variableData.name, variableData.id, optionsData, true);
+				} else {
+					onValueUpdate(variableData.name, variableData.id, value, false);
+				}
+			}
+		},
+		[
+			variableData.multiSelect,
+			variableData.selectedValue,
+			variableData.name,
+			variableData.id,
+			onValueUpdate,
+			optionsData,
+			variableData.showALLOption,
+		],
+	);
+
+	// Add a handler for tracking temporary selection changes
+	const handleTempChange = (inputValue: string | string[]): void => {
+		// Store the selection in temporary state while dropdown is open
+		const value = variableData.multiSelect && !inputValue ? [] : inputValue;
+		setTempSelection(value);
+	};
+
+	// Handle dropdown visibility changes
+	const handleDropdownVisibleChange = (visible: boolean): void => {
+		// Initialize temp selection when opening dropdown
+		if (visible) {
+			setTempSelection(getSelectValue(variableData.selectedValue, variableData));
+		}
+		// Apply changes when closing dropdown
+		else if (!visible && tempSelection !== undefined) {
+			// Call handleChange with the temporarily stored selection
+			handleChange(tempSelection);
+			setTempSelection(undefined);
+		}
+	};
+
+	// do not debounce the above function as we do not need debounce in select variables
+	const debouncedHandleChange = debounce(handleChange, 500);
+
+	const { selectedValue } = variableData;
+	const selectedValueStringified = useMemo(
+		() => getSelectValue(selectedValue, variableData),
+		[selectedValue, variableData],
+	);
+
+	const enableSelectAll = variableData.multiSelect && variableData.showALLOption;
+
+	const selectValue =
+		variableData.allSelected && enableSelectAll
+			? 'ALL'
+			: selectedValueStringified;
+
+	// Apply default value on first render if no selection exists
+	// eslint-disable-next-line sonarjs/cognitive-complexity
+	const finalSelectedValues = useMemo(() => {
+		if (variableData.multiSelect) {
+			let value = tempSelection || selectedValue;
+			if (isEmpty(value)) {
+				if (variableData.showALLOption) {
+					if (variableData.defaultValue) {
+						value = variableData.defaultValue;
+					} else {
+						value = optionsData;
+					}
+				} else if (variableData.defaultValue) {
+					value = variableData.defaultValue;
+				} else {
+					value = optionsData?.[0];
+				}
+			}
+
+			return value;
+		}
+		if (isEmpty(selectedValue)) {
+			if (variableData.defaultValue) {
+				return variableData.defaultValue;
+			}
+			return optionsData[0]?.toString();
+		}
+
+		return selectedValue;
+	}, [
+		variableData.multiSelect,
+		variableData.showALLOption,
+		variableData.defaultValue,
+		selectedValue,
+		tempSelection,
+		optionsData,
+	]);
+
+	useEffect(() => {
+		if (
+			(variableData.multiSelect && !(tempSelection || selectValue)) ||
+			isEmpty(selectValue)
+		) {
+			handleChange(finalSelectedValues as string[] | string);
+		}
+	}, [
+		finalSelectedValues,
+		handleChange,
+		selectValue,
+		tempSelection,
+		variableData.multiSelect,
+	]);
+
+	useEffect(() => {
+		// Fetch options for CUSTOM Type
+		if (variableData.type === 'CUSTOM') {
+			getOptions(null);
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [variableData.type, variableData.customValue]);

 	return (
-		<div className="variable-item">
+		<div className={`variable-item${isTextboxFocused ? ' focused' : ''}`}>
 			<Typography.Text className="variable-name" ellipsis>
-				${name}
-				{description && (
-					<Tooltip title={description}>
+				${variableData.name}
+				{variableData.description && (
+					<Tooltip title={variableData.description}>
 						<InfoCircleOutlined className="info-icon" />
 					</Tooltip>
 				)}
 			</Typography.Text>

 			<div className="variable-value">
-				{variableType === 'TEXTBOX' && (
-					<TextboxVariableInput
-						variableData={variableData}
-						onValueUpdate={onValueUpdate}
+				{variableData.type === 'TEXTBOX' ? (
+					<Input
+						ref={textboxInputRef}
+						placeholder="Enter value"
+						data-testid={`variable-textbox-${variableData.id}`}
+						bordered={false}
+						value={textboxInputValue}
+						title={textboxInputValue}
+						onChange={(e): void => {
+							setTextboxInputValue(e.target.value);
+						}}
+						onFocus={(): void => {
+							setIsTextboxFocused(true);
+						}}
+						onBlur={(e): void => {
+							setIsTextboxFocused(false);
+							const value = e.target.value.trim();
+							// If empty, reset to default value
+							if (!value && variableData.defaultValue) {
+								setTextboxInputValue(variableData.defaultValue.toString());
+								debouncedHandleChange(variableData.defaultValue.toString());
+							} else {
+								debouncedHandleChange(value);
+							}
+						}}
+						onKeyDown={(e): void => {
+							if (e.key === 'Enter') {
+								const value = textboxInputValue.trim();
+								if (!value && variableData.defaultValue) {
+									setTextboxInputValue(variableData.defaultValue.toString());
+									debouncedHandleChange(variableData.defaultValue.toString());
+								} else {
+									debouncedHandleChange(value);
+								}
+								textboxInputRef.current?.blur();
+							}
+						}}
 					/>
+				) : (
+					optionsData &&
+					(variableData.multiSelect ? (
+						<CustomMultiSelect
+							key={
+								selectValue && Array.isArray(selectValue)
+									? selectValue.join(' ')
+									: selectValue || variableData.id
+							}
+							options={optionsData.map((option) => ({
+								label: option.toString(),
+								value: option.toString(),
+							}))}
+							defaultValue={variableData.defaultValue || selectValue}
+							onChange={handleTempChange}
+							bordered={false}
+							placeholder="Select value"
+							placement="bottomLeft"
+							style={SelectItemStyle}
+							loading={isLoading}
+							showSearch
+							data-testid="variable-select"
+							className="variable-select"
+							popupClassName="dropdown-styles"
+							maxTagCount={2}
+							getPopupContainer={popupContainer}
+							value={tempSelection || selectValue}
+							onDropdownVisibleChange={handleDropdownVisibleChange}
+							errorMessage={errorMessage}
+							// eslint-disable-next-line react/no-unstable-nested-components
+							maxTagPlaceholder={(omittedValues): JSX.Element => {
+								const maxDisplayValues = 10;
+								const valuesToShow = omittedValues.slice(0, maxDisplayValues);
+								const hasMore = omittedValues.length > maxDisplayValues;
+								const tooltipText =
+									valuesToShow.map(({ value }) => value).join(', ') +
+									(hasMore ? ` + ${omittedValues.length - maxDisplayValues} more` : '');
+
+								return (
+									<Tooltip title={tooltipText}>
+										<span>+ {omittedValues.length} </span>
+									</Tooltip>
+								);
+							}}
+							onClear={(): void => {
+								handleChange([]);
+							}}
+							enableAllSelection={enableSelectAll}
+							maxTagTextLength={30}
+							allowClear={selectValue !== ALL_SELECT_VALUE && selectValue !== 'ALL'}
+							onRetry={(): void => {
+								setErrorMessage(null);
+								refetch();
+							}}
+						/>
+					) : (
+						<CustomSelect
+							key={
+								selectValue && Array.isArray(selectValue)
+									? selectValue.join(' ')
+									: selectValue || variableData.id
+							}
+							defaultValue={variableData.defaultValue || selectValue}
+							onChange={handleChange}
+							bordered={false}
+							placeholder="Select value"
+							style={SelectItemStyle}
+							loading={isLoading}
+							showSearch
+							data-testid="variable-select"
+							className="variable-select"
+							popupClassName="dropdown-styles"
+							getPopupContainer={popupContainer}
+							options={optionsData.map((option) => ({
+								label: option.toString(),
+								value: option.toString(),
+							}))}
+							value={selectValue}
+							errorMessage={errorMessage}
+							onRetry={(): void => {
+								setErrorMessage(null);
+								refetch();
+							}}
+						/>
+					))
 				)}
-				{variableType === 'CUSTOM' && (
-					<CustomVariableInput
-						variableData={variableData}
-						onValueUpdate={onValueUpdate}
-					/>
-				)}
-				{variableType === 'QUERY' && (
-					<QueryVariableInput
-						variableData={variableData}
-						onValueUpdate={onValueUpdate}
-						existingVariables={existingVariables}
-						variablesToGetUpdated={variablesToGetUpdated}
-						setVariablesToGetUpdated={setVariablesToGetUpdated}
-						dependencyData={dependencyData}
-					/>
-				)}
-				{variableType === 'DYNAMIC' && (
-					<DynamicVariableInput
-						variableData={variableData}
-						onValueUpdate={onValueUpdate}
-						existingVariables={existingVariables}
-					/>
+				{variableData.type !== 'TEXTBOX' && errorMessage && (
+					<span style={{ margin: '0 0.5rem' }}>
+						<Popover
+							placement="top"
+							content={<Typography>{errorMessage}</Typography>}
+						>
+							<WarningOutlined style={{ color: orange[5] }} />
+						</Popover>
+					</span>
 				)}
 			</div>
 		</div>
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/DynamicVariableSelection.test.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/DynamicVariableSelection.test.tsx
@@ -5,7 +5,7 @@ import * as ReactRedux from 'react-redux';
 import { fireEvent, render, screen } from '@testing-library/react';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';

-import DynamicVariableInput from '../DynamicVariableInput';
+import DynamicVariableSelection from '../DynamicVariableSelection';

 // Don't mock the components - use real ones

@@ -54,7 +54,7 @@ const mockApiResponse = {
 // Mock scrollIntoView since it's not available in JSDOM
 window.HTMLElement.prototype.scrollIntoView = jest.fn();

-describe('DynamicVariableInput Component', () => {
+describe('DynamicVariableSelection Component', () => {
 	const mockOnValueUpdate = jest.fn();

 	const mockDynamicVariableData: IDashboardVariable = {
@@ -108,13 +108,18 @@ describe('DynamicVariableInput Component', () => {

 	it('renders with single select variable correctly', () => {
 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={mockDynamicVariableData}
 				existingVariables={mockExistingVariables}
 				onValueUpdate={mockOnValueUpdate}
 			/>,
 		);

+		// Verify component renders correctly
+		expect(
+			screen.getByText(`$${mockDynamicVariableData.name}`),
+		).toBeInTheDocument();
+
 		// Verify the selected value is displayed
 		const selectedItem = screen.getByRole('combobox');
 		expect(selectedItem).toBeInTheDocument();
@@ -131,13 +136,18 @@ describe('DynamicVariableInput Component', () => {
 		};

 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={multiSelectWithAllSelected}
 				existingVariables={mockExistingVariables}
 				onValueUpdate={mockOnValueUpdate}
 			/>,
 		);

+		// Verify variable name is rendered
+		expect(
+			screen.getByText(`$${multiSelectWithAllSelected.name}`),
+		).toBeInTheDocument();
+
 		// In ALL selected mode, there should be an "ALL" text element
 		expect(screen.getByText('ALL')).toBeInTheDocument();
 	});
@@ -154,13 +164,18 @@ describe('DynamicVariableInput Component', () => {
 		});

 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={mockDynamicVariableData}
 				existingVariables={mockExistingVariables}
 				onValueUpdate={mockOnValueUpdate}
 			/>,
 		);

+		// Verify component renders in loading state
+		expect(
+			screen.getByText(`$${mockDynamicVariableData.name}`),
+		).toBeInTheDocument();
+
 		// Open dropdown to see loading text
 		const selectElement = screen.getByRole('combobox');
 		fireEvent.mouseDown(selectElement);
@@ -184,13 +199,18 @@ describe('DynamicVariableInput Component', () => {
 		});

 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={mockDynamicVariableData}
 				existingVariables={mockExistingVariables}
 				onValueUpdate={mockOnValueUpdate}
 			/>,
 		);

+		// Verify the component renders
+		expect(
+			screen.getByText(`$${mockDynamicVariableData.name}`),
+		).toBeInTheDocument();
+
 		// For error states, we should check that error handling is in place
 		// Without opening the dropdown as the error message might be handled differently
 		expect(ReactQuery.useQuery).toHaveBeenCalled();
@@ -199,7 +219,7 @@ describe('DynamicVariableInput Component', () => {

 	it('makes API call to fetch variable values', () => {
 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={mockDynamicVariableData}
 				existingVariables={mockExistingVariables}
 				onValueUpdate={mockOnValueUpdate}
@@ -215,8 +235,6 @@ describe('DynamicVariableInput Component', () => {
 				'2023-01-01T00:00:00Z', // minTime from useSelector mock
 				'2023-01-02T00:00:00Z', // maxTime from useSelector mock
 				'',
-				'Traces',
-				'service.name',
 			],
 			expect.objectContaining({
 				enabled: true, // Type is 'DYNAMIC'
@@ -237,13 +255,16 @@ describe('DynamicVariableInput Component', () => {
 		};

 		render(
-			<DynamicVariableInput
+			<DynamicVariableSelection
 				variableData={customVariable}
 				existingVariables={{ ...mockExistingVariables, custom1: customVariable }}
 				onValueUpdate={mockOnValueUpdate}
 			/>,
 		);

+		// Verify the component correctly displays the selected value
+		expect(screen.getByText(`$${customVariable.name}`)).toBeInTheDocument();
+
 		// Find the selection item in the component using data-testid
 		const selectElement = screen.getByTestId('variable-select');
 		expect(selectElement).toBeInTheDocument();
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/VariableItem.defaulting.behavior.test.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/VariableItem.defaulting.behavior.test.tsx
@@ -63,10 +63,10 @@ describe('VariableItem Default Value Selection Behavior', () => {
 				expect(screen.getByTestId(VARIABLE_SELECT_TESTID)).toBeInTheDocument();
 			});

-			expect(await screen.findByText('option1')).toBeInTheDocument();
+			expect(screen.getByText('option1')).toBeInTheDocument();
 		});

-		test('should auto-select first option when no previous and no default', async () => {
+		test('should show placeholder when no previous and no default', async () => {
 			const variable: IDashboardVariable = {
 				id: TEST_VARIABLE_ID,
 				name: TEST_VARIABLE_NAME,
@@ -85,8 +85,7 @@ describe('VariableItem Default Value Selection Behavior', () => {
 				expect(screen.getByTestId(VARIABLE_SELECT_TESTID)).toBeInTheDocument();
 			});

-			// With the new variable select strategy, the first option is auto-selected
-			expect(await screen.findByText('option1')).toBeInTheDocument();
+			expect(screen.getByText('Select value')).toBeInTheDocument();
 		});
 	});

@@ -111,7 +110,7 @@ describe('VariableItem Default Value Selection Behavior', () => {
 				expect(screen.getByTestId(VARIABLE_SELECT_TESTID)).toBeInTheDocument();
 			});

-			expect(await screen.findByText('ALL')).toBeInTheDocument();
+			expect(screen.getByText('ALL')).toBeInTheDocument();
 		});
 	});

@@ -135,7 +134,7 @@ describe('VariableItem Default Value Selection Behavior', () => {
 				expect(screen.getByTestId(VARIABLE_SELECT_TESTID)).toBeInTheDocument();
 			});

-			expect(await screen.findByText('Select value')).toBeInTheDocument();
+			expect(screen.getByText('Select value')).toBeInTheDocument();
 		});
 	});
 });
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/useDashboardVariableSelectHelper.ts
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/useDashboardVariableSelectHelper.ts
@@ -1,252 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-import { isEmpty } from 'lodash-es';
-import { IDashboardVariable } from 'types/api/dashboard/getAll';
-
-import { ALL_SELECT_VALUE } from '../utils';
-import { areArraysEqual, getSelectValue } from './util';
-import { VariableSelectStrategy } from './variableSelectStrategy/variableSelectStrategyTypes';
-import {
-	areArraysEqualIgnoreOrder,
-	uniqueValues,
-} from './variableSelectStrategy/variableSelectStrategyUtils';
-
-interface UseDashboardVariableSelectHelperParams {
-	variableData: IDashboardVariable;
-	optionsData: (string | number | boolean)[];
-	onValueUpdate: (
-		name: string,
-		id: string,
-		value: IDashboardVariable['selectedValue'],
-		allSelected: boolean,
-		haveCustomValuesSelected?: boolean,
-	) => void;
-	strategy: VariableSelectStrategy;
-	/** Override for all available option strings (default: optionsData.map(String)) */
-	allAvailableOptionStrings?: string[];
-}
-
-interface UseDashboardVariableSelectHelperReturn {
-	// State
-	tempSelection: string | string[] | undefined;
-	setTempSelection: React.Dispatch<
-		React.SetStateAction<string | string[] | undefined>
-	>;
-	value: string | string[] | undefined;
-	defaultValue: string | string[] | undefined;
-
-	// Derived values
-	enableSelectAll: boolean;
-
-	// Handlers
-	onChange: (value: string | string[]) => void;
-	onDropdownVisibleChange: (visible: boolean) => void;
-	handleClear: () => void;
-
-	// Default value helpers
-	applyDefaultIfNeeded: (
-		overrideOptions?: (string | number | boolean)[],
-	) => void;
-}
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function useDashboardVariableSelectHelper({
-	variableData,
-	optionsData,
-	onValueUpdate,
-	strategy,
-	allAvailableOptionStrings,
-}: UseDashboardVariableSelectHelperParams): UseDashboardVariableSelectHelperReturn {
-	const { selectedValue } = variableData;
-
-	const [tempSelection, setTempSelection] = useState<
-		string | string[] | undefined
-	>(undefined);
-
-	const selectedValueStringified = useMemo(
-		() => getSelectValue(selectedValue, variableData),
-		[selectedValue, variableData],
-	);
-
-	const enableSelectAll = variableData.multiSelect && variableData.showALLOption;
-
-	const effectiveAllAvailableOptionStrings = useMemo(
-		() => allAvailableOptionStrings ?? optionsData.map((v) => v.toString()),
-		[allAvailableOptionStrings, optionsData],
-	);
-
-	const selectValue =
-		variableData.allSelected && enableSelectAll
-			? ALL_SELECT_VALUE
-			: selectedValueStringified;
-
-	const getDefaultValue = useCallback(
-		(overrideOptions?: (string | number | boolean)[]) => {
-			const options = overrideOptions || optionsData;
-			if (variableData.multiSelect) {
-				if (variableData.showALLOption) {
-					return variableData.defaultValue || options.map((o) => o.toString());
-				}
-				return variableData.defaultValue || options?.[0]?.toString();
-			}
-			return variableData.defaultValue || options[0]?.toString();
-		},
-		[
-			variableData.multiSelect,
-			variableData.showALLOption,
-			variableData.defaultValue,
-			optionsData,
-		],
-	);
-
-	const defaultValue = useMemo(() => getDefaultValue(), [getDefaultValue]);
-
-	const handleChange = useCallback(
-		(inputValue: string | string[]): void => {
-			const value = variableData.multiSelect && !inputValue ? [] : inputValue;
-
-			if (
-				value === variableData.selectedValue ||
-				(Array.isArray(value) &&
-					Array.isArray(variableData.selectedValue) &&
-					areArraysEqual(value, variableData.selectedValue))
-			) {
-				return;
-			}
-
-			strategy.handleChange({
-				value,
-				variableData,
-				optionsData,
-				allAvailableOptionStrings: effectiveAllAvailableOptionStrings,
-				onValueUpdate,
-			});
-		},
-		[
-			variableData,
-			optionsData,
-			effectiveAllAvailableOptionStrings,
-			onValueUpdate,
-			strategy,
-		],
-	);
-
-	const handleTempChange = useCallback(
-		(inputValue: string | string[]): void => {
-			// Store the selection in temporary state while dropdown is open
-			const value = variableData.multiSelect && !inputValue ? [] : inputValue;
-			setTempSelection(uniqueValues(value));
-		},
-		[variableData.multiSelect],
-	);
-
-	// Single select onChange: apply default if value is empty
-	const handleSingleSelectChange = useCallback(
-		(inputValue: string | string[]): void => {
-			if (isEmpty(inputValue)) {
-				if (defaultValue !== undefined) {
-					handleChange(defaultValue as string | string[]);
-				}
-				return;
-			}
-			handleChange(inputValue);
-		},
-		[handleChange, defaultValue],
-	);
-
-	// Handle dropdown visibility changes
-	const onDropdownVisibleChange = useCallback(
-		(visible: boolean): void => {
-			// Initialize temp selection when opening dropdown
-			if (visible) {
-				if (variableData.allSelected && enableSelectAll) {
-					// When ALL is selected, show all available options as individually checked
-					setTempSelection([...effectiveAllAvailableOptionStrings]);
-				} else {
-					setTempSelection(getSelectValue(variableData.selectedValue, variableData));
-				}
-			}
-			// Apply changes when closing dropdown
-			else if (!visible && tempSelection !== undefined) {
-				// If ALL was selected before AND all options remain selected, skip updating
-				const wasAllSelected = enableSelectAll && variableData.allSelected;
-				const isAllSelectedAfter =
-					enableSelectAll &&
-					Array.isArray(tempSelection) &&
-					tempSelection.length === effectiveAllAvailableOptionStrings.length &&
-					effectiveAllAvailableOptionStrings.every((v) => tempSelection.includes(v));
-
-				if (wasAllSelected && isAllSelectedAfter) {
-					setTempSelection(undefined);
-					return;
-				}
-
-				// Apply default if closing with empty selection
-				let valueToApply = tempSelection;
-				if (isEmpty(tempSelection) && defaultValue !== undefined) {
-					valueToApply = defaultValue as string | string[];
-				}
-
-				// Order-agnostic change detection
-				const currentValue = variableData.selectedValue;
-				const hasChanged =
-					valueToApply !== currentValue &&
-					!(
-						Array.isArray(valueToApply) &&
-						Array.isArray(currentValue) &&
-						areArraysEqualIgnoreOrder(valueToApply, currentValue)
-					);
-
-				if (hasChanged) {
-					handleChange(valueToApply);
-				}
-				setTempSelection(undefined);
-			}
-		},
-		[
-			variableData,
-			enableSelectAll,
-			effectiveAllAvailableOptionStrings,
-			tempSelection,
-			handleChange,
-			defaultValue,
-		],
-	);
-
-	// Explicit function for callers to apply default on mount / data load
-	// Pass overrideOptions when freshly-loaded options aren't in state yet (async callers)
-	const applyDefaultIfNeeded = useCallback(
-		(overrideOptions?: (string | number | boolean)[]): void => {
-			if (isEmpty(selectValue)) {
-				const defaultValueFromOptions = getDefaultValue(overrideOptions);
-				if (defaultValueFromOptions !== undefined) {
-					handleChange(defaultValueFromOptions as string | string[]);
-				}
-			}
-		},
-		[selectValue, handleChange, getDefaultValue],
-	);
-
-	const handleClear = useCallback((): void => {
-		handleChange([]);
-	}, [handleChange]);
-
-	const value = variableData.multiSelect
-		? tempSelection || selectValue
-		: selectValue;
-
-	const onChange = useMemo(() => {
-		return variableData.multiSelect ? handleTempChange : handleSingleSelectChange;
-	}, [variableData.multiSelect, handleTempChange, handleSingleSelectChange]);
-
-	return {
-		tempSelection,
-		setTempSelection,
-		enableSelectAll,
-		onDropdownVisibleChange,
-		handleClear,
-		value,
-		defaultValue,
-		onChange,
-		applyDefaultIfNeeded,
-	};
-}
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/util.ts
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/util.ts
@@ -363,15 +363,21 @@ export const uniqueOptions = (options: OptionData[]): OptionData[] => {
 	return uniqueOptions;
 };

-export const getSelectValue = (
-	selectedValue: IDashboardVariable['selectedValue'],
-	variableData: IDashboardVariable,
-): string | string[] | undefined => {
-	if (Array.isArray(selectedValue)) {
-		if (!variableData.multiSelect && selectedValue.length === 1) {
-			return selectedValue[0]?.toString();
-		}
-		return selectedValue.map((item) => item.toString());
+export const uniqueValues = (values: string[] | string): string[] | string => {
+	if (Array.isArray(values)) {
+		const uniqueValues: string[] = [];
+		const seenValues = new Set<string>();
+
+		values.forEach((value) => {
+			if (seenValues.has(value)) {
+				return;
+			}
+			seenValues.add(value);
+			uniqueValues.push(value);
+		});
+
+		return uniqueValues;
 	}
-	return selectedValue?.toString();
+
+	return values;
 };
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/customVariableSelectStrategy.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/customVariableSelectStrategy.tsx
@@ -1,4 +0,0 @@
-import { defaultVariableSelectStrategy } from './defaultVariableSelectStrategy';
-import { VariableSelectStrategy } from './variableSelectStrategyTypes';
-
-export const customVariableSelectStrategy: VariableSelectStrategy = defaultVariableSelectStrategy;
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/defaultVariableSelectStrategy.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/defaultVariableSelectStrategy.tsx
@@ -1,20 +0,0 @@
-import { VariableSelectStrategy } from './variableSelectStrategyTypes';
-
-export const defaultVariableSelectStrategy: VariableSelectStrategy = {
-	handleChange({ value, variableData, optionsData, onValueUpdate }) {
-		if (!variableData.name) {
-			return;
-		}
-
-		const isAllSelected =
-			Array.isArray(value) &&
-			value.length > 0 &&
-			optionsData.every((option) => value.includes(option.toString()));
-
-		if (isAllSelected && variableData.showALLOption) {
-			onValueUpdate(variableData.name, variableData.id, optionsData, true);
-		} else {
-			onValueUpdate(variableData.name, variableData.id, value, false);
-		}
-	},
-};
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/dynamicVariableSelectStrategy.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/dynamicVariableSelectStrategy.tsx
@@ -1,37 +0,0 @@
-import { ALL_SELECT_VALUE } from 'container/DashboardContainer/utils';
-
-import { VariableSelectStrategy } from './variableSelectStrategyTypes';
-
-export const dynamicVariableSelectStrategy: VariableSelectStrategy = {
-	handleChange({
-		value,
-		variableData,
-		allAvailableOptionStrings,
-		onValueUpdate,
-	}) {
-		if (!variableData.name) {
-			return;
-		}
-
-		if (
-			value === ALL_SELECT_VALUE ||
-			(Array.isArray(value) && value.includes(ALL_SELECT_VALUE))
-		) {
-			onValueUpdate(variableData.name, variableData.id, null, true);
-		} else {
-			// For ALL selection in dynamic variables, pass null to avoid storing values
-			// The parent component will handle this appropriately
-			const haveCustomValuesSelected =
-				Array.isArray(value) &&
-				!value.every((v) => allAvailableOptionStrings.includes(v.toString()));
-
-			onValueUpdate(
-				variableData.name,
-				variableData.id,
-				value,
-				allAvailableOptionStrings.every((v) => value.includes(v.toString())),
-				haveCustomValuesSelected,
-			);
-		}
-	},
-};
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/queryVariableSelectStrategy.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/queryVariableSelectStrategy.tsx
@@ -1,4 +0,0 @@
-import { defaultVariableSelectStrategy } from './defaultVariableSelectStrategy';
-import { VariableSelectStrategy } from './variableSelectStrategyTypes';
-
-export const queryVariableSelectStrategy: VariableSelectStrategy = defaultVariableSelectStrategy;
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/variableSelectStrategyTypes.ts
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/variableSelectStrategyTypes.ts
@@ -1,17 +0,0 @@
-import { IDashboardVariable } from 'types/api/dashboard/getAll';
-
-export interface VariableSelectStrategy {
-	handleChange(params: {
-		value: string | string[];
-		variableData: IDashboardVariable;
-		optionsData: (string | number | boolean)[];
-		allAvailableOptionStrings: string[];
-		onValueUpdate: (
-			name: string,
-			id: string,
-			value: IDashboardVariable['selectedValue'],
-			allSelected: boolean,
-			haveCustomValuesSelected?: boolean,
-		) => void;
-	}): void;
-}
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/variableSelectStrategyUtils.ts
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/variableSelectStrategy/variableSelectStrategyUtils.ts
@@ -1,32 +0,0 @@
-import { isEqual } from 'lodash-es';
-
-export const areArraysEqualIgnoreOrder = (
-	a: (string | number | boolean)[],
-	b: (string | number | boolean)[],
-): boolean => {
-	if (a.length !== b.length) {
-		return false;
-	}
-	const sortedA = [...a].sort();
-	const sortedB = [...b].sort();
-	return isEqual(sortedA, sortedB);
-};
-
-export const uniqueValues = (values: string[] | string): string[] | string => {
-	if (Array.isArray(values)) {
-		const uniqueValues: string[] = [];
-		const seenValues = new Set<string>();
-
-		values.forEach((value) => {
-			if (seenValues.has(value)) {
-				return;
-			}
-			seenValues.add(value);
-			uniqueValues.push(value);
-		});
-
-		return uniqueValues;
-	}
-
-	return values;
-};
--- a/frontend/src/container/DashboardContainer/test/DynamicVariableDefaultBehavior.test.tsx
+++ b/frontend/src/container/DashboardContainer/test/DynamicVariableDefaultBehavior.test.tsx
@@ -2,7 +2,7 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 /* eslint-disable react/jsx-props-no-spreading */
 import React from 'react';
-import { QueryClient, QueryClientProvider, useQuery } from 'react-query';
+import { QueryClient, QueryClientProvider } from 'react-query';
 import * as ReactRedux from 'react-redux';
 import {
 	act,
@@ -15,22 +15,13 @@ import {
 import { getFieldValues } from 'api/dynamicVariables/getFieldValues';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';

-import DynamicVariableInput from '../DashboardVariablesSelection/DynamicVariableInput';
+import DynamicVariableSelection from '../DashboardVariablesSelection/DynamicVariableSelection';

 // Mock the getFieldValues API
 jest.mock('api/dynamicVariables/getFieldValues', () => ({
 	getFieldValues: jest.fn(),
 }));

-// Mock useQuery from react-query
-jest.mock('react-query', () => {
-	const originalModule = jest.requireActual('react-query');
-	return {
-		...originalModule,
-		useQuery: jest.fn(),
-	};
-});
-
 describe('Dynamic Variable Default Behavior', () => {
 	const mockOnValueUpdate = jest.fn();
 	const mockApiResponse = {
@@ -68,46 +59,6 @@ describe('Dynamic Variable Default Behavior', () => {
 		// Mock getFieldValues API to return our test data
 		(getFieldValues as jest.Mock).mockResolvedValue(mockApiResponse);

-		// Mock useQuery implementation to avoid infinite re-renders
-		// and ensure onSuccess is called once
-		(useQuery as jest.Mock).mockImplementation((key, options) => {
-			const { onSuccess, enabled, queryFn } = options || {};
-			const variableName = key[1];
-			const dynamicVarsKey = key[2];
-
-			React.useEffect(() => {
-				if (enabled !== false) {
-					if (onSuccess) {
-						// For 'services' tests:
-						// 1. "Default to ALL" expectations imply empty options -> [] behavior. This happens when selectedValue is undefined (dynamicVarsKey has 'null').
-						// 2. "ALL Option Special Value" needs full options to render the "ALL" item in dropdown. This happens when selectedValue is defined.
-						if (
-							variableName === 'services' &&
-							typeof dynamicVarsKey === 'string' &&
-							dynamicVarsKey.includes('null')
-						) {
-							onSuccess({
-								...mockApiResponse,
-								data: { ...mockApiResponse.data, normalizedValues: [] },
-							});
-						} else {
-							onSuccess(mockApiResponse);
-						}
-					}
-					if (queryFn) {
-						queryFn();
-					}
-				}
-			}, [enabled, variableName, dynamicVarsKey]); // Only depend on enabled/keys
-
-			return {
-				isLoading: false,
-				isError: false,
-				data: mockApiResponse,
-				refetch: jest.fn(),
-			};
-		});
-
 		jest.spyOn(ReactRedux, 'useSelector').mockReturnValue({
 			minTime: '2023-01-01T00:00:00Z',
 			maxTime: '2023-01-02T00:00:00Z',
@@ -133,7 +84,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -169,7 +120,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -213,7 +164,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -221,6 +172,9 @@ describe('Dynamic Variable Default Behavior', () => {
 				);
 			});

+			// Component should render without errors
+			expect(screen.getByText('$service')).toBeInTheDocument();
+
 			// Check if the dropdown is present
 			const selectElement = screen.getByRole('combobox');
 			expect(selectElement).toBeInTheDocument();
@@ -278,7 +232,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -313,7 +267,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -339,7 +293,7 @@ describe('Dynamic Variable Default Behavior', () => {
 			expect(screen.queryByText('backend')).not.toBeInTheDocument();
 		});

-		it('sahould default to ALL when no default and no previous selection', async () => {
+		it('should default to ALL when no default and no previous selection', async () => {
 			const variableData: IDashboardVariable = {
 				id: 'var21',
 				name: 'services',
@@ -357,7 +311,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -391,7 +345,7 @@ describe('Dynamic Variable Default Behavior', () => {
 			expect(mockOnValueUpdate).toHaveBeenCalledWith(
 				'services',
 				'var21',
-				[],
+				[], // Empty array when allSelected is true
 				true, // allSelected = true
 				false,
 			);
@@ -417,7 +371,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -454,7 +408,7 @@ describe('Dynamic Variable Default Behavior', () => {

 			await act(async () => {
 				renderWithQueryClient(
-					<DynamicVariableInput
+					<DynamicVariableSelection
 						variableData={variableData}
 						existingVariables={{ var1: variableData }}
 						onValueUpdate={mockOnValueUpdate}
@@ -462,6 +416,9 @@ describe('Dynamic Variable Default Behavior', () => {
 				);
 			});

+			// Component should render without errors
+			expect(screen.getByText('$services')).toBeInTheDocument();
+
 			// Check if ALL is displayed in the UI (in the main selection area)
 			const allTextElement = screen.getByText('ALL');
 			expect(allTextElement).toBeInTheDocument();
--- a/frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.styles.scss
+++ b/frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.styles.scss
@@ -1,21 +0,0 @@
-.chart-manager-container {
-	width: 100%;
-	max-height: calc(40% - 40px);
-	display: flex;
-	flex-direction: column;
-	gap: 16px;
-
-	.chart-manager-header {
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		gap: 16px;
-
-		.chart-manager-actions-container {
-			display: flex;
-			justify-content: flex-end;
-			align-items: center;
-			gap: 8px;
-		}
-	}
-}
--- a/frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/components/ChartManager/ChartManager.tsx
@@ -1,147 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { Button, Input } from 'antd';
-import { ResizeTable } from 'components/ResizeTable';
-import { getGraphManagerTableColumns } from 'container/GridCardLayout/GridCard/FullView/TableRender/GraphManagerColumns';
-import { ExtendedChartDataset } from 'container/GridCardLayout/GridCard/FullView/types';
-import { getDefaultTableDataSet } from 'container/GridCardLayout/GridCard/FullView/utils';
-import { useNotifications } from 'hooks/useNotifications';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { usePlotContext } from 'lib/uPlotV2/context/PlotContext';
-import useLegendsSync from 'lib/uPlotV2/hooks/useLegendsSync';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
-
-import './ChartManager.styles.scss';
-
-interface ChartManagerProps {
-	config: UPlotConfigBuilder;
-	alignedData: uPlot.AlignedData;
-	yAxisUnit?: string;
-	onCancel?: () => void;
-}
-
-/**
- * ChartManager provides a tabular view to manage the visibility of
- * individual series on a uPlot chart.
- *
- * It syncs with the legend state coming from the plot context and
- * allows users to:
- * - filter series by label
- * - toggle individual series on/off
- * - persist the visibility configuration to local storage.
- *
- * @param config - `UPlotConfigBuilder` instance used to derive chart options.
- * @param alignedData - uPlot aligned data used to build the initial table dataset.
- * @param yAxisUnit - Optional unit label for Y-axis values shown in the table.
- * @param onCancel - Optional callback invoked when the user cancels the dialog.
- */
-export default function ChartManager({
-	config,
-	alignedData,
-	yAxisUnit,
-	onCancel,
-}: ChartManagerProps): JSX.Element {
-	const { notifications } = useNotifications();
-	const { legendItemsMap } = useLegendsSync({
-		config,
-		subscribeToFocusChange: false,
-	});
-	const {
-		onToggleSeriesOnOff,
-		onToggleSeriesVisibility,
-		syncSeriesVisibilityToLocalStorage,
-	} = usePlotContext();
-	const { isDashboardLocked } = useDashboard();
-
-	const [tableDataSet, setTableDataSet] = useState<ExtendedChartDataset[]>(() =>
-		getDefaultTableDataSet(config.getConfig() as uPlot.Options, alignedData),
-	);
-
-	const graphVisibilityState = useMemo(
-		() =>
-			Object.entries(legendItemsMap).reduce<boolean[]>((acc, [key, item]) => {
-				acc[Number(key)] = item.show;
-				return acc;
-			}, []),
-		[legendItemsMap],
-	);
-
-	useEffect(() => {
-		setTableDataSet(
-			getDefaultTableDataSet(config.getConfig() as uPlot.Options, alignedData),
-		);
-	}, [alignedData, config]);
-
-	const filterHandler = useCallback(
-		(event: React.ChangeEvent<HTMLInputElement>): void => {
-			const value = event.target.value.toString().toLowerCase();
-			const updatedDataSet = tableDataSet.map((item) => {
-				if (item.label?.toLocaleLowerCase().includes(value)) {
-					return { ...item, show: true };
-				}
-				return { ...item, show: false };
-			});
-			setTableDataSet(updatedDataSet);
-		},
-		[tableDataSet],
-	);
-
-	const dataSource = useMemo(
-		() =>
-			tableDataSet.filter(
-				(item, index) => index !== 0 && item.show, // skipping the first item as it is the x-axis
-			),
-		[tableDataSet],
-	);
-
-	const columns = useMemo(
-		() =>
-			getGraphManagerTableColumns({
-				tableDataSet,
-				checkBoxOnChangeHandler: (_e, index) => {
-					onToggleSeriesOnOff(index);
-				},
-				graphVisibilityState,
-				labelClickedHandler: onToggleSeriesVisibility,
-				yAxisUnit,
-				isGraphDisabled: isDashboardLocked,
-			}),
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[tableDataSet, graphVisibilityState, yAxisUnit, isDashboardLocked],
-	);
-
-	const handleSave = useCallback((): void => {
-		syncSeriesVisibilityToLocalStorage();
-		notifications.success({
-			message: 'The updated graphs & legends are saved',
-		});
-		if (onCancel) {
-			onCancel();
-		}
-	}, [syncSeriesVisibilityToLocalStorage, notifications, onCancel]);
-
-	return (
-		<div className="chart-manager-container">
-			<div className="chart-manager-header">
-				<Input onChange={filterHandler} placeholder="Filter Series" />
-				<div className="chart-manager-actions-container">
-					<Button type="default" onClick={onCancel}>
-						Cancel
-					</Button>
-					<Button type="primary" onClick={handleSave}>
-						Save
-					</Button>
-				</div>
-			</div>
-			<div className="chart-manager-table-container">
-				<ResizeTable
-					columns={columns}
-					dataSource={dataSource}
-					virtual
-					rowKey="index"
-					scroll={{ y: 200 }}
-					pagination={false}
-				/>
-			</div>
-		</div>
-	);
-}
--- a/frontend/src/container/DashboardContainer/visualization/hooks/usePanelContextMenu.ts
+++ b/frontend/src/container/DashboardContainer/visualization/hooks/usePanelContextMenu.ts
@@ -1,120 +0,0 @@
-import { useCallback } from 'react';
-import { UseQueryResult } from 'react-query';
-import {
-	getTimeRangeFromStepInterval,
-	isApmMetric,
-} from 'container/PanelWrapper/utils';
-import { getUplotClickData } from 'container/QueryTable/Drilldown/drilldownUtils';
-import useGraphContextMenu from 'container/QueryTable/Drilldown/useGraphContextMenu';
-import {
-	PopoverPosition,
-	useCoordinates,
-} from 'periscope/components/ContextMenu';
-import { SuccessResponse } from 'types/api';
-import { Widgets } from 'types/api/dashboard/getAll';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import { DataSource } from 'types/common/queryBuilder';
-
-interface UseTimeSeriesContextMenuParams {
-	widget: Widgets;
-	queryResponse: UseQueryResult<
-		SuccessResponse<MetricRangePayloadProps, unknown>,
-		Error
-	>;
-}
-
-export const usePanelContextMenu = ({
-	widget,
-	queryResponse,
-}: UseTimeSeriesContextMenuParams): {
-	coordinates: { x: number; y: number } | null;
-	popoverPosition: PopoverPosition | null;
-	onClose: () => void;
-	menuItemsConfig: {
-		header?: string | React.ReactNode;
-		items?: React.ReactNode;
-	};
-	clickHandlerWithContextMenu: (...args: any[]) => void;
-} => {
-	const {
-		coordinates,
-		popoverPosition,
-		clickedData,
-		onClose,
-		subMenu,
-		onClick,
-		setSubMenu,
-	} = useCoordinates();
-
-	const { menuItemsConfig } = useGraphContextMenu({
-		widgetId: widget.id || '',
-		query: widget.query,
-		graphData: clickedData,
-		onClose,
-		coordinates,
-		subMenu,
-		setSubMenu,
-		contextLinks: widget.contextLinks,
-		panelType: widget.panelTypes,
-		queryRange: queryResponse,
-	});
-
-	const clickHandlerWithContextMenu = useCallback(
-		(...args: any[]) => {
-			const [
-				xValue,
-				_yvalue,
-				_mouseX,
-				_mouseY,
-				metric,
-				queryData,
-				absoluteMouseX,
-				absoluteMouseY,
-				axesData,
-				focusedSeries,
-			] = args;
-
-			const data = getUplotClickData({
-				metric,
-				queryData,
-				absoluteMouseX,
-				absoluteMouseY,
-				focusedSeries,
-			});
-
-			let timeRange;
-
-			if (axesData && queryData?.queryName) {
-				const compositeQuery = (queryResponse?.data?.params as any)?.compositeQuery;
-
-				if (compositeQuery?.queries) {
-					const specificQuery = compositeQuery.queries.find(
-						(query: any) => query.spec?.name === queryData.queryName,
-					);
-
-					const stepInterval = specificQuery?.spec?.stepInterval || 60;
-
-					timeRange = getTimeRangeFromStepInterval(
-						stepInterval,
-						metric?.clickedTimestamp || xValue,
-						specificQuery?.spec?.signal === DataSource.METRICS &&
-							isApmMetric(specificQuery?.spec?.aggregations[0]?.metricName),
-					);
-				}
-			}
-
-			if (data && data?.record?.queryName) {
-				onClick(data.coord, { ...data.record, label: data.label, timeRange });
-			}
-		},
-		[onClick, queryResponse],
-	);
-
-	return {
-		coordinates,
-		popoverPosition,
-		onClose,
-		menuItemsConfig,
-		clickHandlerWithContextMenu,
-	};
-};
--- a/frontend/src/container/DashboardContainer/visualization/panels/Panel.styles.scss
+++ b/frontend/src/container/DashboardContainer/visualization/panels/Panel.styles.scss
@@ -1,4 +0,0 @@
-.panel-container {
-	height: 100%;
-	width: 100%;
-}
--- a/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx
@@ -1,148 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
-import TimeSeries from 'container/DashboardContainer/visualization/charts/TimeSeries/TimeSeries';
-import ChartManager from 'container/DashboardContainer/visualization/components/ChartManager/ChartManager';
-import { usePanelContextMenu } from 'container/DashboardContainer/visualization/hooks/usePanelContextMenu';
-import { PanelWrapperProps } from 'container/PanelWrapper/panelWrapper.types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import { useResizeObserver } from 'hooks/useDimensions';
-import { LegendPosition } from 'lib/uPlotV2/components/types';
-import { ContextMenu } from 'periscope/components/ContextMenu';
-import { useDashboard } from 'providers/Dashboard/Dashboard';
-import { useTimezone } from 'providers/Timezone';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import uPlot from 'uplot';
-import { getTimeRange } from 'utils/getTimeRange';
-
-import { prepareChartData, prepareUPlotConfig } from '../TimeSeriesPanel/utils';
-
-import '../Panel.styles.scss';
-
-function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
-	const {
-		panelMode,
-		queryResponse,
-		widget,
-		onDragSelect,
-		isFullViewMode,
-		onToggleModelHandler,
-	} = props;
-	const { toScrollWidgetId, setToScrollWidgetId } = useDashboard();
-	const graphRef = useRef<HTMLDivElement>(null);
-	const [minTimeScale, setMinTimeScale] = useState<number>();
-	const [maxTimeScale, setMaxTimeScale] = useState<number>();
-	const containerDimensions = useResizeObserver(graphRef);
-
-	const isDarkMode = useIsDarkMode();
-	const { timezone } = useTimezone();
-
-	useEffect(() => {
-		if (toScrollWidgetId === widget.id) {
-			graphRef.current?.scrollIntoView({
-				behavior: 'smooth',
-				block: 'center',
-			});
-			graphRef.current?.focus();
-			setToScrollWidgetId('');
-		}
-	}, [toScrollWidgetId, setToScrollWidgetId, widget.id]);
-
-	useEffect((): void => {
-		const { startTime, endTime } = getTimeRange(queryResponse);
-
-		setMinTimeScale(startTime);
-		setMaxTimeScale(endTime);
-	}, [queryResponse]);
-
-	const {
-		coordinates,
-		popoverPosition,
-		onClose,
-		menuItemsConfig,
-		clickHandlerWithContextMenu,
-	} = usePanelContextMenu({
-		widget,
-		queryResponse,
-	});
-
-	const chartData = useMemo(() => {
-		if (!queryResponse?.data?.payload) {
-			return [];
-		}
-		return prepareChartData(queryResponse?.data?.payload);
-	}, [queryResponse?.data?.payload]);
-
-	const config = useMemo(() => {
-		return prepareUPlotConfig({
-			widget,
-			isDarkMode,
-			currentQuery: widget.query,
-			onClick: clickHandlerWithContextMenu,
-			onDragSelect,
-			apiResponse: queryResponse?.data?.payload as MetricRangePayloadProps,
-			timezone,
-			panelMode,
-			minTimeScale: minTimeScale,
-			maxTimeScale: maxTimeScale,
-		});
-	}, [
-		widget,
-		isDarkMode,
-		clickHandlerWithContextMenu,
-		onDragSelect,
-		queryResponse?.data?.payload,
-		panelMode,
-		minTimeScale,
-		maxTimeScale,
-		timezone,
-	]);
-
-	const layoutChildren = useMemo(() => {
-		if (!isFullViewMode) {
-			return null;
-		}
-		return (
-			<ChartManager
-				config={config}
-				alignedData={chartData}
-				yAxisUnit={widget.yAxisUnit}
-				onCancel={onToggleModelHandler}
-			/>
-		);
-	}, [
-		isFullViewMode,
-		config,
-		chartData,
-		widget.yAxisUnit,
-		onToggleModelHandler,
-	]);
-
-	return (
-		<div className="panel-container" ref={graphRef}>
-			{containerDimensions.width > 0 && containerDimensions.height > 0 && (
-				<TimeSeries
-					config={config}
-					legendConfig={{
-						position: widget?.legendPosition ?? LegendPosition.BOTTOM,
-					}}
-					yAxisUnit={widget.yAxisUnit}
-					decimalPrecision={widget.decimalPrecision}
-					timezone={timezone.value}
-					data={chartData as uPlot.AlignedData}
-					width={containerDimensions.width}
-					height={containerDimensions.height}
-					layoutChildren={layoutChildren}
-				>
-					<ContextMenu
-						coordinates={coordinates}
-						popoverPosition={popoverPosition}
-						title={menuItemsConfig.header as string}
-						items={menuItemsConfig.items}
-						onClose={onClose}
-					/>
-				</TimeSeries>
-			)}
-		</div>
-	);
-}
-
-export default TimeSeriesPanel;
--- a/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts
+++ b/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts
@@ -1,97 +0,0 @@
-import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import {
-	fillMissingXAxisTimestamps,
-	getXAxisTimestamps,
-} from 'container/DashboardContainer/visualization/panels/utils';
-import { getLegend } from 'lib/dashboard/getQueryResults';
-import getLabelName from 'lib/getLabelName';
-import { OnClickPluginOpts } from 'lib/uPlotLib/plugins/onClickPlugin';
-import {
-	DrawStyle,
-	LineInterpolation,
-	LineStyle,
-	VisibilityMode,
-} from 'lib/uPlotV2/config/types';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { Widgets } from 'types/api/dashboard/getAll';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { PanelMode } from '../types';
-import { buildBaseConfig } from '../utils/baseConfigBuilder';
-
-export const prepareChartData = (
-	apiResponse: MetricRangePayloadProps,
-): uPlot.AlignedData => {
-	const seriesList = apiResponse?.data?.result || [];
-	const timestampArr = getXAxisTimestamps(seriesList);
-	const yAxisValuesArr = fillMissingXAxisTimestamps(timestampArr, seriesList);
-
-	return [timestampArr, ...yAxisValuesArr];
-};
-
-export const prepareUPlotConfig = ({
-	widget,
-	isDarkMode,
-	currentQuery,
-	onClick,
-	onDragSelect,
-	apiResponse,
-	timezone,
-	panelMode,
-	minTimeScale,
-	maxTimeScale,
-}: {
-	widget: Widgets;
-	isDarkMode: boolean;
-	currentQuery: Query;
-	onClick: OnClickPluginOpts['onClick'];
-	onDragSelect: (startTime: number, endTime: number) => void;
-	apiResponse: MetricRangePayloadProps;
-	timezone: Timezone;
-	panelMode: PanelMode;
-	minTimeScale?: number;
-	maxTimeScale?: number;
-}): UPlotConfigBuilder => {
-	const builder = buildBaseConfig({
-		widget,
-		isDarkMode,
-		onClick,
-		onDragSelect,
-		apiResponse,
-		timezone,
-		panelMode,
-		panelType: PANEL_TYPES.TIME_SERIES,
-		minTimeScale,
-		maxTimeScale,
-	});
-
-	apiResponse.data?.result?.forEach((series) => {
-		const baseLabelName = getLabelName(
-			series.metric,
-			series.queryName || '', // query
-			series.legend || '',
-		);
-
-		const label = currentQuery
-			? getLegend(series, currentQuery, baseLabelName)
-			: baseLabelName;
-
-		builder.addSeries({
-			scaleKey: 'y',
-			drawStyle: DrawStyle.Line,
-			label: label,
-			colorMapping: widget.customLegendColors ?? {},
-			spanGaps: false,
-			lineStyle: LineStyle.Solid,
-			lineInterpolation: LineInterpolation.Spline,
-			showPoints: VisibilityMode.Never,
-			pointSize: 5,
-			isDarkMode,
-			panelType: PANEL_TYPES.TIME_SERIES,
-		});
-	});
-
-	return builder;
-};
--- a/frontend/src/container/DashboardContainer/visualization/panels/utils/baseConfigBuilder.ts
+++ b/frontend/src/container/DashboardContainer/visualization/panels/utils/baseConfigBuilder.ts
@@ -1,127 +0,0 @@
-import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import onClickPlugin, {
-	OnClickPluginOpts,
-} from 'lib/uPlotLib/plugins/onClickPlugin';
-import {
-	DistributionType,
-	SelectionPreferencesSource,
-} from 'lib/uPlotV2/config/types';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { ThresholdsDrawHookOptions } from 'lib/uPlotV2/hooks/types';
-import { Widgets } from 'types/api/dashboard/getAll';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import uPlot from 'uplot';
-
-import { PanelMode } from '../types';
-
-export interface BaseConfigBuilderProps {
-	widget: Widgets;
-	apiResponse: MetricRangePayloadProps;
-	isDarkMode: boolean;
-	onClick: OnClickPluginOpts['onClick'];
-	onDragSelect: (startTime: number, endTime: number) => void;
-	timezone: Timezone;
-	panelMode: PanelMode;
-	panelType: PANEL_TYPES;
-	minTimeScale?: number;
-	maxTimeScale?: number;
-}
-
-export function buildBaseConfig({
-	widget,
-	isDarkMode,
-	onClick,
-	onDragSelect,
-	apiResponse,
-	timezone,
-	panelMode,
-	panelType,
-	minTimeScale,
-	maxTimeScale,
-}: BaseConfigBuilderProps): UPlotConfigBuilder {
-	const tzDate = (timestamp: number): Date =>
-		uPlot.tzDate(new Date(timestamp * 1e3), timezone.value);
-
-	const builder = new UPlotConfigBuilder({
-		onDragSelect,
-		widgetId: widget.id,
-		tzDate,
-		shouldSaveSelectionPreference: panelMode === PanelMode.DASHBOARD_VIEW,
-		selectionPreferencesSource: [
-			PanelMode.DASHBOARD_VIEW,
-			PanelMode.STANDALONE_VIEW,
-		].includes(panelMode)
-			? SelectionPreferencesSource.LOCAL_STORAGE
-			: SelectionPreferencesSource.IN_MEMORY,
-	});
-
-	const thresholdOptions: ThresholdsDrawHookOptions = {
-		scaleKey: 'y',
-		thresholds: (widget.thresholds || []).map((threshold) => ({
-			thresholdValue: threshold.thresholdValue ?? 0,
-			thresholdColor: threshold.thresholdColor,
-			thresholdUnit: threshold.thresholdUnit,
-			thresholdLabel: threshold.thresholdLabel,
-		})),
-		yAxisUnit: widget.yAxisUnit,
-	};
-
-	builder.addThresholds(thresholdOptions);
-
-	builder.addScale({
-		scaleKey: 'x',
-		time: true,
-		min: minTimeScale,
-		max: maxTimeScale,
-		logBase: widget.isLogScale ? 10 : undefined,
-		distribution: widget.isLogScale
-			? DistributionType.Logarithmic
-			: DistributionType.Linear,
-	});
-
-	// Y scale – value axis, driven primarily by softMin/softMax and data
-	builder.addScale({
-		scaleKey: 'y',
-		time: false,
-		min: undefined,
-		max: undefined,
-		softMin: widget.softMin ?? undefined,
-		softMax: widget.softMax ?? undefined,
-		// thresholds,
-		logBase: widget.isLogScale ? 10 : undefined,
-		distribution: widget.isLogScale
-			? DistributionType.Logarithmic
-			: DistributionType.Linear,
-	});
-
-	if (typeof onClick === 'function') {
-		builder.addPlugin(
-			onClickPlugin({
-				onClick,
-				apiResponse,
-			}),
-		);
-	}
-
-	builder.addAxis({
-		scaleKey: 'x',
-		show: true,
-		side: 2,
-		isDarkMode,
-		isLogScale: widget.isLogScale,
-		panelType,
-	});
-
-	builder.addAxis({
-		scaleKey: 'y',
-		show: true,
-		side: 3,
-		isDarkMode,
-		isLogScale: widget.isLogScale,
-		yAxisUnit: widget.yAxisUnit,
-		panelType,
-	});
-
-	return builder;
-}
--- a/frontend/src/container/DashboardContainer/visualization/panels/utils/index.ts
+++ b/frontend/src/container/DashboardContainer/visualization/panels/utils/index.ts
@@ -1,54 +0,0 @@
-import { normalizePlotValue } from 'lib/uPlotV2/utils/dataUtils';
-import { QueryData } from 'types/api/widgets/getQuery';
-
-export function getXAxisTimestamps(seriesList: QueryData[]): number[] {
-	const timestamps = new Set<number>();
-
-	seriesList.forEach((series: { values?: [number, string][] }) => {
-		if (series?.values) {
-			series.values.forEach((value) => {
-				timestamps.add(value[0]);
-			});
-		}
-	});
-
-	const timestampsArr = Array.from(timestamps);
-	timestampsArr.sort((a, b) => a - b);
-
-	return timestampsArr;
-}
-
-export function fillMissingXAxisTimestamps(
-	timestampArr: number[],
-	data: Array<{ values?: [number, string][] }>,
-): (number | null)[][] {
-	// Ensure we work with a sorted, de‑duplicated list of x-axis timestamps
-	const canonicalTimestamps = Array.from(new Set(timestampArr)).sort(
-		(a, b) => a - b,
-	);
-
-	return data.map(({ values }) =>
-		buildSeriesYValues(canonicalTimestamps, values),
-	);
-}
-
-function buildSeriesYValues(
-	timestamps: number[],
-	values?: [number, string][],
-): (number | null)[] {
-	if (!values?.length) {
-		return [];
-	}
-
-	const valueByTimestamp = new Map<number, number | null>();
-
-	for (let i = 0; i < values.length; i++) {
-		const [timestamp, rawValue] = values[i];
-		valueByTimestamp.set(timestamp, normalizePlotValue(rawValue));
-	}
-
-	return timestamps.map((timestamp) => {
-		const value = valueByTimestamp.get(timestamp);
-		return value !== undefined ? value : null;
-	});
-}
--- a/frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx
@@ -33,8 +33,8 @@ import { useChartMutable } from 'hooks/useChartMutable';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import GetMinMax from 'lib/getMinMax';
 import { isEmpty } from 'lodash-es';
 import { useAppContext } from 'providers/App/App';
--- a/frontend/src/container/GridCardLayout/GridCard/index.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/index.tsx
@@ -8,8 +8,8 @@ import { populateMultipleResults } from 'container/NewWidget/LeftContainer/Widge
 import { CustomTimeType } from 'container/TopNav/DateTimeSelectionV2/types';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useIntersectionObserver } from 'hooks/useIntersectionObserver';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import getTimeString from 'lib/getTimeString';
 import { isEqual } from 'lodash-es';
 import isEmpty from 'lodash-es/isEmpty';
--- a/frontend/src/container/GridCardLayout/useResolveQuery.ts
+++ b/frontend/src/container/GridCardLayout/useResolveQuery.ts
@@ -6,7 +6,7 @@ import { prepareQueryRangePayloadV5 } from 'api/v5/v5';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { timePreferenceType } from 'container/NewWidget/RightContainer/timeItems';
 import { useDashboardVariablesByType } from 'hooks/dashboard/useDashboardVariablesByType';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { AppState } from 'store/reducers';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
--- a/frontend/src/container/NewWidget/index.tsx
+++ b/frontend/src/container/NewWidget/index.tsx
@@ -27,8 +27,8 @@ import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import createQueryParams from 'lib/createQueryParams';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import { cloneDeep, defaultTo, isEmpty, isUndefined } from 'lodash-es';
 import { Check, X } from 'lucide-react';
 import { DashboardWidgetPageParams } from 'pages/DashboardWidget';
--- a/frontend/src/container/ServiceApplication/utils.ts
+++ b/frontend/src/container/ServiceApplication/utils.ts
@@ -1,8 +1,8 @@
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { getWidgetQueryBuilder } from 'container/MetricsApplication/MetricsApplication.factory';
 import { updateStepInterval } from 'hooks/queryBuilder/useStepInterval';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import { ServicesList } from 'types/api/metrics/getService';
 import { QueryDataV3 } from 'types/api/widgets/getQuery';
 import { EQueryType } from 'types/common/dashboard';
--- a/frontend/src/hooks/queryBuilder/useCreateAlerts.tsx
+++ b/frontend/src/hooks/queryBuilder/useCreateAlerts.tsx
@@ -13,7 +13,7 @@ import { MenuItemKeys } from 'container/GridCardLayout/WidgetHeader/contants';
 import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
 import { useDashboardVariablesByType } from 'hooks/dashboard/useDashboardVariablesByType';
 import { useNotifications } from 'hooks/useNotifications';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { isEmpty } from 'lodash-es';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
--- a/frontend/src/hooks/queryBuilder/useGetWidgetQueryRange.ts
+++ b/frontend/src/hooks/queryBuilder/useGetWidgetQueryRange.ts
@@ -3,8 +3,8 @@ import { useSelector } from 'react-redux';
 import { initialQueriesMap } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { useDashboardVariables } from 'hooks/dashboard/useDashboardVariables';
+import { getDashboardVariables } from 'lib/dashbaordVariables/getDashboardVariables';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { getDashboardVariables } from 'lib/dashboardVariables/getDashboardVariables';
 import { AppState } from 'store/reducers';
 import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
--- a/frontend/src/lib/dashbaordVariables/customCommaValuesParser.ts
+++ b/frontend/src/lib/dashbaordVariables/customCommaValuesParser.ts
--- a/frontend/src/lib/dashbaordVariables/getDashboardVariables.ts
+++ b/frontend/src/lib/dashbaordVariables/getDashboardVariables.ts
--- a/frontend/src/lib/dashbaordVariables/sortVariableValues.ts
+++ b/frontend/src/lib/dashbaordVariables/sortVariableValues.ts
--- a/frontend/src/lib/uPlotLib/utils/tests/getSeriesData.test.ts
+++ b/frontend/src/lib/uPlotLib/utils/tests/getSeriesData.test.ts
@@ -14,7 +14,7 @@ describe('Get Series Data', () => {
 		expect(seriesData.length).toBe(5);
 		expect(seriesData[1].label).toBe('firstLegend');
 		expect(seriesData[1].show).toBe(true);
-		expect(seriesData[1].fill).toBe('#FF6F91');
+		expect(seriesData[1].fill).toBe('#C71585');
 		expect(seriesData[1].width).toBe(2);
 	});

--- a/frontend/src/lib/uPlotV2/components/Legend/Legend.styles.scss
+++ b/frontend/src/lib/uPlotV2/components/Legend/Legend.styles.scss
@@ -24,14 +24,6 @@
 		opacity: 1;
 	}

-	.legend-empty-state {
-		font-size: 12px;
-		color: var(--bg-vanilla-400);
-		text-align: center;
-		padding: 12px;
-		padding: 2rem 0;
-	}
-
 	.legend-virtuoso-container {
 		height: 100%;
 		width: 100%;
--- a/frontend/src/lib/uPlotV2/components/Legend/Legend.tsx
+++ b/frontend/src/lib/uPlotV2/components/Legend/Legend.tsx
@@ -81,13 +81,6 @@ export default function Legend({
 		[focusedSeriesIndex, position],
 	);

-	const isEmptyState = useMemo(() => {
-		if (position !== LegendPosition.RIGHT || !legendSearchQuery.trim()) {
-			return false;
-		}
-		return visibleLegendItems.length === 0;
-	}, [position, legendSearchQuery, visibleLegendItems]);
-
 	return (
 		<div
 			ref={legendContainerRef}
@@ -110,21 +103,15 @@ export default function Legend({
 					/>
 				</div>
 			)}
-			{isEmptyState ? (
-				<div className="legend-empty-state">
-					No series found matching &quot;{legendSearchQuery}&quot;
-				</div>
-			) : (
-				<VirtuosoGrid
-					className={cx(
-						'legend-virtuoso-container',
-						`legend-virtuoso-container-${position.toLowerCase()}`,
-						{ 'legend-virtuoso-container-single-row': isSingleRow },
-					)}
-					data={visibleLegendItems}
-					itemContent={(_, item): JSX.Element => renderLegendItem(item)}
-				/>
-			)}
+			<VirtuosoGrid
+				className={cx(
+					'legend-virtuoso-container',
+					`legend-virtuoso-container-${position.toLowerCase()}`,
+					{ 'legend-virtuoso-container-single-row': isSingleRow },
+				)}
+				data={visibleLegendItems}
+				itemContent={(_, item): JSX.Element => renderLegendItem(item)}
+			/>
 		</div>
 	);
 }
--- a/frontend/src/lib/uPlotV2/components/Tooltip/Tooltip.tsx
+++ b/frontend/src/lib/uPlotV2/components/Tooltip/Tooltip.tsx
@@ -3,7 +3,6 @@ import { Virtuoso } from 'react-virtuoso';
 import cx from 'classnames';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
-import customParseFormat from 'dayjs/plugin/customParseFormat';
 import { useIsDarkMode } from 'hooks/useDarkMode';

 import { TooltipContentItem, TooltipProps } from '../types';
@@ -14,8 +13,6 @@ import './Tooltip.styles.scss';
 const TOOLTIP_LIST_MAX_HEIGHT = 330;
 const TOOLTIP_ITEM_HEIGHT = 38;

-dayjs.extend(customParseFormat);
-
 export default function Tooltip({
 	seriesIndex,
 	dataIndexes,
--- a/frontend/src/lib/uPlotV2/components/tests/UPlotChart.test.tsx
+++ b/frontend/src/lib/uPlotV2/components/tests/UPlotChart.test.tsx
@@ -1,412 +0,0 @@
-import type { ReactNode } from 'react';
-import { render, screen } from '@testing-library/react';
-import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import type { AlignedData } from 'uplot';
-
-import { PlotContextProvider } from '../../context/PlotContext';
-import UPlotChart from '../UPlotChart';
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-		updateSeriesVisibilityToLocalStorage: jest.fn(),
-	}),
-);
-
-jest.mock('@sentry/react', () => ({
-	ErrorBoundary: ({ children }: { children: ReactNode }): JSX.Element => (
-		<>{children}</>
-	),
-}));
-
-jest.mock('pages/ErrorBoundaryFallback/ErrorBoundaryFallback', () => ({
-	__esModule: true,
-	default: (): JSX.Element => <div>Error Fallback</div>,
-}));
-
-interface MockUPlotInstance {
-	root: HTMLDivElement;
-	setData: jest.Mock;
-	setSize: jest.Mock;
-	destroy: jest.Mock;
-}
-
-let instances: MockUPlotInstance[] = [];
-const mockUPlotConstructor = jest.fn();
-
-jest.mock('uplot', () => {
-	function MockUPlot(
-		opts: Record<string, unknown>,
-		data: unknown,
-		target: HTMLElement,
-	): MockUPlotInstance {
-		mockUPlotConstructor(opts, data, target);
-
-		const rootEl = document.createElement('div');
-		target.appendChild(rootEl);
-
-		const inst: MockUPlotInstance = {
-			root: rootEl,
-			setData: jest.fn(),
-			setSize: jest.fn(),
-			destroy: jest.fn(),
-		};
-		instances.push(inst);
-		return inst;
-	}
-
-	MockUPlot.paths = {
-		spline: jest.fn(() => jest.fn()),
-		bars: jest.fn(() => jest.fn()),
-		linear: jest.fn(() => jest.fn()),
-		stepped: jest.fn(() => jest.fn()),
-	};
-	MockUPlot.tzDate = jest.fn();
-
-	return { __esModule: true, default: MockUPlot };
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const createMockConfig = (): UPlotConfigBuilder => {
-	return ({
-		getConfig: jest.fn().mockReturnValue({
-			series: [{ value: (): string => '' }],
-			axes: [],
-			scales: {},
-			hooks: {},
-			cursor: {},
-		}),
-		getWidgetId: jest.fn().mockReturnValue(undefined),
-		getShouldSaveSelectionPreference: jest.fn().mockReturnValue(false),
-	} as unknown) as UPlotConfigBuilder;
-};
-
-const validData: AlignedData = [
-	[1, 2, 3],
-	[10, 20, 30],
-];
-const emptyData: AlignedData = [[]];
-
-const Wrapper = ({ children }: { children: ReactNode }): JSX.Element => (
-	<PlotContextProvider>{children}</PlotContextProvider>
-);
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('UPlotChart', () => {
-	beforeEach(() => {
-		instances = [];
-		mockUPlotConstructor.mockClear();
-	});
-
-	describe('when data is empty', () => {
-		it('displays "No Data" message instead of the chart container', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={emptyData}
-					width={600}
-					height={400}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(screen.getByText('No Data')).toBeInTheDocument();
-			expect(screen.queryByTestId('uplot-main-div')).not.toBeInTheDocument();
-		});
-
-		it('sizes the empty-state container to the given width and height', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={emptyData}
-					width={750}
-					height={350}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			const noDataContainer = screen
-				.getByText('No Data')
-				.closest('.uplot-no-data');
-			expect(noDataContainer).toHaveStyle({ width: '750px', height: '350px' });
-		});
-
-		it('does not create a uPlot instance', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={emptyData}
-					width={600}
-					height={400}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(mockUPlotConstructor).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('chart container', () => {
-		it('renders children inside the chart wrapper', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={validData}
-					width={600}
-					height={400}
-				>
-					<div data-testid="tooltip-plugin">Tooltip</div>
-				</UPlotChart>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(screen.getByTestId('tooltip-plugin')).toBeInTheDocument();
-		});
-	});
-
-	describe('plot creation', () => {
-		it('instantiates uPlot with floored dimensions and the container element', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={validData}
-					width={600.9}
-					height={400.2}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(mockUPlotConstructor).toHaveBeenCalledTimes(1);
-
-			const [opts, data, target] = mockUPlotConstructor.mock.calls[0];
-			expect(opts.width).toBe(600);
-			expect(opts.height).toBe(400);
-			expect(data).toBe(validData);
-			expect(target).toBe(screen.getByTestId('uplot-main-div'));
-		});
-
-		it('merges config builder output into the uPlot options', () => {
-			const config = createMockConfig();
-			config.getConfig = jest.fn().mockReturnValue({
-				series: [{ value: (): string => '' }],
-				axes: [{ scale: 'y' }],
-				scales: { y: {} },
-				hooks: {},
-				cursor: { show: true },
-			});
-
-			render(
-				<UPlotChart
-					config={(config as unknown) as UPlotConfigBuilder}
-					data={validData}
-					width={500}
-					height={300}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			const [opts] = mockUPlotConstructor.mock.calls[0];
-			expect(opts.width).toBe(500);
-			expect(opts.height).toBe(300);
-			expect(opts.axes).toEqual([{ scale: 'y' }]);
-			expect(opts.cursor).toEqual({ show: true });
-		});
-
-		it('skips creation when width or height is 0', () => {
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={validData}
-					width={0}
-					height={0}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(mockUPlotConstructor).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('lifecycle callbacks', () => {
-		it('invokes plotRef with the uPlot instance after creation', () => {
-			const plotRef = jest.fn();
-
-			render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={validData}
-					width={600}
-					height={400}
-					plotRef={plotRef}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			expect(plotRef).toHaveBeenCalledTimes(1);
-			expect(plotRef).toHaveBeenCalledWith(instances[0]);
-		});
-
-		it('destroys the instance and notifies callbacks when data becomes empty', () => {
-			const plotRef = jest.fn();
-			const onDestroy = jest.fn();
-			const config = createMockConfig();
-
-			const { rerender } = render(
-				<UPlotChart
-					config={config}
-					data={validData}
-					width={600}
-					height={400}
-					plotRef={plotRef}
-					onDestroy={onDestroy}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			const firstInstance = instances[0];
-			plotRef.mockClear();
-
-			rerender(
-				<UPlotChart
-					config={config}
-					data={emptyData}
-					width={600}
-					height={400}
-					plotRef={plotRef}
-					onDestroy={onDestroy}
-				/>,
-			);
-
-			expect(onDestroy).toHaveBeenCalledWith(firstInstance);
-			expect(firstInstance.destroy).toHaveBeenCalled();
-			expect(plotRef).toHaveBeenCalledWith(null);
-			expect(screen.getByText('No Data')).toBeInTheDocument();
-		});
-
-		it('destroys the previous instance before creating a new one on config change', () => {
-			const onDestroy = jest.fn();
-			const config1 = createMockConfig();
-			const config2 = createMockConfig();
-
-			const { rerender } = render(
-				<UPlotChart
-					config={config1}
-					data={validData}
-					width={600}
-					height={400}
-					onDestroy={onDestroy}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			const firstInstance = instances[0];
-
-			rerender(
-				<UPlotChart
-					config={config2}
-					data={validData}
-					width={600}
-					height={400}
-					onDestroy={onDestroy}
-				/>,
-			);
-
-			expect(onDestroy).toHaveBeenCalledWith(firstInstance);
-			expect(firstInstance.destroy).toHaveBeenCalled();
-			expect(instances).toHaveLength(2);
-		});
-	});
-
-	describe('prop updates', () => {
-		it('calls setData without recreating the plot when only data changes', () => {
-			const config = createMockConfig();
-			const newData: AlignedData = [
-				[4, 5, 6],
-				[40, 50, 60],
-			];
-
-			const { rerender } = render(
-				<UPlotChart config={config} data={validData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			const inst = instances[0];
-
-			rerender(
-				<UPlotChart config={config} data={newData} width={600} height={400} />,
-			);
-
-			expect(inst.setData).toHaveBeenCalledWith(newData);
-			expect(mockUPlotConstructor).toHaveBeenCalledTimes(1);
-		});
-
-		it('calls setSize with floored values when only dimensions change', () => {
-			const config = createMockConfig();
-
-			const { rerender } = render(
-				<UPlotChart config={config} data={validData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			const instance = instances[0];
-
-			rerender(
-				<UPlotChart
-					config={config}
-					data={validData}
-					width={800.7}
-					height={500.3}
-				/>,
-			);
-
-			expect(instance.setSize).toHaveBeenCalledWith({ width: 800, height: 500 });
-			expect(mockUPlotConstructor).toHaveBeenCalledTimes(1);
-		});
-
-		it('recreates the plot when config changes', () => {
-			const config1 = createMockConfig();
-			const config2 = createMockConfig();
-
-			const { rerender } = render(
-				<UPlotChart config={config1} data={validData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			rerender(
-				<UPlotChart config={config2} data={validData} width={600} height={400} />,
-			);
-
-			expect(mockUPlotConstructor).toHaveBeenCalledTimes(2);
-		});
-
-		it('does nothing when all props remain the same', () => {
-			const config = createMockConfig();
-
-			const { rerender } = render(
-				<UPlotChart config={config} data={validData} width={600} height={400} />,
-				{ wrapper: Wrapper },
-			);
-
-			const instance = instances[0];
-
-			rerender(
-				<UPlotChart config={config} data={validData} width={600} height={400} />,
-			);
-
-			expect(mockUPlotConstructor).toHaveBeenCalledTimes(1);
-			expect(instance.setData).not.toHaveBeenCalled();
-			expect(instance.setSize).not.toHaveBeenCalled();
-		});
-	});
-});
--- a/frontend/src/providers/Dashboard/tests/Dashboard.test.tsx
+++ b/frontend/src/providers/Dashboard/tests/Dashboard.test.tsx
@@ -412,16 +412,14 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			});

 			// Verify dashboard state contains the variables with default values
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
-				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
+			const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

-				expect(parsedVariables).toHaveProperty('environment');
-				expect(parsedVariables).toHaveProperty('services');
-				// Default allSelected values should be preserved
-				expect(parsedVariables.environment.allSelected).toBe(false);
-				expect(parsedVariables.services.allSelected).toBe(false);
-			});
+			expect(parsedVariables).toHaveProperty('environment');
+			expect(parsedVariables).toHaveProperty('services');
+			// Default allSelected values should be preserved
+			expect(parsedVariables.environment.allSelected).toBe(false);
+			expect(parsedVariables.services.allSelected).toBe(false);
 		});

 		it('should merge URL variables with dashboard data and normalize values correctly', async () => {
@@ -468,26 +466,16 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			});

 			// Verify the dashboard state reflects the normalized URL values
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
-				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
+			const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

-				// First ensure the variables exist
-				expect(parsedVariables).toHaveProperty('environment');
-				expect(parsedVariables).toHaveProperty('services');
+			// The selectedValue should be updated with normalized URL values
+			expect(parsedVariables.environment.selectedValue).toBe('development');
+			expect(parsedVariables.services.selectedValue).toEqual(['db', 'cache']);

-				// Then check their properties
-				expect(parsedVariables.environment).toHaveProperty('selectedValue');
-				expect(parsedVariables.services).toHaveProperty('selectedValue');
-
-				// The selectedValue should be updated with normalized URL values
-				expect(parsedVariables.environment.selectedValue).toBe('development');
-				expect(parsedVariables.services.selectedValue).toEqual(['db', 'cache']);
-
-				// allSelected should be set to false when URL values override
-				expect(parsedVariables.environment.allSelected).toBe(false);
-				expect(parsedVariables.services.allSelected).toBe(false);
-			});
+			// allSelected should be set to false when URL values override
+			expect(parsedVariables.environment.allSelected).toBe(false);
+			expect(parsedVariables.services.allSelected).toBe(false);
 		});

 		it('should handle ALL_SELECTED_VALUE from URL and set allSelected correctly', async () => {
@@ -512,8 +500,8 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			);

 			// Verify that allSelected is set to true for the services variable
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
+			await waitFor(async () => {
+				const dashboardVariables = await screen.findByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

 				expect(parsedVariables.services.allSelected).toBe(true);
@@ -615,8 +603,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});

 			// Verify that defaultValue is set from textboxValue
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
+			await waitFor(async () => {
+				const dashboardVariables = await screen.findByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -660,8 +648,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});

 			// Verify that existing defaultValue is preserved
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
+			await waitFor(async () => {
+				const dashboardVariables = await screen.findByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -706,8 +694,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});

 			// Verify that defaultValue is set to empty string
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
+			await waitFor(async () => {
+				const dashboardVariables = await screen.findByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -751,8 +739,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});

 			// Verify that defaultValue is NOT set from textboxValue for QUERY type
-			await waitFor(() => {
-				const dashboardVariables = screen.getByTestId('dashboard-variables');
+			await waitFor(async () => {
+				const dashboardVariables = await screen.findByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');

 				expect(parsedVariables.myQuery.type).toBe('QUERY');
--- a/frontend/src/providers/Dashboard/initializeDefaultVariables.ts
+++ b/frontend/src/providers/Dashboard/initializeDefaultVariables.ts
@@ -1,7 +1,7 @@
 import { ALL_SELECTED_VALUE } from 'components/NewSelect/utils';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';

-import { commaValuesParser } from '../../lib/dashboardVariables/customCommaValuesParser';
+import { commaValuesParser } from '../../lib/dashbaordVariables/customCommaValuesParser';

 interface UrlVariables {
 	[key: string]: any;
--- a/frontend/src/providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreUtils.ts
+++ b/frontend/src/providers/Dashboard/store/dashboardVariables/dashboardVariablesStoreUtils.ts
@@ -4,7 +4,6 @@ import {
 } from 'container/DashboardContainer/DashboardVariablesSelection/util';
 import { IDashboardVariable } from 'types/api/dashboard/getAll';

-import { initializeVariableFetchStore } from '../variableFetchStore';
 import {
 	IDashboardVariables,
 	IDashboardVariablesStoreState,
@@ -63,30 +62,9 @@ export function buildDependencyData(
 	};
 }

-/**
- * Initialize the variable fetch store with the computed dependency data
- */
-function initializeFetchStore(
-	sortedVariablesArray: IDashboardVariable[],
-	dependencyData: IDependencyData | null,
-): void {
-	if (dependencyData) {
-		const allVariableNames = sortedVariablesArray
-			.map((v) => v.name)
-			.filter((name): name is string => !!name);
-
-		initializeVariableFetchStore(
-			allVariableNames,
-			dependencyData.graph,
-			dependencyData.parentDependencyGraph,
-		);
-	}
-}
-
 /**
 * Compute derived values from variables
 * This is a composition of buildSortedVariablesArray and buildDependencyData
- * Also initializes the variable fetch store with the new dependency data
 */
 export function computeDerivedValues(
 	variables: IDashboardVariablesStoreState['variables'],
@@ -97,22 +75,15 @@ export function computeDerivedValues(
 	const sortedVariablesArray = buildSortedVariablesArray(variables);
 	const dependencyData = buildDependencyData(sortedVariablesArray);

-	// Initialize the variable fetch store when dependency data is computed
-	initializeFetchStore(sortedVariablesArray, dependencyData);
-
 	return { sortedVariablesArray, dependencyData };
 }

 /**
 * Update derived values in the store state (for use with immer)
- * Also initializes the variable fetch store with the new dependency data
 */
 export function updateDerivedValues(
 	draft: IDashboardVariablesStoreState,
 ): void {
 	draft.sortedVariablesArray = buildSortedVariablesArray(draft.variables);
 	draft.dependencyData = buildDependencyData(draft.sortedVariablesArray);
-
-	// Initialize the variable fetch store when dependency data is updated
-	initializeFetchStore(draft.sortedVariablesArray, draft.dependencyData);
 }
--- a/frontend/src/providers/Dashboard/store/variableFetchStore.ts
+++ b/frontend/src/providers/Dashboard/store/variableFetchStore.ts
@@ -1,57 +0,0 @@
-import { VariableGraph } from 'container/DashboardContainer/DashboardVariablesSelection/util';
-
-import createStore from './store';
-
-// Fetch state for each variable
-export type VariableFetchState =
-	| 'idle' // stable state - initial or complete
-	| 'loading' // actively fetching data (first time)
-	| 'revalidating' // refetching existing data
-	| 'waiting' // blocked on parent dependencies
-	| 'error';
-
-export interface IVariableFetchStoreState {
-	// Per-variable fetch state
-	states: Record<string, VariableFetchState>;
-
-	// Dependency graphs (set once when variables change)
-	dependencyGraph: VariableGraph; // variable -> children that depend on it
-	parentGraph: VariableGraph; // variable -> parents it depends on
-
-	// Track last update timestamp per variable to trigger re-fetches
-	lastUpdated: Record<string, number>;
-}
-
-const initialState: IVariableFetchStoreState = {
-	states: {},
-	dependencyGraph: {},
-	parentGraph: {},
-	lastUpdated: {},
-};
-
-export const variableFetchStore = createStore<IVariableFetchStoreState>(
-	initialState,
-);
-
-// ============== Actions ==============
-
-/**
- * Initialize the store with dependency graphs and set initial states
- */
-export function initializeVariableFetchStore(
-	variableNames: string[],
-	dependencyGraph: VariableGraph,
-	parentGraph: VariableGraph,
-): void {
-	variableFetchStore.update((draft) => {
-		draft.dependencyGraph = dependencyGraph;
-		draft.parentGraph = parentGraph;
-
-		// Initialize all variables to idle, preserving existing ready states
-		variableNames.forEach((name) => {
-			if (!draft.states[name]) {
-				draft.states[name] = 'idle';
-			}
-		});
-	});
-}
--- a/pkg/alertmanager/alertmanager.go
+++ b/pkg/alertmanager/alertmanager.go
@@ -74,6 +74,21 @@ type Alertmanager interface {
 	CreateInhibitRules(ctx context.Context, orgID valuer.UUID, rules []amConfig.InhibitRule) error
 	DeleteAllInhibitRulesByRuleId(ctx context.Context, orgID valuer.UUID, ruleId string) error

+	// Planned Maintenance CRUD
+	GetAllPlannedMaintenance(ctx context.Context, orgID string) ([]*alertmanagertypes.GettablePlannedMaintenance, error)
+	GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*alertmanagertypes.GettablePlannedMaintenance, error)
+	CreatePlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance) (valuer.UUID, error)
+	EditPlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance, id valuer.UUID) error
+	DeletePlannedMaintenance(ctx context.Context, id valuer.UUID) error
+
+	// Rule State History
+	RecordRuleStateHistory(ctx context.Context, orgID string, entries []alertmanagertypes.RuleStateHistory) error
+	GetLastSavedRuleStateHistory(ctx context.Context, ruleID string) ([]alertmanagertypes.RuleStateHistory, error)
+	GetRuleStateHistoryTimeline(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error)
+	GetRuleStateHistoryTopContributors(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error)
+	GetOverallStateTransitions(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error)
+	GetRuleStats(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStats, error)
+
 	// Collects stats for the organization.
 	statsreporter.StatsCollector
 }
--- a/pkg/alertmanager/alertmanagerserver/server.go
+++ b/pkg/alertmanager/alertmanagerserver/server.go
@@ -68,20 +68,30 @@ type Server struct {
 	wg                  sync.WaitGroup
 	stopc               chan struct{}
 	notificationManager nfmanager.NotificationManager
+
+	// maintenanceExprMuter is an optional muter for expression-based maintenance scoping
+	maintenanceExprMuter types.Muter
+	// muteStageMetrics are created once and reused across SetConfig calls
+	muteStageMetrics *notify.Metrics
+
+	// signozRegisterer is used for metrics in the pipeline
+	signozRegisterer prometheus.Registerer
 }

-func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registerer, srvConfig Config, orgID string, stateStore alertmanagertypes.StateStore, nfManager nfmanager.NotificationManager) (*Server, error) {
+func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registerer, srvConfig Config, orgID string, stateStore alertmanagertypes.StateStore, nfManager nfmanager.NotificationManager, maintenanceExprMuter types.Muter) (*Server, error) {
 	server := &Server{
-		logger:              logger.With("pkg", "go.signoz.io/pkg/alertmanager/alertmanagerserver"),
-		registry:            registry,
-		srvConfig:           srvConfig,
-		orgID:               orgID,
-		stateStore:          stateStore,
-		stopc:               make(chan struct{}),
-		notificationManager: nfManager,
+		logger:               logger.With("pkg", "go.signoz.io/pkg/alertmanager/alertmanagerserver"),
+		registry:             registry,
+		srvConfig:            srvConfig,
+		orgID:                orgID,
+		stateStore:           stateStore,
+		stopc:                make(chan struct{}),
+		notificationManager:  nfManager,
+		maintenanceExprMuter: maintenanceExprMuter,
 	}
-	signozRegisterer := prometheus.WrapRegistererWithPrefix("signoz_", registry)
-	signozRegisterer = prometheus.WrapRegistererWith(prometheus.Labels{"org_id": server.orgID}, signozRegisterer)
+	server.signozRegisterer = prometheus.WrapRegistererWithPrefix("signoz_", registry)
+	server.signozRegisterer = prometheus.WrapRegistererWith(prometheus.Labels{"org_id": server.orgID}, server.signozRegisterer)
+	signozRegisterer := server.signozRegisterer
 	// initialize marker
 	server.marker = alertmanagertypes.NewMarker(signozRegisterer)

@@ -198,6 +208,11 @@ func New(ctx context.Context, logger *slog.Logger, registry prometheus.Registere
 	server.pipelineBuilder = notify.NewPipelineBuilder(signozRegisterer, featurecontrol.NoopFlags{})
 	server.dispatcherMetrics = NewDispatcherMetrics(false, signozRegisterer)

+	if server.maintenanceExprMuter != nil {
+		muteRegisterer := prometheus.WrapRegistererWithPrefix("maintenance_mute_", signozRegisterer)
+		server.muteStageMetrics = notify.NewMetrics(muteRegisterer, featurecontrol.NoopFlags{})
+	}
+
 	return server, nil
 }

@@ -205,6 +220,9 @@ func (server *Server) GetAlerts(ctx context.Context, params alertmanagertypes.Ge
 	return alertmanagertypes.NewGettableAlertsFromAlertProvider(server.alerts, server.alertmanagerConfig, server.marker.Status, func(labels model.LabelSet) {
 		server.inhibitor.Mutes(labels)
 		server.silencer.Mutes(labels)
+		if server.maintenanceExprMuter != nil {
+			server.maintenanceExprMuter.Mutes(labels)
+		}
 	}, params)
 }

@@ -293,6 +311,14 @@ func (server *Server) SetConfig(ctx context.Context, alertmanagerConfig *alertma
 		pipelinePeer,
 	)

+	// Inject expression-based maintenance muter into the pipeline
+	if server.maintenanceExprMuter != nil {
+		ms := notify.NewMuteStage(server.maintenanceExprMuter, server.muteStageMetrics)
+		for name, stage := range pipeline {
+			pipeline[name] = notify.MultiStage{ms, stage}
+		}
+	}
+
 	timeoutFunc := func(d time.Duration) time.Duration {
 		if d < notify.MinTimeout {
 			d = notify.MinTimeout
--- a/pkg/alertmanager/alertmanagerserver/server_e2e_test.go
+++ b/pkg/alertmanager/alertmanagerserver/server_e2e_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"log/slog"
 	"net/http"
+	"sync"
 	"testing"
 	"time"

@@ -22,9 +23,35 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/model"

+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

+// testMuter implements types.Muter for testing maintenance expression muting.
+type testMuter struct {
+	mu       sync.RWMutex
+	muteFunc func(model.LabelSet) bool
+	calls    []model.LabelSet
+}
+
+func (m *testMuter) Mutes(labels model.LabelSet) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.calls = append(m.calls, labels)
+	if m.muteFunc != nil {
+		return m.muteFunc(labels)
+	}
+	return false
+}
+
+func (m *testMuter) getCalls() []model.LabelSet {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	result := make([]model.LabelSet, len(m.calls))
+	copy(result, m.calls)
+	return result
+}
+
 func TestEndToEndAlertManagerFlow(t *testing.T) {
 	ctx := context.Background()
 	providerSettings := instrumentationtest.New().ToProviderSettings()
@@ -90,7 +117,7 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 	stateStore := alertmanagertypestest.NewStateStore()
 	registry := prometheus.NewRegistry()
 	logger := slog.New(slog.DiscardHandler)
-	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager)
+	server, err := New(context.Background(), logger, registry, srvCfg, orgID, stateStore, notificationManager, nil)
 	require.NoError(t, err)
 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
 	require.NoError(t, err)
@@ -221,3 +248,257 @@ func TestEndToEndAlertManagerFlow(t *testing.T) {
 		require.Equal(t, "{__receiver__=\"webhook\"}:{cluster=\"prod-cluster\", instance=\"server-03\", ruleId=\"high-cpu-usage\"}", alertGroups[2].GroupKey)
 	})
 }
+
+// TestEndToEndMaintenanceMuting verifies that the maintenance expression muter
+// integrates correctly with the alertmanager server pipeline:
+// 1. MuteStage is injected into the notification pipeline when a muter is provided
+// 2. Alerts remain visible in GetAlerts during maintenance (muting suppresses
+//    notifications, not alert visibility)
+// 3. The muter is called during GetAlerts for status resolution
+func TestEndToEndMaintenanceMuting(t *testing.T) {
+	ctx := context.Background()
+	providerSettings := instrumentationtest.New().ToProviderSettings()
+
+	store := nfroutingstoretest.NewMockSQLRouteStore()
+	store.MatchExpectationsInOrder(false)
+	notificationManager, err := rulebasednotification.New(ctx, providerSettings, nfmanager.Config{}, store)
+	require.NoError(t, err)
+	orgID := "test-org-maintenance"
+
+	// Create a muter that mutes alerts with severity == "critical"
+	muter := &testMuter{
+		muteFunc: func(labels model.LabelSet) bool {
+			return string(labels["severity"]) == "critical"
+		},
+	}
+
+	srvCfg := NewConfig()
+	stateStore := alertmanagertypestest.NewStateStore()
+	registry := prometheus.NewRegistry()
+	logger := slog.New(slog.DiscardHandler)
+
+	// Create server WITH the maintenance muter
+	server, err := New(ctx, logger, registry, srvCfg, orgID, stateStore, notificationManager, muter)
+	require.NoError(t, err)
+
+	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
+	require.NoError(t, err)
+	err = server.SetConfig(ctx, amConfig)
+	require.NoError(t, err)
+
+	// Put a mix of alerts: 2 critical (should be muted) and 1 warning (should not)
+	now := time.Now()
+	testAlerts := []*alertmanagertypes.PostableAlert{
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId":    "disk-usage",
+					"severity":  "critical",
+					"env":       "prod",
+					"alertname": "DiskUsageHigh",
+				},
+			},
+			Annotations: map[string]string{"summary": "Disk usage critical"},
+			StartsAt:    strfmt.DateTime(now.Add(-5 * time.Minute)),
+			EndsAt:      strfmt.DateTime(time.Time{}),
+		},
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId":    "disk-usage",
+					"severity":  "warning",
+					"env":       "prod",
+					"alertname": "DiskUsageHigh",
+				},
+			},
+			Annotations: map[string]string{"summary": "Disk usage warning"},
+			StartsAt:    strfmt.DateTime(now.Add(-3 * time.Minute)),
+			EndsAt:      strfmt.DateTime(time.Time{}),
+		},
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId":    "memory-usage",
+					"severity":  "critical",
+					"env":       "staging",
+					"alertname": "MemoryUsageHigh",
+				},
+			},
+			Annotations: map[string]string{"summary": "Memory usage critical"},
+			StartsAt:    strfmt.DateTime(now.Add(-2 * time.Minute)),
+			EndsAt:      strfmt.DateTime(time.Time{}),
+		},
+	}
+
+	err = server.PutAlerts(ctx, testAlerts)
+	require.NoError(t, err)
+
+	time.Sleep(2 * time.Second)
+
+	t.Run("alerts_visible_during_maintenance", func(t *testing.T) {
+		// Maintenance muting suppresses notifications, NOT alert visibility.
+		// All 3 alerts should still be returned by GetAlerts.
+		req, err := http.NewRequest(http.MethodGet, "/alerts", nil)
+		require.NoError(t, err)
+
+		params, err := alertmanagertypes.NewGettableAlertsParams(req)
+		require.NoError(t, err)
+
+		alerts, err := server.GetAlerts(ctx, params)
+		require.NoError(t, err)
+		require.Len(t, alerts, 3, "All alerts should be visible during maintenance")
+
+		// Verify labels are intact
+		severities := map[string]int{}
+		for _, alert := range alerts {
+			severities[alert.Alert.Labels["severity"]]++
+		}
+		assert.Equal(t, 2, severities["critical"])
+		assert.Equal(t, 1, severities["warning"])
+	})
+
+	t.Run("muter_called_during_get_alerts", func(t *testing.T) {
+		// The muter should have been called for each alert during GetAlerts.
+		calls := muter.getCalls()
+		assert.GreaterOrEqual(t, len(calls), 3, "Muter should be called for each alert")
+	})
+
+	t.Run("muter_correctly_identifies_targets", func(t *testing.T) {
+		// Verify the muter returns correct results for different label sets
+		assert.True(t, muter.Mutes(model.LabelSet{"severity": "critical", "env": "prod"}),
+			"Should mute critical alerts")
+		assert.False(t, muter.Mutes(model.LabelSet{"severity": "warning", "env": "prod"}),
+			"Should not mute warning alerts")
+		assert.True(t, muter.Mutes(model.LabelSet{"severity": "critical", "env": "staging"}),
+			"Should mute critical regardless of env")
+	})
+
+}
+
+// TestEndToEndMaintenanceCatchAll verifies that a catch-all muter (always returns true)
+// mutes all alerts while keeping them visible.
+func TestEndToEndMaintenanceCatchAll(t *testing.T) {
+	ctx := context.Background()
+	providerSettings := instrumentationtest.New().ToProviderSettings()
+
+	store := nfroutingstoretest.NewMockSQLRouteStore()
+	store.MatchExpectationsInOrder(false)
+	notificationManager, err := rulebasednotification.New(ctx, providerSettings, nfmanager.Config{}, store)
+	require.NoError(t, err)
+	orgID := "test-org-catchall"
+
+	// Catch-all muter: mutes everything
+	muter := &testMuter{
+		muteFunc: func(labels model.LabelSet) bool {
+			return true
+		},
+	}
+
+	srvCfg := NewConfig()
+	stateStore := alertmanagertypestest.NewStateStore()
+	registry := prometheus.NewRegistry()
+	logger := slog.New(slog.DiscardHandler)
+
+	server, err := New(ctx, logger, registry, srvCfg, orgID, stateStore, notificationManager, muter)
+	require.NoError(t, err)
+
+	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
+	require.NoError(t, err)
+	err = server.SetConfig(ctx, amConfig)
+	require.NoError(t, err)
+
+	now := time.Now()
+	testAlerts := []*alertmanagertypes.PostableAlert{
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId": "rule-1", "alertname": "Alert1", "env": "prod",
+				},
+			},
+			StartsAt: strfmt.DateTime(now.Add(-1 * time.Minute)),
+			EndsAt:   strfmt.DateTime(time.Time{}),
+		},
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId": "rule-2", "alertname": "Alert2", "env": "staging",
+				},
+			},
+			StartsAt: strfmt.DateTime(now.Add(-1 * time.Minute)),
+			EndsAt:   strfmt.DateTime(time.Time{}),
+		},
+	}
+
+	err = server.PutAlerts(ctx, testAlerts)
+	require.NoError(t, err)
+
+	time.Sleep(2 * time.Second)
+
+	req, err := http.NewRequest(http.MethodGet, "/alerts", nil)
+	require.NoError(t, err)
+	params, err := alertmanagertypes.NewGettableAlertsParams(req)
+	require.NoError(t, err)
+
+	alerts, err := server.GetAlerts(ctx, params)
+	require.NoError(t, err)
+	assert.Len(t, alerts, 2, "All alerts should remain visible even when catch-all muter is active")
+
+	// Verify the muter was called for each alert
+	calls := muter.getCalls()
+	assert.GreaterOrEqual(t, len(calls), 2, "Muter should be called for each alert")
+}
+
+// TestEndToEndNoMuter verifies the server works correctly without a muter (nil),
+// matching the existing behavior where no maintenance muting is configured.
+func TestEndToEndNoMuter(t *testing.T) {
+	ctx := context.Background()
+	providerSettings := instrumentationtest.New().ToProviderSettings()
+
+	store := nfroutingstoretest.NewMockSQLRouteStore()
+	store.MatchExpectationsInOrder(false)
+	notificationManager, err := rulebasednotification.New(ctx, providerSettings, nfmanager.Config{}, store)
+	require.NoError(t, err)
+	orgID := "test-org-nomuter"
+
+	srvCfg := NewConfig()
+	stateStore := alertmanagertypestest.NewStateStore()
+	registry := prometheus.NewRegistry()
+	logger := slog.New(slog.DiscardHandler)
+
+	// Create server WITHOUT a muter (nil)
+	server, err := New(ctx, logger, registry, srvCfg, orgID, stateStore, notificationManager, nil)
+	require.NoError(t, err)
+
+	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, orgID)
+	require.NoError(t, err)
+	err = server.SetConfig(ctx, amConfig)
+	require.NoError(t, err)
+
+	now := time.Now()
+	testAlerts := []*alertmanagertypes.PostableAlert{
+		{
+			Alert: alertmanagertypes.AlertModel{
+				Labels: map[string]string{
+					"ruleId": "rule-1", "alertname": "Alert1", "severity": "critical",
+				},
+			},
+			StartsAt: strfmt.DateTime(now.Add(-1 * time.Minute)),
+			EndsAt:   strfmt.DateTime(time.Time{}),
+		},
+	}
+
+	err = server.PutAlerts(ctx, testAlerts)
+	require.NoError(t, err)
+
+	time.Sleep(2 * time.Second)
+
+	req, err := http.NewRequest(http.MethodGet, "/alerts", nil)
+	require.NoError(t, err)
+	params, err := alertmanagertypes.NewGettableAlertsParams(req)
+	require.NoError(t, err)
+
+	alerts, err := server.GetAlerts(ctx, params)
+	require.NoError(t, err)
+	assert.Len(t, alerts, 1, "Alert should be returned when no muter is configured")
+	assert.Equal(t, "critical", alerts[0].Alert.Labels["severity"])
+}
--- a/pkg/alertmanager/alertmanagerserver/server_test.go
+++ b/pkg/alertmanager/alertmanagerserver/server_test.go
@@ -25,7 +25,7 @@ import (

 func TestServerSetConfigAndStop(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, nil)
 	require.NoError(t, err)

 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -37,7 +37,7 @@ func TestServerSetConfigAndStop(t *testing.T) {

 func TestServerTestReceiverTypeWebhook(t *testing.T) {
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), NewConfig(), "1", alertmanagertypestest.NewStateStore(), notificationManager, nil)
 	require.NoError(t, err)

 	amConfig, err := alertmanagertypes.NewDefaultConfig(alertmanagertypes.GlobalConfig{}, alertmanagertypes.RouteConfig{GroupInterval: 1 * time.Minute, RepeatInterval: 1 * time.Minute, GroupWait: 1 * time.Minute}, "1")
@@ -85,7 +85,7 @@ func TestServerPutAlerts(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)

 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -133,7 +133,7 @@ func TestServerTestAlert(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)

 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
@@ -238,7 +238,7 @@ func TestServerTestAlertContinuesOnFailure(t *testing.T) {
 	srvCfg := NewConfig()
 	srvCfg.Route.GroupInterval = 1 * time.Second
 	notificationManager := nfmanagertest.NewMock()
-	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager)
+	server, err := New(context.Background(), slog.New(slog.DiscardHandler), prometheus.NewRegistry(), srvCfg, "1", stateStore, notificationManager, nil)
 	require.NoError(t, err)

 	amConfig, err := alertmanagertypes.NewDefaultConfig(srvCfg.Global, srvCfg.Route, "1")
--- a/pkg/alertmanager/alertmanagerstore/clickhousealertmanagerstore/statehistory.go
+++ b/pkg/alertmanager/alertmanagerstore/clickhousealertmanagerstore/statehistory.go
@@ -0,0 +1,531 @@
+package clickhousealertmanagerstore
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/ClickHouse/clickhouse-go/v2"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+const (
+	signozHistoryDBName       = "signoz_analytics"
+	ruleStateHistoryTableName = "distributed_rule_state_history_v2"
+
+	maxPointsInTimeSeries = 300
+)
+
+type stateHistoryStore struct {
+	conn clickhouse.Conn
+}
+
+func NewStateHistoryStore(conn clickhouse.Conn) alertmanagertypes.StateHistoryStore {
+	return &stateHistoryStore{conn: conn}
+}
+
+func (s *stateHistoryStore) WriteRuleStateHistory(ctx context.Context, entries []alertmanagertypes.RuleStateHistory) error {
+	if len(entries) == 0 {
+		return nil
+	}
+
+	statement, err := s.conn.PrepareBatch(ctx, fmt.Sprintf(
+		"INSERT INTO %s.%s (org_id, rule_id, rule_name, overall_state, overall_state_changed, state, state_changed, unix_milli, labels, fingerprint, value) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)",
+		signozHistoryDBName, ruleStateHistoryTableName))
+	if err != nil {
+		return err
+	}
+	defer statement.Abort()
+
+	for _, h := range entries {
+		if err := statement.Append(
+			h.OrgID,
+			h.RuleID, h.RuleName,
+			h.OverallState, h.OverallStateChanged,
+			h.State, h.StateChanged,
+			h.UnixMilli, h.Labels,
+			h.Fingerprint, h.Value,
+		); err != nil {
+			return err
+		}
+	}
+
+	return statement.Send()
+}
+
+func (s *stateHistoryStore) GetLastSavedRuleStateHistory(ctx context.Context, ruleID string) ([]alertmanagertypes.RuleStateHistory, error) {
+	query := fmt.Sprintf(
+		"SELECT org_id, rule_id, rule_name, overall_state, overall_state_changed, state, state_changed, unix_milli, labels, fingerprint, value FROM %s.%s WHERE rule_id = '%s' AND state_changed = true ORDER BY unix_milli DESC LIMIT 1 BY fingerprint",
+		signozHistoryDBName, ruleStateHistoryTableName, ruleID)
+
+	rows, err := s.conn.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var results []alertmanagertypes.RuleStateHistory
+	for rows.Next() {
+		var h alertmanagertypes.RuleStateHistory
+		if err := rows.Scan(
+			&h.OrgID,
+			&h.RuleID, &h.RuleName,
+			&h.OverallState, &h.OverallStateChanged,
+			&h.State, &h.StateChanged,
+			&h.UnixMilli, &h.Labels,
+			&h.Fingerprint, &h.Value,
+		); err != nil {
+			return nil, err
+		}
+		results = append(results, h)
+	}
+
+	return results, rows.Err()
+}
+
+func (s *stateHistoryStore) GetRuleStateHistoryTimeline(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) (*alertmanagertypes.RuleStateTimeline, error) {
+	var conditions []string
+
+	conditions = append(conditions, fmt.Sprintf("org_id = '%s'", orgID))
+	conditions = append(conditions, fmt.Sprintf("rule_id = '%s'", ruleID))
+	conditions = append(conditions, fmt.Sprintf("unix_milli >= %d AND unix_milli < %d", params.Start, params.End))
+
+	if params.State.StringValue() != "" {
+		conditions = append(conditions, fmt.Sprintf("state = '%s'", params.State.StringValue()))
+	}
+
+	whereClause := strings.Join(conditions, " AND ")
+
+	// Main query — paginated results.
+	query := fmt.Sprintf(
+		"SELECT org_id, rule_id, rule_name, overall_state, overall_state_changed, state, state_changed, unix_milli, labels, fingerprint, value FROM %s.%s WHERE %s ORDER BY unix_milli %s LIMIT %d OFFSET %d",
+		signozHistoryDBName, ruleStateHistoryTableName, whereClause, params.Order.StringValue(), params.Limit, params.Offset)
+
+	rows, err := s.conn.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var items []alertmanagertypes.RuleStateHistory
+	for rows.Next() {
+		var h alertmanagertypes.RuleStateHistory
+		if err := rows.Scan(
+			&h.OrgID,
+			&h.RuleID, &h.RuleName,
+			&h.OverallState, &h.OverallStateChanged,
+			&h.State, &h.StateChanged,
+			&h.UnixMilli, &h.Labels,
+			&h.Fingerprint, &h.Value,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, h)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	// Count query.
+	var total uint64
+	countQuery := fmt.Sprintf("SELECT count(*) FROM %s.%s WHERE %s",
+		signozHistoryDBName, ruleStateHistoryTableName, whereClause)
+	if err := s.conn.QueryRow(ctx, countQuery).Scan(&total); err != nil {
+		return nil, err
+	}
+
+	// Labels query — distinct labels for the rule.
+	labelsQuery := fmt.Sprintf("SELECT DISTINCT labels FROM %s.%s WHERE org_id = '%s' AND rule_id = '%s'",
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID)
+	labelRows, err := s.conn.Query(ctx, labelsQuery)
+	if err != nil {
+		return nil, err
+	}
+	defer labelRows.Close()
+
+	labelsMap := make(map[string][]string)
+	for labelRows.Next() {
+		var rawLabel string
+		if err := labelRows.Scan(&rawLabel); err != nil {
+			return nil, err
+		}
+		label := map[string]string{}
+		if err := json.Unmarshal([]byte(rawLabel), &label); err != nil {
+			continue
+		}
+		for k, v := range label {
+			labelsMap[k] = append(labelsMap[k], v)
+		}
+	}
+
+	if items == nil {
+		items = []alertmanagertypes.RuleStateHistory{}
+	}
+
+	return &alertmanagertypes.RuleStateTimeline{
+		Items:  items,
+		Total:  total,
+		Labels: labelsMap,
+	}, nil
+}
+
+func (s *stateHistoryStore) GetRuleStateHistoryTopContributors(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) ([]alertmanagertypes.RuleStateHistoryContributor, error) {
+	query := fmt.Sprintf(`SELECT
+		fingerprint,
+		any(labels) as labels,
+		count(*) as count
+	FROM %s.%s
+	WHERE org_id = '%s' AND rule_id = '%s' AND (state_changed = true) AND (state = 'firing') AND unix_milli >= %d AND unix_milli <= %d
+	GROUP BY fingerprint
+	HAVING labels != '{}'
+	ORDER BY count DESC`,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End)
+
+	rows, err := s.conn.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var contributors []alertmanagertypes.RuleStateHistoryContributor
+	for rows.Next() {
+		var c alertmanagertypes.RuleStateHistoryContributor
+		if err := rows.Scan(&c.Fingerprint, &c.Labels, &c.Count); err != nil {
+			return nil, err
+		}
+		contributors = append(contributors, c)
+	}
+
+	if contributors == nil {
+		contributors = []alertmanagertypes.RuleStateHistoryContributor{}
+	}
+
+	return contributors, rows.Err()
+}
+
+func (s *stateHistoryStore) GetOverallStateTransitions(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) ([]alertmanagertypes.RuleStateTransition, error) {
+	tmpl := `WITH firing_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS firing_time
+    FROM %s.%s
+    WHERE overall_state = 'firing'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+resolution_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS resolution_time
+    FROM %s.%s
+    WHERE overall_state = 'inactive'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+matched_events AS (
+    SELECT
+        f.rule_id,
+        f.state,
+        f.firing_time,
+        MIN(r.resolution_time) AS resolution_time
+    FROM firing_events f
+    LEFT JOIN resolution_events r
+        ON f.rule_id = r.rule_id
+    WHERE r.resolution_time > f.firing_time
+    GROUP BY f.rule_id, f.state, f.firing_time
+)
+SELECT *
+FROM matched_events
+ORDER BY firing_time ASC;`
+
+	query := fmt.Sprintf(tmpl,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End)
+
+	type transition struct {
+		RuleID         string `ch:"rule_id"`
+		State          string `ch:"state"`
+		FiringTime     int64  `ch:"firing_time"`
+		ResolutionTime int64  `ch:"resolution_time"`
+	}
+
+	rows, err := s.conn.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var transitions []transition
+	for rows.Next() {
+		var t transition
+		if err := rows.Scan(&t.RuleID, &t.State, &t.FiringTime, &t.ResolutionTime); err != nil {
+			return nil, err
+		}
+		transitions = append(transitions, t)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	var stateItems []alertmanagertypes.RuleStateTransition
+
+	for idx, item := range transitions {
+		stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+			State: alertmanagertypes.AlertState{String: valuer.NewString(item.State)},
+			Start: item.FiringTime,
+			End:   item.ResolutionTime,
+		})
+		if idx < len(transitions)-1 {
+			nextStart := transitions[idx+1].FiringTime
+			if nextStart > item.ResolutionTime {
+				stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+					State: alertmanagertypes.AlertStateInactive,
+					Start: item.ResolutionTime,
+					End:   nextStart,
+				})
+			}
+		}
+	}
+
+	// Fetch the most recent state to fill in edges.
+	var lastStateStr string
+	stateQuery := fmt.Sprintf(
+		"SELECT state FROM %s.%s WHERE org_id = '%s' AND rule_id = '%s' AND unix_milli <= %d ORDER BY unix_milli DESC LIMIT 1",
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.End)
+	if err := s.conn.QueryRow(ctx, stateQuery).Scan(&lastStateStr); err != nil {
+		lastStateStr = "inactive"
+	}
+
+	if len(transitions) == 0 {
+		stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+			State: alertmanagertypes.AlertState{String: valuer.NewString(lastStateStr)},
+			Start: params.Start,
+			End:   params.End,
+		})
+	} else {
+		if lastStateStr == "inactive" {
+			stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+				State: alertmanagertypes.AlertStateInactive,
+				Start: transitions[len(transitions)-1].ResolutionTime,
+				End:   params.End,
+			})
+		} else {
+			// Find the most recent firing event.
+			var firingTime int64
+			firingQuery := fmt.Sprintf(
+				"SELECT unix_milli FROM %s.%s WHERE org_id = '%s' AND rule_id = '%s' AND overall_state_changed = true AND overall_state = 'firing' AND unix_milli <= %d ORDER BY unix_milli DESC LIMIT 1",
+				signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.End)
+			if err := s.conn.QueryRow(ctx, firingQuery).Scan(&firingTime); err != nil {
+				firingTime = transitions[len(transitions)-1].ResolutionTime
+			}
+			stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+				State: alertmanagertypes.AlertStateInactive,
+				Start: transitions[len(transitions)-1].ResolutionTime,
+				End:   firingTime,
+			})
+			stateItems = append(stateItems, alertmanagertypes.RuleStateTransition{
+				State: alertmanagertypes.AlertStateFiring,
+				Start: firingTime,
+				End:   params.End,
+			})
+		}
+	}
+
+	return stateItems, nil
+}
+
+func (s *stateHistoryStore) GetTotalTriggers(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) (uint64, error) {
+	query := fmt.Sprintf(
+		"SELECT count(*) FROM %s.%s WHERE org_id = '%s' AND rule_id = '%s' AND (state_changed = true) AND (state = 'firing') AND unix_milli >= %d AND unix_milli <= %d",
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End)
+
+	var total uint64
+	if err := s.conn.QueryRow(ctx, query).Scan(&total); err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+func (s *stateHistoryStore) GetTriggersByInterval(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) (*alertmanagertypes.Series, error) {
+	step := minAllowedStepInterval(params.Start, params.End)
+
+	query := fmt.Sprintf(
+		"SELECT count(*), toStartOfInterval(toDateTime(intDiv(unix_milli, 1000)), INTERVAL %d SECOND) as ts FROM %s.%s WHERE org_id = '%s' AND rule_id = '%s' AND (state_changed = true) AND (state = 'firing') AND unix_milli >= %d AND unix_milli <= %d GROUP BY ts ORDER BY ts ASC",
+		step, signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End)
+
+	return s.queryTimeSeries(ctx, query)
+}
+
+func (s *stateHistoryStore) GetAvgResolutionTime(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) (float64, error) {
+	tmpl := `
+WITH firing_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS firing_time
+    FROM %s.%s
+    WHERE overall_state = 'firing'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+resolution_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS resolution_time
+    FROM %s.%s
+    WHERE overall_state = 'inactive'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+matched_events AS (
+    SELECT
+        f.rule_id,
+        f.state,
+        f.firing_time,
+        MIN(r.resolution_time) AS resolution_time
+    FROM firing_events f
+    LEFT JOIN resolution_events r
+        ON f.rule_id = r.rule_id
+    WHERE r.resolution_time > f.firing_time
+    GROUP BY f.rule_id, f.state, f.firing_time
+)
+SELECT AVG(resolution_time - firing_time) / 1000 AS avg_resolution_time
+FROM matched_events;`
+
+	query := fmt.Sprintf(tmpl,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End)
+
+	var avgResolutionTime float64
+	if err := s.conn.QueryRow(ctx, query).Scan(&avgResolutionTime); err != nil {
+		return 0, err
+	}
+	return avgResolutionTime, nil
+}
+
+func (s *stateHistoryStore) GetAvgResolutionTimeByInterval(
+	ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory,
+) (*alertmanagertypes.Series, error) {
+	step := minAllowedStepInterval(params.Start, params.End)
+
+	tmpl := `
+WITH firing_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS firing_time
+    FROM %s.%s
+    WHERE overall_state = 'firing'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+resolution_events AS (
+    SELECT
+        rule_id,
+        state,
+        unix_milli AS resolution_time
+    FROM %s.%s
+    WHERE overall_state = 'inactive'
+      AND overall_state_changed = true
+      AND org_id = '%s'
+      AND rule_id = '%s'
+      AND unix_milli >= %d AND unix_milli <= %d
+),
+matched_events AS (
+    SELECT
+        f.rule_id,
+        f.state,
+        f.firing_time,
+        MIN(r.resolution_time) AS resolution_time
+    FROM firing_events f
+    LEFT JOIN resolution_events r
+        ON f.rule_id = r.rule_id
+    WHERE r.resolution_time > f.firing_time
+    GROUP BY f.rule_id, f.state, f.firing_time
+)
+SELECT toStartOfInterval(toDateTime(firing_time / 1000), INTERVAL %d SECOND) AS ts, AVG(resolution_time - firing_time) / 1000 AS avg_resolution_time
+FROM matched_events
+GROUP BY ts
+ORDER BY ts ASC;`
+
+	query := fmt.Sprintf(tmpl,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End,
+		signozHistoryDBName, ruleStateHistoryTableName, orgID, ruleID, params.Start, params.End, step)
+
+	return s.queryTimeSeries(ctx, query)
+}
+
+func (s *stateHistoryStore) queryTimeSeries(ctx context.Context, query string) (*alertmanagertypes.Series, error) {
+	rows, err := s.conn.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	series := &alertmanagertypes.Series{
+		Labels: map[string]string{},
+	}
+	for rows.Next() {
+		var value float64
+		var ts interface{}
+		if err := rows.Scan(&value, &ts); err != nil {
+			return nil, err
+		}
+		// The timestamp may come back as time.Time from ClickHouse.
+		var timestamp int64
+		switch v := ts.(type) {
+		case int64:
+			timestamp = v
+		default:
+			// Try time.Time
+			if t, ok := ts.(interface{ UnixMilli() int64 }); ok {
+				timestamp = t.UnixMilli()
+			}
+		}
+		series.Points = append(series.Points, alertmanagertypes.Point{
+			Timestamp: timestamp,
+			Value:     value,
+		})
+	}
+
+	if len(series.Points) == 0 {
+		return nil, nil
+	}
+
+	return series, rows.Err()
+}
+
+func minAllowedStepInterval(start, end int64) int64 {
+	step := (end - start) / maxPointsInTimeSeries / 1000
+	if step < 60 {
+		return 60
+	}
+	return step - step%60
+}
--- a/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/maintenance.go
+++ b/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore/maintenance.go
@@ -0,0 +1,165 @@
+package sqlalertmanagerstore
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type maintenance struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func NewMaintenanceStore(store sqlstore.SQLStore) alertmanagertypes.MaintenanceStore {
+	return &maintenance{sqlstore: store}
+}
+
+func (r *maintenance) GetAllPlannedMaintenance(ctx context.Context, orgID string) ([]*alertmanagertypes.GettablePlannedMaintenance, error) {
+	storables := make([]*alertmanagertypes.StorablePlannedMaintenance, 0)
+	err := r.sqlstore.
+		BunDB().
+		NewSelect().
+		Model(&storables).
+		Where("org_id = ?", orgID).
+		Scan(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]*alertmanagertypes.GettablePlannedMaintenance, 0, len(storables))
+	for _, s := range storables {
+		result = append(result, alertmanagertypes.ConvertStorableToGettable(s))
+	}
+
+	return result, nil
+}
+
+func (r *maintenance) GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*alertmanagertypes.GettablePlannedMaintenance, error) {
+	storable := new(alertmanagertypes.StorablePlannedMaintenance)
+	err := r.sqlstore.
+		BunDB().
+		NewSelect().
+		Model(storable).
+		Where("id = ?", id.StringValue()).
+		Scan(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return alertmanagertypes.ConvertStorableToGettable(storable), nil
+}
+
+func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance) (valuer.UUID, error) {
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		return valuer.UUID{}, err
+	}
+
+	var ruleIDsStr string
+	if len(maintenance.RuleIDs) > 0 {
+		data, err := json.Marshal(maintenance.RuleIDs)
+		if err != nil {
+			return valuer.UUID{}, err
+		}
+		ruleIDsStr = string(data)
+	}
+
+	storable := alertmanagertypes.StorablePlannedMaintenance{
+		Identifiable: types.Identifiable{
+			ID: valuer.GenerateUUID(),
+		},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+		UserAuditable: types.UserAuditable{
+			CreatedBy: claims.Email,
+			UpdatedBy: claims.Email,
+		},
+		Name:        maintenance.Name,
+		Description: maintenance.Description,
+		Schedule:    maintenance.Schedule,
+		RuleIDs:     ruleIDsStr,
+		Expression:  maintenance.Expression,
+		OrgID:       claims.OrgID,
+	}
+
+	_, err = r.sqlstore.
+		BunDB().
+		NewInsert().
+		Model(&storable).
+		Exec(ctx)
+	if err != nil {
+		return valuer.UUID{}, err
+	}
+
+	return storable.ID, nil
+}
+
+func (r *maintenance) DeletePlannedMaintenance(ctx context.Context, id valuer.UUID) error {
+	_, err := r.sqlstore.
+		BunDB().
+		NewDelete().
+		Model(new(alertmanagertypes.StorablePlannedMaintenance)).
+		Where("id = ?", id.StringValue()).
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *maintenance) EditPlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance, id valuer.UUID) error {
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	var ruleIDsStr string
+	if len(maintenance.RuleIDs) > 0 {
+		data, err := json.Marshal(maintenance.RuleIDs)
+		if err != nil {
+			return err
+		}
+		ruleIDsStr = string(data)
+	}
+
+	storable := alertmanagertypes.StorablePlannedMaintenance{
+		Identifiable: types.Identifiable{
+			ID: id,
+		},
+		TimeAuditable: types.TimeAuditable{
+			CreatedAt: maintenance.CreatedAt,
+			UpdatedAt: time.Now(),
+		},
+		UserAuditable: types.UserAuditable{
+			CreatedBy: maintenance.CreatedBy,
+			UpdatedBy: claims.Email,
+		},
+		Name:        maintenance.Name,
+		Description: maintenance.Description,
+		Schedule:    maintenance.Schedule,
+		RuleIDs:     ruleIDsStr,
+		Expression:  maintenance.Expression,
+		OrgID:       claims.OrgID,
+	}
+
+	_, err = r.sqlstore.
+		BunDB().
+		NewUpdate().
+		Model(&storable).
+		Where("id = ?", storable.ID.StringValue()).
+		Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/pkg/alertmanager/alertmanagertest/alertmanager.go
+++ b/pkg/alertmanager/alertmanagertest/alertmanager.go
@@ -1845,3 +1845,216 @@ func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) RunAndReturn(run func(ctx
 	_c.Call.Return(run)
 	return _c
 }
+
+// GetAllPlannedMaintenance provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetAllPlannedMaintenance(ctx context.Context, orgID string) ([]*alertmanagertypes.GettablePlannedMaintenance, error) {
+	ret := _mock.Called(ctx, orgID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllPlannedMaintenance")
+	}
+
+	var r0 []*alertmanagertypes.GettablePlannedMaintenance
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*alertmanagertypes.GettablePlannedMaintenance, error)); ok {
+		return returnFunc(ctx, orgID)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).([]*alertmanagertypes.GettablePlannedMaintenance)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// GetPlannedMaintenanceByID provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*alertmanagertypes.GettablePlannedMaintenance, error) {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPlannedMaintenanceByID")
+	}
+
+	var r0 *alertmanagertypes.GettablePlannedMaintenance
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (*alertmanagertypes.GettablePlannedMaintenance, error)); ok {
+		return returnFunc(ctx, id)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*alertmanagertypes.GettablePlannedMaintenance)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// CreatePlannedMaintenance provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) CreatePlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance) (valuer.UUID, error) {
+	ret := _mock.Called(ctx, maintenance)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreatePlannedMaintenance")
+	}
+
+	var r0 valuer.UUID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, alertmanagertypes.GettablePlannedMaintenance) (valuer.UUID, error)); ok {
+		return returnFunc(ctx, maintenance)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, alertmanagertypes.GettablePlannedMaintenance) valuer.UUID); ok {
+		r0 = returnFunc(ctx, maintenance)
+	} else {
+		r0 = ret.Get(0).(valuer.UUID)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// EditPlannedMaintenance provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) EditPlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance, id valuer.UUID) error {
+	ret := _mock.Called(ctx, maintenance, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for EditPlannedMaintenance")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, alertmanagertypes.GettablePlannedMaintenance, valuer.UUID) error); ok {
+		r0 = returnFunc(ctx, maintenance, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// DeletePlannedMaintenance provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) DeletePlannedMaintenance(ctx context.Context, id valuer.UUID) error {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeletePlannedMaintenance")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// RecordRuleStateHistory provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) RecordRuleStateHistory(ctx context.Context, orgID string, entries []alertmanagertypes.RuleStateHistory) error {
+	ret := _mock.Called(ctx, orgID, entries)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RecordRuleStateHistory")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []alertmanagertypes.RuleStateHistory) error); ok {
+		r0 = returnFunc(ctx, orgID, entries)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// GetLastSavedRuleStateHistory provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetLastSavedRuleStateHistory(ctx context.Context, ruleID string) ([]alertmanagertypes.RuleStateHistory, error) {
+	ret := _mock.Called(ctx, ruleID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLastSavedRuleStateHistory")
+	}
+
+	var r0 []alertmanagertypes.RuleStateHistory
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]alertmanagertypes.RuleStateHistory, error)); ok {
+		return returnFunc(ctx, ruleID)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).([]alertmanagertypes.RuleStateHistory)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// GetRuleStateHistoryTimeline provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetRuleStateHistoryTimeline(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error) {
+	ret := _mock.Called(ctx, orgID, ruleID, params)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRuleStateHistoryTimeline")
+	}
+
+	var r0 *alertmanagertypes.RuleStateTimeline
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error)); ok {
+		return returnFunc(ctx, orgID, ruleID, params)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*alertmanagertypes.RuleStateTimeline)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// GetRuleStateHistoryTopContributors provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetRuleStateHistoryTopContributors(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error) {
+	ret := _mock.Called(ctx, orgID, ruleID, params)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRuleStateHistoryTopContributors")
+	}
+
+	var r0 []alertmanagertypes.RuleStateHistoryContributor
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error)); ok {
+		return returnFunc(ctx, orgID, ruleID, params)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).([]alertmanagertypes.RuleStateHistoryContributor)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// GetOverallStateTransitions provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetOverallStateTransitions(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error) {
+	ret := _mock.Called(ctx, orgID, ruleID, params)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOverallStateTransitions")
+	}
+
+	var r0 []alertmanagertypes.RuleStateTransition
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error)); ok {
+		return returnFunc(ctx, orgID, ruleID, params)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).([]alertmanagertypes.RuleStateTransition)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
+
+// GetRuleStats provides a mock function for the type MockAlertmanager
+func (_mock *MockAlertmanager) GetRuleStats(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStats, error) {
+	ret := _mock.Called(ctx, orgID, ruleID, params)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRuleStats")
+	}
+
+	var r0 *alertmanagertypes.RuleStats
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStats, error)); ok {
+		return returnFunc(ctx, orgID, ruleID, params)
+	}
+	if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*alertmanagertypes.RuleStats)
+	}
+	r1 = ret.Error(1)
+	return r0, r1
+}
--- a/pkg/alertmanager/api.go
+++ b/pkg/alertmanager/api.go
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"io"
 	"net/http"
+	"strconv"
 	"time"

 	"github.com/SigNoz/signoz/pkg/errors"
@@ -399,3 +400,312 @@ func (api *API) UpdateRoutePolicy(rw http.ResponseWriter, req *http.Request) {
 	}
 	render.Success(rw, http.StatusOK, result)
 }
+
+func (api *API) ListDowntimeSchedules(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	schedules, err := api.alertmanager.GetAllPlannedMaintenance(ctx, claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if q := req.URL.Query().Get("active"); q != "" {
+		active, _ := strconv.ParseBool(q)
+		filtered := make([]*alertmanagertypes.GettablePlannedMaintenance, 0)
+		for _, schedule := range schedules {
+			now := time.Now().In(time.FixedZone(schedule.Schedule.Timezone, 0))
+			if schedule.IsActive(now) == active {
+				filtered = append(filtered, schedule)
+			}
+		}
+		schedules = filtered
+	}
+
+	if q := req.URL.Query().Get("recurring"); q != "" {
+		recurring, _ := strconv.ParseBool(q)
+		filtered := make([]*alertmanagertypes.GettablePlannedMaintenance, 0)
+		for _, schedule := range schedules {
+			if schedule.IsRecurring() == recurring {
+				filtered = append(filtered, schedule)
+			}
+		}
+		schedules = filtered
+	}
+
+	render.Success(rw, http.StatusOK, schedules)
+}
+
+func (api *API) GetDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	vars := mux.Vars(req)
+	idString, ok := vars["id"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required in path"))
+		return
+	}
+
+	id, err := valuer.NewUUID(idString)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	schedule, err := api.alertmanager.GetPlannedMaintenanceByID(ctx, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, schedule)
+}
+
+func (api *API) CreateDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	var schedule alertmanagertypes.GettablePlannedMaintenance
+	if err := json.Unmarshal(body, &schedule); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+
+	if err := schedule.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	_, err = api.alertmanager.CreatePlannedMaintenance(ctx, schedule)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, nil)
+}
+
+func (api *API) EditDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	vars := mux.Vars(req)
+	idString, ok := vars["id"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required in path"))
+		return
+	}
+
+	id, err := valuer.NewUUID(idString)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+	defer req.Body.Close() //nolint:errcheck
+
+	var schedule alertmanagertypes.GettablePlannedMaintenance
+	if err := json.Unmarshal(body, &schedule); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+
+	if err := schedule.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	err = api.alertmanager.EditPlannedMaintenance(ctx, schedule, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, nil)
+}
+
+func (api *API) DeleteDowntimeSchedule(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	vars := mux.Vars(req)
+	idString, ok := vars["id"]
+	if !ok {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is required in path"))
+		return
+	}
+
+	id, err := valuer.NewUUID(idString)
+	if err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is not a valid uuid-v7"))
+		return
+	}
+
+	err = api.alertmanager.DeletePlannedMaintenance(ctx, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+func (api *API) GetRuleStateHistoryTimeline(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	ruleID := mux.Vars(req)["id"]
+	if ruleID == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "rule ID is required"))
+		return
+	}
+
+	var params alertmanagertypes.QueryRuleStateHistory
+	if err := json.NewDecoder(req.Body).Decode(&params); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+	if err := params.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := api.alertmanager.GetRuleStateHistoryTimeline(ctx, claims.OrgID, ruleID, &params)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
+
+func (api *API) GetRuleStats(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	ruleID := mux.Vars(req)["id"]
+	if ruleID == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "rule ID is required"))
+		return
+	}
+
+	var params alertmanagertypes.QueryRuleStateHistory
+	if err := json.NewDecoder(req.Body).Decode(&params); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+	if err := params.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := api.alertmanager.GetRuleStats(ctx, claims.OrgID, ruleID, &params)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
+
+func (api *API) GetRuleStateHistoryTopContributors(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	ruleID := mux.Vars(req)["id"]
+	if ruleID == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "rule ID is required"))
+		return
+	}
+
+	var params alertmanagertypes.QueryRuleStateHistory
+	if err := json.NewDecoder(req.Body).Decode(&params); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+	if err := params.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := api.alertmanager.GetRuleStateHistoryTopContributors(ctx, claims.OrgID, ruleID, &params)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
+
+func (api *API) GetOverallStateTransitions(rw http.ResponseWriter, req *http.Request) {
+	ctx, cancel := context.WithTimeout(req.Context(), 30*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	ruleID := mux.Vars(req)["id"]
+	if ruleID == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "rule ID is required"))
+		return
+	}
+
+	var params alertmanagertypes.QueryRuleStateHistory
+	if err := json.NewDecoder(req.Body).Decode(&params); err != nil {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid request body: %v", err))
+		return
+	}
+	if err := params.Validate(); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := api.alertmanager.GetOverallStateTransitions(ctx, claims.OrgID, ruleID, &params)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}
--- a/pkg/alertmanager/api_test.go
+++ b/pkg/alertmanager/api_test.go
--- a/pkg/alertmanager/service.go
+++ b/pkg/alertmanager/service.go
@@ -2,10 +2,15 @@ package alertmanager

 import (
 	"context"
+	"encoding/json"
+	"math"
 	"sync"
+	"time"

 	"github.com/prometheus/alertmanager/featurecontrol"
 	"github.com/prometheus/alertmanager/matcher/compat"
+	amtypes "github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"

 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerserver"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
@@ -38,6 +43,15 @@ type Service struct {
 	serversMtx sync.RWMutex

 	notificationManager nfmanager.NotificationManager
+
+	// maintenanceExprMuter is an optional muter for expression-based maintenance scoping
+	maintenanceExprMuter amtypes.Muter
+
+	// stateHistoryStore writes rule state history to persistent storage (e.g. ClickHouse)
+	stateHistoryStore alertmanagertypes.StateHistoryStore
+
+	// stateTracker tracks alert state transitions for v2 state history recording
+	stateTracker *stateTracker
 }

 func New(
@@ -48,16 +62,21 @@ func New(
 	configStore alertmanagertypes.ConfigStore,
 	orgGetter organization.Getter,
 	nfManager nfmanager.NotificationManager,
+	maintenanceExprMuter amtypes.Muter,
+	stateHistoryStore alertmanagertypes.StateHistoryStore,
 ) *Service {
 	service := &Service{
-		config:              config,
-		stateStore:          stateStore,
-		configStore:         configStore,
-		orgGetter:           orgGetter,
-		settings:            settings,
-		servers:             make(map[string]*alertmanagerserver.Server),
-		serversMtx:          sync.RWMutex{},
-		notificationManager: nfManager,
+		config:               config,
+		stateStore:           stateStore,
+		configStore:          configStore,
+		orgGetter:            orgGetter,
+		settings:             settings,
+		servers:              make(map[string]*alertmanagerserver.Server),
+		serversMtx:           sync.RWMutex{},
+		notificationManager:  nfManager,
+		maintenanceExprMuter: maintenanceExprMuter,
+		stateHistoryStore:   stateHistoryStore,
+		stateTracker:         newStateTracker(),
 	}

 	return service
@@ -131,7 +150,21 @@ func (service *Service) PutAlerts(ctx context.Context, orgID string, alerts aler
 		return err
 	}

-	return server.PutAlerts(ctx, alerts)
+	// Convert to typed alerts for state tracking (same conversion the server does).
+	now := time.Now()
+	typedAlerts, _ := alertmanagertypes.NewAlertsFromPostableAlerts(
+		alerts, time.Duration(service.config.Global.ResolveTimeout), now,
+	)
+
+	// Delegate to server for notification pipeline.
+	if err := server.PutAlerts(ctx, alerts); err != nil {
+		return err
+	}
+
+	// Record state history from the incoming alerts.
+	service.recordStateHistoryFromAlerts(ctx, orgID, typedAlerts, now)
+
+	return nil
 }

 func (service *Service) TestReceiver(ctx context.Context, orgID string, receiver alertmanagertypes.Receiver) error {
@@ -176,7 +209,7 @@ func (service *Service) newServer(ctx context.Context, orgID string) (*alertmana
 		return nil, err
 	}

-	server, err := alertmanagerserver.New(ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID, service.stateStore, service.notificationManager)
+	server, err := alertmanagerserver.New(ctx, service.settings.Logger(), service.settings.PrometheusRegisterer(), service.config, orgID, service.stateStore, service.notificationManager, service.maintenanceExprMuter)
 	if err != nil {
 		return nil, err
 	}
@@ -255,6 +288,205 @@ func (service *Service) compareAndSelectConfig(ctx context.Context, incomingConf

 }

+// RecordRuleStateHistory applies maintenance muting logic and writes state history entries.
+// For each entry with State=="firing", if the maintenance muter matches the entry's labels,
+// the state is changed to "muted" before writing.
+func (service *Service) RecordRuleStateHistory(ctx context.Context, orgID string, entries []alertmanagertypes.RuleStateHistory) error {
+	if service.stateHistoryStore == nil {
+		return nil
+	}
+
+	for i := range entries {
+		entries[i].OrgID = orgID
+	}
+
+	if service.maintenanceExprMuter != nil {
+		for i := range entries {
+			if entries[i].State != "firing" {
+				continue
+			}
+			lbls := labelsFromJSON(entries[i].Labels)
+			if lbls == nil {
+				continue
+			}
+			// Add ruleId to the label set for muter matching.
+			lbls["ruleId"] = model.LabelValue(entries[i].RuleID)
+			if service.maintenanceExprMuter.Mutes(lbls) {
+				entries[i].State = "muted"
+			}
+		}
+	}
+
+	return service.stateHistoryStore.WriteRuleStateHistory(ctx, entries)
+}
+
+func (service *Service) GetLastSavedRuleStateHistory(ctx context.Context, ruleID string) ([]alertmanagertypes.RuleStateHistory, error) {
+	if service.stateHistoryStore == nil {
+		return nil, nil
+	}
+
+	return service.stateHistoryStore.GetLastSavedRuleStateHistory(ctx, ruleID)
+}
+
+func (service *Service) GetRuleStateHistoryTimeline(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error) {
+	if service.stateHistoryStore == nil {
+		return &alertmanagertypes.RuleStateTimeline{Items: []alertmanagertypes.RuleStateHistory{}}, nil
+	}
+	return service.stateHistoryStore.GetRuleStateHistoryTimeline(ctx, orgID, ruleID, params)
+}
+
+func (service *Service) GetRuleStateHistoryTopContributors(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error) {
+	if service.stateHistoryStore == nil {
+		return []alertmanagertypes.RuleStateHistoryContributor{}, nil
+	}
+	return service.stateHistoryStore.GetRuleStateHistoryTopContributors(ctx, orgID, ruleID, params)
+}
+
+func (service *Service) GetOverallStateTransitions(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error) {
+	if service.stateHistoryStore == nil {
+		return []alertmanagertypes.RuleStateTransition{}, nil
+	}
+	return service.stateHistoryStore.GetOverallStateTransitions(ctx, orgID, ruleID, params)
+}
+
+func (service *Service) GetRuleStats(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStats, error) {
+	if service.stateHistoryStore == nil {
+		return &alertmanagertypes.RuleStats{}, nil
+	}
+
+	store := service.stateHistoryStore
+
+	// Current period stats.
+	totalCurrentTriggers, err := store.GetTotalTriggers(ctx, orgID, ruleID, params)
+	if err != nil {
+		return nil, err
+	}
+	currentTriggersSeries, err := store.GetTriggersByInterval(ctx, orgID, ruleID, params)
+	if err != nil {
+		return nil, err
+	}
+	currentAvgResolutionTime, err := store.GetAvgResolutionTime(ctx, orgID, ruleID, params)
+	if err != nil {
+		return nil, err
+	}
+	currentAvgResolutionTimeSeries, err := store.GetAvgResolutionTimeByInterval(ctx, orgID, ruleID, params)
+	if err != nil {
+		return nil, err
+	}
+
+	// Past period stats — shift time window backward.
+	pastParams := *params
+	duration := params.End - params.Start
+	if duration >= 86400000 {
+		days := int64(math.Ceil(float64(duration) / 86400000))
+		pastParams.Start -= days * 86400000
+		pastParams.End -= days * 86400000
+	} else {
+		pastParams.Start -= 86400000
+		pastParams.End -= 86400000
+	}
+
+	totalPastTriggers, err := store.GetTotalTriggers(ctx, orgID, ruleID, &pastParams)
+	if err != nil {
+		return nil, err
+	}
+	pastTriggersSeries, err := store.GetTriggersByInterval(ctx, orgID, ruleID, &pastParams)
+	if err != nil {
+		return nil, err
+	}
+	pastAvgResolutionTime, err := store.GetAvgResolutionTime(ctx, orgID, ruleID, &pastParams)
+	if err != nil {
+		return nil, err
+	}
+	pastAvgResolutionTimeSeries, err := store.GetAvgResolutionTimeByInterval(ctx, orgID, ruleID, &pastParams)
+	if err != nil {
+		return nil, err
+	}
+
+	if math.IsNaN(currentAvgResolutionTime) || math.IsInf(currentAvgResolutionTime, 0) {
+		currentAvgResolutionTime = 0
+	}
+	if math.IsNaN(pastAvgResolutionTime) || math.IsInf(pastAvgResolutionTime, 0) {
+		pastAvgResolutionTime = 0
+	}
+
+	return &alertmanagertypes.RuleStats{
+		TotalCurrentTriggers:           totalCurrentTriggers,
+		TotalPastTriggers:              totalPastTriggers,
+		CurrentTriggersSeries:          currentTriggersSeries,
+		PastTriggersSeries:             pastTriggersSeries,
+		CurrentAvgResolutionTime:       currentAvgResolutionTime,
+		PastAvgResolutionTime:          pastAvgResolutionTime,
+		CurrentAvgResolutionTimeSeries: currentAvgResolutionTimeSeries,
+		PastAvgResolutionTimeSeries:    pastAvgResolutionTimeSeries,
+	}, nil
+}
+
+// recordStateHistoryFromAlerts detects state transitions from incoming alerts
+// and records them via RecordRuleStateHistory (which applies maintenance muting).
+func (service *Service) recordStateHistoryFromAlerts(ctx context.Context, orgID string, alerts []*amtypes.Alert, now time.Time) {
+	if service.stateHistoryStore == nil {
+		return
+	}
+
+	entries := service.stateTracker.processAlerts(orgID, alerts, now)
+	if len(entries) == 0 {
+		return
+	}
+
+	if err := service.RecordRuleStateHistory(ctx, orgID, entries); err != nil {
+		service.settings.Logger().ErrorContext(ctx, "failed to record state history", "error", err)
+	}
+}
+
+// StartStateHistorySweep starts a background goroutine that periodically checks
+// for stale firing alerts and records them as resolved. Call this once after creating the service.
+func (service *Service) StartStateHistorySweep(ctx context.Context) {
+	if service.stateHistoryStore == nil {
+		return
+	}
+
+	staleTimeout := 2 * time.Duration(service.config.Global.ResolveTimeout)
+	if staleTimeout == 0 {
+		staleTimeout = 10 * time.Minute
+	}
+
+	go func() {
+		ticker := time.NewTicker(1 * time.Minute)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				now := time.Now()
+				entriesByOrg := service.stateTracker.sweepStale(staleTimeout, now)
+				for orgID, orgEntries := range entriesByOrg {
+					if err := service.RecordRuleStateHistory(ctx, orgID, orgEntries); err != nil {
+						service.settings.Logger().ErrorContext(ctx, "failed to record stale state history", "org_id", orgID, "error", err)
+					}
+				}
+			}
+		}
+	}()
+}
+
+// labelsFromJSON parses a JSON string of labels into a model.LabelSet.
+func labelsFromJSON(labelsJSON string) model.LabelSet {
+	if labelsJSON == "" {
+		return nil
+	}
+	var m map[string]string
+	if err := json.Unmarshal([]byte(labelsJSON), &m); err != nil {
+		return nil
+	}
+	ls := make(model.LabelSet, len(m))
+	for k, v := range m {
+		ls[model.LabelName(k)] = model.LabelValue(v)
+	}
+	return ls
+}
+
 // getServer returns the server for the given orgID. It should be called with the lock held.
 func (service *Service) getServer(orgID string) (*alertmanagerserver.Server, error) {
 	server, ok := service.servers[orgID]
--- a/pkg/alertmanager/service_test.go
+++ b/pkg/alertmanager/service_test.go
@@ -0,0 +1,426 @@
+package alertmanager
+
+import (
+	"context"
+	"math"
+	"sync"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// testMuter implements amtypes.Muter for testing.
+type testMuter struct {
+	mu       sync.Mutex
+	muteFunc func(model.LabelSet) bool
+	calls    []model.LabelSet
+}
+
+func (m *testMuter) Mutes(labels model.LabelSet) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.calls = append(m.calls, labels)
+	if m.muteFunc != nil {
+		return m.muteFunc(labels)
+	}
+	return false
+}
+
+func (m *testMuter) getCalls() []model.LabelSet {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	result := make([]model.LabelSet, len(m.calls))
+	copy(result, m.calls)
+	return result
+}
+
+// fakeStateHistoryStore captures calls for assertion.
+type fakeStateHistoryStore struct {
+	written   []alertmanagertypes.RuleStateHistory
+	lastErr   error
+	getResult []alertmanagertypes.RuleStateHistory
+	getErr    error
+
+	// Stats method returns
+	totalTriggers          uint64
+	totalTriggersErr       error
+	triggersSeries         *alertmanagertypes.Series
+	triggersSeriesErr      error
+	avgResolutionTime      float64
+	avgResolutionTimeErr   error
+	avgResTimeSeries       *alertmanagertypes.Series
+	avgResTimeSeriesErr    error
+
+	// Captures params passed to stats methods
+	statsCalls []*alertmanagertypes.QueryRuleStateHistory
+}
+
+func (w *fakeStateHistoryStore) WriteRuleStateHistory(_ context.Context, entries []alertmanagertypes.RuleStateHistory) error {
+	w.written = append(w.written, entries...)
+	return w.lastErr
+}
+
+func (w *fakeStateHistoryStore) GetLastSavedRuleStateHistory(_ context.Context, _ string) ([]alertmanagertypes.RuleStateHistory, error) {
+	return w.getResult, w.getErr
+}
+
+func (w *fakeStateHistoryStore) GetRuleStateHistoryTimeline(_ context.Context, _ string, _ string, _ *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error) {
+	return nil, nil
+}
+
+func (w *fakeStateHistoryStore) GetRuleStateHistoryTopContributors(_ context.Context, _ string, _ string, _ *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error) {
+	return nil, nil
+}
+
+func (w *fakeStateHistoryStore) GetOverallStateTransitions(_ context.Context, _ string, _ string, _ *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error) {
+	return nil, nil
+}
+
+func (w *fakeStateHistoryStore) GetTotalTriggers(_ context.Context, _ string, _ string, params *alertmanagertypes.QueryRuleStateHistory) (uint64, error) {
+	w.statsCalls = append(w.statsCalls, params)
+	return w.totalTriggers, w.totalTriggersErr
+}
+
+func (w *fakeStateHistoryStore) GetTriggersByInterval(_ context.Context, _ string, _ string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.Series, error) {
+	w.statsCalls = append(w.statsCalls, params)
+	return w.triggersSeries, w.triggersSeriesErr
+}
+
+func (w *fakeStateHistoryStore) GetAvgResolutionTime(_ context.Context, _ string, _ string, params *alertmanagertypes.QueryRuleStateHistory) (float64, error) {
+	w.statsCalls = append(w.statsCalls, params)
+	return w.avgResolutionTime, w.avgResolutionTimeErr
+}
+
+func (w *fakeStateHistoryStore) GetAvgResolutionTimeByInterval(_ context.Context, _ string, _ string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.Series, error) {
+	w.statsCalls = append(w.statsCalls, params)
+	return w.avgResTimeSeries, w.avgResTimeSeriesErr
+}
+
+func TestLabelsFromJSON(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  model.LabelSet
+	}{
+		{
+			name:  "empty string",
+			input: "",
+			want:  nil,
+		},
+		{
+			name:  "invalid json",
+			input: "not json",
+			want:  nil,
+		},
+		{
+			name:  "valid labels",
+			input: `{"env":"prod","severity":"critical"}`,
+			want: model.LabelSet{
+				"env":      "prod",
+				"severity": "critical",
+			},
+		},
+		{
+			name:  "empty object",
+			input: `{}`,
+			want:  model.LabelSet{},
+		},
+		{
+			name:  "single label",
+			input: `{"alertname":"HighCPU"}`,
+			want:  model.LabelSet{"alertname": "HighCPU"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := labelsFromJSON(tc.input)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
+
+func TestRecordRuleStateHistory(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("nil writer returns nil", func(t *testing.T) {
+		svc := &Service{stateHistoryStore: nil}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing"},
+		})
+		require.NoError(t, err)
+	})
+
+	t.Run("no muter writes entries unchanged", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: nil,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Labels: `{"env":"prod"}`},
+			{RuleID: "r2", State: "normal", Labels: `{"env":"staging"}`},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 2)
+		assert.Equal(t, "firing", writer.written[0].State)
+		assert.Equal(t, "normal", writer.written[1].State)
+	})
+
+	t.Run("muter changes firing to muted when matched", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(ls model.LabelSet) bool {
+				return ls["env"] == "prod"
+			},
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Labels: `{"env":"prod"}`},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 1)
+		assert.Equal(t, "muted", writer.written[0].State)
+	})
+
+	t.Run("muter does not change firing when not matched", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(ls model.LabelSet) bool {
+				return ls["env"] == "prod"
+			},
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Labels: `{"env":"staging"}`},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 1)
+		assert.Equal(t, "firing", writer.written[0].State)
+	})
+
+	t.Run("muter only affects firing entries", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(model.LabelSet) bool { return true }, // mute everything
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "normal", Labels: `{"env":"prod"}`},
+			{RuleID: "r2", State: "no_data", Labels: `{"env":"prod"}`},
+			{RuleID: "r3", State: "firing", Labels: `{"env":"prod"}`},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 3)
+		assert.Equal(t, "normal", writer.written[0].State, "normal should not be muted")
+		assert.Equal(t, "no_data", writer.written[1].State, "no_data should not be muted")
+		assert.Equal(t, "muted", writer.written[2].State, "firing should become muted")
+	})
+
+	t.Run("ruleId is injected into labels for muter evaluation", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(ls model.LabelSet) bool {
+				return ls["ruleId"] == "target-rule"
+			},
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "target-rule", State: "firing", Labels: `{"env":"prod"}`},
+			{RuleID: "other-rule", State: "firing", Labels: `{"env":"prod"}`},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 2)
+		assert.Equal(t, "muted", writer.written[0].State, "target-rule should be muted")
+		assert.Equal(t, "firing", writer.written[1].State, "other-rule should not be muted")
+
+		// Verify the muter received labels with ruleId injected
+		calls := muter.getCalls()
+		require.Len(t, calls, 2)
+		assert.Equal(t, model.LabelValue("target-rule"), calls[0]["ruleId"])
+		assert.Equal(t, model.LabelValue("other-rule"), calls[1]["ruleId"])
+	})
+
+	t.Run("invalid labels JSON skips muting check", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(model.LabelSet) bool { return true },
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Labels: "not-json"},
+			{RuleID: "r2", State: "firing", Labels: ""},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 2)
+		// Both should stay firing because labels couldn't be parsed
+		assert.Equal(t, "firing", writer.written[0].State)
+		assert.Equal(t, "firing", writer.written[1].State)
+		// Muter should not have been called
+		assert.Empty(t, muter.getCalls())
+	})
+
+	t.Run("mixed entries with selective muting", func(t *testing.T) {
+		writer := &fakeStateHistoryStore{}
+		muter := &testMuter{
+			muteFunc: func(ls model.LabelSet) bool {
+				return ls["severity"] == "warning"
+			},
+		}
+		svc := &Service{
+			stateHistoryStore:   writer,
+			maintenanceExprMuter: muter,
+		}
+
+		entries := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Labels: `{"severity":"critical"}`, Fingerprint: 1},
+			{RuleID: "r2", State: "firing", Labels: `{"severity":"warning"}`, Fingerprint: 2},
+			{RuleID: "r3", State: "normal", Labels: `{"severity":"warning"}`, Fingerprint: 3},
+			{RuleID: "r4", State: "firing", Labels: `{"severity":"warning"}`, Fingerprint: 4},
+		}
+		err := svc.RecordRuleStateHistory(ctx, "org-1", entries)
+		require.NoError(t, err)
+		require.Len(t, writer.written, 4)
+		assert.Equal(t, "firing", writer.written[0].State, "critical firing stays firing")
+		assert.Equal(t, "muted", writer.written[1].State, "warning firing becomes muted")
+		assert.Equal(t, "normal", writer.written[2].State, "normal is never muted")
+		assert.Equal(t, "muted", writer.written[3].State, "warning firing becomes muted")
+	})
+}
+
+func TestGetLastSavedRuleStateHistory(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("nil writer returns nil", func(t *testing.T) {
+		svc := &Service{stateHistoryStore: nil}
+		result, err := svc.GetLastSavedRuleStateHistory(ctx, "r1")
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("delegates to writer", func(t *testing.T) {
+		expected := []alertmanagertypes.RuleStateHistory{
+			{RuleID: "r1", State: "firing", Fingerprint: 123},
+		}
+		writer := &fakeStateHistoryStore{getResult: expected}
+		svc := &Service{stateHistoryStore: writer}
+
+		result, err := svc.GetLastSavedRuleStateHistory(ctx, "r1")
+		require.NoError(t, err)
+		assert.Equal(t, expected, result)
+	})
+}
+
+func TestGetRuleStats(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("aggregates current and past period stats", func(t *testing.T) {
+		currentSeries := &alertmanagertypes.Series{Points: []alertmanagertypes.Point{{Timestamp: 1000, Value: 5}}}
+		currentResSeries := &alertmanagertypes.Series{Points: []alertmanagertypes.Point{{Timestamp: 1000, Value: 120}}}
+		store := &fakeStateHistoryStore{
+			totalTriggers:     10,
+			triggersSeries:    currentSeries,
+			avgResolutionTime: 300.5,
+			avgResTimeSeries:  currentResSeries,
+		}
+		svc := &Service{stateHistoryStore: store}
+
+		params := &alertmanagertypes.QueryRuleStateHistory{
+			Start: 1000,
+			End:   90000000, // ~1 day
+		}
+		result, err := svc.GetRuleStats(ctx, "org-1", "rule-1", params)
+		require.NoError(t, err)
+
+		assert.Equal(t, uint64(10), result.TotalCurrentTriggers)
+		assert.Equal(t, uint64(10), result.TotalPastTriggers)
+		assert.Equal(t, currentSeries, result.CurrentTriggersSeries)
+		assert.Equal(t, 300.5, result.CurrentAvgResolutionTime)
+	})
+
+	t.Run("period shifting for duration >= 1 day", func(t *testing.T) {
+		store := &fakeStateHistoryStore{}
+		svc := &Service{stateHistoryStore: store}
+
+		// 2-day window: Start=0, End=172800000 (2 days in millis)
+		params := &alertmanagertypes.QueryRuleStateHistory{
+			Start: 0,
+			End:   172800000,
+		}
+		_, err := svc.GetRuleStats(ctx, "org-1", "rule-1", params)
+		require.NoError(t, err)
+
+		// First 4 calls are current period, next 4 are past period.
+		// For 2 days: ceil(172800000/86400000) = 2, shift = 2*86400000 = 172800000
+		require.GreaterOrEqual(t, len(store.statsCalls), 8)
+		pastParams := store.statsCalls[4] // first past period call
+		assert.Equal(t, int64(-172800000), pastParams.Start)
+		assert.Equal(t, int64(0), pastParams.End)
+	})
+
+	t.Run("period shifting for duration < 1 day", func(t *testing.T) {
+		store := &fakeStateHistoryStore{}
+		svc := &Service{stateHistoryStore: store}
+
+		// 1-hour window
+		params := &alertmanagertypes.QueryRuleStateHistory{
+			Start: 100000000,
+			End:   103600000, // 3600000ms = 1 hour
+		}
+		_, err := svc.GetRuleStats(ctx, "org-1", "rule-1", params)
+		require.NoError(t, err)
+
+		// For < 1 day: shift by exactly 1 day (86400000ms)
+		require.GreaterOrEqual(t, len(store.statsCalls), 8)
+		pastParams := store.statsCalls[4]
+		assert.Equal(t, int64(100000000-86400000), pastParams.Start)
+		assert.Equal(t, int64(103600000-86400000), pastParams.End)
+	})
+
+	t.Run("NaN and Inf avg resolution times are zeroed", func(t *testing.T) {
+		for _, val := range []float64{math.NaN(), math.Inf(1), math.Inf(-1)} {
+			store := &fakeStateHistoryStore{
+				avgResolutionTime: val,
+			}
+			svc := &Service{stateHistoryStore: store}
+
+			result, err := svc.GetRuleStats(ctx, "org-1", "rule-1", &alertmanagertypes.QueryRuleStateHistory{
+				Start: 0, End: 100000000,
+			})
+			require.NoError(t, err)
+			assert.Equal(t, float64(0), result.CurrentAvgResolutionTime)
+			assert.Equal(t, float64(0), result.PastAvgResolutionTime)
+		}
+	})
+}
+
--- a/pkg/alertmanager/signozalertmanager/expreval.go
+++ b/pkg/alertmanager/signozalertmanager/expreval.go
@@ -0,0 +1,150 @@
+package signozalertmanager
+
+import (
+	"log/slog"
+	"strings"
+	"sync"
+
+	"github.com/expr-lang/expr"
+	"github.com/prometheus/common/model"
+)
+
+// convertLabelSetToEnv converts a flat label set with dotted keys into a nested map
+// structure for expr-lang evaluation. When both a leaf and a deeper nested path exist
+// (e.g. "foo" and "foo.bar"), the nested structure takes precedence.
+func convertLabelSetToEnv(labelSet model.LabelSet) map[string]interface{} {
+	env := make(map[string]interface{})
+
+	for lk, lv := range labelSet {
+		key := strings.TrimSpace(string(lk))
+		value := string(lv)
+
+		if strings.Contains(key, ".") {
+			parts := strings.Split(key, ".")
+			current := env
+
+			for i, raw := range parts {
+				part := strings.TrimSpace(raw)
+
+				last := i == len(parts)-1
+				if last {
+					if _, isMap := current[part].(map[string]interface{}); isMap {
+						break
+					}
+					current[part] = value
+					break
+				}
+
+				if nextMap, ok := current[part].(map[string]interface{}); ok {
+					current = nextMap
+					continue
+				}
+
+				newMap := make(map[string]interface{})
+				current[part] = newMap
+				current = newMap
+			}
+			continue
+		}
+
+		if _, isMap := env[key].(map[string]interface{}); isMap {
+			continue
+		}
+		env[key] = value
+	}
+
+	return env
+}
+
+// evaluateExpr compiles and runs an expr-lang expression against the given label set.
+func evaluateExpr(expression string, labelSet model.LabelSet) (bool, error) {
+	env := convertLabelSetToEnv(labelSet)
+
+	program, err := expr.Compile(expression, expr.Env(env))
+	if err != nil {
+		return false, err
+	}
+
+	output, err := expr.Run(program, env)
+	if err != nil {
+		return false, err
+	}
+
+	if boolVal, ok := output.(bool); ok {
+		return boolVal, nil
+	}
+
+	return false, nil
+}
+
+// activeMaintenanceExpr holds an active maintenance's scoping criteria.
+// Muting logic: (ruleIDs match OR ruleIDs empty) AND (expression match OR expression empty).
+type activeMaintenanceExpr struct {
+	ruleIDs    []string
+	expression string
+}
+
+// MaintenanceExprMuter implements types.Muter for expression-based maintenance scoping.
+// It evaluates expr-lang expressions against alert labels to determine if an alert
+// should be muted (suppressed) during a maintenance window.
+type MaintenanceExprMuter struct {
+	mu          sync.RWMutex
+	expressions []activeMaintenanceExpr
+	logger      *slog.Logger
+}
+
+// NewMaintenanceExprMuter creates a new MaintenanceExprMuter.
+func NewMaintenanceExprMuter(logger *slog.Logger) *MaintenanceExprMuter {
+	return &MaintenanceExprMuter{
+		logger: logger,
+	}
+}
+
+// Mutes returns true if the given label set matches any active maintenance entry.
+// Each entry uses AND logic: (ruleIDs match OR empty) AND (expression match OR empty).
+// Empty ruleIDs means all rules are in scope. Empty expression means all labels match.
+func (m *MaintenanceExprMuter) Mutes(labels model.LabelSet) bool {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	for _, ae := range m.expressions {
+		// Check rule scope: empty ruleIDs means all rules match.
+		ruleMatch := len(ae.ruleIDs) == 0
+		if !ruleMatch {
+			alertRuleID := string(labels["ruleId"])
+			for _, rid := range ae.ruleIDs {
+				if rid == alertRuleID {
+					ruleMatch = true
+					break
+				}
+			}
+		}
+		if !ruleMatch {
+			continue
+		}
+
+		// Check expression scope: empty expression means all labels match.
+		if ae.expression == "" {
+			return true
+		}
+
+		matched, err := evaluateExpr(ae.expression, labels)
+		if err != nil {
+			m.logger.Error("failed to evaluate maintenance expression",
+				"expression", ae.expression,
+				"error", err)
+			continue
+		}
+		if matched {
+			return true
+		}
+	}
+	return false
+}
+
+// SetActiveExpressions updates the list of active maintenance expressions.
+func (m *MaintenanceExprMuter) SetActiveExpressions(exprs []activeMaintenanceExpr) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.expressions = exprs
+}
--- a/pkg/alertmanager/signozalertmanager/provider.go
+++ b/pkg/alertmanager/signozalertmanager/provider.go
@@ -10,12 +10,14 @@ import (
 	amConfig "github.com/prometheus/alertmanager/config"

 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/clickhousealertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/alertmanagerstore/sqlalertmanagerstore"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
@@ -23,25 +25,34 @@ import (
 )

 type provider struct {
-	service             *alertmanager.Service
-	config              alertmanager.Config
-	settings            factory.ScopedProviderSettings
-	configStore         alertmanagertypes.ConfigStore
-	stateStore          alertmanagertypes.StateStore
-	notificationManager nfmanager.NotificationManager
-	stopC               chan struct{}
+	service              *alertmanager.Service
+	config               alertmanager.Config
+	settings             factory.ScopedProviderSettings
+	configStore          alertmanagertypes.ConfigStore
+	stateStore           alertmanagertypes.StateStore
+	notificationManager  nfmanager.NotificationManager
+	maintenanceStore     alertmanagertypes.MaintenanceStore
+	maintenanceExprMuter *MaintenanceExprMuter
+	orgGetter            organization.Getter
+	stopC                chan struct{}
 }

-func NewFactory(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
+func NewFactory(sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager, telemetryStore telemetrystore.TelemetryStore) factory.ProviderFactory[alertmanager.Alertmanager, alertmanager.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, settings factory.ProviderSettings, config alertmanager.Config) (alertmanager.Alertmanager, error) {
-		return New(ctx, settings, config, sqlstore, orgGetter, notificationManager)
+		return New(ctx, settings, config, sqlstore, orgGetter, notificationManager, telemetryStore)
 	})
 }

-func New(ctx context.Context, providerSettings factory.ProviderSettings, config alertmanager.Config, sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager) (*provider, error) {
+func New(ctx context.Context, providerSettings factory.ProviderSettings, config alertmanager.Config, sqlstore sqlstore.SQLStore, orgGetter organization.Getter, notificationManager nfmanager.NotificationManager, telemetryStore telemetrystore.TelemetryStore) (*provider, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager")
 	configStore := sqlalertmanagerstore.NewConfigStore(sqlstore)
 	stateStore := sqlalertmanagerstore.NewStateStore(sqlstore)
+	maintenanceExprMuter := NewMaintenanceExprMuter(settings.Logger())
+
+	var stateHistoryStore alertmanagertypes.StateHistoryStore
+	if telemetryStore != nil {
+		stateHistoryStore = clickhousealertmanagerstore.NewStateHistoryStore(telemetryStore.ClickhouseDB())
+	}

 	p := &provider{
 		service: alertmanager.New(
@@ -52,13 +63,18 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 			configStore,
 			orgGetter,
 			notificationManager,
+			maintenanceExprMuter,
+			stateHistoryStore,
 		),
-		settings:            settings,
-		config:              config,
-		configStore:         configStore,
-		stateStore:          stateStore,
-		notificationManager: notificationManager,
-		stopC:               make(chan struct{}),
+		settings:             settings,
+		config:               config,
+		configStore:          configStore,
+		stateStore:           stateStore,
+		notificationManager:  notificationManager,
+		maintenanceStore:     sqlalertmanagerstore.NewMaintenanceStore(sqlstore),
+		maintenanceExprMuter: maintenanceExprMuter,
+		orgGetter:            orgGetter,
+		stopC:                make(chan struct{}),
 	}

 	return p, nil
@@ -70,16 +86,28 @@ func (provider *provider) Start(ctx context.Context) error {
 		return err
 	}

-	ticker := time.NewTicker(provider.config.Signoz.PollInterval)
-	defer ticker.Stop()
+	// Initial maintenance sync before entering the ticker loop.
+	provider.syncMaintenance(ctx, provider.maintenanceExprMuter)
+
+	// Start background sweep for stale alerts in state history tracking.
+	provider.service.StartStateHistorySweep(ctx)
+
+	serverTicker := time.NewTicker(provider.config.Signoz.PollInterval)
+	defer serverTicker.Stop()
+
+	maintenanceTicker := time.NewTicker(maintenanceSyncInterval)
+	defer maintenanceTicker.Stop()
+
 	for {
 		select {
 		case <-provider.stopC:
 			return nil
-		case <-ticker.C:
+		case <-serverTicker.C:
 			if err := provider.service.SyncServers(ctx); err != nil {
 				provider.settings.Logger().ErrorContext(ctx, "failed to sync alertmanager servers", "error", err)
 			}
+		case <-maintenanceTicker.C:
+			provider.syncMaintenance(ctx, provider.maintenanceExprMuter)
 		}
 	}
 }
@@ -561,3 +589,89 @@ func (provider *provider) DeleteAllInhibitRulesByRuleId(ctx context.Context, org

 	return provider.configStore.Set(ctx, config)
 }
+
+func (provider *provider) GetAllPlannedMaintenance(ctx context.Context, orgID string) ([]*alertmanagertypes.GettablePlannedMaintenance, error) {
+	return provider.maintenanceStore.GetAllPlannedMaintenance(ctx, orgID)
+}
+
+func (provider *provider) GetPlannedMaintenanceByID(ctx context.Context, id valuer.UUID) (*alertmanagertypes.GettablePlannedMaintenance, error) {
+	return provider.maintenanceStore.GetPlannedMaintenanceByID(ctx, id)
+}
+
+func (provider *provider) CreatePlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance) (valuer.UUID, error) {
+	return provider.maintenanceStore.CreatePlannedMaintenance(ctx, maintenance)
+}
+
+func (provider *provider) EditPlannedMaintenance(ctx context.Context, maintenance alertmanagertypes.GettablePlannedMaintenance, id valuer.UUID) error {
+	return provider.maintenanceStore.EditPlannedMaintenance(ctx, maintenance, id)
+}
+
+func (provider *provider) DeletePlannedMaintenance(ctx context.Context, id valuer.UUID) error {
+	return provider.maintenanceStore.DeletePlannedMaintenance(ctx, id)
+}
+
+func (provider *provider) RecordRuleStateHistory(ctx context.Context, orgID string, entries []alertmanagertypes.RuleStateHistory) error {
+	return provider.service.RecordRuleStateHistory(ctx, orgID, entries)
+}
+
+func (provider *provider) GetLastSavedRuleStateHistory(ctx context.Context, ruleID string) ([]alertmanagertypes.RuleStateHistory, error) {
+	return provider.service.GetLastSavedRuleStateHistory(ctx, ruleID)
+}
+
+func (provider *provider) GetRuleStateHistoryTimeline(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStateTimeline, error) {
+	return provider.service.GetRuleStateHistoryTimeline(ctx, orgID, ruleID, params)
+}
+
+func (provider *provider) GetRuleStateHistoryTopContributors(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateHistoryContributor, error) {
+	return provider.service.GetRuleStateHistoryTopContributors(ctx, orgID, ruleID, params)
+}
+
+func (provider *provider) GetOverallStateTransitions(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) ([]alertmanagertypes.RuleStateTransition, error) {
+	return provider.service.GetOverallStateTransitions(ctx, orgID, ruleID, params)
+}
+
+func (provider *provider) GetRuleStats(ctx context.Context, orgID string, ruleID string, params *alertmanagertypes.QueryRuleStateHistory) (*alertmanagertypes.RuleStats, error) {
+	return provider.service.GetRuleStats(ctx, orgID, ruleID, params)
+}
+
+const (
+	maintenanceSyncInterval = 30 * time.Second
+)
+
+// syncMaintenance checks planned maintenance windows and updates the given
+// MaintenanceExprMuter with active maintenance entries. The muter is injected
+// into the notification pipeline as a MuteStage, suppressing notifications
+// while allowing rules to continue evaluating (preserving state history).
+func (provider *provider) syncMaintenance(ctx context.Context, muter *MaintenanceExprMuter) {
+	orgs, err := provider.orgGetter.ListByOwnedKeyRange(ctx)
+	if err != nil {
+		provider.settings.Logger().ErrorContext(ctx, "failed to list orgs for maintenance sync", "error", err)
+		return
+	}
+
+	now := time.Now()
+	var activeExprs []activeMaintenanceExpr
+
+	for _, org := range orgs {
+		orgID := org.ID.StringValue()
+		maintenanceList, err := provider.maintenanceStore.GetAllPlannedMaintenance(ctx, orgID)
+		if err != nil {
+			provider.settings.Logger().ErrorContext(ctx, "failed to get planned maintenance for sync", "orgID", orgID, "error", err)
+			continue
+		}
+
+		for _, maint := range maintenanceList {
+			_, active := maint.CurrentWindowEndTime(now)
+			if !active {
+				continue
+			}
+
+			activeExprs = append(activeExprs, activeMaintenanceExpr{
+				ruleIDs:    maint.RuleIDs,
+				expression: maint.Expression,
+			})
+		}
+	}
+
+	muter.SetActiveExpressions(activeExprs)
+}
--- a/pkg/alertmanager/signozalertmanager/provider_test.go
+++ b/pkg/alertmanager/signozalertmanager/provider_test.go
@@ -0,0 +1,216 @@
+package signozalertmanager
+
+import (
+	"log/slog"
+	"testing"
+
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMaintenanceExprMuter(t *testing.T) {
+	logger := slog.New(slog.DiscardHandler)
+
+	tests := []struct {
+		name   string
+		exprs  []activeMaintenanceExpr
+		labels model.LabelSet
+		want   bool
+	}{
+		// --- no maintenance ---
+		{
+			name:   "no expressions - not muted",
+			exprs:  nil,
+			labels: model.LabelSet{"env": "prod"},
+			want:   false,
+		},
+		// --- expression only (ruleIDs empty = all rules) ---
+		{
+			name: "expression only - matching",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "prod"`},
+			},
+			labels: model.LabelSet{"env": "prod"},
+			want:   true,
+		},
+		{
+			name: "expression only - non-matching",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "prod"`},
+			},
+			labels: model.LabelSet{"env": "staging"},
+			want:   false,
+		},
+		{
+			name: "expression only - matches regardless of ruleId label",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "prod"`},
+			},
+			labels: model.LabelSet{"env": "prod", "ruleId": "any-rule"},
+			want:   true,
+		},
+		// --- ruleIDs only (expression empty = all labels) ---
+		{
+			name: "ruleIDs only - matching rule",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1", "rule-2"}},
+			},
+			labels: model.LabelSet{"ruleId": "rule-1", "env": "prod"},
+			want:   true,
+		},
+		{
+			name: "ruleIDs only - non-matching rule",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1", "rule-2"}},
+			},
+			labels: model.LabelSet{"ruleId": "rule-3", "env": "prod"},
+			want:   false,
+		},
+		{
+			name: "ruleIDs only - no ruleId label on alert",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}},
+			},
+			labels: model.LabelSet{"env": "prod"},
+			want:   false,
+		},
+		// --- ruleIDs AND expression ---
+		{
+			name: "ruleIDs AND expression - both match",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}, expression: `severity == "critical"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-1", "severity": "critical"},
+			want:   true,
+		},
+		{
+			name: "ruleIDs AND expression - rule matches, expression does not",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}, expression: `severity == "critical"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-1", "severity": "warning"},
+			want:   false,
+		},
+		{
+			name: "ruleIDs AND expression - expression matches, rule does not",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}, expression: `severity == "critical"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-999", "severity": "critical"},
+			want:   false,
+		},
+		{
+			name: "ruleIDs AND expression - neither matches",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}, expression: `severity == "critical"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-999", "severity": "warning"},
+			want:   false,
+		},
+		// --- catch-all (both empty) ---
+		{
+			name: "catch-all - empty ruleIDs and empty expression mutes everything",
+			exprs: []activeMaintenanceExpr{
+				{},
+			},
+			labels: model.LabelSet{"ruleId": "any-rule", "env": "anything"},
+			want:   true,
+		},
+		// --- multiple expressions ---
+		{
+			name: "multiple entries - first matches",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "prod"`},
+				{expression: `env == "staging"`},
+			},
+			labels: model.LabelSet{"env": "prod"},
+			want:   true,
+		},
+		{
+			name: "multiple entries - second matches",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "staging"`},
+				{expression: `env == "prod"`},
+			},
+			labels: model.LabelSet{"env": "prod"},
+			want:   true,
+		},
+		{
+			name: "multiple entries - none match",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "staging"`},
+				{expression: `env == "dev"`},
+			},
+			labels: model.LabelSet{"env": "prod"},
+			want:   false,
+		},
+		{
+			name: "multiple entries - ruleIDs entry matches, expression entry does not",
+			exprs: []activeMaintenanceExpr{
+				{ruleIDs: []string{"rule-1"}},
+				{expression: `env == "staging"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-1", "env": "prod"},
+			want:   true,
+		},
+		// --- complex expressions ---
+		{
+			name: "complex expression with AND",
+			exprs: []activeMaintenanceExpr{
+				{expression: `severity == "critical" && env == "prod"`},
+			},
+			labels: model.LabelSet{"severity": "critical", "env": "prod"},
+			want:   true,
+		},
+		{
+			name: "complex expression with AND - partial match",
+			exprs: []activeMaintenanceExpr{
+				{expression: `severity == "critical" && env == "prod"`},
+			},
+			labels: model.LabelSet{"severity": "warning", "env": "prod"},
+			want:   false,
+		},
+		{
+			name: "expression with OR logic",
+			exprs: []activeMaintenanceExpr{
+				{expression: `env == "prod" || env == "staging"`},
+			},
+			labels: model.LabelSet{"env": "staging"},
+			want:   true,
+		},
+		{
+			name: "expression with nested label (dotted key)",
+			exprs: []activeMaintenanceExpr{
+				{expression: `labels.env == "prod"`},
+			},
+			labels: model.LabelSet{"labels.env": "prod"},
+			want:   true,
+		},
+		// --- ruleId as expression (user can also match ruleId via expression) ---
+		{
+			name: "expression matching specific ruleId label",
+			exprs: []activeMaintenanceExpr{
+				{expression: `ruleId == "rule-1"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-1", "env": "prod"},
+			want:   true,
+		},
+		{
+			name: "expression matching specific ruleId label - non-matching",
+			exprs: []activeMaintenanceExpr{
+				{expression: `ruleId == "rule-1"`},
+			},
+			labels: model.LabelSet{"ruleId": "rule-3", "env": "prod"},
+			want:   false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			muter := NewMaintenanceExprMuter(logger)
+			muter.SetActiveExpressions(tc.exprs)
+			got := muter.Mutes(tc.labels)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
--- a/pkg/alertmanager/statehistory.go
+++ b/pkg/alertmanager/statehistory.go
@@ -0,0 +1,263 @@
+package alertmanager
+
+import (
+	"encoding/json"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+)
+
+// trackedAlert represents the last known state of a single alert series.
+type trackedAlert struct {
+	state    string // "firing" or "inactive"
+	labels   string // JSON labels
+	ruleName string
+	value    float64
+	lastSeen time.Time
+}
+
+// ruleOverallState tracks the overall state of a rule across all its alert series.
+type ruleOverallState struct {
+	state string // "firing" or "inactive"
+}
+
+// stateTracker maintains per-org, per-rule, per-fingerprint alert state
+// to detect state transitions when PutAlerts is called.
+type stateTracker struct {
+	mu           sync.Mutex
+	alerts       map[string]map[string]map[uint64]*trackedAlert // orgID → ruleID → fingerprint → state
+	overallState map[string]map[string]*ruleOverallState        // orgID → ruleID → overall state
+}
+
+func newStateTracker() *stateTracker {
+	return &stateTracker{
+		alerts:       make(map[string]map[string]map[uint64]*trackedAlert),
+		overallState: make(map[string]map[string]*ruleOverallState),
+	}
+}
+
+// processAlerts detects state transitions from incoming alerts and returns
+// RuleStateHistory entries for transitions only.
+func (t *stateTracker) processAlerts(orgID string, alerts []*types.Alert, now time.Time) []alertmanagertypes.RuleStateHistory {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	if _, ok := t.alerts[orgID]; !ok {
+		t.alerts[orgID] = make(map[string]map[uint64]*trackedAlert)
+	}
+	if _, ok := t.overallState[orgID]; !ok {
+		t.overallState[orgID] = make(map[string]*ruleOverallState)
+	}
+
+	var entries []alertmanagertypes.RuleStateHistory
+
+	// Track which rules were affected in this batch for overall_state computation.
+	affectedRules := make(map[string]bool)
+
+	for _, alert := range alerts {
+		ruleID := string(alert.Labels[model.LabelName("ruleId")])
+		if ruleID == "" {
+			continue
+		}
+
+		fp := uint64(alert.Fingerprint())
+		ruleName := string(alert.Labels[model.LabelName("alertname")])
+		labelsJSON := labelsToJSON(alert.Labels)
+		value := valueFromAnnotations(alert.Annotations)
+
+		var newState string
+		if !alert.EndsAt.IsZero() && !alert.EndsAt.After(now) {
+			newState = "inactive"
+		} else {
+			newState = "firing"
+		}
+
+		if _, ok := t.alerts[orgID][ruleID]; !ok {
+			t.alerts[orgID][ruleID] = make(map[uint64]*trackedAlert)
+		}
+
+		tracked, exists := t.alerts[orgID][ruleID][fp]
+
+		if !exists {
+			// First time seeing this alert.
+			t.alerts[orgID][ruleID][fp] = &trackedAlert{
+				state:    newState,
+				labels:   labelsJSON,
+				ruleName: ruleName,
+				value:    value,
+				lastSeen: now,
+			}
+			if newState == "firing" {
+				// New firing alert — record transition.
+				entries = append(entries, alertmanagertypes.RuleStateHistory{
+					OrgID:       orgID,
+					RuleID:      ruleID,
+					RuleName:    ruleName,
+					State:       "firing",
+					StateChanged: true,
+					UnixMilli:   now.UnixMilli(),
+					Labels:      labelsJSON,
+					Fingerprint: fp,
+					Value:       value,
+				})
+				affectedRules[ruleID] = true
+			}
+			// Not found + resolved: no-op (we didn't track it firing).
+			continue
+		}
+
+		// Alert exists in tracker — check for transition.
+		tracked.lastSeen = now
+		tracked.value = value
+		tracked.labels = labelsJSON
+
+		if tracked.state != newState {
+			// State transition detected.
+			tracked.state = newState
+			entries = append(entries, alertmanagertypes.RuleStateHistory{
+				OrgID:        orgID,
+				RuleID:       ruleID,
+				RuleName:     ruleName,
+				State:        newState,
+				StateChanged: true,
+				UnixMilli:    now.UnixMilli(),
+				Labels:       labelsJSON,
+				Fingerprint:  fp,
+				Value:        value,
+			})
+			affectedRules[ruleID] = true
+		}
+		// Same state — no transition, nothing to record.
+	}
+
+	// Compute overall_state for affected rules and set on entries.
+	for ruleID := range affectedRules {
+		currentOverall := t.computeOverallState(orgID, ruleID)
+		prevOverall, hasPrev := t.overallState[orgID][ruleID]
+
+		overallChanged := !hasPrev || prevOverall.state != currentOverall
+		if !hasPrev {
+			t.overallState[orgID][ruleID] = &ruleOverallState{state: currentOverall}
+		} else {
+			prevOverall.state = currentOverall
+		}
+
+		// Set overall_state on all entries for this rule.
+		for i := range entries {
+			if entries[i].RuleID == ruleID {
+				entries[i].OverallState = currentOverall
+				entries[i].OverallStateChanged = overallChanged
+			}
+		}
+	}
+
+	return entries
+}
+
+// computeOverallState returns "firing" if any tracked alert for the rule is firing.
+func (t *stateTracker) computeOverallState(orgID, ruleID string) string {
+	ruleAlerts, ok := t.alerts[orgID][ruleID]
+	if !ok {
+		return "inactive"
+	}
+	for _, a := range ruleAlerts {
+		if a.state == "firing" {
+			return "firing"
+		}
+	}
+	return "inactive"
+}
+
+// sweepStale finds alerts that haven't been updated within staleTimeout and
+// records them as resolved. Returns transition entries grouped by orgID.
+func (t *stateTracker) sweepStale(staleTimeout time.Duration, now time.Time) map[string][]alertmanagertypes.RuleStateHistory {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	result := make(map[string][]alertmanagertypes.RuleStateHistory)
+	affectedRules := make(map[string]map[string]bool) // orgID → ruleID → true
+
+	for orgID, rules := range t.alerts {
+		for ruleID, fingerprints := range rules {
+			for fp, tracked := range fingerprints {
+				if tracked.state != "firing" {
+					continue
+				}
+				if now.Sub(tracked.lastSeen) <= staleTimeout {
+					continue
+				}
+
+				// Stale firing alert — mark as resolved.
+				tracked.state = "inactive"
+				result[orgID] = append(result[orgID], alertmanagertypes.RuleStateHistory{
+					OrgID:        orgID,
+					RuleID:       ruleID,
+					RuleName:     tracked.ruleName,
+					State:        "inactive",
+					StateChanged: true,
+					UnixMilli:    now.UnixMilli(),
+					Labels:       tracked.labels,
+					Fingerprint:  fp,
+					Value:        tracked.value,
+				})
+
+				if affectedRules[orgID] == nil {
+					affectedRules[orgID] = make(map[string]bool)
+				}
+				affectedRules[orgID][ruleID] = true
+			}
+		}
+	}
+
+	// Compute overall_state for affected rules.
+	for orgID, rules := range affectedRules {
+		for ruleID := range rules {
+			currentOverall := t.computeOverallState(orgID, ruleID)
+			prevOverall, hasPrev := t.overallState[orgID][ruleID]
+
+			overallChanged := !hasPrev || prevOverall.state != currentOverall
+			if hasPrev {
+				prevOverall.state = currentOverall
+			}
+
+			for i := range result[orgID] {
+				if result[orgID][i].RuleID == ruleID {
+					result[orgID][i].OverallState = currentOverall
+					result[orgID][i].OverallStateChanged = overallChanged
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// labelsToJSON converts a model.LabelSet to a JSON string.
+func labelsToJSON(ls model.LabelSet) string {
+	m := make(map[string]string, len(ls))
+	for k, v := range ls {
+		m[string(k)] = string(v)
+	}
+	b, err := json.Marshal(m)
+	if err != nil {
+		return "{}"
+	}
+	return string(b)
+}
+
+// valueFromAnnotations extracts the metric value from alert annotations.
+func valueFromAnnotations(annotations model.LabelSet) float64 {
+	valStr := string(annotations[model.LabelName("value")])
+	if valStr == "" {
+		return 0
+	}
+	v, err := strconv.ParseFloat(valStr, 64)
+	if err != nil {
+		return 0
+	}
+	return v
+}
--- a/pkg/alertmanager/statehistory_test.go
+++ b/pkg/alertmanager/statehistory_test.go
@@ -0,0 +1,328 @@
+package alertmanager
+
+import (
+	"testing"
+	"time"
+
+	"github.com/prometheus/alertmanager/types"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func makeAlert(ruleID, alertname string, firing bool, now time.Time, extraLabels map[string]string) *types.Alert {
+	labels := model.LabelSet{
+		"ruleId":    model.LabelValue(ruleID),
+		"alertname": model.LabelValue(alertname),
+	}
+	for k, v := range extraLabels {
+		labels[model.LabelName(k)] = model.LabelValue(v)
+	}
+
+	alert := &types.Alert{
+		Alert: model.Alert{
+			Labels:      labels,
+			Annotations: model.LabelSet{"value": "42.5"},
+			StartsAt:    now.Add(-1 * time.Minute),
+		},
+		UpdatedAt: now,
+	}
+
+	if firing {
+		alert.EndsAt = now.Add(5 * time.Minute) // future = firing
+	} else {
+		alert.EndsAt = now.Add(-10 * time.Second) // past = resolved
+	}
+
+	return alert
+}
+
+func TestProcessAlerts_NewFiringAlert(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	alerts := []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}
+
+	entries := tracker.processAlerts("org-1", alerts, now)
+
+	require.Len(t, entries, 1)
+	assert.Equal(t, "firing", entries[0].State)
+	assert.Equal(t, "rule-1", entries[0].RuleID)
+	assert.Equal(t, "HighCPU", entries[0].RuleName)
+	assert.Equal(t, "org-1", entries[0].OrgID)
+	assert.Equal(t, true, entries[0].StateChanged)
+	assert.Equal(t, 42.5, entries[0].Value)
+	assert.Equal(t, now.UnixMilli(), entries[0].UnixMilli)
+	assert.Equal(t, "firing", entries[0].OverallState)
+	assert.Equal(t, true, entries[0].OverallStateChanged)
+}
+
+func TestProcessAlerts_StillFiringNoTransition(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	alerts := []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}
+
+	// First call: new firing.
+	entries := tracker.processAlerts("org-1", alerts, now)
+	require.Len(t, entries, 1)
+
+	// Second call: still firing — no transition.
+	entries = tracker.processAlerts("org-1", alerts, now.Add(1*time.Minute))
+	assert.Empty(t, entries)
+}
+
+func TestProcessAlerts_FiringThenResolved(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// First: fire the alert.
+	firingAlerts := []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}
+	entries := tracker.processAlerts("org-1", firingAlerts, now)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "firing", entries[0].State)
+
+	// Second: resolve the alert.
+	resolvedAlerts := []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now.Add(5*time.Minute), map[string]string{"host": "server-1"}),
+	}
+	entries = tracker.processAlerts("org-1", resolvedAlerts, now.Add(5*time.Minute))
+	require.Len(t, entries, 1)
+	assert.Equal(t, "inactive", entries[0].State)
+	assert.Equal(t, "rule-1", entries[0].RuleID)
+	assert.Equal(t, "inactive", entries[0].OverallState)
+	assert.Equal(t, true, entries[0].OverallStateChanged)
+}
+
+func TestProcessAlerts_ResolvedWithoutPriorFiring(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// A resolved alert arriving without prior tracking should produce no entry.
+	alerts := []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now, map[string]string{"host": "server-1"}),
+	}
+
+	entries := tracker.processAlerts("org-1", alerts, now)
+	assert.Empty(t, entries)
+}
+
+func TestProcessAlerts_ReFiring(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Fire.
+	entries := tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}, now)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "firing", entries[0].State)
+
+	// Resolve.
+	entries = tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now.Add(5*time.Minute), map[string]string{"host": "server-1"}),
+	}, now.Add(5*time.Minute))
+	require.Len(t, entries, 1)
+	assert.Equal(t, "inactive", entries[0].State)
+
+	// Re-fire.
+	entries = tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now.Add(10*time.Minute), map[string]string{"host": "server-1"}),
+	}, now.Add(10*time.Minute))
+	require.Len(t, entries, 1)
+	assert.Equal(t, "firing", entries[0].State)
+	assert.Equal(t, "firing", entries[0].OverallState)
+	assert.Equal(t, true, entries[0].OverallStateChanged)
+}
+
+func TestProcessAlerts_OverallStateComputation(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Fire two series for the same rule.
+	entries := tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-2"}),
+	}, now)
+	require.Len(t, entries, 2)
+	assert.Equal(t, "firing", entries[0].OverallState)
+	assert.Equal(t, "firing", entries[1].OverallState)
+
+	// Resolve only one series — overall should still be "firing".
+	entries = tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now.Add(5*time.Minute), map[string]string{"host": "server-1"}),
+	}, now.Add(5*time.Minute))
+	require.Len(t, entries, 1)
+	assert.Equal(t, "inactive", entries[0].State)
+	assert.Equal(t, "firing", entries[0].OverallState)
+	assert.Equal(t, false, entries[0].OverallStateChanged) // still firing overall
+
+	// Resolve the second series — overall should transition to "inactive".
+	entries = tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now.Add(6*time.Minute), map[string]string{"host": "server-2"}),
+	}, now.Add(6*time.Minute))
+	require.Len(t, entries, 1)
+	assert.Equal(t, "inactive", entries[0].State)
+	assert.Equal(t, "inactive", entries[0].OverallState)
+	assert.Equal(t, true, entries[0].OverallStateChanged) // transitioned to inactive
+}
+
+func TestProcessAlerts_MultipleRulesIndependent(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	entries := tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+		makeAlert("rule-2", "HighMem", true, now, map[string]string{"host": "server-1"}),
+	}, now)
+
+	require.Len(t, entries, 2)
+	// Each rule has its own overall state.
+	assert.Equal(t, "rule-1", entries[0].RuleID)
+	assert.Equal(t, "rule-2", entries[1].RuleID)
+	assert.Equal(t, "firing", entries[0].OverallState)
+	assert.Equal(t, "firing", entries[1].OverallState)
+}
+
+func TestProcessAlerts_AlertWithoutRuleIDSkipped(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	alert := &types.Alert{
+		Alert: model.Alert{
+			Labels:   model.LabelSet{"alertname": "NoRuleID"},
+			StartsAt: now.Add(-1 * time.Minute),
+			EndsAt:   now.Add(5 * time.Minute),
+		},
+		UpdatedAt: now,
+	}
+
+	entries := tracker.processAlerts("org-1", []*types.Alert{alert}, now)
+	assert.Empty(t, entries)
+}
+
+func TestProcessAlerts_MultipleOrgs(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Org 1 fires.
+	entries1 := tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, nil),
+	}, now)
+	require.Len(t, entries1, 1)
+	assert.Equal(t, "org-1", entries1[0].OrgID)
+
+	// Org 2 fires same rule ID — independent tracking.
+	entries2 := tracker.processAlerts("org-2", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, nil),
+	}, now)
+	require.Len(t, entries2, 1)
+	assert.Equal(t, "org-2", entries2[0].OrgID)
+}
+
+func TestSweepStale_FiringAlertBecomesInactive(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Fire an alert.
+	tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}, now)
+
+	// Sweep with staleTimeout = 5 minutes, 10 minutes later.
+	result := tracker.sweepStale(5*time.Minute, now.Add(10*time.Minute))
+
+	require.Len(t, result["org-1"], 1)
+	assert.Equal(t, "inactive", result["org-1"][0].State)
+	assert.Equal(t, "rule-1", result["org-1"][0].RuleID)
+	assert.Equal(t, "inactive", result["org-1"][0].OverallState)
+	assert.Equal(t, true, result["org-1"][0].OverallStateChanged)
+}
+
+func TestSweepStale_RecentAlertNotSwept(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Fire an alert.
+	tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, map[string]string{"host": "server-1"}),
+	}, now)
+
+	// Sweep with staleTimeout = 10 minutes, only 2 minutes later.
+	result := tracker.sweepStale(10*time.Minute, now.Add(2*time.Minute))
+	assert.Empty(t, result)
+}
+
+func TestSweepStale_InactiveAlertNotSwept(t *testing.T) {
+	tracker := newStateTracker()
+	now := time.Now()
+
+	// Fire then resolve.
+	tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", true, now, nil),
+	}, now)
+	tracker.processAlerts("org-1", []*types.Alert{
+		makeAlert("rule-1", "HighCPU", false, now.Add(1*time.Minute), nil),
+	}, now.Add(1*time.Minute))
+
+	// Sweep much later — should produce nothing since alert is already inactive.
+	result := tracker.sweepStale(5*time.Minute, now.Add(30*time.Minute))
+	assert.Empty(t, result)
+}
+
+func TestLabelsToJSON(t *testing.T) {
+	ls := model.LabelSet{
+		"alertname": "HighCPU",
+		"env":       "prod",
+	}
+
+	result := labelsToJSON(ls)
+
+	// Parse back and verify.
+	parsed := labelsFromJSON(result)
+	require.NotNil(t, parsed)
+	assert.Equal(t, model.LabelValue("HighCPU"), parsed["alertname"])
+	assert.Equal(t, model.LabelValue("prod"), parsed["env"])
+}
+
+func TestValueFromAnnotations(t *testing.T) {
+	tests := []struct {
+		name        string
+		annotations model.LabelSet
+		want        float64
+	}{
+		{
+			name:        "valid float",
+			annotations: model.LabelSet{"value": "42.5"},
+			want:        42.5,
+		},
+		{
+			name:        "empty value",
+			annotations: model.LabelSet{},
+			want:        0,
+		},
+		{
+			name:        "invalid value",
+			annotations: model.LabelSet{"value": "not-a-number"},
+			want:        0,
+		},
+		{
+			name:        "scientific notation",
+			annotations: model.LabelSet{"value": "1.5E+02"},
+			want:        150,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := valueFromAnnotations(tc.annotations)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
--- a/pkg/apis/fields/api.go
+++ b/pkg/apis/fields/api.go
@@ -0,0 +1,127 @@
+package fields
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
+	"github.com/SigNoz/signoz/pkg/telemetrymeter"
+	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+type API struct {
+	telemetryStore         telemetrystore.TelemetryStore
+	telemetryMetadataStore telemetrytypes.MetadataStore
+}
+
+// TODO: move this to module and remove metastore init
+func NewAPI(
+	settings factory.ProviderSettings,
+	telemetryStore telemetrystore.TelemetryStore,
+) *API {
+	telemetryMetadataStore := telemetrymetadata.NewTelemetryMetaStore(
+		settings,
+		telemetryStore,
+		telemetrytraces.DBName,
+		telemetrytraces.TagAttributesV2TableName,
+		telemetrytraces.SpanAttributesKeysTblName,
+		telemetrytraces.SpanIndexV3TableName,
+		telemetrymetrics.DBName,
+		telemetrymetrics.AttributesMetadataTableName,
+		telemetrymeter.DBName,
+		telemetrymeter.SamplesAgg1dTableName,
+		telemetrylogs.DBName,
+		telemetrylogs.LogsV2TableName,
+		telemetrylogs.TagAttributesV2TableName,
+		telemetrylogs.LogAttributeKeysTblName,
+		telemetrylogs.LogResourceKeysTblName,
+		telemetrymetadata.DBName,
+		telemetrymetadata.AttributesMetadataLocalTableName,
+	)
+
+	return &API{
+		telemetryStore:         telemetryStore,
+		telemetryMetadataStore: telemetryMetadataStore,
+	}
+}
+
+func (api *API) GetFieldsKeys(w http.ResponseWriter, r *http.Request) {
+
+	type fieldKeysResponse struct {
+		Keys     map[string][]*telemetrytypes.TelemetryFieldKey `json:"keys"`
+		Complete bool                                           `json:"complete"`
+	}
+
+	bodyBytes, _ := io.ReadAll(r.Body)
+	r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	ctx := r.Context()
+
+	fieldKeySelector, err := parseFieldKeyRequest(r)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	keys, complete, err := api.telemetryMetadataStore.GetKeys(ctx, fieldKeySelector)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	response := fieldKeysResponse{
+		Keys:     keys,
+		Complete: complete,
+	}
+
+	render.Success(w, http.StatusOK, response)
+}
+
+func (api *API) GetFieldsValues(w http.ResponseWriter, r *http.Request) {
+
+	type fieldValuesResponse struct {
+		Values   *telemetrytypes.TelemetryFieldValues `json:"values"`
+		Complete bool                                 `json:"complete"`
+	}
+
+	bodyBytes, _ := io.ReadAll(r.Body)
+	r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	ctx := r.Context()
+
+	fieldValueSelector, err := parseFieldValueRequest(r)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	allValues, allComplete, err := api.telemetryMetadataStore.GetAllValues(ctx, fieldValueSelector)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	relatedValues, relatedComplete, err := api.telemetryMetadataStore.GetRelatedValues(ctx, fieldValueSelector)
+	if err != nil {
+		// we don't want to return error if we fail to get related values for some reason
+		relatedValues = []string{}
+	}
+
+	values := &telemetrytypes.TelemetryFieldValues{
+		StringValues:  allValues.StringValues,
+		NumberValues:  allValues.NumberValues,
+		RelatedValues: relatedValues,
+	}
+
+	response := fieldValuesResponse{
+		Values:   values,
+		Complete: allComplete && relatedComplete,
+	}
+
+	render.Success(w, http.StatusOK, response)
+}
--- a/pkg/apis/fields/parse.go
+++ b/pkg/apis/fields/parse.go
@@ -0,0 +1,162 @@
+package fields
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+func parseFieldKeyRequest(r *http.Request) (*telemetrytypes.FieldKeySelector, error) {
+	var req telemetrytypes.FieldKeySelector
+	var signal telemetrytypes.Signal
+	var source telemetrytypes.Source
+	var err error
+
+	signalStr := r.URL.Query().Get("signal")
+	if signalStr != "" {
+		signal = telemetrytypes.Signal{String: valuer.NewString(signalStr)}
+	} else {
+		signal = telemetrytypes.SignalUnspecified
+	}
+
+	sourceStr := r.URL.Query().Get("source")
+	if sourceStr != "" {
+		source = telemetrytypes.Source{String: valuer.NewString(sourceStr)}
+	} else {
+		source = telemetrytypes.SourceUnspecified
+	}
+
+	if r.URL.Query().Get("limit") != "" {
+		limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse limit")
+		}
+		req.Limit = limit
+	} else {
+		req.Limit = 1000
+	}
+
+	var startUnixMilli, endUnixMilli int64
+
+	if r.URL.Query().Get("startUnixMilli") != "" {
+		startUnixMilli, err = strconv.ParseInt(r.URL.Query().Get("startUnixMilli"), 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse startUnixMilli")
+		}
+		// Round down to the nearest 6 hours (21600000 milliseconds)
+		startUnixMilli -= startUnixMilli % 21600000
+	}
+	if r.URL.Query().Get("endUnixMilli") != "" {
+		endUnixMilli, err = strconv.ParseInt(r.URL.Query().Get("endUnixMilli"), 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse endUnixMilli")
+		}
+	}
+
+	// Parse fieldContext directly instead of using JSON unmarshalling.
+	var fieldContext telemetrytypes.FieldContext
+	fieldContextStr := r.URL.Query().Get("fieldContext")
+	if fieldContextStr != "" {
+		fieldContext = telemetrytypes.FieldContext{String: valuer.NewString(fieldContextStr)}
+	}
+
+	// Parse fieldDataType directly instead of using JSON unmarshalling.
+	var fieldDataType telemetrytypes.FieldDataType
+	fieldDataTypeStr := r.URL.Query().Get("fieldDataType")
+	if fieldDataTypeStr != "" {
+		fieldDataType = telemetrytypes.FieldDataType{String: valuer.NewString(fieldDataTypeStr)}
+	}
+
+	metricName := r.URL.Query().Get("metricName")
+	var metricContext *telemetrytypes.MetricContext
+	if metricName != "" {
+		metricContext = &telemetrytypes.MetricContext{
+			MetricName: metricName,
+		}
+	}
+
+	name := r.URL.Query().Get("searchText")
+
+	if name != "" && fieldContext == telemetrytypes.FieldContextUnspecified {
+		parsedFieldKey := telemetrytypes.GetFieldKeyFromKeyText(name)
+		if parsedFieldKey.FieldContext != telemetrytypes.FieldContextUnspecified {
+			// Only apply inferred context if it is valid for the current signal
+			if isContextValidForSignal(parsedFieldKey.FieldContext, signal) {
+				name = parsedFieldKey.Name
+				fieldContext = parsedFieldKey.FieldContext
+			}
+		}
+	}
+
+	req = telemetrytypes.FieldKeySelector{
+		StartUnixMilli:    startUnixMilli,
+		EndUnixMilli:      endUnixMilli,
+		Signal:            signal,
+		Source:            source,
+		Name:              name,
+		FieldContext:      fieldContext,
+		FieldDataType:     fieldDataType,
+		Limit:             req.Limit,
+		SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeFuzzy,
+		MetricContext:     metricContext,
+	}
+	return &req, nil
+}
+
+func parseFieldValueRequest(r *http.Request) (*telemetrytypes.FieldValueSelector, error) {
+	keySelector, err := parseFieldKeyRequest(r)
+	if err != nil {
+		return nil, errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "failed to parse field key request")
+	}
+
+	name := r.URL.Query().Get("name")
+	if name != "" && keySelector.FieldContext == telemetrytypes.FieldContextUnspecified {
+		parsedFieldKey := telemetrytypes.GetFieldKeyFromKeyText(name)
+		if parsedFieldKey.FieldContext != telemetrytypes.FieldContextUnspecified {
+			// Only apply inferred context if it is valid for the current signal
+			if isContextValidForSignal(parsedFieldKey.FieldContext, keySelector.Signal) {
+				name = parsedFieldKey.Name
+				keySelector.FieldContext = parsedFieldKey.FieldContext
+			}
+		}
+	}
+	keySelector.Name = name
+	existingQuery := r.URL.Query().Get("existingQuery")
+	value := r.URL.Query().Get("searchText")
+
+	// Parse limit for fieldValue request, fallback to default 50 if parsing fails.
+	limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
+	if err != nil {
+		limit = 50
+	}
+
+	req := telemetrytypes.FieldValueSelector{
+		FieldKeySelector: keySelector,
+		ExistingQuery:    existingQuery,
+		Value:            value,
+		Limit:            limit,
+	}
+
+	return &req, nil
+}
+
+func isContextValidForSignal(ctx telemetrytypes.FieldContext, signal telemetrytypes.Signal) bool {
+	if ctx == telemetrytypes.FieldContextResource ||
+		ctx == telemetrytypes.FieldContextAttribute ||
+		ctx == telemetrytypes.FieldContextScope {
+		return true
+	}
+
+	switch signal.StringValue() {
+	case telemetrytypes.SignalLogs.StringValue():
+		return ctx == telemetrytypes.FieldContextLog || ctx == telemetrytypes.FieldContextBody
+	case telemetrytypes.SignalTraces.StringValue():
+		return ctx == telemetrytypes.FieldContextSpan || ctx == telemetrytypes.FieldContextEvent || ctx == telemetrytypes.FieldContextTrace
+	case telemetrytypes.SignalMetrics.StringValue():
+		return ctx == telemetrytypes.FieldContextMetric
+	}
+	return true
+}
--- a/pkg/apiserver/signozapiserver/fields.go
+++ b/pkg/apiserver/signozapiserver/fields.go
@@ -1,50 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addFieldsRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/fields/keys", handler.New(provider.authZ.ViewAccess(provider.fieldsHandler.GetFieldsKeys), handler.OpenAPIDef{
-		ID:                  "GetFieldsKeys",
-		Tags:                []string{"fields"},
-		Summary:             "Get field keys",
-		Description:         "This endpoint returns field keys",
-		Request:             nil,
-		RequestQuery:        new(telemetrytypes.PostableFieldKeysParams),
-		RequestContentType:  "",
-		Response:            new(telemetrytypes.GettableFieldKeys),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/fields/values", handler.New(provider.authZ.ViewAccess(provider.fieldsHandler.GetFieldsValues), handler.OpenAPIDef{
-		ID:                  "GetFieldsValues",
-		Tags:                []string{"fields"},
-		Summary:             "Get field values",
-		Description:         "This endpoint returns field values",
-		Request:             nil,
-		RequestQuery:        new(telemetrytypes.PostableFieldValueParams),
-		RequestContentType:  "",
-		Response:            new(telemetrytypes.GettableFieldValues),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}
--- a/pkg/apiserver/signozapiserver/provider.go
+++ b/pkg/apiserver/signozapiserver/provider.go
@@ -13,11 +13,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/modules/role"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -42,8 +42,8 @@ type provider struct {
 	dashboardHandler       dashboard.Handler
 	metricsExplorerHandler metricsexplorer.Handler
 	gatewayHandler         gateway.Handler
-	fieldsHandler          fields.Handler
-	authzHandler           authz.Handler
+	roleGetter             role.Getter
+	roleHandler            role.Handler
 }

 func NewFactory(
@@ -61,31 +61,11 @@ func NewFactory(
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
 	gatewayHandler gateway.Handler,
-	fieldsHandler fields.Handler,
-	authzHandler authz.Handler,
+	roleGetter role.Getter,
+	roleHandler role.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
-		return newProvider(
-			ctx,
-			providerSettings,
-			config,
-			orgGetter,
-			authz,
-			orgHandler,
-			userHandler,
-			sessionHandler,
-			authDomainHandler,
-			preferenceHandler,
-			globalHandler,
-			promoteHandler,
-			flaggerHandler,
-			dashboardModule,
-			dashboardHandler,
-			metricsExplorerHandler,
-			gatewayHandler,
-			fieldsHandler,
-			authzHandler,
-		)
+		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler, promoteHandler, flaggerHandler, dashboardModule, dashboardHandler, metricsExplorerHandler, gatewayHandler, roleGetter, roleHandler)
 	})
 }

@@ -107,8 +87,8 @@ func newProvider(
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
 	gatewayHandler gateway.Handler,
-	fieldsHandler fields.Handler,
-	authzHandler authz.Handler,
+	roleGetter role.Getter,
+	roleHandler role.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -129,11 +109,11 @@ func newProvider(
 		dashboardHandler:       dashboardHandler,
 		metricsExplorerHandler: metricsExplorerHandler,
 		gatewayHandler:         gatewayHandler,
-		fieldsHandler:          fieldsHandler,
-		authzHandler:           authzHandler,
+		roleGetter:             roleGetter,
+		roleHandler:            roleHandler,
 	}

-	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
+	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz, roleGetter)

 	if err := provider.AddToRouter(router); err != nil {
 		return nil, err
@@ -195,10 +175,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}

-	if err := provider.addFieldsRoutes(router); err != nil {
-		return err
-	}
-
 	return nil
 }

--- a/pkg/apiserver/signozapiserver/role.go
+++ b/pkg/apiserver/signozapiserver/role.go
@@ -10,7 +10,7 @@ import (
 )

 func (provider *provider) addRoleRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/roles", handler.New(provider.authZ.AdminAccess(provider.authzHandler.Create), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/roles", handler.New(provider.authZ.AdminAccess(provider.roleHandler.Create), handler.OpenAPIDef{
 		ID:                  "CreateRole",
 		Tags:                []string{"role"},
 		Summary:             "Create role",
@@ -27,7 +27,7 @@ func (provider *provider) addRoleRoutes(router *mux.Router) error {
 		return err
 	}

-	if err := router.Handle("/api/v1/roles", handler.New(provider.authZ.AdminAccess(provider.authzHandler.List), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/roles", handler.New(provider.authZ.AdminAccess(provider.roleHandler.List), handler.OpenAPIDef{
 		ID:                  "ListRoles",
 		Tags:                []string{"role"},
 		Summary:             "List roles",
@@ -44,7 +44,7 @@ func (provider *provider) addRoleRoutes(router *mux.Router) error {
 		return err
 	}

-	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.authzHandler.Get), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.roleHandler.Get), handler.OpenAPIDef{
 		ID:                  "GetRole",
 		Tags:                []string{"role"},
 		Summary:             "Get role",
@@ -61,7 +61,7 @@ func (provider *provider) addRoleRoutes(router *mux.Router) error {
 		return err
 	}

-	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.authzHandler.Patch), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.roleHandler.Patch), handler.OpenAPIDef{
 		ID:                  "PatchRole",
 		Tags:                []string{"role"},
 		Summary:             "Patch role",
@@ -78,7 +78,7 @@ func (provider *provider) addRoleRoutes(router *mux.Router) error {
 		return err
 	}

-	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.authzHandler.Delete), handler.OpenAPIDef{
+	if err := router.Handle("/api/v1/roles/{id}", handler.New(provider.authZ.AdminAccess(provider.roleHandler.Delete), handler.OpenAPIDef{
 		ID:                  "DeleteRole",
 		Tags:                []string{"role"},
 		Summary:             "Delete role",
--- a/pkg/apiserver/signozapiserver/user.go
+++ b/pkg/apiserver/signozapiserver/user.go
@@ -325,7 +325,7 @@ func (provider *provider) addUserRoutes(router *mux.Router) error {
 		Response:            nil,
 		ResponseContentType: "",
 		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnprocessableEntity},
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
 		Deprecated:          false,
 		SecuritySchemes:     []handler.OpenAPISecurityScheme{},
 	})).Methods(http.MethodPost).GetError(); err != nil {
--- a/pkg/authz/authz.go
+++ b/pkg/authz/authz.go
@@ -2,11 +2,9 @@ package authz

 import (
 	"context"
-	"net/http"

 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/roletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 )
@@ -31,76 +29,4 @@ type AuthZ interface {

 	// Lists the selectors for objects assigned to subject (s) with relation (r) on resource (s)
 	ListObjects(context.Context, string, authtypes.Relation, authtypes.Typeable) ([]*authtypes.Object, error)
-
-	// Creates the role.
-	Create(context.Context, valuer.UUID, *roletypes.Role) error
-
-	// Gets the role if it exists or creates one.
-	GetOrCreate(context.Context, valuer.UUID, *roletypes.Role) (*roletypes.Role, error)
-
-	// Gets the objects associated with the given role and relation.
-	GetObjects(context.Context, valuer.UUID, valuer.UUID, authtypes.Relation) ([]*authtypes.Object, error)
-
-	// Gets all the typeable resources registered from role registry.
-	GetResources(context.Context) []*authtypes.Resource
-
-	// Patches the role.
-	Patch(context.Context, valuer.UUID, *roletypes.Role) error
-
-	// Patches the objects in authorization server associated with the given role and relation
-	PatchObjects(context.Context, valuer.UUID, string, authtypes.Relation, []*authtypes.Object, []*authtypes.Object) error
-
-	// Deletes the role and tuples in authorization server.
-	Delete(context.Context, valuer.UUID, valuer.UUID) error
-
-	// Gets the role
-	Get(context.Context, valuer.UUID, valuer.UUID) (*roletypes.Role, error)
-
-	// Gets the role by org_id and name
-	GetByOrgIDAndName(context.Context, valuer.UUID, string) (*roletypes.Role, error)
-
-	// Lists all the roles for the organization.
-	List(context.Context, valuer.UUID) ([]*roletypes.Role, error)
-
-	//  Lists all the roles for the organization filtered by name
-	ListByOrgIDAndNames(context.Context, valuer.UUID, []string) ([]*roletypes.Role, error)
-
-	// Grants a role to the subject based on role name.
-	Grant(context.Context, valuer.UUID, string, string) error
-
-	// Revokes a granted role from the subject based on role name.
-	Revoke(context.Context, valuer.UUID, string, string) error
-
-	// Changes the granted role for the subject based on role name.
-	ModifyGrant(context.Context, valuer.UUID, string, string, string) error
-
-	// Bootstrap the managed roles.
-	CreateManagedRoles(context.Context, valuer.UUID, []*roletypes.Role) error
-
-	// Bootstrap managed roles transactions and user assignments
-	CreateManagedUserRoleTransactions(context.Context, valuer.UUID, valuer.UUID) error
-}
-
-type RegisterTypeable interface {
-	MustGetTypeables() []authtypes.Typeable
-
-	MustGetManagedRoleTransactions() map[string][]*authtypes.Transaction
-}
-
-type Handler interface {
-	Create(http.ResponseWriter, *http.Request)
-
-	Get(http.ResponseWriter, *http.Request)
-
-	GetObjects(http.ResponseWriter, *http.Request)
-
-	GetResources(http.ResponseWriter, *http.Request)
-
-	List(http.ResponseWriter, *http.Request)
-
-	Patch(http.ResponseWriter, *http.Request)
-
-	PatchObjects(http.ResponseWriter, *http.Request)
-
-	Delete(http.ResponseWriter, *http.Request)
 }
--- a/pkg/authz/openfgaserver/logger.go
+++ b/pkg/authz/openfgaserver/logger.go
@@ -1,4 +1,4 @@
-package openfgaserver
+package openfgaauthz

 import (
 	"context"
--- a/pkg/authz/openfgaauthz/provider.go
+++ b/pkg/authz/openfgaauthz/provider.go
@@ -2,24 +2,35 @@ package openfgaauthz

 import (
 	"context"
+	"strconv"
+	"sync"

 	authz "github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/authz/authzstore/sqlauthzstore"
-	"github.com/SigNoz/signoz/pkg/authz/openfgaserver"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/roletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"

 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
+	openfgapkgserver "github.com/openfga/openfga/pkg/server"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+var (
+	openfgaDefaultStore = valuer.NewString("signoz")
 )

 type provider struct {
-	server *openfgaserver.Server
-	store  roletypes.Store
+	config        authz.Config
+	settings      factory.ScopedProviderSettings
+	openfgaSchema []openfgapkgtransformer.ModuleFile
+	openfgaServer *openfgapkgserver.Server
+	storeID       string
+	modelID       string
+	mtx           sync.RWMutex
+	stopChan      chan struct{}
 }

 func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) factory.ProviderFactory[authz.AuthZ, authz.Config] {
@@ -29,194 +40,301 @@ func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtr
 }

 func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) (authz.AuthZ, error) {
-	server, err := openfgaserver.NewOpenfgaServer(ctx, settings, config, sqlstore, openfgaSchema)
+	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/authz/openfgaauthz")
+
+	store, err := NewSQLStore(sqlstore)
 	if err != nil {
+		scopedProviderSettings.Logger().DebugContext(ctx, "failed to initialize sqlstore for authz")
+		return nil, err
+	}
+
+	// setup the openfga server
+	opts := []openfgapkgserver.OpenFGAServiceV1Option{
+		openfgapkgserver.WithDatastore(store),
+		openfgapkgserver.WithLogger(NewLogger(scopedProviderSettings.Logger())),
+		openfgapkgserver.WithContextPropagationToDatastore(true),
+	}
+	openfgaServer, err := openfgapkgserver.NewServerWithOpts(opts...)
+	if err != nil {
+		scopedProviderSettings.Logger().DebugContext(ctx, "failed to create authz server")
 		return nil, err
 	}

 	return &provider{
-		server: server,
-		store:  sqlauthzstore.NewSqlAuthzStore(sqlstore),
+		config:        config,
+		settings:      scopedProviderSettings,
+		openfgaServer: openfgaServer,
+		openfgaSchema: openfgaSchema,
+		mtx:           sync.RWMutex{},
+		stopChan:      make(chan struct{}),
 	}, nil
 }

 func (provider *provider) Start(ctx context.Context) error {
-	return provider.server.Start(ctx)
+	storeId, err := provider.getOrCreateStore(ctx, openfgaDefaultStore.StringValue())
+	if err != nil {
+		return err
+	}
+
+	modelID, err := provider.getOrCreateModel(ctx, storeId)
+	if err != nil {
+		return err
+	}
+
+	provider.mtx.Lock()
+	provider.modelID = modelID
+	provider.storeID = storeId
+	provider.mtx.Unlock()
+
+	<-provider.stopChan
+	return nil
 }

 func (provider *provider) Stop(ctx context.Context) error {
-	return provider.server.Stop(ctx)
+	provider.openfgaServer.Close()
+	close(provider.stopChan)
+	return nil
 }

 func (provider *provider) Check(ctx context.Context, tupleReq *openfgav1.TupleKey) error {
-	return provider.server.Check(ctx, tupleReq)
+	storeID, modelID := provider.getStoreIDandModelID()
+	checkResponse, err := provider.openfgaServer.Check(
+		ctx,
+		&openfgav1.CheckRequest{
+			StoreId:              storeID,
+			AuthorizationModelId: modelID,
+			TupleKey: &openfgav1.CheckRequestTupleKey{
+				User:     tupleReq.User,
+				Relation: tupleReq.Relation,
+				Object:   tupleReq.Object,
+			},
+		})
+	if err != nil {
+		return errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "authorization server is unavailable").WithAdditional(err.Error())
+	}
+
+	if !checkResponse.Allowed {
+		return errors.Newf(errors.TypeForbidden, authtypes.ErrCodeAuthZForbidden, "subject %s cannot %s object %s", tupleReq.User, tupleReq.Relation, tupleReq.Object)
+	}
+
+	return nil
 }

 func (provider *provider) BatchCheck(ctx context.Context, tupleReq []*openfgav1.TupleKey) error {
-	return provider.server.BatchCheck(ctx, tupleReq)
+	storeID, modelID := provider.getStoreIDandModelID()
+	batchCheckItems := make([]*openfgav1.BatchCheckItem, 0)
+	for idx, tuple := range tupleReq {
+		batchCheckItems = append(batchCheckItems, &openfgav1.BatchCheckItem{
+			TupleKey: &openfgav1.CheckRequestTupleKey{
+				User:     tuple.User,
+				Relation: tuple.Relation,
+				Object:   tuple.Object,
+			},
+			// the batch check response is map[string] keyed by correlationID.
+			CorrelationId: strconv.Itoa(idx),
+		})
+	}
+
+	checkResponse, err := provider.openfgaServer.BatchCheck(
+		ctx,
+		&openfgav1.BatchCheckRequest{
+			StoreId:              storeID,
+			AuthorizationModelId: modelID,
+			Checks:               batchCheckItems,
+		})
+	if err != nil {
+		return errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "authorization server is unavailable").WithAdditional(err.Error())
+	}
+
+	for _, checkResponse := range checkResponse.Result {
+		if checkResponse.GetAllowed() {
+			return nil
+		}
+	}
+
+	return errors.Newf(errors.TypeForbidden, authtypes.ErrCodeAuthZForbidden, "subjects are not authorized for requested access")
+
 }

-func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	return provider.server.CheckWithTupleCreation(ctx, claims, orgID, relation, typeable, selectors, roleSelectors)
+func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, _ authtypes.Relation, _ authtypes.Typeable, _ []authtypes.Selector, roleSelectors []authtypes.Selector) error {
+	subject, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
+	if err != nil {
+		return err
+	}
+
+	tuples, err := authtypes.TypeableRole.Tuples(subject, authtypes.RelationAssignee, roleSelectors, orgID)
+	if err != nil {
+		return err
+	}
+
+	err = provider.BatchCheck(ctx, tuples)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }

-func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	return provider.server.CheckWithTupleCreationWithoutClaims(ctx, orgID, relation, typeable, selectors, roleSelectors)
+func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, _ authtypes.Relation, _ authtypes.Typeable, _ []authtypes.Selector, roleSelectors []authtypes.Selector) error {
+	subject, err := authtypes.NewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
+	if err != nil {
+		return err
+	}
+
+	tuples, err := authtypes.TypeableRole.Tuples(subject, authtypes.RelationAssignee, roleSelectors, orgID)
+	if err != nil {
+		return err
+	}
+
+	err = provider.BatchCheck(ctx, tuples)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }

 func (provider *provider) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
-	return provider.server.Write(ctx, additions, deletions)
+	if len(additions) == 0 && len(deletions) == 0 {
+		return nil
+	}
+
+	storeID, modelID := provider.getStoreIDandModelID()
+	deletionTuplesWithoutCondition := make([]*openfgav1.TupleKeyWithoutCondition, len(deletions))
+	for idx, tuple := range deletions {
+		deletionTuplesWithoutCondition[idx] = &openfgav1.TupleKeyWithoutCondition{User: tuple.User, Object: tuple.Object, Relation: tuple.Relation}
+	}
+
+	_, err := provider.openfgaServer.Write(ctx, &openfgav1.WriteRequest{
+		StoreId:              storeID,
+		AuthorizationModelId: modelID,
+		Writes: func() *openfgav1.WriteRequestWrites {
+			if len(additions) == 0 {
+				return nil
+			}
+			return &openfgav1.WriteRequestWrites{
+				TupleKeys:   additions,
+				OnDuplicate: "ignore",
+			}
+		}(),
+		Deletes: func() *openfgav1.WriteRequestDeletes {
+			if len(deletionTuplesWithoutCondition) == 0 {
+				return nil
+			}
+			return &openfgav1.WriteRequestDeletes{
+				TupleKeys: deletionTuplesWithoutCondition,
+				OnMissing: "ignore",
+			}
+		}(),
+	})
+
+	return err
 }

 func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
-	return provider.server.ListObjects(ctx, subject, relation, typeable)
-}
-
-func (provider *provider) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*roletypes.Role, error) {
-	storableRole, err := provider.store.Get(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	return roletypes.NewRoleFromStorableRole(storableRole), nil
-}
-
-func (provider *provider) GetByOrgIDAndName(ctx context.Context, orgID valuer.UUID, name string) (*roletypes.Role, error) {
-	storableRole, err := provider.store.GetByOrgIDAndName(ctx, orgID, name)
-	if err != nil {
-		return nil, err
-	}
-
-	return roletypes.NewRoleFromStorableRole(storableRole), nil
-}
-
-func (provider *provider) List(ctx context.Context, orgID valuer.UUID) ([]*roletypes.Role, error) {
-	storableRoles, err := provider.store.List(ctx, orgID)
-	if err != nil {
-		return nil, err
-	}
-
-	roles := make([]*roletypes.Role, len(storableRoles))
-	for idx, storableRole := range storableRoles {
-		roles[idx] = roletypes.NewRoleFromStorableRole(storableRole)
-	}
-
-	return roles, nil
-}
-
-func (provider *provider) ListByOrgIDAndNames(ctx context.Context, orgID valuer.UUID, names []string) ([]*roletypes.Role, error) {
-	storableRoles, err := provider.store.ListByOrgIDAndNames(ctx, orgID, names)
-	if err != nil {
-		return nil, err
-	}
-
-	roles := make([]*roletypes.Role, len(storableRoles))
-	for idx, storable := range storableRoles {
-		roles[idx] = roletypes.NewRoleFromStorableRole(storable)
-	}
-
-	return roles, nil
-}
-
-func (provider *provider) Grant(ctx context.Context, orgID valuer.UUID, name string, subject string) error {
-	tuples, err := authtypes.TypeableRole.Tuples(
-		subject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, name),
-		},
-		orgID,
-	)
-	if err != nil {
-		return err
-	}
-	return provider.Write(ctx, tuples, nil)
-}
-
-func (provider *provider) ModifyGrant(ctx context.Context, orgID valuer.UUID, existingRoleName string, updatedRoleName string, subject string) error {
-	err := provider.Revoke(ctx, orgID, existingRoleName, subject)
-	if err != nil {
-		return err
-	}
-
-	err = provider.Grant(ctx, orgID, updatedRoleName, subject)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (provider *provider) Revoke(ctx context.Context, orgID valuer.UUID, name string, subject string) error {
-	tuples, err := authtypes.TypeableRole.Tuples(
-		subject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, name),
-		},
-		orgID,
-	)
-	if err != nil {
-		return err
-	}
-	return provider.Write(ctx, nil, tuples)
-}
-
-func (provider *provider) CreateManagedRoles(ctx context.Context, _ valuer.UUID, managedRoles []*roletypes.Role) error {
-	err := provider.store.RunInTx(ctx, func(ctx context.Context) error {
-		for _, role := range managedRoles {
-			err := provider.store.Create(ctx, roletypes.NewStorableRoleFromRole(role))
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
+	storeID, modelID := provider.getStoreIDandModelID()
+	response, err := provider.openfgaServer.ListObjects(ctx, &openfgav1.ListObjectsRequest{
+		StoreId:              storeID,
+		AuthorizationModelId: modelID,
+		User:                 subject,
+		Relation:             relation.StringValue(),
+		Type:                 typeable.Type().StringValue(),
 	})
-
 	if err != nil {
-		return err
+		return nil, errors.Wrapf(err, errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "cannot list objects for subject %s with relation %s for type %s", subject, relation.StringValue(), typeable.Type().StringValue())
 	}

-	return nil
+	return authtypes.MustNewObjectsFromStringSlice(response.Objects), nil
 }

-func (provider *provider) SetManagedRoleTransactions(context.Context, valuer.UUID) error {
-	return nil
+func (provider *provider) getOrCreateStore(ctx context.Context, name string) (string, error) {
+	stores, err := provider.openfgaServer.ListStores(ctx, &openfgav1.ListStoresRequest{})
+	if err != nil {
+		return "", err
+	}
+
+	for _, store := range stores.GetStores() {
+		if store.GetName() == name {
+			return store.Id, nil
+		}
+	}
+
+	store, err := provider.openfgaServer.CreateStore(ctx, &openfgav1.CreateStoreRequest{Name: name})
+	if err != nil {
+		return "", err
+	}
+
+	return store.Id, nil
 }

-func (provider *provider) CreateManagedUserRoleTransactions(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
-	return provider.Grant(ctx, orgID, roletypes.SigNozAdminRoleName, authtypes.MustNewSubject(authtypes.TypeableUser, userID.String(), orgID, nil))
+func (provider *provider) getOrCreateModel(ctx context.Context, storeID string) (string, error) {
+	schema, err := openfgapkgtransformer.TransformModuleFilesToModel(provider.openfgaSchema, "1.1")
+	if err != nil {
+		return "", err
+	}
+
+	authorisationModels, err := provider.openfgaServer.ReadAuthorizationModels(ctx, &openfgav1.ReadAuthorizationModelsRequest{StoreId: storeID})
+	if err != nil {
+		return "", err
+	}
+
+	for _, authModel := range authorisationModels.GetAuthorizationModels() {
+		equal, err := provider.isModelEqual(schema, authModel)
+		if err != nil {
+			return "", err
+		}
+		if equal {
+			return authModel.Id, nil
+		}
+	}
+
+	authorizationModel, err := provider.openfgaServer.WriteAuthorizationModel(ctx, &openfgav1.WriteAuthorizationModelRequest{
+		StoreId:         storeID,
+		TypeDefinitions: schema.TypeDefinitions,
+		SchemaVersion:   schema.SchemaVersion,
+		Conditions:      schema.Conditions,
+	})
+	if err != nil {
+		return "", err
+	}
+
+	return authorizationModel.AuthorizationModelId, nil
 }

-func (setter *provider) Create(_ context.Context, _ valuer.UUID, _ *roletypes.Role) error {
-	return errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
+// the language model doesn't have any equality check
+// https://github.com/openfga/language/blob/main/pkg/go/transformer/module-to-model_test.go#L38
+func (provider *provider) isModelEqual(expected *openfgav1.AuthorizationModel, actual *openfgav1.AuthorizationModel) (bool, error) {
+	// we need to initialize a new model since the model extracted from schema doesn't have id
+	expectedAuthModel := openfgav1.AuthorizationModel{
+		SchemaVersion:   expected.SchemaVersion,
+		TypeDefinitions: expected.TypeDefinitions,
+		Conditions:      expected.Conditions,
+	}
+	expectedAuthModelBytes, err := protojson.Marshal(&expectedAuthModel)
+	if err != nil {
+		return false, err
+	}
+
+	actualAuthModel := openfgav1.AuthorizationModel{
+		SchemaVersion:   actual.SchemaVersion,
+		TypeDefinitions: actual.TypeDefinitions,
+		Conditions:      actual.Conditions,
+	}
+	actualAuthModelBytes, err := protojson.Marshal(&actualAuthModel)
+	if err != nil {
+		return false, err
+	}
+
+	return string(expectedAuthModelBytes) == string(actualAuthModelBytes), nil
+
 }

-func (provider *provider) GetOrCreate(_ context.Context, _ valuer.UUID, _ *roletypes.Role) (*roletypes.Role, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
-}
+func (provider *provider) getStoreIDandModelID() (string, string) {
+	provider.mtx.RLock()
+	defer provider.mtx.RUnlock()

-func (provider *provider) GetResources(_ context.Context) []*authtypes.Resource {
-	return nil
-}
+	storeID := provider.storeID
+	modelID := provider.modelID

-func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*authtypes.Object, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
-}
-
-func (provider *provider) Patch(_ context.Context, _ valuer.UUID, _ *roletypes.Role) error {
-	return errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
-}
-
-func (provider *provider) PatchObjects(_ context.Context, _ valuer.UUID, _ string, _ authtypes.Relation, _, _ []*authtypes.Object) error {
-	return errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
-}
-
-func (provider *provider) Delete(_ context.Context, _ valuer.UUID, _ valuer.UUID) error {
-	return errors.Newf(errors.TypeUnsupported, roletypes.ErrCodeRoleUnsupported, "not implemented")
-}
-
-func (provider *provider) MustGetTypeables() []authtypes.Typeable {
-	return nil
+	return storeID, modelID
 }
--- a/pkg/authz/openfgaauthz/provider_test.go
+++ b/pkg/authz/openfgaauthz/provider_test.go
@@ -1,4 +1,4 @@
-package openfgaserver
+package openfgaauthz

 import (
 	"context"
@@ -20,7 +20,7 @@ func TestProviderStartStop(t *testing.T) {

 	expectedModel := `module base 
 	type user`
-	provider, err := NewOpenfgaServer(context.Background(), providerSettings, authz.Config{}, sqlstore, []transformer.ModuleFile{{Name: "test.fga", Contents: expectedModel}})
+	provider, err := newOpenfgaProvider(context.Background(), providerSettings, authz.Config{}, sqlstore, []transformer.ModuleFile{{Name: "test.fga", Contents: expectedModel}})
 	require.NoError(t, err)

 	storeRows := sqlstore.Mock().NewRows([]string{"id", "name", "created_at", "updated_at"}).AddRow("01K3V0NTN47MPTMEV1PD5ST6ZC", "signoz", time.Now(), time.Now())
--- a/pkg/authz/openfgaserver/sqlstore.go
+++ b/pkg/authz/openfgaserver/sqlstore.go
@@ -1,4 +1,4 @@
-package openfgaserver
+package openfgaauthz

 import (
 	"github.com/SigNoz/signoz/pkg/errors"
--- a/pkg/authz/openfgaserver/server.go
+++ b/pkg/authz/openfgaserver/server.go
@@ -1,334 +0,0 @@
-package openfgaserver
-
-import (
-	"context"
-	"strconv"
-	"sync"
-
-	authz "github.com/SigNoz/signoz/pkg/authz"
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	openfgav1 "github.com/openfga/api/proto/openfga/v1"
-	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
-	openfgapkgserver "github.com/openfga/openfga/pkg/server"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-var (
-	openfgaDefaultStore = valuer.NewString("signoz")
-)
-
-type Server struct {
-	config        authz.Config
-	settings      factory.ScopedProviderSettings
-	openfgaSchema []openfgapkgtransformer.ModuleFile
-	openfgaServer *openfgapkgserver.Server
-	storeID       string
-	modelID       string
-	mtx           sync.RWMutex
-	stopChan      chan struct{}
-}
-
-func NewOpenfgaServer(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile) (*Server, error) {
-	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/authz/openfgaauthz")
-
-	store, err := NewSQLStore(sqlstore)
-	if err != nil {
-		scopedProviderSettings.Logger().DebugContext(ctx, "failed to initialize sqlstore for authz")
-		return nil, err
-	}
-
-	// setup the openfga server
-	opts := []openfgapkgserver.OpenFGAServiceV1Option{
-		openfgapkgserver.WithDatastore(store),
-		openfgapkgserver.WithLogger(NewLogger(scopedProviderSettings.Logger())),
-		openfgapkgserver.WithContextPropagationToDatastore(true),
-	}
-	openfgaServer, err := openfgapkgserver.NewServerWithOpts(opts...)
-	if err != nil {
-		scopedProviderSettings.Logger().DebugContext(ctx, "failed to create authz server")
-		return nil, err
-	}
-
-	return &Server{
-		config:        config,
-		settings:      scopedProviderSettings,
-		openfgaServer: openfgaServer,
-		openfgaSchema: openfgaSchema,
-		mtx:           sync.RWMutex{},
-		stopChan:      make(chan struct{}),
-	}, nil
-}
-
-func (server *Server) Start(ctx context.Context) error {
-	storeID, err := server.getOrCreateStore(ctx, openfgaDefaultStore.StringValue())
-	if err != nil {
-		return err
-	}
-
-	modelID, err := server.getOrCreateModel(ctx, storeID)
-	if err != nil {
-		return err
-	}
-
-	server.mtx.Lock()
-	server.modelID = modelID
-	server.storeID = storeID
-	server.mtx.Unlock()
-
-	<-server.stopChan
-	return nil
-}
-
-func (server *Server) Stop(ctx context.Context) error {
-	server.openfgaServer.Close()
-	close(server.stopChan)
-	return nil
-}
-
-func (server *Server) Check(ctx context.Context, tupleReq *openfgav1.TupleKey) error {
-	storeID, modelID := server.getStoreIDandModelID()
-	checkResponse, err := server.openfgaServer.Check(
-		ctx,
-		&openfgav1.CheckRequest{
-			StoreId:              storeID,
-			AuthorizationModelId: modelID,
-			TupleKey: &openfgav1.CheckRequestTupleKey{
-				User:     tupleReq.User,
-				Relation: tupleReq.Relation,
-				Object:   tupleReq.Object,
-			},
-		})
-	if err != nil {
-		return errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "authorization server is unavailable").WithAdditional(err.Error())
-	}
-
-	if !checkResponse.Allowed {
-		return errors.Newf(errors.TypeForbidden, authtypes.ErrCodeAuthZForbidden, "subject %s cannot %s object %s", tupleReq.User, tupleReq.Relation, tupleReq.Object)
-	}
-
-	return nil
-}
-
-func (server *Server) BatchCheck(ctx context.Context, tupleReq []*openfgav1.TupleKey) error {
-	storeID, modelID := server.getStoreIDandModelID()
-	batchCheckItems := make([]*openfgav1.BatchCheckItem, 0)
-	for idx, tuple := range tupleReq {
-		batchCheckItems = append(batchCheckItems, &openfgav1.BatchCheckItem{
-			TupleKey: &openfgav1.CheckRequestTupleKey{
-				User:     tuple.User,
-				Relation: tuple.Relation,
-				Object:   tuple.Object,
-			},
-			// the batch check response is map[string] keyed by correlationID.
-			CorrelationId: strconv.Itoa(idx),
-		})
-	}
-
-	checkResponse, err := server.openfgaServer.BatchCheck(
-		ctx,
-		&openfgav1.BatchCheckRequest{
-			StoreId:              storeID,
-			AuthorizationModelId: modelID,
-			Checks:               batchCheckItems,
-		})
-	if err != nil {
-		return errors.Newf(errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "authorization server is unavailable").WithAdditional(err.Error())
-	}
-
-	for _, checkResponse := range checkResponse.Result {
-		if checkResponse.GetAllowed() {
-			return nil
-		}
-	}
-
-	return errors.Newf(errors.TypeForbidden, authtypes.ErrCodeAuthZForbidden, "subjects are not authorized for requested access")
-
-}
-
-func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, _ authtypes.Relation, _ authtypes.Typeable, _ []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	subject, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
-	if err != nil {
-		return err
-	}
-
-	tuples, err := authtypes.TypeableRole.Tuples(subject, authtypes.RelationAssignee, roleSelectors, orgID)
-	if err != nil {
-		return err
-	}
-
-	err = server.BatchCheck(ctx, tuples)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (server *Server) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, _ authtypes.Relation, _ authtypes.Typeable, _ []authtypes.Selector, roleSelectors []authtypes.Selector) error {
-	subject, err := authtypes.NewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
-	if err != nil {
-		return err
-	}
-
-	tuples, err := authtypes.TypeableRole.Tuples(subject, authtypes.RelationAssignee, roleSelectors, orgID)
-	if err != nil {
-		return err
-	}
-
-	err = server.BatchCheck(ctx, tuples)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (server *Server) Write(ctx context.Context, additions []*openfgav1.TupleKey, deletions []*openfgav1.TupleKey) error {
-	if len(additions) == 0 && len(deletions) == 0 {
-		return nil
-	}
-
-	storeID, modelID := server.getStoreIDandModelID()
-	deletionTuplesWithoutCondition := make([]*openfgav1.TupleKeyWithoutCondition, len(deletions))
-	for idx, tuple := range deletions {
-		deletionTuplesWithoutCondition[idx] = &openfgav1.TupleKeyWithoutCondition{User: tuple.User, Object: tuple.Object, Relation: tuple.Relation}
-	}
-
-	_, err := server.openfgaServer.Write(ctx, &openfgav1.WriteRequest{
-		StoreId:              storeID,
-		AuthorizationModelId: modelID,
-		Writes: func() *openfgav1.WriteRequestWrites {
-			if len(additions) == 0 {
-				return nil
-			}
-			return &openfgav1.WriteRequestWrites{
-				TupleKeys:   additions,
-				OnDuplicate: "ignore",
-			}
-		}(),
-		Deletes: func() *openfgav1.WriteRequestDeletes {
-			if len(deletionTuplesWithoutCondition) == 0 {
-				return nil
-			}
-			return &openfgav1.WriteRequestDeletes{
-				TupleKeys: deletionTuplesWithoutCondition,
-				OnMissing: "ignore",
-			}
-		}(),
-	})
-
-	return err
-}
-
-func (server *Server) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, typeable authtypes.Typeable) ([]*authtypes.Object, error) {
-	storeID, modelID := server.getStoreIDandModelID()
-	response, err := server.openfgaServer.ListObjects(ctx, &openfgav1.ListObjectsRequest{
-		StoreId:              storeID,
-		AuthorizationModelId: modelID,
-		User:                 subject,
-		Relation:             relation.StringValue(),
-		Type:                 typeable.Type().StringValue(),
-	})
-	if err != nil {
-		return nil, errors.Wrapf(err, errors.TypeInternal, authtypes.ErrCodeAuthZUnavailable, "cannot list objects for subject %s with relation %s for type %s", subject, relation.StringValue(), typeable.Type().StringValue())
-	}
-
-	return authtypes.MustNewObjectsFromStringSlice(response.Objects), nil
-}
-
-func (server *Server) getOrCreateStore(ctx context.Context, name string) (string, error) {
-	stores, err := server.openfgaServer.ListStores(ctx, &openfgav1.ListStoresRequest{})
-	if err != nil {
-		return "", err
-	}
-
-	for _, store := range stores.GetStores() {
-		if store.GetName() == name {
-			return store.Id, nil
-		}
-	}
-
-	store, err := server.openfgaServer.CreateStore(ctx, &openfgav1.CreateStoreRequest{Name: name})
-	if err != nil {
-		return "", err
-	}
-
-	return store.Id, nil
-}
-
-func (server *Server) getOrCreateModel(ctx context.Context, storeID string) (string, error) {
-	schema, err := openfgapkgtransformer.TransformModuleFilesToModel(server.openfgaSchema, "1.1")
-	if err != nil {
-		return "", err
-	}
-
-	authorisationModels, err := server.openfgaServer.ReadAuthorizationModels(ctx, &openfgav1.ReadAuthorizationModelsRequest{StoreId: storeID})
-	if err != nil {
-		return "", err
-	}
-
-	for _, authModel := range authorisationModels.GetAuthorizationModels() {
-		equal, err := server.isModelEqual(schema, authModel)
-		if err != nil {
-			return "", err
-		}
-		if equal {
-			return authModel.Id, nil
-		}
-	}
-
-	authorizationModel, err := server.openfgaServer.WriteAuthorizationModel(ctx, &openfgav1.WriteAuthorizationModelRequest{
-		StoreId:         storeID,
-		TypeDefinitions: schema.TypeDefinitions,
-		SchemaVersion:   schema.SchemaVersion,
-		Conditions:      schema.Conditions,
-	})
-	if err != nil {
-		return "", err
-	}
-
-	return authorizationModel.AuthorizationModelId, nil
-}
-
-// the language model doesn't have any equality check
-// https://github.com/openfga/language/blob/main/pkg/go/transformer/module-to-model_test.go#L38
-func (server *Server) isModelEqual(expected *openfgav1.AuthorizationModel, actual *openfgav1.AuthorizationModel) (bool, error) {
-	// we need to initialize a new model since the model extracted from schema doesn't have id
-	expectedAuthModel := openfgav1.AuthorizationModel{
-		SchemaVersion:   expected.SchemaVersion,
-		TypeDefinitions: expected.TypeDefinitions,
-		Conditions:      expected.Conditions,
-	}
-	expectedAuthModelBytes, err := protojson.Marshal(&expectedAuthModel)
-	if err != nil {
-		return false, err
-	}
-
-	actualAuthModel := openfgav1.AuthorizationModel{
-		SchemaVersion:   actual.SchemaVersion,
-		TypeDefinitions: actual.TypeDefinitions,
-		Conditions:      actual.Conditions,
-	}
-	actualAuthModelBytes, err := protojson.Marshal(&actualAuthModel)
-	if err != nil {
-		return false, err
-	}
-
-	return string(expectedAuthModelBytes) == string(actualAuthModelBytes), nil
-
-}
-
-func (server *Server) getStoreIDandModelID() (string, string) {
-	server.mtx.RLock()
-	defer server.mtx.RUnlock()
-
-	storeID := server.storeID
-	modelID := server.modelID
-
-	return storeID, modelID
-}
--- a/pkg/http/middleware/authz.go
+++ b/pkg/http/middleware/authz.go
@@ -8,6 +8,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/role"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/roletypes"
@@ -23,14 +24,15 @@ type AuthZ struct {
 	logger       *slog.Logger
 	orgGetter    organization.Getter
 	authzService authz.AuthZ
+	roleGetter   role.Getter
 }

-func NewAuthZ(logger *slog.Logger, orgGetter organization.Getter, authzService authz.AuthZ) *AuthZ {
+func NewAuthZ(logger *slog.Logger, orgGetter organization.Getter, authzService authz.AuthZ, roleGetter role.Getter) *AuthZ {
 	if logger == nil {
 		panic("cannot build authz middleware, logger is empty")
 	}

-	return &AuthZ{logger: logger, orgGetter: orgGetter, authzService: authzService}
+	return &AuthZ{logger: logger, orgGetter: orgGetter, authzService: authzService, roleGetter: roleGetter}
 }

 func (middleware *AuthZ) ViewAccess(next http.HandlerFunc) http.HandlerFunc {
--- a/pkg/modules/dashboard/dashboard.go
+++ b/pkg/modules/dashboard/dashboard.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"

-	"github.com/SigNoz/signoz/pkg/authz"
+	"github.com/SigNoz/signoz/pkg/modules/role"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
@@ -51,7 +51,7 @@ type Module interface {

 	statsreporter.StatsCollector

-	authz.RegisterTypeable
+	role.RegisterTypeable
 }

 type Handler interface {
--- a/pkg/modules/dashboard/impldashboard/module.go
+++ b/pkg/modules/dashboard/impldashboard/module.go
@@ -206,10 +206,6 @@ func (module *module) MustGetTypeables() []authtypes.Typeable {
 	return []authtypes.Typeable{dashboardtypes.TypeableMetaResourceDashboard, dashboardtypes.TypeableMetaResourcesDashboards}
 }

-func (module *module) MustGetManagedRoleTransactions() map[string][]*authtypes.Transaction {
-	return nil
-}
-
 // not supported
 func (module *module) CreatePublic(ctx context.Context, orgID valuer.UUID, publicDashboard *dashboardtypes.PublicDashboard) error {
 	return errors.Newf(errors.TypeUnsupported, dashboardtypes.ErrCodePublicDashboardUnsupported, "not implemented")
--- a/pkg/modules/fields/handler.go
+++ b/pkg/modules/fields/handler.go
@@ -1,11 +0,0 @@
-package fields
-
-import "net/http"
-
-type Handler interface {
-	// Gets the fields keys for the given field key selector
-	GetFieldsKeys(http.ResponseWriter, *http.Request)
-
-	// Gets the fields values for the given field value selector
-	GetFieldsValues(http.ResponseWriter, *http.Request)
-}
--- a/Show More
+++ b/Show More