refactor: rename selectedDashboard to dashboardData

Renames the `selectedDashboard` store field (and related setters/getters `setSelectedDashboard`, `getSelectedDashboard`) to `dashboardData` across the frontend. Also renames incidental locals (`updatedSelectedDashboard`, `mockSelectedDashboard`, and the ExportPanel's local `selectedDashboardId`).
fix: alerts creation for query types other than builder (#11030 )
2026-04-21 19:30:29 +01:00 · 2026-04-21 19:50:08 +05:30 · 2026-04-21 11:33:32 +00:00 · 2026-04-21 11:06:49 +00:00 · 2026-04-21 11:04:32 +00:00 · 2026-04-21 08:36:04 +00:00
299 changed files with 10750 additions and 26708 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -16,38 +16,38 @@ go.mod @therealpandey

 # Scaffold Owners

-/pkg/config/ @vikrantgupta25
-/pkg/errors/ @vikrantgupta25
-/pkg/factory/ @vikrantgupta25
-/pkg/types/ @vikrantgupta25
-/pkg/valuer/ @vikrantgupta25
-/cmd/ @vikrantgupta25
-.golangci.yml @vikrantgupta25
+/pkg/config/ @therealpandey
+/pkg/errors/ @therealpandey
+/pkg/factory/ @therealpandey
+/pkg/types/ @therealpandey
+/pkg/valuer/ @therealpandey
+/cmd/ @therealpandey
+.golangci.yml @therealpandey

 # Zeus Owners

-/pkg/zeus/ @vikrantgupta25
-/ee/zeus/ @vikrantgupta25
-/pkg/licensing/ @vikrantgupta25
-/ee/licensing/ @vikrantgupta25
+/pkg/zeus/ @therealpandey
+/ee/zeus/ @therealpandey
+/pkg/licensing/ @therealpandey
+/ee/licensing/ @therealpandey

 # SQL Owners

-/pkg/sqlmigration/ @vikrantgupta25
-/ee/sqlmigration/ @vikrantgupta25
-/pkg/sqlschema/ @vikrantgupta25
-/ee/sqlschema/ @vikrantgupta25
+/pkg/sqlmigration/ @therealpandey
+/ee/sqlmigration/ @therealpandey
+/pkg/sqlschema/ @therealpandey
+/ee/sqlschema/ @therealpandey

 # Analytics Owners

-/pkg/analytics/ @vikrantgupta25
-/pkg/statsreporter/ @vikrantgupta25
+/pkg/analytics/ @therealpandey
+/pkg/statsreporter/ @therealpandey

 # Emailing Owners

-/pkg/emailing/ @vikrantgupta25
-/pkg/types/emailtypes/ @vikrantgupta25
-/templates/email/ @vikrantgupta25
+/pkg/emailing/ @therealpandey
+/pkg/types/emailtypes/ @therealpandey
+/templates/email/ @therealpandey

 # Querier Owners

@@ -97,23 +97,23 @@ go.mod @therealpandey

 # AuthN / AuthZ Owners

-/pkg/authz/ @vikrantgupta25
-/ee/authz/ @vikrantgupta25
-/pkg/authn/ @vikrantgupta25
-/ee/authn/ @vikrantgupta25
-/pkg/modules/user/ @vikrantgupta25
-/pkg/modules/session/ @vikrantgupta25
-/pkg/modules/organization/ @vikrantgupta25
-/pkg/modules/authdomain/ @vikrantgupta25
-/pkg/modules/role/ @vikrantgupta25
+/pkg/authz/ @therealpandey
+/ee/authz/ @therealpandey
+/pkg/authn/ @therealpandey
+/ee/authn/ @therealpandey
+/pkg/modules/user/ @therealpandey
+/pkg/modules/session/ @therealpandey
+/pkg/modules/organization/ @therealpandey
+/pkg/modules/authdomain/ @therealpandey
+/pkg/modules/role/ @therealpandey

 # IdentN Owners
-/pkg/identn/ @vikrantgupta25
-/pkg/http/middleware/identn.go @vikrantgupta25
+/pkg/identn/ @therealpandey
+/pkg/http/middleware/identn.go @therealpandey

 # Integration tests

-/tests/integration/ @vikrantgupta25
+/tests/integration/ @therealpandey

 # OpenAPI types generator

--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -1,226 +1,5 @@
 components:
  schemas:
-    Aio11YpricingruletypesCacheMode:
-      enum:
-      - subtract
-      - additive
-      - unknown
-      type: string
-    Aio11YpricingruletypesListPricingRulesResponse:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/Aio11YpricingruletypesPricingRule'
-          nullable: true
-          type: array
-        limit:
-          type: integer
-        offset:
-          type: integer
-        total:
-          type: integer
-      required:
-      - items
-      - total
-      - offset
-      - limit
-      type: object
-    Aio11YpricingruletypesPostablePricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/Aio11YpricingruletypesCacheMode'
-        costCacheRead:
-          format: double
-          type: number
-        costCacheWrite:
-          format: double
-          type: number
-        costInput:
-          format: double
-          type: number
-        costOutput:
-          format: double
-          type: number
-        enabled:
-          type: boolean
-        modelName:
-          type: string
-        modelPattern:
-          items:
-            type: string
-          nullable: true
-          type: array
-        unit:
-          $ref: '#/components/schemas/Aio11YpricingruletypesUnit'
-      required:
-      - modelName
-      - modelPattern
-      - unit
-      - cacheMode
-      - costInput
-      - costOutput
-      - costCacheRead
-      - costCacheWrite
-      - enabled
-      type: object
-    Aio11YpricingruletypesPricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/Aio11YpricingruletypesCacheMode'
-        costCacheRead:
-          format: double
-          type: number
-        costCacheWrite:
-          format: double
-          type: number
-        costInput:
-          format: double
-          type: number
-        costOutput:
-          format: double
-          type: number
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        id:
-          type: string
-        isOverride:
-          type: boolean
-        model:
-          type: string
-        modelPattern:
-          items:
-            type: string
-          nullable: true
-          type: array
-        orgId:
-          type: string
-        syncedAt:
-          format: date-time
-          nullable: true
-          type: string
-        unit:
-          $ref: '#/components/schemas/Aio11YpricingruletypesUnit'
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - model
-      - modelPattern
-      - unit
-      - cacheMode
-      - costInput
-      - costOutput
-      - costCacheRead
-      - costCacheWrite
-      - isOverride
-      - enabled
-      type: object
-    Aio11YpricingruletypesSyncPricingRulesRequest:
-      properties:
-        rules:
-          items:
-            $ref: '#/components/schemas/Aio11YpricingruletypesSyncablePricingRule'
-          nullable: true
-          type: array
-      required:
-      - rules
-      type: object
-    Aio11YpricingruletypesSyncPricingRulesResponse:
-      properties:
-        refreshed:
-          type: integer
-        synced:
-          type: integer
-      required:
-      - synced
-      - refreshed
-      type: object
-    Aio11YpricingruletypesSyncablePricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/Aio11YpricingruletypesCacheMode'
-        costCacheRead:
-          format: double
-          type: number
-        costCacheWrite:
-          format: double
-          type: number
-        costInput:
-          format: double
-          type: number
-        costOutput:
-          format: double
-          type: number
-        enabled:
-          type: boolean
-        modelName:
-          type: string
-        modelPattern:
-          items:
-            type: string
-          nullable: true
-          type: array
-        sourceId:
-          type: string
-        unit:
-          $ref: '#/components/schemas/Aio11YpricingruletypesUnit'
-      required:
-      - modelName
-      - modelPattern
-      - unit
-      - cacheMode
-      - costInput
-      - costOutput
-      - costCacheRead
-      - costCacheWrite
-      - enabled
-      - sourceId
-      type: object
-    Aio11YpricingruletypesUnit:
-      enum:
-      - per_million_tokens
-      type: string
-    Aio11YpricingruletypesUpdatablePricingRule:
-      properties:
-        cacheMode:
-          $ref: '#/components/schemas/Aio11YpricingruletypesCacheMode'
-        costCacheRead:
-          nullable: true
-          type: number
-        costCacheWrite:
-          nullable: true
-          type: number
-        costInput:
-          nullable: true
-          type: number
-        costOutput:
-          nullable: true
-          type: number
-        enabled:
-          nullable: true
-          type: boolean
-        isOverride:
-          nullable: true
-          type: boolean
-        modelName:
-          nullable: true
-          type: string
-        modelPattern:
-          items:
-            type: string
-          type: array
-        unit:
-          $ref: '#/components/schemas/Aio11YpricingruletypesUnit'
-      type: object
    AlertmanagertypesChannel:
      properties:
        createdAt:
@@ -4865,361 +4644,6 @@ info:
  version: ""
 openapi: 3.0.3
 paths:
-  /api/v1/ai-o11y/pricing_rules:
-    get:
-      deprecated: false
-      description: Returns all LLM pricing rules for the authenticated org, with pagination.
-      operationId: ListPricingRules
-      parameters:
-      - in: query
-        name: offset
-        schema:
-          type: integer
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Aio11YpricingruletypesListPricingRulesResponse'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "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: List pricing rules
-      tags:
-      - ai-o11y
-    post:
-      deprecated: false
-      description: Creates a new LLM pricing rule for the org. Always sets is_override
-        = true.
-      operationId: CreatePricingRule
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/Aio11YpricingruletypesPostablePricingRule'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Aio11YpricingruletypesPricingRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create a pricing rule
-      tags:
-      - ai-o11y
-  /api/v1/ai-o11y/pricing_rules/{id}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a pricing rule. If auto-synced, it will be recreated
-        on the next sync cycle.
-      operationId: DeletePricingRule
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a pricing rule
-      tags:
-      - ai-o11y
-    get:
-      deprecated: false
-      description: Returns a single LLM pricing rule by ID.
-      operationId: GetPricingRule
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Aio11YpricingruletypesPricingRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                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
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get a pricing rule
-      tags:
-      - ai-o11y
-    patch:
-      deprecated: false
-      description: Partially updates an existing pricing rule. Changing any cost field
-        sets is_override = true.
-      operationId: UpdatePricingRule
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/Aio11YpricingruletypesUpdatablePricingRule'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Aio11YpricingruletypesPricingRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a pricing rule
-      tags:
-      - ai-o11y
-  /api/v1/ai-o11y/pricing_rules/sync:
-    put:
-      deprecated: false
-      description: Zeus bulk-upserts upstream pricing. Non-override rules get costs
-        updated; override rules get only SourceConfig refreshed.
-      operationId: SyncPricingRules
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/Aio11YpricingruletypesSyncPricingRulesRequest'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/Aio11YpricingruletypesSyncPricingRulesResponse'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "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:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Bulk sync pricing rules
-      tags:
-      - ai-o11y
  /api/v1/alerts:
    get:
      deprecated: false
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -62,8 +62,8 @@
    "@signozhq/popover": "0.1.2",
    "@signozhq/radio-group": "0.0.4",
    "@signozhq/resizable": "0.0.2",
-    "@signozhq/table": "0.3.7",
    "@signozhq/tabs": "0.0.11",
+    "@signozhq/table": "0.3.8",
    "@signozhq/toggle-group": "0.0.3",
    "@signozhq/ui": "0.0.5",
    "@tanstack/react-table": "8.21.3",
--- a/frontend/src/api/generated/services/ai-o11y/index.ts
+++ b/frontend/src/api/generated/services/ai-o11y/index.ts
@@ -1,577 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useMutation, useQuery } from 'react-query';
-
-import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	Aio11YpricingruletypesPostablePricingRuleDTO,
-	Aio11YpricingruletypesSyncPricingRulesRequestDTO,
-	Aio11YpricingruletypesUpdatablePricingRuleDTO,
-	CreatePricingRule201,
-	DeletePricingRulePathParameters,
-	GetPricingRule200,
-	GetPricingRulePathParameters,
-	ListPricingRules200,
-	ListPricingRulesParams,
-	RenderErrorResponseDTO,
-	SyncPricingRules200,
-	UpdatePricingRule200,
-	UpdatePricingRulePathParameters,
-} from '../sigNoz.schemas';
-
-/**
- * Returns all LLM pricing rules for the authenticated org, with pagination.
- * @summary List pricing rules
- */
-export const listPricingRules = (
-	params?: ListPricingRulesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListPricingRules200>({
-		url: `/api/v1/ai-o11y/pricing_rules`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListPricingRulesQueryKey = (
-	params?: ListPricingRulesParams,
-) => {
-	return [`/api/v1/ai-o11y/pricing_rules`, ...(params ? [params] : [])] as const;
-};
-
-export const getListPricingRulesQueryOptions = <
-	TData = Awaited<ReturnType<typeof listPricingRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListPricingRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listPricingRules>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListPricingRulesQueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listPricingRules>>> = ({
-		signal,
-	}) => listPricingRules(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listPricingRules>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListPricingRulesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listPricingRules>>
->;
-export type ListPricingRulesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List pricing rules
- */
-
-export function useListPricingRules<
-	TData = Awaited<ReturnType<typeof listPricingRules>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	params?: ListPricingRulesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listPricingRules>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListPricingRulesQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List pricing rules
- */
-export const invalidateListPricingRules = async (
-	queryClient: QueryClient,
-	params?: ListPricingRulesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListPricingRulesQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates a new LLM pricing rule for the org. Always sets is_override = true.
- * @summary Create a pricing rule
- */
-export const createPricingRule = (
-	aio11YpricingruletypesPostablePricingRuleDTO: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreatePricingRule201>({
-		url: `/api/v1/ai-o11y/pricing_rules`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: aio11YpricingruletypesPostablePricingRuleDTO,
-		signal,
-	});
-};
-
-export const getCreatePricingRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createPricingRule>>,
-		TError,
-		{ data: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createPricingRule>>,
-	TError,
-	{ data: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO> },
-	TContext
-> => {
-	const mutationKey = ['createPricingRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createPricingRule>>,
-		{ data: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createPricingRule(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreatePricingRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createPricingRule>>
->;
-export type CreatePricingRuleMutationBody = BodyType<Aio11YpricingruletypesPostablePricingRuleDTO>;
-export type CreatePricingRuleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a pricing rule
- */
-export const useCreatePricingRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createPricingRule>>,
-		TError,
-		{ data: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createPricingRule>>,
-	TError,
-	{ data: BodyType<Aio11YpricingruletypesPostablePricingRuleDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreatePricingRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a pricing rule. If auto-synced, it will be recreated on the next sync cycle.
- * @summary Delete a pricing rule
- */
-export const deletePricingRule = ({ id }: DeletePricingRulePathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/ai-o11y/pricing_rules/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeletePricingRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deletePricingRule>>,
-		TError,
-		{ pathParams: DeletePricingRulePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deletePricingRule>>,
-	TError,
-	{ pathParams: DeletePricingRulePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deletePricingRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deletePricingRule>>,
-		{ pathParams: DeletePricingRulePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deletePricingRule(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeletePricingRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deletePricingRule>>
->;
-
-export type DeletePricingRuleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a pricing rule
- */
-export const useDeletePricingRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deletePricingRule>>,
-		TError,
-		{ pathParams: DeletePricingRulePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deletePricingRule>>,
-	TError,
-	{ pathParams: DeletePricingRulePathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeletePricingRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns a single LLM pricing rule by ID.
- * @summary Get a pricing rule
- */
-export const getPricingRule = (
-	{ id }: GetPricingRulePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetPricingRule200>({
-		url: `/api/v1/ai-o11y/pricing_rules/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetPricingRuleQueryKey = ({
-	id,
-}: GetPricingRulePathParameters) => {
-	return [`/api/v1/ai-o11y/pricing_rules/${id}`] as const;
-};
-
-export const getGetPricingRuleQueryOptions = <
-	TData = Awaited<ReturnType<typeof getPricingRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetPricingRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getPricingRule>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetPricingRuleQueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getPricingRule>>> = ({
-		signal,
-	}) => getPricingRule({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getPricingRule>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetPricingRuleQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getPricingRule>>
->;
-export type GetPricingRuleQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get a pricing rule
- */
-
-export function useGetPricingRule<
-	TData = Awaited<ReturnType<typeof getPricingRule>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetPricingRulePathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getPricingRule>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetPricingRuleQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get a pricing rule
- */
-export const invalidateGetPricingRule = async (
-	queryClient: QueryClient,
-	{ id }: GetPricingRulePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetPricingRuleQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Partially updates an existing pricing rule. Changing any cost field sets is_override = true.
- * @summary Update a pricing rule
- */
-export const updatePricingRule = (
-	{ id }: UpdatePricingRulePathParameters,
-	aio11YpricingruletypesUpdatablePricingRuleDTO: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>,
-) => {
-	return GeneratedAPIInstance<UpdatePricingRule200>({
-		url: `/api/v1/ai-o11y/pricing_rules/${id}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: aio11YpricingruletypesUpdatablePricingRuleDTO,
-	});
-};
-
-export const getUpdatePricingRuleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updatePricingRule>>,
-		TError,
-		{
-			pathParams: UpdatePricingRulePathParameters;
-			data: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updatePricingRule>>,
-	TError,
-	{
-		pathParams: UpdatePricingRulePathParameters;
-		data: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updatePricingRule'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updatePricingRule>>,
-		{
-			pathParams: UpdatePricingRulePathParameters;
-			data: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updatePricingRule(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdatePricingRuleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updatePricingRule>>
->;
-export type UpdatePricingRuleMutationBody = BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-export type UpdatePricingRuleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a pricing rule
- */
-export const useUpdatePricingRule = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updatePricingRule>>,
-		TError,
-		{
-			pathParams: UpdatePricingRulePathParameters;
-			data: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updatePricingRule>>,
-	TError,
-	{
-		pathParams: UpdatePricingRulePathParameters;
-		data: BodyType<Aio11YpricingruletypesUpdatablePricingRuleDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdatePricingRuleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Zeus bulk-upserts upstream pricing. Non-override rules get costs updated; override rules get only SourceConfig refreshed.
- * @summary Bulk sync pricing rules
- */
-export const syncPricingRules = (
-	aio11YpricingruletypesSyncPricingRulesRequestDTO: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO>,
-) => {
-	return GeneratedAPIInstance<SyncPricingRules200>({
-		url: `/api/v1/ai-o11y/pricing_rules/sync`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: aio11YpricingruletypesSyncPricingRulesRequestDTO,
-	});
-};
-
-export const getSyncPricingRulesMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof syncPricingRules>>,
-		TError,
-		{ data: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof syncPricingRules>>,
-	TError,
-	{ data: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO> },
-	TContext
-> => {
-	const mutationKey = ['syncPricingRules'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof syncPricingRules>>,
-		{ data: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return syncPricingRules(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type SyncPricingRulesMutationResult = NonNullable<
-	Awaited<ReturnType<typeof syncPricingRules>>
->;
-export type SyncPricingRulesMutationBody = BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO>;
-export type SyncPricingRulesMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Bulk sync pricing rules
- */
-export const useSyncPricingRules = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof syncPricingRules>>,
-		TError,
-		{ data: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof syncPricingRules>>,
-	TError,
-	{ data: BodyType<Aio11YpricingruletypesSyncPricingRulesRequestDTO> },
-	TContext
-> => {
-	const mutationOptions = getSyncPricingRulesMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -4,251 +4,6 @@
 * * regenerate with 'yarn generate:api'
 * SigNoz
 */
-export enum Aio11YpricingruletypesCacheModeDTO {
-	subtract = 'subtract',
-	additive = 'additive',
-	unknown = 'unknown',
-}
-export interface Aio11YpricingruletypesListPricingRulesResponseDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: Aio11YpricingruletypesPricingRuleDTO[] | null;
-	/**
-	 * @type integer
-	 */
-	limit: number;
-	/**
-	 * @type integer
-	 */
-	offset: number;
-	/**
-	 * @type integer
-	 */
-	total: number;
-}
-
-export interface Aio11YpricingruletypesPostablePricingRuleDTO {
-	cacheMode: Aio11YpricingruletypesCacheModeDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheRead: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheWrite: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costInput: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costOutput: number;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	modelName: string;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	modelPattern: string[] | null;
-	unit: Aio11YpricingruletypesUnitDTO;
-}
-
-export interface Aio11YpricingruletypesPricingRuleDTO {
-	cacheMode: Aio11YpricingruletypesCacheModeDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheRead: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheWrite: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costInput: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costOutput: number;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type boolean
-	 */
-	isOverride: boolean;
-	/**
-	 * @type string
-	 */
-	model: string;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	modelPattern: string[] | null;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 * @nullable true
-	 */
-	syncedAt?: Date | null;
-	unit: Aio11YpricingruletypesUnitDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface Aio11YpricingruletypesSyncPricingRulesRequestDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	rules: Aio11YpricingruletypesSyncablePricingRuleDTO[] | null;
-}
-
-export interface Aio11YpricingruletypesSyncPricingRulesResponseDTO {
-	/**
-	 * @type integer
-	 */
-	refreshed: number;
-	/**
-	 * @type integer
-	 */
-	synced: number;
-}
-
-export interface Aio11YpricingruletypesSyncablePricingRuleDTO {
-	cacheMode: Aio11YpricingruletypesCacheModeDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheRead: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costCacheWrite: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costInput: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	costOutput: number;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	modelName: string;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	modelPattern: string[] | null;
-	/**
-	 * @type string
-	 */
-	sourceId: string;
-	unit: Aio11YpricingruletypesUnitDTO;
-}
-
-export enum Aio11YpricingruletypesUnitDTO {
-	per_million_tokens = 'per_million_tokens',
-}
-export interface Aio11YpricingruletypesUpdatablePricingRuleDTO {
-	cacheMode?: Aio11YpricingruletypesCacheModeDTO;
-	/**
-	 * @type number
-	 * @nullable true
-	 */
-	costCacheRead?: number | null;
-	/**
-	 * @type number
-	 * @nullable true
-	 */
-	costCacheWrite?: number | null;
-	/**
-	 * @type number
-	 * @nullable true
-	 */
-	costInput?: number | null;
-	/**
-	 * @type number
-	 * @nullable true
-	 */
-	costOutput?: number | null;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	isOverride?: boolean | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	modelName?: string | null;
-	/**
-	 * @type array
-	 */
-	modelPattern?: string[];
-	unit?: Aio11YpricingruletypesUnitDTO;
-}
-
 export interface AlertmanagertypesChannelDTO {
 	/**
 	 * @type string
@@ -5936,68 +5691,6 @@ export interface ZeustypesPostableProfileDTO {
 	where_did_you_discover_signoz: string;
 }

-export type ListPricingRulesParams = {
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-};
-
-export type ListPricingRules200 = {
-	data: Aio11YpricingruletypesListPricingRulesResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreatePricingRule201 = {
-	data: Aio11YpricingruletypesPricingRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeletePricingRulePathParameters = {
-	id: string;
-};
-export type GetPricingRulePathParameters = {
-	id: string;
-};
-export type GetPricingRule200 = {
-	data: Aio11YpricingruletypesPricingRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type UpdatePricingRulePathParameters = {
-	id: string;
-};
-export type UpdatePricingRule200 = {
-	data: Aio11YpricingruletypesPricingRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type SyncPricingRules200 = {
-	data: Aio11YpricingruletypesSyncPricingRulesResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetAlerts200 = {
 	/**
 	 * @type array
--- a/frontend/src/api/infra/getHostAttributeKeys.ts
+++ b/frontend/src/api/infra/getHostAttributeKeys.ts
@@ -2,7 +2,7 @@ import axios from 'api';
 import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
 import { AxiosError, AxiosResponse } from 'axios';
 import { baseAutoCompleteIdKeysOrder } from 'constants/queryBuilder';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
+import { InfraMonitoringEntity } from 'container/InfraMonitoringK8s/constants';
 import { createIdFromObjectFields } from 'lib/createIdFromObjectFields';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import {
@@ -12,7 +12,7 @@ import {

 export const getHostAttributeKeys = async (
 	searchText = '',
-	entity: K8sCategory,
+	entity: InfraMonitoringEntity,
 ): Promise<SuccessResponse<IQueryAutocompleteResponse> | ErrorResponse> => {
 	try {
 		const response: AxiosResponse<{
--- a/frontend/src/api/infraMonitoring/getHostLists.ts
+++ b/frontend/src/api/infraMonitoring/getHostLists.ts
@@ -33,6 +33,8 @@ export interface HostData {
 	hostName: string;
 	active: boolean;
 	os: string;
+	/** Present when the list API returns grouped rows or extra resource attributes. */
+	meta?: Record<string, string>;
 	cpu: number;
 	cpuTimeSeries: TimeSeries;
 	memory: number;
--- a/frontend/src/api/infraMonitoring/getK8sNodesList.ts
+++ b/frontend/src/api/infraMonitoring/getK8sNodesList.ts
@@ -1,127 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
-
-import { UnderscoreToDotMap } from '../utils';
-
-export interface K8sNodesListPayload {
-	filters: TagFilter;
-	groupBy?: BaseAutocompleteData[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
-
-export interface K8sNodesData {
-	nodeUID: string;
-	nodeCPUUsage: number;
-	nodeCPUAllocatable: number;
-	nodeMemoryUsage: number;
-	nodeMemoryAllocatable: number;
-	meta: {
-		k8s_node_name: string;
-		k8s_node_uid: string;
-		k8s_cluster_name: string;
-	};
-}
-
-export interface K8sNodesListResponse {
-	status: string;
-	data: {
-		type: string;
-		records: K8sNodesData[];
-		groups: null;
-		total: number;
-		sentAnyHostMetricsData: boolean;
-		isSendingK8SAgentMetrics: boolean;
-	};
-}
-
-export const nodesMetaMap = [
-	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
-	{ dot: 'k8s.node.uid', under: 'k8s_node_uid' },
-	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
-] as const;
-
-export function mapNodesMeta(
-	raw: Record<string, unknown>,
-): K8sNodesData['meta'] {
-	const out: Record<string, unknown> = { ...raw };
-	nodesMetaMap.forEach(({ dot, under }) => {
-		if (dot in raw) {
-			const v = raw[dot];
-			out[under] = typeof v === 'string' ? v : raw[under];
-		}
-	});
-	return out as K8sNodesData['meta'];
-}
-
-export const getK8sNodesList = async (
-	props: K8sNodesListPayload,
-	signal?: AbortSignal,
-	headers?: Record<string, string>,
-	dotMetricsEnabled = false,
-): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
-	try {
-		const requestProps =
-			dotMetricsEnabled && Array.isArray(props.filters?.items)
-				? {
-						...props,
-						filters: {
-							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
-								(acc, item) => {
-									if (item.value === undefined) {
-										return acc;
-									}
-									if (
-										item.key &&
-										typeof item.key === 'object' &&
-										'key' in item.key &&
-										typeof item.key.key === 'string'
-									) {
-										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
-										acc.push({
-											...item,
-											key: { ...item.key, key: mappedKey },
-										});
-									} else {
-										acc.push(item);
-									}
-									return acc;
-								},
-								[] as typeof props.filters.items,
-							),
-						},
-				  }
-				: props;
-
-		const response = await axios.post('/nodes/list', requestProps, {
-			signal,
-			headers,
-		});
-		const payload: K8sNodesListResponse = response.data;
-
-		// one-liner to map dot→underscore
-		payload.data.records = payload.data.records.map((record) => ({
-			...record,
-			meta: mapNodesMeta(record.meta as Record<string, unknown>),
-		}));
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: 'Success',
-			payload,
-			params: requestProps,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
--- a/frontend/src/auto-import-registry.d.ts
+++ b/frontend/src/auto-import-registry.d.ts
@@ -24,7 +24,7 @@ import '@signozhq/input';
 import '@signozhq/popover';
 import '@signozhq/radio-group';
 import '@signozhq/resizable';
-import '@signozhq/table';
 import '@signozhq/tabs';
+import '@signozhq/table';
 import '@signozhq/toggle-group';
 import '@signozhq/ui';
--- a/frontend/src/components/CeleryTask/useNavigateToExplorer.ts
+++ b/frontend/src/components/CeleryTask/useNavigateToExplorer.ts
@@ -79,7 +79,7 @@ export function useNavigateToExplorer(): (
 	);

 	const { getUpdatedQuery } = useUpdatedQuery();
-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();
 	const { notifications } = useNotifications();

 	return useCallback(
@@ -111,7 +111,7 @@ export function useNavigateToExplorer(): (
 						panelTypes: PANEL_TYPES.TIME_SERIES,
 						timePreferance: 'GLOBAL_TIME',
 					},
-					selectedDashboard,
+					dashboardData,
 				})
 					.then((query) => {
 						preparedQuery = query;
@@ -140,7 +140,7 @@ export function useNavigateToExplorer(): (
 			minTime,
 			maxTime,
 			getUpdatedQuery,
-			selectedDashboard,
+			dashboardData,
 			notifications,
 		],
 	);
--- a/frontend/src/components/HostMetricsDetail/HostMetricDetail.interfaces.ts
+++ b/frontend/src/components/HostMetricsDetail/HostMetricDetail.interfaces.ts
@@ -1,7 +0,0 @@
-import { HostData } from 'api/infraMonitoring/getHostLists';
-
-export type HostDetailProps = {
-	host: HostData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};
--- a/frontend/src/components/HostMetricsDetail/HostMetricTraces/HostMetricTraces.styles.scss
+++ b/frontend/src/components/HostMetricsDetail/HostMetricTraces/HostMetricTraces.styles.scss
@@ -1,145 +0,0 @@
-.host-metric-traces {
-	margin-top: 1rem;
-
-	.host-metric-traces-header {
-		display: flex;
-		justify-content: space-between;
-		margin-bottom: 1rem;
-
-		gap: 8px;
-		padding: 12px;
-		border-radius: 3px;
-		border: 1px solid var(--l1-border);
-
-		.filter-section {
-			flex: 1;
-
-			.ant-select-selector {
-				border-radius: 2px;
-				border: 1px solid var(--l1-border) !important;
-				background-color: var(--l3-background) !important;
-
-				input {
-					font-size: 12px;
-				}
-
-				.ant-tag .ant-typography {
-					font-size: 12px;
-				}
-			}
-		}
-	}
-
-	.host-metric-traces-table {
-		.ant-table-content {
-			overflow: hidden !important;
-		}
-
-		.ant-table {
-			border-radius: 3px;
-			border: 1px solid var(--l1-border);
-
-			.ant-table-thead > tr > th {
-				padding: 12px;
-				font-weight: 500;
-				font-size: 12px;
-				line-height: 18px;
-
-				background: color-mix(in srgb, var(--bg-robin-200) 1%, transparent);
-				border-bottom: none;
-
-				color: var(--l2-foreground);
-				font-family: Inter;
-				font-size: 11px;
-				font-style: normal;
-				font-weight: 600;
-				line-height: 18px; /* 163.636% */
-				letter-spacing: 0.44px;
-				text-transform: uppercase;
-
-				&::before {
-					background-color: transparent;
-				}
-			}
-
-			.ant-table-thead > tr > th:has(.hostname-column-header) {
-				background: var(--l2-background);
-			}
-
-			.ant-table-cell {
-				padding: 12px;
-				font-size: 13px;
-				line-height: 20px;
-				color: var(--l1-foreground);
-				background: color-mix(in srgb, var(--bg-robin-200) 1%, transparent);
-			}
-
-			.ant-table-cell:has(.hostname-column-value) {
-				background: var(--l2-background);
-			}
-
-			.hostname-column-value {
-				color: var(--l1-foreground);
-				font-family: 'Geist Mono';
-				font-style: normal;
-				font-weight: 600;
-				line-height: 20px; /* 142.857% */
-				letter-spacing: -0.07px;
-			}
-
-			.status-cell {
-				.active-tag {
-					color: var(--bg-forest-500);
-					padding: 4px 8px;
-					border-radius: 4px;
-					font-size: 12px;
-					font-weight: 500;
-				}
-			}
-
-			.progress-container {
-				.ant-progress-bg {
-					height: 8px !important;
-					border-radius: 4px;
-				}
-			}
-
-			.ant-table-tbody > tr:hover > td {
-				background: color-mix(in srgb, var(--l1-foreground) 4%, transparent);
-			}
-
-			.ant-table-cell:first-child {
-				text-align: justify;
-			}
-
-			.ant-table-cell:nth-child(2) {
-				padding-left: 16px;
-				padding-right: 16px;
-			}
-
-			.ant-table-cell:nth-child(n + 3) {
-				padding-right: 24px;
-			}
-			.column-header-right {
-				text-align: right;
-			}
-			.ant-table-tbody > tr > td {
-				border-bottom: none;
-			}
-
-			.ant-table-thead
-				> tr
-				> th:not(:last-child):not(.ant-table-selection-column):not(.ant-table-row-expand-icon-cell):not([colspan])::before {
-				background-color: transparent;
-			}
-
-			.ant-empty-normal {
-				visibility: hidden;
-			}
-		}
-
-		.ant-table-container::after {
-			content: none;
-		}
-	}
-}
--- a/frontend/src/components/HostMetricsDetail/HostMetricTraces/HostMetricTraces.tsx
+++ b/frontend/src/components/HostMetricsDetail/HostMetricTraces/HostMetricTraces.tsx
@@ -1,222 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import logEvent from 'api/common/logEvent';
-import { ResizeTable } from 'components/ResizeTable';
-import { DEFAULT_ENTITY_VERSION } from 'constants/app';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
-import NoLogs from 'container/NoLogs/NoLogs';
-import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
-import { ErrorText } from 'container/TimeSeriesView/styles';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import TraceExplorerControls from 'container/TracesExplorer/Controls';
-import { PER_PAGE_OPTIONS } from 'container/TracesExplorer/ListView/configs';
-import { TracesLoading } from 'container/TracesExplorer/TraceLoading/TraceLoading';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { Pagination } from 'hooks/queryPagination';
-import useUrlQueryData from 'hooks/useUrlQueryData';
-import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-
-import { VIEWS } from '../constants';
-import { getHostTracesQueryPayload, selectedColumns } from './constants';
-import { getListColumns } from './utils';
-
-import './HostMetricTraces.styles.scss';
-
-interface Props {
-	timeRange: {
-		startTime: number;
-		endTime: number;
-	};
-	isModalTimeSelection: boolean;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-	handleChangeTracesFilters: (
-		value: IBuilderQuery['filters'],
-		view: VIEWS,
-	) => void;
-	tracesFilters: IBuilderQuery['filters'];
-	selectedInterval: Time;
-}
-
-function HostMetricTraces({
-	timeRange,
-	isModalTimeSelection,
-	handleTimeChange,
-	handleChangeTracesFilters,
-	tracesFilters,
-	selectedInterval,
-}: Props): JSX.Element {
-	const [traces, setTraces] = useState<any[]>([]);
-	const [offset] = useState<number>(0);
-
-	const { currentQuery } = useQueryBuilder();
-	const updatedCurrentQuery = useMemo(
-		() => ({
-			...currentQuery,
-			builder: {
-				...currentQuery.builder,
-				queryData: [
-					{
-						...currentQuery.builder.queryData[0],
-						dataSource: DataSource.TRACES,
-						aggregateOperator: 'noop',
-						aggregateAttribute: {
-							...currentQuery.builder.queryData[0].aggregateAttribute,
-						},
-						filters: {
-							items:
-								tracesFilters?.items?.filter((item) => item.key?.key !== 'host.name') ||
-								[],
-							op: 'AND',
-						},
-					},
-				],
-			},
-		}),
-		[currentQuery, tracesFilters?.items],
-	);
-
-	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
-
-	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
-		QueryParams.pagination,
-	);
-
-	const queryPayload = useMemo(
-		() =>
-			getHostTracesQueryPayload(
-				timeRange.startTime,
-				timeRange.endTime,
-				paginationQueryData?.offset || offset,
-				tracesFilters,
-			),
-		[
-			timeRange.startTime,
-			timeRange.endTime,
-			offset,
-			tracesFilters,
-			paginationQueryData,
-		],
-	);
-
-	const { data, isLoading, isFetching, isError } = useQuery({
-		queryKey: [
-			'hostMetricTraces',
-			timeRange.startTime,
-			timeRange.endTime,
-			offset,
-			tracesFilters,
-			DEFAULT_ENTITY_VERSION,
-			paginationQueryData,
-		],
-		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
-		enabled: !!queryPayload,
-	});
-
-	const traceListColumns = getListColumns(selectedColumns);
-
-	useEffect(() => {
-		if (data?.payload?.data?.newResult?.data?.result) {
-			const currentData = data.payload.data.newResult.data.result;
-			if (currentData.length > 0 && currentData[0].list) {
-				if (offset === 0) {
-					setTraces(currentData[0].list ?? []);
-				} else {
-					setTraces((prev) => [...prev, ...(currentData[0].list ?? [])]);
-				}
-			}
-		}
-	}, [data, offset]);
-
-	const isDataEmpty =
-		!isLoading && !isFetching && !isError && traces.length === 0;
-	const hasAdditionalFilters =
-		tracesFilters?.items && tracesFilters?.items?.length > 1;
-
-	const totalCount =
-		data?.payload?.data?.newResult?.data?.result?.[0]?.list?.length || 0;
-
-	const handleRowClick = useCallback(() => {
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.HostEntity,
-			view: InfraMonitoringEvents.TracesView,
-		});
-	}, []);
-
-	return (
-		<div className="host-metric-traces">
-			<div className="host-metric-traces-header">
-				<div className="filter-section">
-					{query && (
-						<QueryBuilderSearch
-							query={query as IBuilderQuery}
-							onChange={(value): void =>
-								handleChangeTracesFilters(value, VIEWS.TRACES)
-							}
-							disableNavigationShortcuts
-						/>
-					)}
-				</div>
-				<div className="datetime-section">
-					<DateTimeSelectionV2
-						showAutoRefresh
-						showRefreshText={false}
-						hideShareModal
-						isModalTimeSelection={isModalTimeSelection}
-						onTimeChange={handleTimeChange}
-						defaultRelativeTime="5m"
-						modalSelectedInterval={selectedInterval}
-						modalInitialStartTime={timeRange.startTime * 1000}
-						modalInitialEndTime={timeRange.endTime * 1000}
-					/>
-				</div>
-			</div>
-
-			{isError && <ErrorText>{data?.error || 'Something went wrong'}</ErrorText>}
-
-			{isLoading && traces.length === 0 && <TracesLoading />}
-
-			{isDataEmpty && !hasAdditionalFilters && (
-				<NoLogs dataSource={DataSource.TRACES} />
-			)}
-
-			{isDataEmpty && hasAdditionalFilters && (
-				<EmptyLogsSearch dataSource={DataSource.TRACES} panelType="LIST" />
-			)}
-
-			{!isError && traces.length > 0 && (
-				<div className="host-metric-traces-table">
-					<TraceExplorerControls
-						isLoading={isFetching && traces.length === 0}
-						totalCount={totalCount}
-						perPageOptions={PER_PAGE_OPTIONS}
-						showSizeChanger={false}
-					/>
-					<ResizeTable
-						tableLayout="fixed"
-						pagination={false}
-						scroll={{ x: true }}
-						loading={isFetching && traces.length === 0}
-						dataSource={traces}
-						columns={traceListColumns}
-						onRow={(): Record<string, unknown> => ({
-							onClick: (): void => handleRowClick(),
-						})}
-					/>
-				</div>
-			)}
-		</div>
-	);
-}
-
-export default HostMetricTraces;
--- a/frontend/src/components/HostMetricsDetail/HostMetricTraces/constants.ts
+++ b/frontend/src/components/HostMetricsDetail/HostMetricTraces/constants.ts
@@ -1,183 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import {
-	BaseAutocompleteData,
-	DataTypes,
-} from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { EQueryType } from 'types/common/dashboard';
-import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
-import { nanoToMilli } from 'utils/timeUtils';
-
-export const columns = [
-	{
-		dataIndex: 'timestamp',
-		key: 'timestamp',
-		title: 'Timestamp',
-		width: 200,
-		render: (timestamp: string): string => new Date(timestamp).toLocaleString(),
-	},
-	{
-		title: 'Service Name',
-		dataIndex: ['data', 'serviceName'],
-		key: 'serviceName-string-tag',
-		width: 150,
-	},
-	{
-		title: 'Name',
-		dataIndex: ['data', 'name'],
-		key: 'name-string-tag',
-		width: 145,
-	},
-	{
-		title: 'Duration',
-		dataIndex: ['data', 'durationNano'],
-		key: 'durationNano-float64-tag',
-		width: 145,
-		render: (duration: number): string => `${nanoToMilli(duration)}ms`,
-	},
-	{
-		title: 'HTTP Method',
-		dataIndex: ['data', 'httpMethod'],
-		key: 'httpMethod-string-tag',
-		width: 145,
-	},
-	{
-		title: 'Status Code',
-		dataIndex: ['data', 'responseStatusCode'],
-		key: 'responseStatusCode-string-tag',
-		width: 145,
-	},
-];
-
-export const selectedColumns: BaseAutocompleteData[] = [
-	{
-		key: 'timestamp',
-		dataType: DataTypes.String,
-		type: 'tag',
-	},
-	{
-		key: 'serviceName',
-		dataType: DataTypes.String,
-		type: 'tag',
-	},
-	{
-		key: 'name',
-		dataType: DataTypes.String,
-		type: 'tag',
-	},
-	{
-		key: 'durationNano',
-		dataType: DataTypes.Float64,
-		type: 'tag',
-	},
-	{
-		key: 'httpMethod',
-		dataType: DataTypes.String,
-		type: 'tag',
-	},
-	{
-		key: 'responseStatusCode',
-		dataType: DataTypes.String,
-		type: 'tag',
-	},
-];
-
-export const getHostTracesQueryPayload = (
-	start: number,
-	end: number,
-	offset = 0,
-	filters: IBuilderQuery['filters'],
-): GetQueryResultsProps => ({
-	query: {
-		promql: [],
-		clickhouse_sql: [],
-		builder: {
-			queryData: [
-				{
-					dataSource: DataSource.TRACES,
-					queryName: 'A',
-					aggregateOperator: 'noop',
-					aggregateAttribute: {
-						id: '------false',
-						dataType: DataTypes.EMPTY,
-						key: '',
-						type: '',
-					},
-					timeAggregation: 'rate',
-					spaceAggregation: 'sum',
-					functions: [],
-					filters,
-					expression: 'A',
-					disabled: false,
-					stepInterval: 60,
-					having: [],
-					limit: null,
-					orderBy: [
-						{
-							columnName: 'timestamp',
-							order: 'desc',
-						},
-					],
-					groupBy: [],
-					legend: '',
-					reduceTo: ReduceOperators.AVG,
-				},
-			],
-			queryFormulas: [],
-			queryTraceOperator: [],
-		},
-		id: '572f1d91-6ac0-46c0-b726-c21488b34434',
-		queryType: EQueryType.QUERY_BUILDER,
-	},
-	graphType: PANEL_TYPES.LIST,
-	selectedTime: 'GLOBAL_TIME',
-	start,
-	end,
-	params: {
-		dataSource: DataSource.TRACES,
-	},
-	tableParams: {
-		pagination: {
-			limit: 10,
-			offset,
-		},
-		selectColumns: [
-			{
-				key: 'serviceName',
-				dataType: 'string',
-				type: 'tag',
-				id: 'serviceName--string--tag--true',
-				isIndexed: false,
-			},
-			{
-				key: 'name',
-				dataType: 'string',
-				type: 'tag',
-				id: 'name--string--tag--true',
-				isIndexed: false,
-			},
-			{
-				key: 'durationNano',
-				dataType: 'float64',
-				type: 'tag',
-				id: 'durationNano--float64--tag--true',
-				isIndexed: false,
-			},
-			{
-				key: 'httpMethod',
-				dataType: 'string',
-				type: 'tag',
-				id: 'httpMethod--string--tag--true',
-				isIndexed: false,
-			},
-			{
-				key: 'responseStatusCode',
-				dataType: 'string',
-				type: 'tag',
-				id: 'responseStatusCode--string--tag--true',
-				isIndexed: false,
-			},
-		],
-	},
-});
--- a/frontend/src/components/HostMetricsDetail/HostMetricsDetail.styles.scss
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsDetail.styles.scss
@@ -1,176 +0,0 @@
-.host-detail-drawer {
-	border-left: 1px solid var(--l1-border);
-	background: var(--l2-background);
-	box-shadow: -4px 10px 16px 2px rgba(0, 0, 0, 0.2);
-
-	.ant-drawer-header {
-		padding: 8px 16px;
-		border-bottom: none;
-
-		align-items: stretch;
-
-		border-bottom: 1px solid var(--l1-border);
-		background: var(--l2-background);
-	}
-
-	.ant-drawer-close {
-		margin-inline-end: 0px;
-	}
-
-	.ant-drawer-body {
-		display: flex;
-		flex-direction: column;
-		padding: 16px;
-	}
-
-	.title {
-		color: var(--l2-foreground);
-		font-family: 'Geist Mono';
-		font-size: 14px;
-		font-style: normal;
-		font-weight: 500;
-		line-height: 20px; /* 142.857% */
-		letter-spacing: -0.07px;
-	}
-
-	.radio-button {
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		padding-top: var(--padding-1);
-		border: 1px solid var(--l1-border);
-		background: var(--l3-background);
-		box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-	}
-
-	.host-detail-drawer__host {
-		.host-details-grid {
-			.labels-row,
-			.values-row {
-				display: grid;
-				grid-template-columns: 1fr 1.5fr 1.5fr 1.5fr;
-				gap: 30px;
-				align-items: center;
-			}
-
-			.labels-row {
-				margin-bottom: 8px;
-			}
-
-			.host-details-metadata-label {
-				color: var(--l2-foreground);
-				font-family: Inter;
-				font-size: 11px;
-				font-style: normal;
-				font-weight: 500;
-				line-height: 18px; /* 163.636% */
-				letter-spacing: 0.44px;
-				text-transform: uppercase;
-			}
-
-			.status-tag {
-				margin: 0;
-
-				&.active {
-					color: var(--success-500);
-					background: var(--success-100);
-					border-color: var(--success-500);
-				}
-
-				&.inactive {
-					color: var(--error-500);
-					background: var(--error-100);
-					border-color: var(--error-500);
-				}
-			}
-
-			.progress-container {
-				width: 158px;
-				.ant-progress {
-					margin: 0;
-
-					.ant-progress-text {
-						font-weight: 600;
-					}
-				}
-			}
-
-			.ant-card {
-				&.ant-card-bordered {
-					border: 1px solid var(--l1-border) !important;
-				}
-			}
-		}
-	}
-
-	.tabs-and-search {
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		margin: 16px 0;
-
-		.action-btn {
-			border-radius: 2px;
-			border: 1px solid var(--l1-border);
-			background: var(--l3-background);
-			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-			display: flex;
-			align-items: center;
-			justify-content: center;
-		}
-	}
-
-	.views-tabs-container {
-		margin-top: 1.5rem;
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-
-		.views-tabs {
-			color: var(--l2-foreground);
-
-			.view-title {
-				display: flex;
-				gap: var(--margin-2);
-				align-items: center;
-				justify-content: center;
-				font-size: var(--font-size-xs);
-				font-style: normal;
-				font-weight: var(--font-weight-normal);
-			}
-
-			.tab {
-				border: 1px solid var(--l1-border);
-				width: 114px;
-			}
-
-			.tab::before {
-				background: var(--l1-border);
-			}
-
-			.selected_view {
-				background: var(--l3-background);
-				color: var(--l1-foreground);
-				border: 1px solid var(--l1-border);
-			}
-
-			.selected_view::before {
-				background: var(--l1-border);
-			}
-		}
-
-		.compass-button {
-			width: 30px;
-			height: 30px;
-
-			border-radius: 2px;
-			border: 1px solid var(--l1-border);
-			background: var(--l3-background);
-			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
-		}
-	}
-
-	.ant-drawer-close {
-		padding: 0px;
-	}
-}
--- a/frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsDetails.tsx
@@ -1,595 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { useSearchParams } from 'react-router-dom-v5-compat';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import {
-	Button,
-	Divider,
-	Drawer,
-	Progress,
-	Radio,
-	Tag,
-	Typography,
-} from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
-import { INFRA_MONITORING_K8S_PARAMS_KEYS } from 'container/InfraMonitoringK8s/constants';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	Package2,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import { VIEW_TYPES, VIEWS } from './constants';
-import Containers from './Containers/Containers';
-import { HostDetailProps } from './HostMetricDetail.interfaces';
-import HostMetricLogsDetailedView from './HostMetricsLogs/HostMetricLogsDetailedView';
-import HostMetricTraces from './HostMetricTraces/HostMetricTraces';
-import Metrics from './Metrics/Metrics';
-import Processes from './Processes/Processes';
-
-import './HostMetricsDetail.styles.scss';
-// eslint-disable-next-line sonarjs/cognitive-complexity
-function HostMetricsDetails({
-	host,
-	onClose,
-	isModalTimeSelection,
-}: HostDetailProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-	const [searchParams, setSearchParams] = useSearchParams();
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useState<VIEWS>(
-		(searchParams.get('view') as VIEWS) || VIEWS.METRICS,
-	);
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
-		const queryKey =
-			urlView === VIEW_TYPES.LOGS
-				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
-				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
-		const filters = getFiltersFromParams(searchParams, queryKey);
-		if (filters) {
-			return filters;
-		}
-
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: 'host.name',
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'host.name--string--resource--false',
-					},
-					op: '=',
-					value: host?.hostName || '',
-				},
-			],
-		};
-	}, [host?.hostName, searchParams]);
-
-	const [logFilters, setLogFilters] = useState<IBuilderQuery['filters']>(
-		initialFilters,
-	);
-
-	const [tracesFilters, setTracesFilters] = useState<IBuilderQuery['filters']>(
-		initialFilters,
-	);
-
-	useEffect(() => {
-		if (host) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.HostEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-			});
-		}
-	}, [host]);
-
-	useEffect(() => {
-		setLogFilters(initialFilters);
-		setTracesFilters(initialFilters);
-	}, [initialFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		if (host?.hostName) {
-			setSelectedView(e.target.value);
-			setSearchParams({
-				...Object.fromEntries(searchParams.entries()),
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
-			});
-		}
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.HostEntity,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.HostEntity,
-				interval,
-				page: InfraMonitoringEvents.DetailedPage,
-			});
-		},
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogFilters((prevFilters) => {
-				const hostNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === 'host.name',
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) => item.key?.key !== 'id' && item.key?.key !== 'host.name',
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.HostEntity,
-						view: InfraMonitoringEvents.LogsView,
-						page: InfraMonitoringEvents.DetailedPage,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						hostNameFilter,
-						...(newFilters || []),
-						...(paginationFilter ? [paginationFilter] : []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setSearchParams({
-					...Object.fromEntries(searchParams.entries()),
-					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
-						updatedFilters,
-					),
-					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
-				});
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setTracesFilters((prevFilters) => {
-				const hostNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === 'host.name',
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.HostEntity,
-						view: InfraMonitoringEvents.TracesView,
-						page: InfraMonitoringEvents.DetailedPage,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						hostNameFilter,
-						...(value?.items?.filter((item) => item.key?.key !== 'host.name') || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setSearchParams({
-					...Object.fromEntries(searchParams.entries()),
-					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
-						updatedFilters,
-					),
-					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
-				});
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			view: selectedView,
-			entity: InfraMonitoringEvents.HostEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logFilters,
-				items: logFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: tracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		setSelectedInterval(selectedTime as Time);
-		lastSelectedInterval.current = null;
-		setSearchParams({});
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">{host?.hostName}</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!host}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="host-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{host && (
-				<>
-					<div className="host-detail-drawer__host">
-						<div className="host-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="host-details-metadata-label"
-								>
-									STATUS
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="host-details-metadata-label"
-								>
-									OPERATING SYSTEM
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="host-details-metadata-label"
-								>
-									CPU USAGE
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="host-details-metadata-label"
-								>
-									MEMORY USAGE
-								</Typography.Text>
-							</div>
-
-							<div className="values-row">
-								<Tag
-									bordered
-									className={`infra-monitoring-tags ${
-										host.active ? 'active' : 'inactive'
-									}`}
-								>
-									{host.active ? 'ACTIVE' : 'INACTIVE'}
-								</Tag>
-								{host.os ? (
-									<Tag className="infra-monitoring-tags" bordered>
-										{host.os}
-									</Tag>
-								) : (
-									<Typography.Text>-</Typography.Text>
-								)}
-								<div className="progress-container">
-									<Progress
-										percent={Number((host.cpu * 100).toFixed(1))}
-										size="small"
-										strokeColor={((): string => {
-											const cpuPercent = Number((host.cpu * 100).toFixed(1));
-											if (cpuPercent >= 90) {
-												return Color.BG_SAKURA_500;
-											}
-											if (cpuPercent >= 60) {
-												return Color.BG_AMBER_500;
-											}
-											return Color.BG_FOREST_500;
-										})()}
-										className="progress-bar"
-									/>
-								</div>
-								<div className="progress-container">
-									<Progress
-										percent={Number((host.memory * 100).toFixed(1))}
-										size="small"
-										strokeColor={((): string => {
-											const memoryPercent = Number((host.memory * 100).toFixed(1));
-											if (memoryPercent >= 90) {
-												return Color.BG_CHERRY_500;
-											}
-											if (memoryPercent >= 60) {
-												return Color.BG_AMBER_500;
-											}
-											return Color.BG_FOREST_500;
-										})()}
-										className="progress-bar"
-									/>
-								</div>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.CONTAINERS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.CONTAINERS}
-							>
-								<div className="view-title">
-									<Package2 size={14} />
-									Containers
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.PROCESSES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.PROCESSES}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Processes
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-
-					{selectedView === VIEW_TYPES.METRICS && (
-						<Metrics
-							selectedInterval={selectedInterval}
-							hostName={host.hostName}
-							timeRange={modalTimeRange}
-							handleTimeChange={handleTimeChange}
-							isModalTimeSelection={isModalTimeSelection}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<HostMetricLogsDetailedView
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logFilters}
-							selectedInterval={selectedInterval}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<HostMetricTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={tracesFilters}
-							selectedInterval={selectedInterval}
-						/>
-					)}
-
-					{selectedView === VIEW_TYPES.CONTAINERS && <Containers />}
-					{selectedView === VIEW_TYPES.PROCESSES && <Processes />}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default HostMetricsDetails;
--- a/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogs.styles.scss
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogs.styles.scss
@@ -1,119 +0,0 @@
-.host-metrics-logs-container {
-	margin-top: 1rem;
-
-	.filter-section {
-		flex: 1;
-
-		.ant-select-selector {
-			border-radius: 2px;
-			border: 1px solid var(--l1-border) !important;
-
-			input {
-				font-size: 12px;
-			}
-
-			.ant-tag .ant-typography {
-				font-size: 12px;
-			}
-		}
-	}
-
-	.host-metrics-logs-header {
-		display: flex;
-		justify-content: space-between;
-		gap: 8px;
-
-		padding: 12px;
-		border-radius: 3px;
-		border: 1px solid var(--l1-border);
-	}
-
-	.host-metrics-logs {
-		margin-top: 1rem;
-
-		.virtuoso-list {
-			overflow-y: hidden !important;
-
-			&::-webkit-scrollbar {
-				width: 0.3rem;
-				height: 0.3rem;
-			}
-
-			&::-webkit-scrollbar-track {
-				background: transparent;
-			}
-
-			&::-webkit-scrollbar-thumb {
-				background: var(--l1-border);
-			}
-
-			&::-webkit-scrollbar-thumb:hover {
-				background: var(--l1-border);
-			}
-
-			.ant-row {
-				width: fit-content;
-			}
-		}
-
-		.skeleton-container {
-			height: 100%;
-			padding: 16px;
-		}
-	}
-}
-
-.host-metrics-logs-list-container {
-	flex: 1;
-	height: calc(100vh - 272px) !important;
-	display: flex;
-	height: 100%;
-
-	.raw-log-content {
-		width: 100%;
-		text-wrap: inherit;
-		word-wrap: break-word;
-	}
-}
-
-.host-metrics-logs-list-card {
-	width: 100%;
-	margin-top: 12px;
-
-	.ant-card-body {
-		padding: 0;
-
-		height: 100%;
-		width: 100%;
-	}
-}
-
-.logs-loading-skeleton {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-	gap: 8px;
-	padding: 8px 0;
-
-	.ant-skeleton-input-sm {
-		height: 18px;
-	}
-}
-
-.no-logs-found {
-	height: 50vh;
-	width: 100%;
-	display: flex;
-	justify-content: center;
-	align-items: center;
-
-	padding: 24px;
-	box-sizing: border-box;
-
-	.ant-typography {
-		display: flex;
-		align-items: center;
-		gap: 16px;
-	}
-}
--- a/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogsDetailedView.tsx
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogsDetailedView.tsx
@@ -1,100 +0,0 @@
-import { useMemo } from 'react';
-import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-
-import { VIEWS } from '../constants';
-import HostMetricsLogs from './HostMetricsLogs';
-
-import './HostMetricLogs.styles.scss';
-
-interface Props {
-	timeRange: {
-		startTime: number;
-		endTime: number;
-	};
-	isModalTimeSelection: boolean;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-	handleChangeLogFilters: (value: IBuilderQuery['filters'], view: VIEWS) => void;
-	logFilters: IBuilderQuery['filters'];
-	selectedInterval: Time;
-}
-
-function HostMetricLogsDetailedView({
-	timeRange,
-	isModalTimeSelection,
-	handleTimeChange,
-	handleChangeLogFilters,
-	logFilters,
-	selectedInterval,
-}: Props): JSX.Element {
-	const { currentQuery } = useQueryBuilder();
-	const updatedCurrentQuery = useMemo(
-		() => ({
-			...currentQuery,
-			builder: {
-				...currentQuery.builder,
-				queryData: [
-					{
-						...currentQuery.builder.queryData[0],
-						dataSource: DataSource.LOGS,
-						aggregateOperator: 'noop',
-						aggregateAttribute: {
-							...currentQuery.builder.queryData[0].aggregateAttribute,
-						},
-						filters: {
-							items:
-								logFilters?.items?.filter((item) => item.key?.key !== 'host.name') ||
-								[],
-							op: 'AND',
-						},
-					},
-				],
-			},
-		}),
-		[currentQuery, logFilters?.items],
-	);
-
-	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
-
-	return (
-		<div className="host-metrics-logs-container">
-			<div className="host-metrics-logs-header">
-				<div className="filter-section">
-					{query && (
-						<QueryBuilderSearch
-							query={query as IBuilderQuery}
-							onChange={(value): void => handleChangeLogFilters(value, VIEWS.LOGS)}
-							disableNavigationShortcuts
-						/>
-					)}
-				</div>
-				<div className="datetime-section">
-					<DateTimeSelectionV2
-						showAutoRefresh
-						showRefreshText={false}
-						hideShareModal
-						isModalTimeSelection={isModalTimeSelection}
-						onTimeChange={handleTimeChange}
-						defaultRelativeTime="5m"
-						modalSelectedInterval={selectedInterval}
-						modalInitialStartTime={timeRange.startTime * 1000}
-						modalInitialEndTime={timeRange.endTime * 1000}
-					/>
-				</div>
-			</div>
-			<HostMetricsLogs timeRange={timeRange} filters={logFilters} />
-		</div>
-	);
-}
-
-export default HostMetricLogsDetailedView;
--- a/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricsLogs.tsx
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricsLogs.tsx
@@ -1,187 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
-import { useQuery } from 'react-query';
-import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
-import { Card } from 'antd';
-import LogDetail from 'components/LogDetail';
-import RawLogView from 'components/Logs/RawLogView';
-import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
-import { DEFAULT_ENTITY_VERSION } from 'constants/app';
-import LogsError from 'container/LogsError/LogsError';
-import { LogsLoading } from 'container/LogsLoading/LogsLoading';
-import { FontSize } from 'container/OptionsMenu/types';
-import { useHandleLogsPagination } from 'hooks/infraMonitoring/useHandleLogsPagination';
-import useLogDetailHandlers from 'hooks/logs/useLogDetailHandlers';
-import useScrollToLog from 'hooks/logs/useScrollToLog';
-import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { ILog } from 'types/api/logs/log';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import { getHostLogsQueryPayload } from './constants';
-import NoLogsContainer from './NoLogsContainer';
-
-import './HostMetricLogs.styles.scss';
-
-interface Props {
-	timeRange: {
-		startTime: number;
-		endTime: number;
-	};
-	filters: IBuilderQuery['filters'];
-}
-
-function HostMetricsLogs({ timeRange, filters }: Props): JSX.Element {
-	const virtuosoRef = useRef<VirtuosoHandle>(null);
-	const {
-		activeLog,
-		onAddToQuery,
-		selectedTab,
-		handleSetActiveLog,
-		handleCloseLogDetail,
-	} = useLogDetailHandlers();
-
-	const basePayload = getHostLogsQueryPayload(
-		timeRange.startTime,
-		timeRange.endTime,
-		filters,
-	);
-	const {
-		logs,
-		hasReachedEndOfLogs,
-		isPaginating,
-		currentPage,
-		setIsPaginating,
-		handleNewData,
-		loadMoreLogs,
-		queryPayload,
-	} = useHandleLogsPagination({
-		timeRange,
-		filters,
-		excludeFilterKeys: ['host.name'],
-		basePayload,
-	});
-
-	const { data, isLoading, isFetching, isError } = useQuery({
-		queryKey: [
-			'hostMetricsLogs',
-			timeRange.startTime,
-			timeRange.endTime,
-			filters,
-			currentPage,
-		],
-		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
-		enabled: !!queryPayload,
-		keepPreviousData: isPaginating,
-	});
-
-	useEffect(() => {
-		if (data?.payload?.data?.newResult?.data?.result) {
-			handleNewData(data.payload.data.newResult.data.result);
-		}
-	}, [data, handleNewData]);
-
-	useEffect(() => {
-		setIsPaginating(false);
-	}, [data, setIsPaginating]);
-
-	const handleScrollToLog = useScrollToLog({
-		logs,
-		virtuosoRef,
-	});
-
-	const getItemContent = useCallback(
-		(_: number, logToRender: ILog): JSX.Element => {
-			return (
-				<div key={logToRender.id}>
-					<RawLogView
-						isTextOverflowEllipsisDisabled
-						data={logToRender}
-						linesPerRow={5}
-						fontSize={FontSize.MEDIUM}
-						selectedFields={[
-							{
-								dataType: 'string',
-								type: '',
-								name: 'body',
-							},
-							{
-								dataType: 'string',
-								type: '',
-								name: 'timestamp',
-							},
-						]}
-						onSetActiveLog={handleSetActiveLog}
-						onClearActiveLog={handleCloseLogDetail}
-						isActiveLog={activeLog?.id === logToRender.id}
-					/>
-				</div>
-			);
-		},
-		[activeLog, handleSetActiveLog, handleCloseLogDetail],
-	);
-
-	const renderFooter = useCallback(
-		(): JSX.Element | null => (
-			<>
-				{isFetching ? (
-					<div className="logs-loading-skeleton"> Loading more logs ... </div>
-				) : hasReachedEndOfLogs ? (
-					<div className="logs-loading-skeleton"> *** End *** </div>
-				) : null}
-			</>
-		),
-		[isFetching, hasReachedEndOfLogs],
-	);
-
-	const renderContent = useMemo(
-		() => (
-			<Card bordered={false} className="host-metrics-logs-list-card">
-				<OverlayScrollbar isVirtuoso>
-					<Virtuoso
-						className="host-metrics-logs-virtuoso"
-						key="host-metrics-logs-virtuoso"
-						ref={virtuosoRef}
-						data={logs}
-						endReached={loadMoreLogs}
-						totalCount={logs.length}
-						itemContent={getItemContent}
-						overscan={200}
-						components={{
-							Footer: renderFooter,
-						}}
-					/>
-				</OverlayScrollbar>
-			</Card>
-		),
-		[logs, loadMoreLogs, getItemContent, renderFooter],
-	);
-
-	return (
-		<div className="host-metrics-logs">
-			{isLoading && <LogsLoading />}
-			{!isLoading && !isError && logs.length === 0 && <NoLogsContainer />}
-			{isError && !isLoading && <LogsError />}
-			{!isLoading && !isError && logs.length > 0 && (
-				<div
-					className="host-metrics-logs-list-container"
-					data-log-detail-ignore="true"
-				>
-					{renderContent}
-				</div>
-			)}
-			{selectedTab && activeLog && (
-				<LogDetail
-					log={activeLog}
-					onClose={handleCloseLogDetail}
-					logs={logs}
-					onNavigateLog={handleSetActiveLog}
-					selectedTab={selectedTab}
-					onAddToQuery={onAddToQuery}
-					onClickActionItem={onAddToQuery}
-					onScrollToLog={handleScrollToLog}
-				/>
-			)}
-		</div>
-	);
-}
-
-export default HostMetricsLogs;
--- a/frontend/src/components/HostMetricsDetail/HostMetricsLogs/NoLogsContainer.tsx
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsLogs/NoLogsContainer.tsx
@@ -1,16 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { Typography } from 'antd';
-import { Ghost } from 'lucide-react';
-
-const { Text } = Typography;
-
-export default function NoLogsContainer(): React.ReactElement {
-	return (
-		<div className="no-logs-found">
-			<Text type="secondary">
-				<Ghost size={24} color={Color.BG_AMBER_500} /> No logs found for this host
-				in the selected time range.
-			</Text>
-		</div>
-	);
-}
--- a/frontend/src/components/HostMetricsDetail/HostMetricsLogs/constants.ts
+++ b/frontend/src/components/HostMetricsDetail/HostMetricsLogs/constants.ts
@@ -1,61 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { EQueryType } from 'types/common/dashboard';
-import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
-import { v4 as uuidv4 } from 'uuid';
-
-export const getHostLogsQueryPayload = (
-	start: number,
-	end: number,
-	filters: IBuilderQuery['filters'],
-): GetQueryResultsProps => ({
-	graphType: PANEL_TYPES.LIST,
-	selectedTime: 'GLOBAL_TIME',
-	query: {
-		clickhouse_sql: [],
-		promql: [],
-		builder: {
-			queryData: [
-				{
-					dataSource: DataSource.LOGS,
-					queryName: 'A',
-					aggregateOperator: 'noop',
-					aggregateAttribute: {
-						id: '------false',
-						dataType: DataTypes.String,
-						key: '',
-						type: '',
-					},
-					timeAggregation: 'rate',
-					spaceAggregation: 'sum',
-					functions: [],
-					filters,
-					expression: 'A',
-					disabled: false,
-					stepInterval: 60,
-					having: [],
-					limit: null,
-					orderBy: [
-						{
-							columnName: 'timestamp',
-							order: 'desc',
-						},
-					],
-					groupBy: [],
-					legend: '',
-					reduceTo: ReduceOperators.AVG,
-					offset: 0,
-					pageSize: 100,
-				},
-			],
-			queryFormulas: [],
-			queryTraceOperator: [],
-		},
-		id: uuidv4(),
-		queryType: EQueryType.QUERY_BUILDER,
-	},
-	start,
-	end,
-});
--- a/frontend/src/components/HostMetricsDetail/Metrics/Metrics.styles.scss
+++ b/frontend/src/components/HostMetricsDetail/Metrics/Metrics.styles.scss
@@ -1,45 +0,0 @@
-.empty-container {
-	display: flex;
-	justify-content: center;
-	align-items: center;
-	height: 100%;
-}
-
-.host-metrics-container {
-	margin-top: 1rem;
-}
-
-.metrics-header {
-	display: flex;
-	justify-content: flex-end;
-	margin-top: 1rem;
-
-	gap: 8px;
-	padding: 12px;
-	border-radius: 3px;
-	border: 1px solid var(--l1-border);
-}
-
-.host-metrics-card {
-	margin: 8px 0 1rem 0;
-	height: 300px;
-	padding: 10px;
-
-	border: 1px solid var(--l1-border);
-
-	.ant-card-body {
-		padding: 0;
-	}
-
-	.chart-container {
-		width: 100%;
-		height: 100%;
-	}
-
-	.no-data-container {
-		position: absolute;
-		top: 50%;
-		left: 50%;
-		transform: translate(-50%, -50%);
-	}
-}
--- a/frontend/src/components/HostMetricsDetail/Metrics/Metrics.tsx
+++ b/frontend/src/components/HostMetricsDetail/Metrics/Metrics.tsx
@@ -1,233 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { QueryFunctionContext, useQueries, UseQueryResult } from 'react-query';
-import { Card, Col, Row, Skeleton, Typography } from 'antd';
-import cx from 'classnames';
-import Uplot from 'components/Uplot';
-import { ENTITY_VERSION_V4 } from 'constants/app';
-import {
-	getHostQueryPayload,
-	hostWidgetInfo,
-} from 'container/LogDetailedView/InfraMetrics/constants';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import { useResizeObserver } from 'hooks/useDimensions';
-import { useMultiIntersectionObserver } from 'hooks/useMultiIntersectionObserver';
-import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { getUPlotChartOptions } from 'lib/uPlotLib/getUplotChartOptions';
-import { getUPlotChartData } from 'lib/uPlotLib/utils/getUplotChartData';
-import { SuccessResponse } from 'types/api';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-
-import { FeatureKeys } from '../../../constants/features';
-import { useAppContext } from '../../../providers/App/App';
-
-import './Metrics.styles.scss';
-
-interface MetricsTabProps {
-	timeRange: {
-		startTime: number;
-		endTime: number;
-	};
-	isModalTimeSelection: boolean;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-	selectedInterval: Time;
-
-	hostName: string;
-}
-
-function Metrics({
-	selectedInterval,
-	hostName,
-	timeRange,
-	handleTimeChange,
-	isModalTimeSelection,
-}: MetricsTabProps): JSX.Element {
-	const { featureFlags } = useAppContext();
-	const dotMetricsEnabled =
-		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
-			?.active || false;
-
-	const {
-		visibilities,
-		setElement,
-	} = useMultiIntersectionObserver(hostWidgetInfo.length, { threshold: 0.1 });
-
-	const legendScrollPositionRef = useRef<{
-		scrollTop: number;
-		scrollLeft: number;
-	}>({
-		scrollTop: 0,
-		scrollLeft: 0,
-	});
-
-	const queryPayloads = useMemo(
-		() =>
-			getHostQueryPayload(
-				hostName,
-				timeRange.startTime,
-				timeRange.endTime,
-				dotMetricsEnabled,
-			),
-		[hostName, timeRange.startTime, timeRange.endTime, dotMetricsEnabled],
-	);
-
-	const queries = useQueries(
-		queryPayloads.map((payload, index) => ({
-			queryKey: ['host-metrics', payload, ENTITY_VERSION_V4, 'HOST'],
-			queryFn: ({
-				signal,
-			}: QueryFunctionContext): Promise<
-				SuccessResponse<MetricRangePayloadProps>
-			> => GetMetricQueryRange(payload, ENTITY_VERSION_V4, undefined, signal),
-			enabled: !!payload && visibilities[index],
-			keepPreviousData: true,
-		})),
-	);
-
-	const isDarkMode = useIsDarkMode();
-	const graphRef = useRef<HTMLDivElement>(null);
-	const dimensions = useResizeObserver(graphRef);
-	const { currentQuery } = useQueryBuilder();
-
-	const chartData = useMemo(
-		() => queries.map(({ data }) => getUPlotChartData(data?.payload)),
-		[queries],
-	);
-
-	const [graphTimeIntervals, setGraphTimeIntervals] = useState<
-		{
-			start: number;
-			end: number;
-		}[]
-	>(
-		new Array(queries.length).fill({
-			start: timeRange.startTime,
-			end: timeRange.endTime,
-		}),
-	);
-
-	useEffect(() => {
-		setGraphTimeIntervals(
-			new Array(queries.length).fill({
-				start: timeRange.startTime,
-				end: timeRange.endTime,
-			}),
-		);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [timeRange]);
-
-	const onDragSelect = useCallback(
-		(start: number, end: number, graphIndex: number) => {
-			const startTimestamp = Math.trunc(start);
-			const endTimestamp = Math.trunc(end);
-
-			setGraphTimeIntervals((prev) => {
-				const newIntervals = [...prev];
-				newIntervals[graphIndex] = {
-					start: Math.floor(startTimestamp / 1000),
-					end: Math.floor(endTimestamp / 1000),
-				};
-				return newIntervals;
-			});
-		},
-		[],
-	);
-
-	const options = useMemo(
-		() =>
-			queries.map(({ data }, idx) =>
-				getUPlotChartOptions({
-					apiResponse: data?.payload,
-					isDarkMode,
-					dimensions,
-					yAxisUnit: hostWidgetInfo[idx].yAxisUnit,
-					softMax: null,
-					softMin: null,
-					minTimeScale: graphTimeIntervals[idx].start,
-					maxTimeScale: graphTimeIntervals[idx].end,
-					onDragSelect: (start, end) => onDragSelect(start, end, idx),
-					query: currentQuery,
-					legendScrollPosition: legendScrollPositionRef.current,
-					setLegendScrollPosition: (position: {
-						scrollTop: number;
-						scrollLeft: number;
-					}) => {
-						legendScrollPositionRef.current = position;
-					},
-				}),
-			),
-		[
-			queries,
-			isDarkMode,
-			dimensions,
-			graphTimeIntervals,
-			onDragSelect,
-			currentQuery,
-		],
-	);
-
-	const renderCardContent = (
-		query: UseQueryResult<SuccessResponse<MetricRangePayloadProps>, unknown>,
-		idx: number,
-	): JSX.Element => {
-		if ((!query.data && query.isLoading) || !visibilities[idx]) {
-			return <Skeleton />;
-		}
-
-		if (query.error) {
-			const errorMessage =
-				(query.error as Error)?.message || 'Something went wrong';
-			return <div>{errorMessage}</div>;
-		}
-		return (
-			<div
-				className={cx('chart-container', {
-					'no-data-container':
-						!query.isLoading && !query?.data?.payload?.data?.result?.length,
-				})}
-			>
-				<Uplot options={options[idx]} data={chartData[idx]} />
-			</div>
-		);
-	};
-
-	return (
-		<>
-			<div className="metrics-header">
-				<div className="metrics-datetime-section">
-					<DateTimeSelectionV2
-						showAutoRefresh
-						showRefreshText={false}
-						hideShareModal
-						onTimeChange={handleTimeChange}
-						defaultRelativeTime="5m"
-						isModalTimeSelection={isModalTimeSelection}
-						modalSelectedInterval={selectedInterval}
-						modalInitialStartTime={timeRange.startTime * 1000}
-						modalInitialEndTime={timeRange.endTime * 1000}
-					/>
-				</div>
-			</div>
-			<Row gutter={24} className="host-metrics-container">
-				{queries.map((query, idx) => (
-					<Col ref={setElement(idx)} span={12} key={hostWidgetInfo[idx].title}>
-						<Typography.Text>{hostWidgetInfo[idx].title}</Typography.Text>
-						<Card bordered className="host-metrics-card" ref={graphRef}>
-							{renderCardContent(query, idx)}
-						</Card>
-					</Col>
-				))}
-			</Row>
-		</>
-	);
-}
-
-export default Metrics;
--- a/frontend/src/components/HostMetricsDetail/constants.ts
+++ b/frontend/src/components/HostMetricsDetail/constants.ts
@@ -1,17 +0,0 @@
-export enum VIEWS {
-	METRICS = 'metrics',
-	LOGS = 'logs',
-	TRACES = 'traces',
-	CONTAINERS = 'containers',
-	PROCESSES = 'processes',
-	EVENTS = 'events',
-}
-
-export const VIEW_TYPES = {
-	METRICS: VIEWS.METRICS,
-	LOGS: VIEWS.LOGS,
-	TRACES: VIEWS.TRACES,
-	CONTAINERS: VIEWS.CONTAINERS,
-	PROCESSES: VIEWS.PROCESSES,
-	EVENTS: VIEWS.EVENTS,
-};
--- a/frontend/src/components/HostMetricsDetail/index.tsx
+++ b/frontend/src/components/HostMetricsDetail/index.tsx
@@ -1,3 +0,0 @@
-import HostMetricsDetails from './HostMetricsDetails';
-
-export default HostMetricsDetails;
--- a/frontend/src/components/QueryBuilderV2/QueryV2/tests/QuerySearch.test.tsx
+++ b/frontend/src/components/QueryBuilderV2/QueryV2/tests/QuerySearch.test.tsx
@@ -87,8 +87,8 @@ jest.mock('hooks/useDarkMode', () => ({
 }));

 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
-	useDashboardStore: (): { selectedDashboard: undefined } => ({
-		selectedDashboard: undefined,
+	useDashboardStore: (): { dashboardData: undefined } => ({
+		dashboardData: undefined,
 	}),
 }));

--- a/frontend/src/container/DashboardContainer/DashboardDescription/tests/DashboardDescription.test.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardDescription/tests/DashboardDescription.test.tsx
@@ -196,12 +196,12 @@ describe('Dashboard landing page actions header tests', () => {
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);

 		useDashboardStore.setState({
-			selectedDashboard: (getDashboardById.data as unknown) as Dashboard,
+			dashboardData: (getDashboardById.data as unknown) as Dashboard,
 			layouts: [],
 			panelMap: {},
 			setPanelMap: jest.fn(),
 			setLayouts: jest.fn(),
-			setSelectedDashboard: jest.fn(),
+			setDashboardData: jest.fn(),
 			columnWidths: {},
 		});

--- a/frontend/src/container/DashboardContainer/DashboardDescription/index.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardDescription/index.tsx
@@ -78,12 +78,12 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);
 	const {
-		selectedDashboard,
+		dashboardData,
 		panelMap,
 		setPanelMap,
 		layouts,
 		setLayouts,
-		setSelectedDashboard,
+		setDashboardData,
 	} = useDashboardStore();

 	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
@@ -98,10 +98,10 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {

 	const isPublicDashboardEnabled = isCloudUser || isEnterpriseSelfHostedUser;

-	const selectedData = selectedDashboard
+	const selectedData = dashboardData
 		? {
-				...selectedDashboard.data,
-				uuid: selectedDashboard.id,
+				...dashboardData.data,
+				uuid: dashboardData.id,
 		  }
 		: ({} as DashboardData);
 	const { dashboardVariables } = useDashboardVariables();
@@ -133,8 +133,8 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {

 	let isAuthor = false;

-	if (selectedDashboard && user && user.email) {
-		isAuthor = selectedDashboard?.createdBy === user?.email;
+	if (dashboardData && user && user.email) {
+		isAuthor = dashboardData?.createdBy === user?.email;
 	}

 	let permissions: ComponentTypes[] = ['add_panel'];
@@ -146,7 +146,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	const { notifications } = useNotifications();

 	const userRole: ROLES | null =
-		selectedDashboard?.createdBy === user?.email
+		dashboardData?.createdBy === user?.email
 			? (USER_ROLES.AUTHOR as ROLES)
 			: user.role;

@@ -155,9 +155,9 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	const onEmptyWidgetHandler = useCallback(() => {
 		setIsPanelTypeSelectionModalOpen(true);
 		logEvent('Dashboard Detail: Add new panel clicked', {
-			dashboardId: selectedDashboard?.id,
-			dashboardName: selectedDashboard?.data.title,
-			numberOfPanels: selectedDashboard?.data.widgets?.length,
+			dashboardId: dashboardData?.id,
+			dashboardName: dashboardData?.data.title,
+			numberOfPanels: dashboardData?.data.widgets?.length,
 		});
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [setIsPanelTypeSelectionModalOpen]);
@@ -168,14 +168,14 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	};

 	const onNameChangeHandler = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}
 		const updatedDashboard: Props = {
-			id: selectedDashboard.id,
+			id: dashboardData.id,

 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				title: updatedTitle,
 			},
 		};
@@ -186,7 +186,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 				});
 				setIsRenameDashboardOpen(false);
 				if (updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.data);
+					setDashboardData(updatedDashboard.data);
 				}
 			},
 			onError: () => {
@@ -203,10 +203,10 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	// the context value is sometimes not available during the initial render
 	// due to which the updatedTitle is set to some previous value
 	useEffect(() => {
-		if (selectedDashboard) {
-			setUpdatedTitle(selectedDashboard.data.title);
+		if (dashboardData) {
+			setUpdatedTitle(dashboardData.data.title);
 		}
-	}, [selectedDashboard]);
+	}, [dashboardData]);

 	useEffect(() => {
 		if (state.error) {
@@ -227,7 +227,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	}, [state.error, state.value, t, notifications]);

 	function handleAddRow(): void {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}
 		const id = uuid();
@@ -246,10 +246,10 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		}

 		const updatedDashboard: Props = {
-			id: selectedDashboard.id,
+			id: dashboardData.id,

 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				layout: [
 					{
 						i: id,
@@ -265,7 +265,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 				],
 				panelMap: { ...panelMap, [id]: newRowWidgetMap },
 				widgets: [
-					...(selectedDashboard.data.widgets || []),
+					...(dashboardData.data.widgets || []),
 					{
 						id,
 						title: sectionName,
@@ -282,7 +282,7 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 					if (updatedDashboard.data.data.layout) {
 						setLayouts(sortLayout(updatedDashboard.data.data.layout));
 					}
-					setSelectedDashboard(updatedDashboard.data);
+					setDashboardData(updatedDashboard.data);
 					setPanelMap(updatedDashboard.data?.data?.panelMap || {});
 				}

@@ -299,8 +299,8 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 		error: errorPublicDashboardData,
 		isError: isErrorPublicDashboardData,
 	} = useGetPublicDashboardMeta(
-		selectedDashboard?.id || '',
-		!!selectedDashboard?.id && isPublicDashboardEnabled,
+		dashboardData?.id || '',
+		!!dashboardData?.id && isPublicDashboardEnabled,
 	);

 	useEffect(() => {
@@ -378,14 +378,14 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 									{(isAuthor || user.role === USER_ROLES.ADMIN) && (
 										<Tooltip
 											title={
-												selectedDashboard?.createdBy === 'integration' &&
+												dashboardData?.createdBy === 'integration' &&
 												'Dashboards created by integrations cannot be unlocked'
 											}
 										>
 											<Button
 												type="text"
 												icon={<LockKeyhole size={14} />}
-												disabled={selectedDashboard?.createdBy === 'integration'}
+												disabled={dashboardData?.createdBy === 'integration'}
 												onClick={handleLockDashboardToggle}
 												data-testid="lock-unlock-dashboard"
 											>
@@ -457,9 +457,9 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 								</section>
 								<section className="delete-dashboard">
 									<DeleteButton
-										createdBy={selectedDashboard?.createdBy || ''}
-										name={selectedDashboard?.data.title || ''}
-										id={String(selectedDashboard?.id) || ''}
+										createdBy={dashboardData?.createdBy || ''}
+										name={dashboardData?.data.title || ''}
+										id={String(dashboardData?.id) || ''}
 										isLocked={isDashboardLocked}
 										routeToListPage
 									/>
--- a/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/VariableItem.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/VariableItem.tsx
@@ -239,7 +239,7 @@ function VariableItem({

 	const [selectedWidgets, setSelectedWidgets] = useState<string[]>([]);

-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();
 	const widgetsByDynamicVariableId = useWidgetsByDynamicVariableId();

 	useEffect(() => {
@@ -248,7 +248,7 @@ function VariableItem({
 		} else if (dynamicVariablesSelectedValue?.name) {
 			const widgets = getWidgetsHavingDynamicVariableAttribute(
 				dynamicVariablesSelectedValue?.name,
-				(selectedDashboard?.data?.widgets?.filter(
+				(dashboardData?.data?.widgets?.filter(
 					(widget) => widget.panelTypes !== PANEL_GROUP_TYPES.ROW,
 				) || []) as Widgets[],
 				variableData.name,
@@ -257,7 +257,7 @@ function VariableItem({
 		}
 	}, [
 		dynamicVariablesSelectedValue?.name,
-		selectedDashboard,
+		dashboardData,
 		variableData.id,
 		variableData.name,
 		widgetsByDynamicVariableId,
--- a/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/WidgetSelector.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/VariableItem/WidgetSelector.tsx
@@ -12,17 +12,17 @@ export function WidgetSelector({
 	selectedWidgets: string[];
 	setSelectedWidgets: (widgets: string[]) => void;
 }): JSX.Element {
-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();

 	// Get layout IDs for cross-referencing
 	const layoutIds = new Set(
-		(selectedDashboard?.data?.layout || []).map((item) => item.i),
+		(dashboardData?.data?.layout || []).map((item) => item.i),
 	);

 	// Filter and deduplicate widgets by ID, keeping only those with layout entries
 	// and excluding row widgets since they are not panels that can have variables
 	const widgets = Object.values(
-		(selectedDashboard?.data?.widgets || []).reduce(
+		(dashboardData?.data?.widgets || []).reduce(
 			(acc: Record<string, WidgetRow | Widgets>, widget: WidgetRow | Widgets) => {
 				if (
 					widget.id &&
--- a/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/index.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/DashboardVariableSettings/index.tsx
@@ -87,7 +87,7 @@ function VariablesSettings({

 	const { t } = useTranslation(['dashboard']);

-	const { selectedDashboard, setSelectedDashboard } = useDashboardStore();
+	const { dashboardData, setDashboardData } = useDashboardStore();
 	const { dashboardVariables } = useDashboardVariables();

 	const { notifications } = useNotifications();
@@ -173,7 +173,7 @@ function VariablesSettings({
 		widgetIds?: string[],
 		applyToAll?: boolean,
 	): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

@@ -181,16 +181,16 @@ function VariablesSettings({
 			(currentRequestedId &&
 				updatedVariablesData[currentRequestedId || '']?.type === 'DYNAMIC' &&
 				addDynamicVariableToPanels(
-					selectedDashboard,
+					dashboardData,
 					updatedVariablesData[currentRequestedId || ''],
 					widgetIds,
 					applyToAll,
 				)) ||
-			selectedDashboard;
+			dashboardData;

 		updateMutation.mutateAsync(
 			{
-				id: selectedDashboard.id,
+				id: dashboardData.id,

 				data: {
 					...newDashboard.data,
@@ -200,7 +200,7 @@ function VariablesSettings({
 			{
 				onSuccess: (updatedDashboard) => {
 					if (updatedDashboard.data) {
-						setSelectedDashboard(updatedDashboard.data);
+						setDashboardData(updatedDashboard.data);
 						notifications.success({
 							message: t('variable_updated_successfully'),
 						});
--- a/frontend/src/container/DashboardContainer/DashboardSettings/General/index.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/General/index.tsx
@@ -15,11 +15,11 @@ import './GeneralSettings.styles.scss';
 const { Option } = Select;

 function GeneralDashboardSettings(): JSX.Element {
-	const { selectedDashboard, setSelectedDashboard } = useDashboardStore();
+	const { dashboardData, setDashboardData } = useDashboardStore();

 	const updateDashboardMutation = useUpdateDashboard();

-	const selectedData = selectedDashboard?.data;
+	const selectedData = dashboardData?.data;

 	const { title = '', tags = [], description = '', image = Base64Icons[0] } =
 		selectedData || {};
@@ -37,15 +37,15 @@ function GeneralDashboardSettings(): JSX.Element {
 	const { t } = useTranslation('common');

 	const onSaveHandler = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		updateDashboardMutation.mutate(
 			{
-				id: selectedDashboard.id,
+				id: dashboardData.id,
 				data: {
-					...selectedDashboard.data,
+					...dashboardData.data,
 					description: updatedDescription,
 					tags: updatedTags,
 					title: updatedTitle,
@@ -55,7 +55,7 @@ function GeneralDashboardSettings(): JSX.Element {
 			{
 				onSuccess: (updatedDashboard) => {
 					if (updatedDashboard.data) {
-						setSelectedDashboard(updatedDashboard.data);
+						setDashboardData(updatedDashboard.data);
 					}
 				},
 				onError: () => {},
--- a/frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/tests/PublicDashboard.test.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/tests/PublicDashboard.test.tsx
@@ -41,7 +41,7 @@ const DASHBOARD_VARIABLES_WARNING =
 // Use wildcard pattern to match both relative and absolute URLs in MSW
 const publicDashboardURL = `*/api/v1/dashboards/${MOCK_DASHBOARD_ID}/public`;

-const mockSelectedDashboard = {
+const mockDashboardData = {
 	id: MOCK_DASHBOARD_ID,
 	data: {
 		title: 'Test Dashboard',
@@ -70,7 +70,7 @@ beforeEach(() => {

 	// Mock useDashboardStore
 	mockUseDashboard.mockReturnValue(({
-		selectedDashboard: mockSelectedDashboard,
+		dashboardData: mockDashboardData,
 	} as unknown) as ReturnType<typeof useDashboardStore>);

 	// Mock useCopyToClipboard
--- a/frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx
@@ -60,7 +60,7 @@ function PublicDashboardSetting(): JSX.Element {
 	const [defaultTimeRange, setDefaultTimeRange] = useState(DEFAULT_TIME_RANGE);
 	const [, setCopyPublicDashboardURL] = useCopyToClipboard();

-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();

 	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();

@@ -85,8 +85,8 @@ function PublicDashboardSetting(): JSX.Element {
 		refetch: refetchPublicDashboard,
 		error: errorPublicDashboard,
 	} = useGetPublicDashboardMeta(
-		selectedDashboard?.id || '',
-		!!selectedDashboard?.id && isPublicDashboardEnabled,
+		dashboardData?.id || '',
+		!!dashboardData?.id && isPublicDashboardEnabled,
 	);

 	const isPublicDashboard = !!publicDashboardData?.publicPath;
@@ -155,36 +155,36 @@ function PublicDashboardSetting(): JSX.Element {
 	});

 	const handleCreatePublicDashboard = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		createPublicDashboard({
-			dashboardId: selectedDashboard.id,
+			dashboardId: dashboardData.id,
 			timeRangeEnabled,
 			defaultTimeRange,
 		});
 	};

 	const handleUpdatePublicDashboard = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		updatePublicDashboard({
-			dashboardId: selectedDashboard.id,
+			dashboardId: dashboardData.id,
 			timeRangeEnabled,
 			defaultTimeRange,
 		});
 	};

 	const handleRevokePublicDashboardAccess = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		revokePublicDashboardAccess({
-			id: selectedDashboard.id,
+			id: dashboardData.id,
 		});
 	};

--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.tsx
@@ -26,10 +26,10 @@ import VariableItem from './VariableItem';
 import './DashboardVariableSelection.styles.scss';

 function DashboardVariableSelection(): JSX.Element | null {
-	const { dashboardId, setSelectedDashboard } = useDashboardStore(
+	const { dashboardId, setDashboardData } = useDashboardStore(
 		useShallow((s) => ({
-			dashboardId: s.selectedDashboard?.id ?? '',
-			setSelectedDashboard: s.setSelectedDashboard,
+			dashboardId: s.dashboardData?.id ?? '',
+			setDashboardData: s.setDashboardData,
 		})),
 	);

@@ -99,7 +99,7 @@ function DashboardVariableSelection(): JSX.Element | null {

 			// Synchronously update the external store with the new variable value so that
 			// child variables see the updated parent value when they refetch, rather than
-			// waiting for setSelectedDashboard → useEffect → updateDashboardVariablesStore.
+			// waiting for setDashboardData → useEffect → updateDashboardVariablesStore.
 			const updatedVariables = { ...dashboardVariables };
 			if (updatedVariables[id]) {
 				updatedVariables[id] = {
@@ -119,7 +119,7 @@ function DashboardVariableSelection(): JSX.Element | null {
 			}
 			updateDashboardVariablesStore({ dashboardId, variables: updatedVariables });

-			setSelectedDashboard((prev) => {
+			setDashboardData((prev) => {
 				if (prev) {
 					const oldVariables = { ...prev?.data.variables };
 					// this is added to handle case where we have two different
@@ -157,7 +157,7 @@ function DashboardVariableSelection(): JSX.Element | null {
 			// Safe to call synchronously now that the store already has the updated value.
 			enqueueDescendantsOfVariable(name);
 		},
-		[dashboardId, dashboardVariables, updateUrlVariable, setSelectedDashboard],
+		[dashboardId, dashboardVariables, updateUrlVariable, setDashboardData],
 	);

 	return (
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/DashboardVariableSelection.test.tsx
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/test/DashboardVariableSelection.test.tsx
@@ -30,11 +30,11 @@ const mockVariableItemCallbacks: {
 } = {};

 // Mock providers/Dashboard/Dashboard
-const mockSetSelectedDashboard = jest.fn();
+const mockSetDashboardData = jest.fn();
 const mockUpdateLocalStorageDashboardVariables = jest.fn();
 interface MockDashboardStoreState {
-	selectedDashboard?: { id: string };
-	setSelectedDashboard: typeof mockSetSelectedDashboard;
+	dashboardData?: { id: string };
+	setDashboardData: typeof mockSetDashboardData;
 	updateLocalStorageDashboardVariables: typeof mockUpdateLocalStorageDashboardVariables;
 }
 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
@@ -42,8 +42,8 @@ jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
 		selector?: (s: Record<string, unknown>) => MockDashboardStoreState,
 	): MockDashboardStoreState => {
 		const state = {
-			selectedDashboard: { id: 'dash-1' },
-			setSelectedDashboard: mockSetSelectedDashboard,
+			dashboardData: { id: 'dash-1' },
+			setDashboardData: mockSetDashboardData,
 			updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,
 		};
 		return selector ? selector(state) : state;
--- a/frontend/src/container/DashboardContainer/DashboardVariablesSelection/useDashboardVariableUpdate.ts
+++ b/frontend/src/container/DashboardContainer/DashboardVariablesSelection/useDashboardVariableUpdate.ts
@@ -38,15 +38,11 @@ interface UseDashboardVariableUpdateReturn {
 }

 export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn => {
-	const {
-		dashboardId,
-		selectedDashboard,
-		setSelectedDashboard,
-	} = useDashboardStore(
+	const { dashboardId, dashboardData, setDashboardData } = useDashboardStore(
 		useShallow((s) => ({
-			dashboardId: s.selectedDashboard?.id ?? '',
-			selectedDashboard: s.selectedDashboard,
-			setSelectedDashboard: s.setSelectedDashboard,
+			dashboardId: s.dashboardData?.id ?? '',
+			dashboardData: s.dashboardData,
+			setDashboardData: s.setDashboardData,
 		})),
 	);
 	const addDynamicVariableToPanels = useAddDynamicVariableToPanels();
@@ -74,8 +70,8 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 					isDynamic,
 				);

-				if (selectedDashboard) {
-					setSelectedDashboard((prev) => {
+				if (dashboardData) {
+					setDashboardData((prev) => {
 						if (prev) {
 							const oldVariables = prev?.data.variables;
 							// this is added to handle case where we have two different
@@ -110,7 +106,7 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 				}
 			}
 		},
-		[dashboardId, selectedDashboard, setSelectedDashboard],
+		[dashboardId, dashboardData, setDashboardData],
 	);

 	const updateVariables = useCallback(
@@ -120,23 +116,23 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 			widgetIds?: string[],
 			applyToAll?: boolean,
 		): void => {
-			if (!selectedDashboard) {
+			if (!dashboardData) {
 				return;
 			}

 			const newDashboard =
 				(currentRequestedId &&
 					addDynamicVariableToPanels(
-						selectedDashboard,
+						dashboardData,
 						updatedVariablesData[currentRequestedId || ''],
 						widgetIds,
 						applyToAll,
 					)) ||
-				selectedDashboard;
+				dashboardData;

 			updateMutation.mutateAsync(
 				{
-					id: selectedDashboard.id,
+					id: dashboardData.id,

 					data: {
 						...newDashboard.data,
@@ -146,7 +142,7 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 				{
 					onSuccess: (updatedDashboard) => {
 						if (updatedDashboard.data) {
-							setSelectedDashboard(updatedDashboard.data);
+							setDashboardData(updatedDashboard.data);
 							// notifications.success({
 							// 	message: t('variable_updated_successfully'),
 							// });
@@ -155,12 +151,7 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 				},
 			);
 		},
-		[
-			selectedDashboard,
-			addDynamicVariableToPanels,
-			updateMutation,
-			setSelectedDashboard,
-		],
+		[dashboardData, addDynamicVariableToPanels, updateMutation, setDashboardData],
 	);

 	const createVariable = useCallback(
@@ -172,13 +163,13 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 			source: 'logs' | 'traces' | 'metrics' | 'all sources' = 'all sources',
 			// widgetId?: string,
 		): void => {
-			if (!selectedDashboard) {
+			if (!dashboardData) {
 				console.warn('No dashboard selected for variable creation');
 				return;
 			}

 			// Get current dashboard variables
-			const currentVariables = selectedDashboard.data.variables || {};
+			const currentVariables = dashboardData.data.variables || {};

 			// Create tableRowData like Dashboard Settings does
 			const tableRowData = [];
@@ -234,7 +225,7 @@ export const useDashboardVariableUpdate = (): UseDashboardVariableUpdateReturn =
 			const updatedVariables = convertVariablesToDbFormat(tableRowData);
 			updateVariables(updatedVariables, newVariable.id, [], false);
 		},
-		[selectedDashboard, updateVariables],
+		[dashboardData, updateVariables],
 	);

 	return {
--- a/frontend/src/container/DashboardContainer/test/IntegrationTests.test.tsx
+++ b/frontend/src/container/DashboardContainer/test/IntegrationTests.test.tsx
@@ -47,12 +47,12 @@ const mockDashboard = {
 };

 // Mock the dashboard provider with stable functions to prevent infinite loops
-const mockSetSelectedDashboard = jest.fn();
+const mockSetDashboardData = jest.fn();
 const mockUpdateLocalStorageDashboardVariables = jest.fn();
 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
 	useDashboardStore: (): any => ({
-		selectedDashboard: mockDashboard,
-		setSelectedDashboard: mockSetSelectedDashboard,
+		dashboardData: mockDashboard,
+		setDashboardData: mockSetDashboardData,
 		updateLocalStorageDashboardVariables: mockUpdateLocalStorageDashboardVariables,
 	}),
 }));
--- a/frontend/src/container/DashboardContainer/test/PanelManagement.test.tsx
+++ b/frontend/src/container/DashboardContainer/test/PanelManagement.test.tsx
@@ -58,7 +58,7 @@ const mockDashboard = {
 // Mock dependencies
 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
 	useDashboardStore: (): any => ({
-		selectedDashboard: mockDashboard,
+		dashboardData: mockDashboard,
 	}),
 }));

@@ -154,7 +154,7 @@ describe('Panel Management Tests', () => {
 			// Temporarily mock the dashboard
 			jest.doMock('providers/Dashboard/store/useDashboardStore', () => ({
 				useDashboardStore: (): any => ({
-					selectedDashboard: modifiedDashboard,
+					dashboardData: modifiedDashboard,
 				}),
 			}));

--- a/frontend/src/container/DashboardContainer/components/DashboardHeader/DashboardBreadcrumbs.tsx
+++ b/frontend/src/container/DashboardContainer/components/DashboardHeader/DashboardBreadcrumbs.tsx
@@ -13,13 +13,13 @@ import './DashboardBreadcrumbs.styles.scss';

 function DashboardBreadcrumbs(): JSX.Element {
 	const { safeNavigate } = useSafeNavigate();
-	const { selectedDashboard } = useDashboardStore();
-	const updatedAtRef = useRef(selectedDashboard?.updatedAt);
+	const { dashboardData } = useDashboardStore();
+	const updatedAtRef = useRef(dashboardData?.updatedAt);

-	const selectedData = selectedDashboard
+	const selectedData = dashboardData
 		? {
-				...selectedDashboard.data,
-				uuid: selectedDashboard.id,
+				...dashboardData.data,
+				uuid: dashboardData.id,
 		  }
 		: ({} as DashboardData);

@@ -31,7 +31,7 @@ function DashboardBreadcrumbs(): JSX.Element {
 		);

 		const hasDashboardBeenUpdated =
-			selectedDashboard?.updatedAt !== updatedAtRef.current;
+			dashboardData?.updatedAt !== updatedAtRef.current;
 		if (!hasDashboardBeenUpdated && dashboardsListQueryParamsString) {
 			safeNavigate({
 				pathname: ROUTES.ALL_DASHBOARD,
@@ -40,7 +40,7 @@ function DashboardBreadcrumbs(): JSX.Element {
 		} else {
 			safeNavigate(ROUTES.ALL_DASHBOARD);
 		}
-	}, [safeNavigate, selectedDashboard?.updatedAt]);
+	}, [safeNavigate, dashboardData?.updatedAt]);

 	return (
 		<div className="dashboard-breadcrumbs">
--- a/frontend/src/container/DashboardContainer/visualization/charts/ChartWrapper/ChartWrapper.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/charts/ChartWrapper/ChartWrapper.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react';
+import { useCallback, useMemo, useRef } from 'react';
 import ChartLayout from 'container/DashboardContainer/visualization/layout/ChartLayout/ChartLayout';
 import Legend from 'lib/uPlotV2/components/Legend/Legend';
 import {
@@ -30,6 +30,7 @@ export default function ChartWrapper({
 	onDestroy = noop,
 	children,
 	layoutChildren,
+	yAxisUnit,
 	customTooltip,
 	pinnedTooltipElement,
 	'data-testid': testId,
@@ -62,6 +63,13 @@ export default function ChartWrapper({
 		[customTooltip],
 	);

+	const syncMetadata = useMemo(
+		() => ({
+			yAxisUnit,
+		}),
+		[yAxisUnit],
+	);
+
 	return (
 		<PlotContextProvider>
 			<ChartLayout
@@ -99,6 +107,7 @@ export default function ChartWrapper({
 									averageLegendWidth + TOOLTIP_WIDTH_PADDING,
 								)}
 								syncKey={syncKey}
+								syncMetadata={syncMetadata}
 								render={renderTooltipCallback}
 								pinnedTooltipElement={pinnedTooltipElement}
 							/>
--- a/frontend/src/container/DashboardContainer/visualization/charts/Histogram/Histogram.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/charts/Histogram/Histogram.tsx
@@ -24,13 +24,12 @@ export default function Histogram(props: HistogramChartProps): JSX.Element {
 			}
 			const tooltipProps: HistogramTooltipProps = {
 				...props,
-				timezone: rest.timezone,
 				yAxisUnit: rest.yAxisUnit,
 				decimalPrecision: rest.decimalPrecision,
 			};
 			return <HistogramTooltip {...tooltipProps} />;
 		},
-		[customTooltip, rest.timezone, rest.yAxisUnit, rest.decimalPrecision],
+		[customTooltip, rest.yAxisUnit, rest.decimalPrecision],
 	);

 	return (
--- a/frontend/src/container/DashboardContainer/visualization/charts/types.ts
+++ b/frontend/src/container/DashboardContainer/visualization/charts/types.ts
@@ -12,10 +12,7 @@ interface BaseChartProps {
 	height: number;
 	showTooltip?: boolean;
 	showLegend?: boolean;
-	timezone?: Timezone;
 	canPinTooltip?: boolean;
-	yAxisUnit?: string;
-	decimalPrecision?: PrecisionOption;
 	pinnedTooltipElement?: (clickData: TooltipClickData) => React.ReactNode;
 	customTooltip?: (props: TooltipRenderArgs) => React.ReactNode;
 	'data-testid'?: string;
@@ -32,18 +29,31 @@ interface UPlotBasedChartProps {
 	layoutChildren?: React.ReactNode;
 }

+interface UPlotChartDataProps {
+	yAxisUnit?: string;
+	decimalPrecision?: PrecisionOption;
+}
+
 export interface TimeSeriesChartProps
 	extends BaseChartProps,
-		UPlotBasedChartProps {}
+		UPlotBasedChartProps,
+		UPlotChartDataProps {
+	timezone?: Timezone;
+}

 export interface HistogramChartProps
 	extends BaseChartProps,
-		UPlotBasedChartProps {
+		UPlotBasedChartProps,
+		UPlotChartDataProps {
 	isQueriesMerged?: boolean;
 }

-export interface BarChartProps extends BaseChartProps, UPlotBasedChartProps {
+export interface BarChartProps
+	extends BaseChartProps,
+		UPlotBasedChartProps,
+		UPlotChartDataProps {
 	isStackedBarChart?: boolean;
+	timezone?: Timezone;
 }

 export type ChartProps =
--- a/frontend/src/container/DashboardContainer/visualization/components/ChartManager/tests/ChartManager.test.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/components/ChartManager/tests/ChartManager.test.tsx
@@ -35,15 +35,15 @@ jest.mock('lib/uPlotV2/hooks/useLegendsSync', () => ({
 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
 	useDashboardStore: (
 		selector?: (s: {
-			selectedDashboard: { locked: boolean } | undefined;
-		}) => { selectedDashboard: { locked: boolean } },
-	): { selectedDashboard: { locked: boolean } } => {
-		const mockState = { selectedDashboard: { locked: false } };
+			dashboardData: { locked: boolean } | undefined;
+		}) => { dashboardData: { locked: boolean } },
+	): { dashboardData: { locked: boolean } } => {
+		const mockState = { dashboardData: { locked: false } };
 		return selector ? selector(mockState) : mockState;
 	},
 	selectIsDashboardLocked: (s: {
-		selectedDashboard: { locked: boolean } | undefined;
-	}): boolean => s.selectedDashboard?.locked ?? false,
+		dashboardData: { locked: boolean } | undefined;
+	}): boolean => s.dashboardData?.locked ?? false,
 }));

 jest.mock('hooks/useNotifications', () => ({
--- a/frontend/src/container/DashboardContainer/visualization/panels/BarPanel/BarPanel.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/panels/BarPanel/BarPanel.tsx
@@ -123,13 +123,13 @@ function BarPanel(props: PanelWrapperProps): JSX.Element {
 					}}
 					plotRef={onPlotRef}
 					onDestroy={onPlotDestroy}
-					yAxisUnit={widget.yAxisUnit}
-					decimalPrecision={widget.decimalPrecision}
 					data={chartData as uPlot.AlignedData}
 					width={containerDimensions.width}
 					height={containerDimensions.height}
 					layoutChildren={layoutChildren}
 					isStackedBarChart={widget.stackedBarChart ?? false}
+					yAxisUnit={widget.yAxisUnit}
+					decimalPrecision={widget.decimalPrecision}
 					timezone={timezone}
 				>
 					<ContextMenu
--- a/frontend/src/container/DashboardContainer/visualization/panels/HistogramPanel/HistogramPanel.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/panels/HistogramPanel/HistogramPanel.tsx
@@ -3,8 +3,6 @@ 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 { DashboardCursorSync } from 'lib/uPlotV2/plugins/TooltipPlugin/types';
-import { useTimezone } from 'providers/Timezone';
 import uPlot from 'uplot';

 import Histogram from '../../charts/Histogram/Histogram';
@@ -29,7 +27,6 @@ function HistogramPanel(props: PanelWrapperProps): JSX.Element {
 	const containerDimensions = useResizeObserver(graphRef);

 	const isDarkMode = useIsDarkMode();
-	const { timezone } = useTimezone();

 	const config = useMemo(() => {
 		return prepareHistogramPanelConfig({
@@ -92,11 +89,9 @@ function HistogramPanel(props: PanelWrapperProps): JSX.Element {
 					onDestroy={(): void => {
 						uPlotRef.current = null;
 					}}
-					isQueriesMerged={widget.mergeAllActiveQueries}
 					yAxisUnit={widget.yAxisUnit}
 					decimalPrecision={widget.decimalPrecision}
-					syncMode={DashboardCursorSync.Crosshair}
-					timezone={timezone}
+					isQueriesMerged={widget.mergeAllActiveQueries}
 					data={chartData as uPlot.AlignedData}
 					width={containerDimensions.width}
 					height={containerDimensions.height}
--- a/frontend/src/container/DashboardContainer/visualization/panels/HistogramPanel/tests/HistogramPanel.test.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/panels/HistogramPanel/tests/HistogramPanel.test.tsx
@@ -48,8 +48,8 @@ jest.mock(
 					{JSON.stringify({
 						legendPosition: props.legendConfig?.position,
 						isQueriesMerged: props.isQueriesMerged,
-						yAxisUnit: props.yAxisUnit,
-						decimalPrecision: props.decimalPrecision,
+						yAxisUnit: props?.yAxisUnit,
+						decimalPrecision: props?.decimalPrecision,
 					})}
 				</div>
 				{props.layoutChildren}
--- a/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx
+++ b/frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx
@@ -112,9 +112,9 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 					legendConfig={{
 						position: widget?.legendPosition ?? LegendPosition.BOTTOM,
 					}}
+					timezone={timezone}
 					yAxisUnit={widget.yAxisUnit}
 					decimalPrecision={widget.decimalPrecision}
-					timezone={timezone}
 					data={chartData as uPlot.AlignedData}
 					width={containerDimensions.width}
 					height={containerDimensions.height}
--- a/frontend/src/container/ExportPanel/ExportPanelContainer.tsx
+++ b/frontend/src/container/ExportPanel/ExportPanelContainer.tsx
@@ -24,9 +24,7 @@ function ExportPanelContainer({
 }: ExportPanelProps): JSX.Element {
 	const { t } = useTranslation(['dashboard']);

-	const [selectedDashboardId, setSelectedDashboardId] = useState<string | null>(
-		null,
-	);
+	const [dashboardId, setDashboardId] = useState<string | null>(null);

 	const {
 		data,
@@ -55,17 +53,17 @@ function ExportPanelContainer({

 	const handleExportClick = useCallback((): void => {
 		const currentSelectedDashboard = data?.data?.find(
-			({ id }) => id === selectedDashboardId,
+			({ id }) => id === dashboardId,
 		);

 		onExport(currentSelectedDashboard || null, false);
-	}, [data, selectedDashboardId, onExport]);
+	}, [data, dashboardId, onExport]);

 	const handleSelect = useCallback(
-		(selectedDashboardValue: string): void => {
-			setSelectedDashboardId(selectedDashboardValue);
+		(selectedDashboardId: string): void => {
+			setDashboardId(selectedDashboardId);
 		},
-		[setSelectedDashboardId],
+		[setDashboardId],
 	);

 	const handleNewDashboard = useCallback(async () => {
@@ -85,10 +83,7 @@ function ExportPanelContainer({
 	const isDashboardLoading = isAllDashboardsLoading || createDashboardLoading;

 	const isDisabled =
-		isAllDashboardsLoading ||
-		!options?.length ||
-		!selectedDashboardId ||
-		isLoading;
+		isAllDashboardsLoading || !options?.length || !dashboardId || isLoading;

 	return (
 		<Wrapper direction="vertical">
@@ -101,7 +96,7 @@ function ExportPanelContainer({
 					showSearch
 					loading={isDashboardLoading}
 					disabled={isDashboardLoading}
-					value={selectedDashboardId}
+					value={dashboardId}
 					onSelect={handleSelect}
 					filterOption={filterOptions}
 				/>
--- a/frontend/src/container/GridCardLayout/DashboardEmptyState/DashboardEmptyState.tsx
+++ b/frontend/src/container/GridCardLayout/DashboardEmptyState/DashboardEmptyState.tsx
@@ -27,7 +27,7 @@ export default function DashboardEmptyState(): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);

-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();
 	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);

 	const variablesSettingsTabHandle = useRef<VariablesSettingsTab>(null);
@@ -43,7 +43,7 @@ export default function DashboardEmptyState(): JSX.Element {
 	}

 	const userRole: ROLES | null =
-		selectedDashboard?.createdBy === user?.email
+		dashboardData?.createdBy === user?.email
 			? (USER_ROLES.AUTHOR as ROLES)
 			: user.role;

@@ -52,9 +52,9 @@ export default function DashboardEmptyState(): JSX.Element {
 	const onEmptyWidgetHandler = useCallback(() => {
 		setIsPanelTypeSelectionModalOpen(true);
 		logEvent('Dashboard Detail: Add new panel clicked', {
-			dashboardId: selectedDashboard?.id,
-			dashboardName: selectedDashboard?.data.title,
-			numberOfPanels: selectedDashboard?.data.widgets?.length,
+			dashboardId: dashboardData?.id,
+			dashboardName: dashboardData?.data.title,
+			numberOfPanels: dashboardData?.data.widgets?.length,
 		});
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [setIsPanelTypeSelectionModalOpen]);
--- a/frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx
@@ -91,7 +91,7 @@ function FullView({
 		setCurrentGraphRef(fullViewRef);
 	}, [setCurrentGraphRef]);

-	const { selectedDashboard, setColumnWidths } = useDashboardStore();
+	const { dashboardData, setColumnWidths } = useDashboardStore();
 	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);

 	const onColumnWidthsChange = useCallback(
@@ -166,7 +166,7 @@ function FullView({
 		enableDrillDown,
 		widget,
 		setRequestData,
-		selectedDashboard,
+		dashboardData,
 		selectedPanelType,
 	});

@@ -344,7 +344,7 @@ function FullView({
 							<>
 								<QueryBuilderV2
 									panelType={selectedPanelType}
-									version={selectedDashboard?.data?.version || 'v3'}
+									version={dashboardData?.data?.version || 'v3'}
 									isListViewPanel={selectedPanelType === PANEL_TYPES.LIST}
 									signalSourceChangeEnabled
 									// filterConfigs={filterConfigs}
--- a/frontend/src/container/GridCardLayout/GridCard/FullView/useDrilldown.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/FullView/useDrilldown.tsx
@@ -19,7 +19,7 @@ export interface DrilldownQueryProps {
 	widget: Widgets;
 	setRequestData: Dispatch<SetStateAction<GetQueryResultsProps>>;
 	enableDrillDown: boolean;
-	selectedDashboard: Dashboard | undefined;
+	dashboardData: Dashboard | undefined;
 	selectedPanelType: PANEL_TYPES;
 }

@@ -34,7 +34,7 @@ const useDrilldown = ({
 	enableDrillDown,
 	widget,
 	setRequestData,
-	selectedDashboard,
+	dashboardData,
 	selectedPanelType,
 }: DrilldownQueryProps): UseDrilldownReturn => {
 	const isMounted = useRef(false);
@@ -60,11 +60,11 @@ const useDrilldown = ({
 		isMounted.current = true;
 	}, [widget, enableDrillDown, compositeQuery, redirectWithQueryBuilderData]);

-	const dashboardEditView = selectedDashboard?.id
+	const dashboardEditView = dashboardData?.id
 		? generateExportToDashboardLink({
 				query: currentQuery,
 				panelType: selectedPanelType,
-				dashboardId: selectedDashboard?.id || '',
+				dashboardId: dashboardData?.id || '',
 				widgetId: widget.id,
 		  })
 		: '';
--- a/frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.test.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.test.tsx
@@ -163,13 +163,13 @@ const mockProps: WidgetGraphComponentProps = {
 // Mock useDashabord hook
 jest.mock('providers/Dashboard/store/useDashboardStore', () => ({
 	useDashboardStore: (): any => ({
-		selectedDashboard: {
+		dashboardData: {
 			data: {
 				variables: [],
 			},
 		},
 		setLayouts: jest.fn(),
-		setSelectedDashboard: jest.fn(),
+		setDashboardData: jest.fn(),
 		setColumnWidths: jest.fn(),
 	}),
 }));
--- a/frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.tsx
+++ b/frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.tsx
@@ -103,8 +103,8 @@ function WidgetGraphComponent({

 	const {
 		setLayouts,
-		selectedDashboard,
-		setSelectedDashboard,
+		dashboardData,
+		setDashboardData,
 		setColumnWidths,
 	} = useDashboardStore();

@@ -125,33 +125,33 @@ function WidgetGraphComponent({
 	const updateDashboardMutation = useUpdateDashboard();

 	const onDeleteHandler = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

-		const updatedWidgets = selectedDashboard?.data?.widgets?.filter(
+		const updatedWidgets = dashboardData?.data?.widgets?.filter(
 			(e) => e.id !== widget.id,
 		);

 		const updatedLayout =
-			selectedDashboard.data.layout?.filter((e) => e.i !== widget.id) || [];
+			dashboardData.data.layout?.filter((e) => e.i !== widget.id) || [];

-		const updatedSelectedDashboard: Props = {
+		const updatedDashboardData: Props = {
 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				widgets: updatedWidgets,
 				layout: updatedLayout,
 			},
-			id: selectedDashboard.id,
+			id: dashboardData.id,
 		};

-		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
+		updateDashboardMutation.mutateAsync(updatedDashboardData, {
 			onSuccess: (updatedDashboard) => {
 				if (setLayouts) {
 					setLayouts(updatedDashboard.data?.data?.layout || []);
 				}
-				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.data);
+				if (setDashboardData && updatedDashboard.data) {
+					setDashboardData(updatedDashboard.data);
 				}
 				setDeleteModal(false);
 			},
@@ -159,35 +159,35 @@ function WidgetGraphComponent({
 	};

 	const onCloneHandler = async (): Promise<void> => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		const uuid = v4();

 		// this is added to make sure the cloned panel is of the same dimensions as the original one
-		const originalPanelLayout = selectedDashboard.data.layout?.find(
+		const originalPanelLayout = dashboardData.data.layout?.find(
 			(l) => l.i === widget.id,
 		);

 		const newLayoutItem = placeWidgetAtBottom(
 			uuid,
-			selectedDashboard?.data.layout || [],
+			dashboardData?.data.layout || [],
 			originalPanelLayout?.w || 6,
 			originalPanelLayout?.h || 6,
 		);

-		const layout = [...(selectedDashboard.data.layout || []), newLayoutItem];
+		const layout = [...(dashboardData.data.layout || []), newLayoutItem];

 		updateDashboardMutation.mutateAsync(
 			{
-				id: selectedDashboard.id,
+				id: dashboardData.id,

 				data: {
-					...selectedDashboard.data,
+					...dashboardData.data,
 					layout,
 					widgets: [
-						...(selectedDashboard.data.widgets || []),
+						...(dashboardData.data.widgets || []),
 						{
 							...{
 								...widget,
@@ -202,8 +202,8 @@ function WidgetGraphComponent({
 					if (setLayouts) {
 						setLayouts(updatedDashboard.data?.data?.layout || []);
 					}
-					if (setSelectedDashboard && updatedDashboard.data) {
-						setSelectedDashboard(updatedDashboard.data);
+					if (setDashboardData && updatedDashboard.data) {
+						setDashboardData(updatedDashboard.data);
 					}
 					notifications.success({
 						message: 'Panel cloned successfully, redirecting to new copy.',
--- a/frontend/src/container/GridCardLayout/GridCardLayout.tsx
+++ b/frontend/src/container/GridCardLayout/GridCardLayout.tsx
@@ -70,16 +70,16 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 		useIsFetching([REACT_QUERY_KEY.DASHBOARD_BY_ID]) > 0;

 	const {
-		selectedDashboard,
+		dashboardData,
 		layouts,
 		setLayouts,
 		panelMap,
 		setPanelMap,
-		setSelectedDashboard,
+		setDashboardData,
 		columnWidths,
 	} = useDashboardStore();
 	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);
-	const { data } = selectedDashboard || {};
+	const { data } = dashboardData || {};
 	const { pathname } = useLocation();
 	const dispatch = useDispatch();

@@ -124,7 +124,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	}

 	const userRole: ROLES | null =
-		selectedDashboard?.createdBy === user?.email
+		dashboardData?.createdBy === user?.email
 			? (USER_ROLES.AUTHOR as ROLES)
 			: user.role;

@@ -146,27 +146,27 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	useEffect(() => {
 		if (!logEventCalledRef.current && !isUndefined(data)) {
 			logEvent('Dashboard Detail: Opened', {
-				dashboardId: selectedDashboard?.id,
+				dashboardId: dashboardData?.id,
 				dashboardName: data.title,
 				numberOfPanels: data.widgets?.length,
 				numberOfVariables: Object.keys(dashboardVariables).length || 0,
 			});
 			logEventCalledRef.current = true;
 		}
-	}, [dashboardVariables, data, selectedDashboard?.id]);
+	}, [dashboardVariables, data, dashboardData?.id]);

 	const onSaveHandler = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

 		const updatedDashboard: Props = {
-			id: selectedDashboard.id,
+			id: dashboardData.id,
 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				panelMap: { ...currentPanelMap },
 				layout: dashboardLayout.filter((e) => e.i !== PANEL_TYPES.EMPTY_WIDGET),
-				widgets: selectedDashboard?.data?.widgets?.map((widget) => {
+				widgets: dashboardData?.data?.widgets?.map((widget) => {
 					if (columnWidths?.[widget.id]) {
 						return {
 							...widget,
@@ -184,7 +184,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 					if (updatedDashboard.data.data.layout) {
 						setLayouts(sortLayout(updatedDashboard.data.data.layout));
 					}
-					setSelectedDashboard(updatedDashboard.data);
+					setDashboardData(updatedDashboard.data);
 					setPanelMap(updatedDashboard.data?.data?.panelMap || {});
 				}
 			},
@@ -243,7 +243,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 			dashboardLayout &&
 			Array.isArray(dashboardLayout) &&
 			dashboardLayout.length > 0 &&
-			hasColumnWidthsChanged(columnWidths, selectedDashboard);
+			hasColumnWidthsChanged(columnWidths, dashboardData);

 		if (shouldSaveLayout || shouldSaveColumnWidths) {
 			onSaveHandler();
@@ -253,7 +253,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {

 	const onSettingsModalSubmit = (): void => {
 		const newTitle = form.getFieldValue('title');
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

@@ -261,7 +261,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 			return;
 		}

-		const currentWidget = selectedDashboard?.data?.widgets?.find(
+		const currentWidget = dashboardData?.data?.widgets?.find(
 			(e) => e.id === currentSelectRowId,
 		);

@@ -269,25 +269,25 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 			return;
 		}

-		const updatedWidgets = selectedDashboard?.data?.widgets?.map((e) =>
+		const updatedWidgets = dashboardData?.data?.widgets?.map((e) =>
 			e.id === currentSelectRowId ? { ...e, title: newTitle } : e,
 		);

-		const updatedSelectedDashboard: Props = {
-			id: selectedDashboard.id,
+		const updatedDashboardData: Props = {
+			id: dashboardData.id,
 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				widgets: updatedWidgets,
 			},
 		};

-		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
+		updateDashboardMutation.mutateAsync(updatedDashboardData, {
 			onSuccess: (updatedDashboard) => {
 				if (setLayouts) {
 					setLayouts(updatedDashboard.data?.data?.layout || []);
 				}
-				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.data);
+				if (setDashboardData && updatedDashboard.data) {
+					setDashboardData(updatedDashboard.data);
 				}
 				if (setPanelMap) {
 					setPanelMap(updatedDashboard.data?.data?.panelMap || {});
@@ -311,7 +311,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	}, [currentSelectRowId, form, widgets]);

 	const handleRowCollapse = (id: string): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}
 		const { updatedLayout, updatedPanelMap } = applyRowCollapse(
@@ -343,7 +343,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	};

 	const handleRowDelete = (): void => {
-		if (!selectedDashboard) {
+		if (!dashboardData) {
 			return;
 		}

@@ -351,34 +351,33 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 			return;
 		}

-		const updatedWidgets = selectedDashboard?.data?.widgets?.filter(
+		const updatedWidgets = dashboardData?.data?.widgets?.filter(
 			(e) => e.id !== currentSelectRowId,
 		);

 		const updatedLayout =
-			selectedDashboard.data.layout?.filter((e) => e.i !== currentSelectRowId) ||
-			[];
+			dashboardData.data.layout?.filter((e) => e.i !== currentSelectRowId) || [];

 		const updatedPanelMap = { ...currentPanelMap };
 		delete updatedPanelMap[currentSelectRowId];

-		const updatedSelectedDashboard: Props = {
-			id: selectedDashboard.id,
+		const updatedDashboardData: Props = {
+			id: dashboardData.id,
 			data: {
-				...selectedDashboard.data,
+				...dashboardData.data,
 				widgets: updatedWidgets,
 				layout: updatedLayout,
 				panelMap: updatedPanelMap,
 			},
 		};

-		updateDashboardMutation.mutateAsync(updatedSelectedDashboard, {
+		updateDashboardMutation.mutateAsync(updatedDashboardData, {
 			onSuccess: (updatedDashboard) => {
 				if (setLayouts) {
 					setLayouts(updatedDashboard.data?.data?.layout || []);
 				}
-				if (setSelectedDashboard && updatedDashboard.data) {
-					setSelectedDashboard(updatedDashboard.data);
+				if (setDashboardData && updatedDashboard.data) {
+					setDashboardData(updatedDashboard.data);
 				}
 				if (setPanelMap) {
 					setPanelMap(updatedDashboard.data?.data?.panelMap || {});
@@ -390,10 +389,8 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 	};
 	const isDashboardEmpty = useMemo(
 		() =>
-			selectedDashboard?.data.layout
-				? selectedDashboard?.data.layout?.length === 0
-				: true,
-		[selectedDashboard],
+			dashboardData?.data.layout ? dashboardData?.data.layout?.length === 0 : true,
+		[dashboardData],
 	);

 	let isDataAvailableInAnyWidget = false;
@@ -512,7 +509,7 @@ function GraphLayout(props: GraphLayoutProps): JSX.Element {
 									widget={(currentWidget as Widgets) || ({ id, query: {} } as Widgets)}
 									headerMenuList={widgetActions}
 									variables={dashboardVariables}
-									// version={selectedDashboard?.data?.version}
+									// version={dashboardData?.data?.version}
 									version={ENTITY_VERSION_V5}
 									onDragSelect={onDragSelect}
 									dataAvailable={checkIfDataExists}
--- a/frontend/src/container/GridCardLayout/WidgetRow.tsx
+++ b/frontend/src/container/GridCardLayout/WidgetRow.tsx
@@ -42,14 +42,14 @@ export function WidgetRowHeader(props: WidgetRowHeaderProps): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);

-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();
 	const isDashboardLocked = useDashboardStore(selectIsDashboardLocked);

 	const permissions: ComponentTypes[] = ['add_panel'];
 	const { user } = useAppContext();

 	const userRole: ROLES | null =
-		selectedDashboard?.createdBy === user?.email
+		dashboardData?.createdBy === user?.email
 			? (USER_ROLES.AUTHOR as ROLES)
 			: user.role;
 	const [addPanelPermission] = useComponentPermission(permissions, userRole);
@@ -87,11 +87,11 @@ export function WidgetRowHeader(props: WidgetRowHeaderProps): JSX.Element {
 							icon={<Plus size={14} />}
 							onClick={(): void => {
 								// TODO: @AshwinBhatkal Simplify this check in cleanup of https://github.com/SigNoz/engineering-pod/issues/3953
-								if (!selectedDashboard?.id) {
+								if (!dashboardData?.id) {
 									return;
 								}

-								setSelectedRowWidgetId(selectedDashboard.id, id);
+								setSelectedRowWidgetId(dashboardData.id, id);
 								setIsPanelTypeSelectionModalOpen(true);
 							}}
 						>
--- a/frontend/src/container/GridCardLayout/useNavigateToExplorerPages.ts
+++ b/frontend/src/container/GridCardLayout/useNavigateToExplorerPages.ts
@@ -121,7 +121,7 @@ function useNavigateToExplorerPages(): (
 ) => Promise<{
 	[queryName: string]: { filters: TagFilterItem[]; dataSource?: string };
 }> {
-	const { selectedDashboard } = useDashboardStore();
+	const { dashboardData } = useDashboardStore();
 	const { notifications } = useNotifications();

 	return useCallback(
@@ -143,7 +143,7 @@ function useNavigateToExplorerPages(): (
 			}
 		},
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[selectedDashboard, notifications],
+		[dashboardData, notifications],
 	);
 }

--- a/frontend/src/container/GridCardLayout/useResolveQuery.ts
+++ b/frontend/src/container/GridCardLayout/useResolveQuery.ts
@@ -20,7 +20,7 @@ interface UseUpdatedQueryOptions {
 		panelTypes: PANEL_TYPES;
 		timePreferance: timePreferenceType;
 	};
-	selectedDashboard?: any;
+	dashboardData?: any;
 }

 interface UseUpdatedQueryResult {
@@ -44,7 +44,7 @@ function useUpdatedQuery(): UseUpdatedQueryResult {
 	const getUpdatedQuery = useCallback(
 		async ({
 			widgetConfig,
-			selectedDashboard,
+			dashboardData,
 		}: UseUpdatedQueryOptions): Promise<Query> => {
 			// Prepare query payload with resolved variables
 			const { queryPayload } = prepareQueryRangePayloadV5({
@@ -52,7 +52,7 @@ function useUpdatedQuery(): UseUpdatedQueryResult {
 				graphType: getGraphType(widgetConfig.panelTypes),
 				selectedTime: widgetConfig.timePreferance,
 				globalSelectedInterval,
-				variables: getDashboardVariables(selectedDashboard?.data?.variables),
+				variables: getDashboardVariables(dashboardData?.data?.variables),
 				originalGraphType: widgetConfig.panelTypes,
 				dynamicVariables: dashboardDynamicVariables,
 			});
--- a/frontend/src/container/GridCardLayout/utils.ts
+++ b/frontend/src/container/GridCardLayout/utils.ts
@@ -149,16 +149,16 @@ export function extractQueryNamesFromExpression(expression: string): string[] {

 export const hasColumnWidthsChanged = (
 	columnWidths: Record<string, Record<string, number>>,
-	selectedDashboard?: Dashboard,
+	dashboardData?: Dashboard,
 ): boolean => {
 	// If no column widths stored, no changes
-	if (isEmpty(columnWidths) || !selectedDashboard) {
+	if (isEmpty(columnWidths) || !dashboardData) {
 		return false;
 	}

 	// Check each widget's column widths
 	return Object.keys(columnWidths).some((widgetId) => {
-		const dashboardWidget = selectedDashboard?.data?.widgets?.find(
+		const dashboardWidget = dashboardData?.data?.widgets?.find(
 			(widget) => widget.id === widgetId,
 		) as Widgets;

--- a/frontend/src/container/InfraMonitoringHosts/Hosts.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/Hosts.tsx
@@ -0,0 +1,205 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { VerticalAlignTopOutlined } from '@ant-design/icons';
+import { Button, Tooltip, Typography } from 'antd';
+import logEvent from 'api/common/logEvent';
+import QuickFilters from 'components/QuickFilters/QuickFilters';
+import { QuickFiltersSource } from 'components/QuickFilters/types';
+import { InfraMonitoringEvents } from 'constants/events';
+import { FeatureKeys } from 'constants/features';
+import K8sBaseDetails from 'container/InfraMonitoringK8s/Base/K8sBaseDetails';
+import { K8sBaseList } from 'container/InfraMonitoringK8s/Base/K8sBaseList';
+import { K8sBaseFilters } from 'container/InfraMonitoringK8s/Base/types';
+import { InfraMonitoringEntity } from 'container/InfraMonitoringK8s/constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFilters,
+} from 'container/InfraMonitoringK8s/hooks';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
+import { Filter } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import {
+	fetchHostEntityData,
+	fetchHostListData,
+	getHostMetricsQueryPayload,
+	hostDetailsMetadataConfig,
+	hostGetEntityName,
+	hostGetSelectedItemFilters,
+	hostInitialEventsFilter,
+	hostInitialLogTracesFilter,
+	hostWidgetInfo,
+} from './constants';
+import {
+	hostColumns,
+	hostColumnsConfig,
+	hostRenderRowData,
+} from './table.config';
+import { getHostsQuickFiltersConfig } from './utils';
+
+import styles from './InfraMonitoringHosts.module.scss';
+
+function Hosts(): JSX.Element {
+	const [showFilters, setShowFilters] = useState(true);
+	const [, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [urlFilters, setUrlFilters] = useInfraMonitoringFilters();
+
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
+	const { currentQuery } = useQueryBuilder();
+	const { handleChangeQueryData } = useQueryOperations({
+		index: 0,
+		query: currentQuery.builder.queryData[0],
+		entityVersion: '',
+	});
+
+	// Track previous urlFilters to only sync when the value actually changes
+	// (not when handleChangeQueryData changes due to query updates)
+	const prevUrlFiltersRef = useRef<string | null>(null);
+
+	useEffect(() => {
+		const currentFiltersJson = urlFilters ? JSON.stringify(urlFilters) : null;
+
+		// Only sync if urlFilters value has actually changed
+		if (prevUrlFiltersRef.current !== currentFiltersJson) {
+			prevUrlFiltersRef.current = currentFiltersJson;
+			// Sync filters to query builder, using empty filter when urlFilters is null
+			handleChangeQueryData('filters', urlFilters || { items: [], op: 'and' });
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [urlFilters]); // handleChangeQueryData intentionally omitted - we call the current version but don't re-run when it changes
+
+	const handleFilterVisibilityChange = (): void => {
+		setShowFilters(!showFilters);
+	};
+
+	const handleQuickFiltersChange = (query: Query): void => {
+		const filters = query.builder.queryData[0].filters;
+		// Nuqs batches these calls into a single URL update
+		// The useEffect will sync filters to query builder
+		setUrlFilters(filters || null);
+		setCurrentPage(1);
+		logEvent(InfraMonitoringEvents.FilterApplied, {
+			entity: InfraMonitoringEvents.HostEntity,
+			page: InfraMonitoringEvents.ListPage,
+		});
+	};
+
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
+
+			return fetchHostListData(filters, signal);
+		},
+		[],
+	);
+
+	const fetchEntityData = useCallback(
+		async (
+			filters: Parameters<typeof fetchHostEntityData>[0],
+			signal?: AbortSignal,
+		) => fetchHostEntityData(filters, signal),
+		[],
+	);
+
+	const getSelectedItemFilters = useCallback(
+		(selectedItem: string) =>
+			hostGetSelectedItemFilters(selectedItem, dotMetricsEnabled),
+		[dotMetricsEnabled],
+	);
+
+	const getInitialLogTracesFilters = useCallback(
+		(host: import('api/infraMonitoring/getHostLists').HostData) =>
+			hostInitialLogTracesFilter(host, dotMetricsEnabled),
+		[dotMetricsEnabled],
+	);
+
+	const primaryFilterKeys = useMemo(
+		() => [dotMetricsEnabled ? 'host.name' : 'host_name'],
+		[dotMetricsEnabled],
+	);
+
+	const controlListPrefix = !showFilters ? (
+		<div className={styles.quickFiltersToggleContainer}>
+			<Button
+				className="periscope-btn ghost"
+				type="text"
+				size="small"
+				onClick={handleFilterVisibilityChange}
+			>
+				<Filter size={14} />
+			</Button>
+		</div>
+	) : undefined;
+
+	return (
+		<>
+			<div className={styles.infraMonitoringContainer}>
+				<div className={styles.infraContentRow}>
+					{showFilters && (
+						<div className={styles.quickFiltersContainer}>
+							<div className={styles.quickFiltersContainerHeader}>
+								<Typography.Text>Filters</Typography.Text>
+								<Tooltip title="Collapse Filters">
+									<VerticalAlignTopOutlined
+										rotate={270}
+										onClick={handleFilterVisibilityChange}
+									/>
+								</Tooltip>
+							</div>
+							<QuickFilters
+								source={QuickFiltersSource.INFRA_MONITORING}
+								config={getHostsQuickFiltersConfig(dotMetricsEnabled)}
+								handleFilterVisibilityChange={handleFilterVisibilityChange}
+								onFilterChange={handleQuickFiltersChange}
+							/>
+						</div>
+					)}
+					<div
+						className={`${styles.listContainer}${
+							showFilters ? ` ${styles.listContainerFiltersVisible}` : ''
+						}`}
+					>
+						<K8sBaseList
+							controlListPrefix={controlListPrefix}
+							entity={InfraMonitoringEntity.HOSTS}
+							tableColumnsDefinitions={hostColumns}
+							tableColumns={hostColumnsConfig}
+							fetchListData={fetchListData}
+							renderRowData={hostRenderRowData}
+							eventCategory={InfraMonitoringEvents.HostEntity}
+						/>
+					</div>
+				</div>
+			</div>
+			<K8sBaseDetails
+				category={InfraMonitoringEntity.HOSTS}
+				eventCategory={InfraMonitoringEvents.HostEntity}
+				getSelectedItemFilters={getSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={hostGetEntityName}
+				getInitialLogTracesFilters={getInitialLogTracesFilters}
+				getInitialEventsFilters={hostInitialEventsFilter}
+				primaryFilterKeys={primaryFilterKeys}
+				metadataConfig={hostDetailsMetadataConfig}
+				entityWidgetInfo={hostWidgetInfo}
+				getEntityQueryPayload={getHostMetricsQueryPayload}
+				queryKeyPrefix="hosts"
+				tabsConfig={{
+					showEvents: false,
+					showContainers: true,
+					showProcesses: true,
+				}}
+			/>
+		</>
+	);
+}
+
+export default Hosts;
--- a/frontend/src/container/InfraMonitoringHosts/HostsEmptyOrIncorrectMetrics.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/HostsEmptyOrIncorrectMetrics.tsx
@@ -1,54 +0,0 @@
-import { Typography } from 'antd';
-
-import eyesEmojiUrl from '@/assets/Images/eyesEmoji.svg';
-
-export default function HostsEmptyOrIncorrectMetrics({
-	noData,
-	incorrectData,
-}: {
-	noData: boolean;
-	incorrectData: boolean;
-}): JSX.Element {
-	return (
-		<div className="hosts-empty-state-container">
-			<div className="hosts-empty-state-container-content">
-				<img className="eyes-emoji" src={eyesEmojiUrl} alt="eyes emoji" />
-
-				{noData && (
-					<div className="no-hosts-message">
-						<Typography.Title level={5} className="no-hosts-message-title">
-							No host metrics data received yet.
-						</Typography.Title>
-
-						<Typography.Text className="no-hosts-message-text">
-							Infrastructure monitoring requires the{' '}
-							<a
-								href="https://github.com/open-telemetry/semantic-conventions/blob/main/docs/system/system-metrics.md"
-								target="_blank"
-								rel="noreferrer"
-							>
-								OpenTelemetry system metrics
-							</a>
-							. Please refer to{' '}
-							<a
-								href="https://signoz.io/docs/userguide/hostmetrics"
-								target="_blank"
-								rel="noreferrer"
-							>
-								this
-							</a>{' '}
-							to learn how to send host metrics to SigNoz.
-						</Typography.Text>
-					</div>
-				)}
-
-				{incorrectData && (
-					<Typography.Text className="incorrect-metrics-message">
-						To see host metrics, upgrade to the latest version of SigNoz k8s-infra
-						chart. Please contact support if you need help.
-					</Typography.Text>
-				)}
-			</div>
-		</div>
-	);
-}
--- a/frontend/src/container/InfraMonitoringHosts/HostsList.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/HostsList.tsx
@@ -1,253 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import { VerticalAlignTopOutlined } from '@ant-design/icons';
-import { Button, Tooltip, Typography } from 'antd';
-import logEvent from 'api/common/logEvent';
-import {
-	getHostLists,
-	HostListPayload,
-	HostListResponse,
-} from 'api/infraMonitoring/getHostLists';
-import HostMetricDetail from 'components/HostMetricsDetail';
-import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { QuickFiltersSource } from 'components/QuickFilters/types';
-import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringFiltersHosts,
-	useInfraMonitoringOrderByHosts,
-} from 'container/InfraMonitoringK8s/hooks';
-import { usePageSize } from 'container/InfraMonitoringK8s/utils';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { Filter } from 'lucide-react';
-import { parseAsString, useQueryState } from 'nuqs';
-import { useAppContext } from 'providers/App/App';
-import { useGlobalTimeStore } from 'store/globalTime';
-import {
-	getAutoRefreshQueryKey,
-	NANO_SECOND_MULTIPLIER,
-} from 'store/globalTime/utils';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import {
-	IBuilderQuery,
-	Query,
-	TagFilter,
-} from 'types/api/queryBuilder/queryBuilderData';
-
-import HostsListControls from './HostsListControls';
-import HostsListTable from './HostsListTable';
-import { getHostListsQuery, GetHostsQuickFiltersConfig } from './utils';
-
-import './InfraMonitoring.styles.scss';
-
-const defaultFilters: TagFilter = { items: [], op: 'and' };
-const baseQuery = getHostListsQuery();
-
-function HostsList(): JSX.Element {
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filters, setFilters] = useInfraMonitoringFiltersHosts();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderByHosts();
-
-	const [showFilters, setShowFilters] = useState<boolean>(true);
-
-	const [selectedHostName, setSelectedHostName] = useQueryState(
-		'hostName',
-		parseAsString.withDefault(''),
-	);
-
-	const handleOrderByChange = (
-		orderByValue: {
-			columnName: string;
-			order: 'asc' | 'desc';
-		} | null,
-	): void => {
-		setOrderBy(orderByValue);
-	};
-
-	const handleHostClick = (hostName: string): void => {
-		setSelectedHostName(hostName);
-	};
-
-	const { pageSize, setPageSize } = usePageSize('hosts');
-
-	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
-	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
-	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
-	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
-
-	const queryKey = useMemo(
-		() =>
-			getAutoRefreshQueryKey(
-				selectedTime,
-				REACT_QUERY_KEY.GET_HOST_LIST,
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(filters),
-				JSON.stringify(orderBy),
-			),
-		[pageSize, currentPage, filters, orderBy, selectedTime],
-	);
-
-	const { data, isFetching, isLoading, isError } = useQuery<
-		SuccessResponse<HostListResponse> | ErrorResponse,
-		Error
-	>({
-		queryKey,
-		queryFn: ({ signal }) => {
-			const { minTime, maxTime } = getMinMaxTime();
-
-			const payload: HostListPayload = {
-				...baseQuery,
-				limit: pageSize,
-				offset: (currentPage - 1) * pageSize,
-				filters: filters ?? defaultFilters,
-				orderBy,
-				start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
-				end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
-			};
-
-			return getHostLists(payload, signal);
-		},
-		enabled: true,
-		keepPreviousData: true,
-		refetchInterval: isRefreshEnabled ? refreshInterval : false,
-	});
-
-	const hostMetricsData = useMemo(() => data?.payload?.data?.records || [], [
-		data,
-	]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const { featureFlags } = useAppContext();
-	const dotMetricsEnabled =
-		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
-			?.active || false;
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			const isNewFilterAdded = value?.items?.length !== filters?.items?.length;
-			setFilters(value ?? null);
-			handleChangeQueryData('filters', value);
-			if (isNewFilterAdded) {
-				setCurrentPage(1);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.HostEntity,
-						page: InfraMonitoringEvents.ListPage,
-					});
-				}
-			}
-		},
-		[filters, setFilters, setCurrentPage, handleChangeQueryData],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			total: data?.payload?.data?.total,
-			entity: InfraMonitoringEvents.HostEntity,
-			page: InfraMonitoringEvents.ListPage,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedHostData = useMemo(() => {
-		if (!selectedHostName?.trim()) {
-			return null;
-		}
-		return (
-			hostMetricsData.find((host) => host.hostName === selectedHostName) || null
-		);
-	}, [selectedHostName, hostMetricsData]);
-
-	const handleCloseHostDetail = (): void => {
-		setSelectedHostName(null);
-	};
-
-	const handleFilterVisibilityChange = (): void => {
-		setShowFilters(!showFilters);
-	};
-
-	const handleQuickFiltersChange = (query: Query): void => {
-		handleChangeQueryData('filters', query.builder.queryData[0].filters);
-		handleFiltersChange(query.builder.queryData[0].filters);
-	};
-
-	return (
-		<div className="hosts-list">
-			<div className="hosts-list-content">
-				{showFilters && (
-					<div className="hosts-quick-filters-container">
-						<div className="hosts-quick-filters-container-header">
-							<Typography.Text>Filters</Typography.Text>
-							<Tooltip title="Collapse Filters">
-								<VerticalAlignTopOutlined
-									rotate={270}
-									onClick={handleFilterVisibilityChange}
-								/>
-							</Tooltip>
-						</div>
-						<QuickFilters
-							source={QuickFiltersSource.INFRA_MONITORING}
-							config={GetHostsQuickFiltersConfig(dotMetricsEnabled)}
-							handleFilterVisibilityChange={handleFilterVisibilityChange}
-							onFilterChange={handleQuickFiltersChange}
-						/>
-					</div>
-				)}
-				<div className="hosts-list-table-container">
-					<div className="hosts-list-table-header">
-						{!showFilters && (
-							<div className="quick-filters-toggle-container">
-								<Button
-									className="periscope-btn ghost"
-									type="text"
-									size="small"
-									onClick={handleFilterVisibilityChange}
-								>
-									<Filter size={14} />
-								</Button>
-							</div>
-						)}
-						<HostsListControls
-							filters={filters}
-							handleFiltersChange={handleFiltersChange}
-							showAutoRefresh={!selectedHostData}
-						/>
-					</div>
-					<HostsListTable
-						isLoading={isLoading}
-						isFetching={isFetching}
-						isError={isError}
-						tableData={data}
-						hostMetricsData={hostMetricsData}
-						filters={filters ?? defaultFilters}
-						currentPage={currentPage}
-						setCurrentPage={setCurrentPage}
-						onHostClick={handleHostClick}
-						pageSize={pageSize}
-						setPageSize={setPageSize}
-						setOrderBy={handleOrderByChange}
-						orderBy={orderBy}
-					/>
-				</div>
-			</div>
-			<HostMetricDetail
-				host={selectedHostData}
-				isModalTimeSelection
-				onClose={handleCloseHostDetail}
-			/>
-		</div>
-	);
-}
-
-export default HostsList;
--- a/frontend/src/container/InfraMonitoringHosts/HostsListControls.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/HostsListControls.tsx
@@ -1,72 +0,0 @@
-import { useCallback, useMemo } from 'react';
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-
-import './InfraMonitoring.styles.scss';
-
-function HostsListControls({
-	handleFiltersChange,
-	filters,
-	showAutoRefresh,
-}: {
-	handleFiltersChange: (value: IBuilderQuery['filters']) => void;
-	filters: IBuilderQuery['filters'] | null;
-	showAutoRefresh: boolean;
-}): JSX.Element {
-	const currentQuery = initialQueriesMap[DataSource.METRICS];
-	const updatedCurrentQuery = useMemo(
-		() => ({
-			...currentQuery,
-			builder: {
-				...currentQuery.builder,
-				queryData: [
-					{
-						...currentQuery.builder.queryData[0],
-						aggregateOperator: 'noop',
-						aggregateAttribute: {
-							...currentQuery.builder.queryData[0].aggregateAttribute,
-						},
-						filters,
-					},
-				],
-			},
-		}),
-		[currentQuery, filters],
-	);
-	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
-
-	const handleChangeTagFilters = useCallback(
-		(value: IBuilderQuery['filters']) => {
-			handleFiltersChange(value);
-		},
-		[handleFiltersChange],
-	);
-
-	return (
-		<div className="hosts-list-controls">
-			<div className="hosts-list-controls-left">
-				<QueryBuilderSearch
-					query={query as IBuilderQuery}
-					onChange={handleChangeTagFilters}
-					isInfraMonitoring
-					disableNavigationShortcuts
-					entity={K8sCategory.HOSTS}
-				/>
-			</div>
-
-			<div className="time-selector">
-				<DateTimeSelectionV2
-					showAutoRefresh={showAutoRefresh}
-					showRefreshText={false}
-					hideShareModal
-				/>
-			</div>
-		</div>
-	);
-}
-
-export default HostsListControls;
--- a/frontend/src/container/InfraMonitoringHosts/HostsListTable.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/HostsListTable.tsx
@@ -1,271 +0,0 @@
-import React, { useCallback, useMemo, useState } from 'react';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Skeleton,
-	Spin,
-	Table,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import ErrorContent from 'components/ErrorModal/components/ErrorContent';
-import { InfraMonitoringEvents } from 'constants/events';
-import { isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
-
-import emptyStateUrl from '@/assets/Icons/emptyState.svg';
-import eyesEmojiUrl from '@/assets/Images/eyesEmoji.svg';
-
-import HostsEmptyOrIncorrectMetrics from './HostsEmptyOrIncorrectMetrics';
-import {
-	EmptyOrLoadingViewProps,
-	formatDataForTable,
-	getHostsListColumns,
-	HostRowData,
-	HostsListTableProps,
-} from './utils';
-
-function EmptyOrLoadingView(
-	viewState: EmptyOrLoadingViewProps,
-): React.ReactNode {
-	if (viewState.showTableLoadingState) {
-		return (
-			<div className="hosts-list-loading-state">
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-				<Skeleton.Input
-					className="hosts-list-loading-state-item"
-					size="large"
-					block
-					active
-				/>
-			</div>
-		);
-	}
-	const { isError, data } = viewState;
-	if (isError || data?.error || (data?.statusCode || 0) >= 300) {
-		return (
-			<ErrorContent
-				error={{
-					code: data?.statusCode || 500,
-					message: data?.error || 'Something went wrong',
-				}}
-			/>
-		);
-	}
-	if (viewState.showHostsEmptyState) {
-		return (
-			<HostsEmptyOrIncorrectMetrics
-				noData={!viewState.sentAnyHostMetricsData}
-				incorrectData={viewState.isSendingIncorrectK8SAgentMetrics}
-			/>
-		);
-	}
-	if (viewState.showEndTimeBeforeRetentionMessage) {
-		return (
-			<div className="hosts-empty-state-container">
-				<div className="hosts-empty-state-container-content">
-					<img className="eyes-emoji" src={eyesEmojiUrl} alt="eyes emoji" />
-					<div className="no-hosts-message">
-						<Typography.Title level={5} className="no-hosts-message-title">
-							Queried time range is before earliest host metrics
-						</Typography.Title>
-						<Typography.Text className="no-hosts-message-text">
-							Your requested end time is earlier than the earliest detected time of
-							host metrics data, please adjust your end time.
-						</Typography.Text>
-					</div>
-				</div>
-			</div>
-		);
-	}
-	if (viewState.showNoRecordsInSelectedTimeRangeMessage) {
-		return (
-			<div className="no-filtered-hosts-message-container">
-				<div className="no-filtered-hosts-message-content">
-					<img
-						src={emptyStateUrl}
-						alt="thinking-emoji"
-						className="empty-state-svg"
-					/>
-					<Typography.Title level={5} className="no-filtered-hosts-title">
-						No host metrics found
-					</Typography.Title>
-					<Typography.Text className="no-filtered-hosts-message">
-						No host metrics in the selected time range and filters. Please adjust your
-						time range or filters.
-					</Typography.Text>
-				</div>
-			</div>
-		);
-	}
-	return null;
-}
-
-export default function HostsListTable({
-	isLoading,
-	isFetching,
-	isError,
-	tableData: data,
-	hostMetricsData,
-	filters,
-	onHostClick,
-	currentPage,
-	setCurrentPage,
-	pageSize,
-	setOrderBy,
-	setPageSize,
-	orderBy,
-}: HostsListTableProps): JSX.Element {
-	const [defaultOrderBy] = useState(orderBy);
-	const columns = useMemo(() => getHostsListColumns(defaultOrderBy), [
-		defaultOrderBy,
-	]);
-
-	const sentAnyHostMetricsData = useMemo(
-		() => data?.payload?.data?.sentAnyHostMetricsData || false,
-		[data],
-	);
-
-	const isSendingIncorrectK8SAgentMetrics = useMemo(
-		() => data?.payload?.data?.isSendingK8SAgentMetrics || false,
-		[data],
-	);
-
-	const endTimeBeforeRetention = useMemo(
-		() => data?.payload?.data?.endTimeBeforeRetention || false,
-		[data],
-	);
-
-	const formattedHostMetricsData = useMemo(
-		() => formatDataForTable(hostMetricsData),
-		[hostMetricsData],
-	);
-
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const handleTableChange: TableProps<HostRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<HostRowData> | SorterResult<HostRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: sorter.order === 'ascend' ? 'asc' : 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleRowClick = (
-		record: HostRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (isModifierKeyPressed(event)) {
-			const params = new URLSearchParams(window.location.search);
-			params.set('hostName', record.hostName);
-			openInNewTab(`${window.location.pathname}?${params.toString()}`);
-			return;
-		}
-		onHostClick(record.hostName);
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.HostEntity,
-			page: InfraMonitoringEvents.ListPage,
-		});
-	};
-
-	const showHostsEmptyState =
-		!isFetching &&
-		!isLoading &&
-		formattedHostMetricsData.length === 0 &&
-		(!sentAnyHostMetricsData || isSendingIncorrectK8SAgentMetrics) &&
-		!filters.items.length &&
-		!endTimeBeforeRetention;
-
-	const showEndTimeBeforeRetentionMessage =
-		!isFetching &&
-		!isLoading &&
-		formattedHostMetricsData.length === 0 &&
-		endTimeBeforeRetention &&
-		!filters.items.length;
-
-	const showNoRecordsInSelectedTimeRangeMessage =
-		!isFetching &&
-		!isLoading &&
-		formattedHostMetricsData.length === 0 &&
-		!showEndTimeBeforeRetentionMessage &&
-		!showHostsEmptyState;
-
-	const showTableLoadingState =
-		(isLoading || isFetching) && formattedHostMetricsData.length === 0;
-
-	const emptyOrLoadingView = EmptyOrLoadingView({
-		isError,
-		data,
-		showHostsEmptyState,
-		sentAnyHostMetricsData,
-		isSendingIncorrectK8SAgentMetrics,
-		showEndTimeBeforeRetentionMessage,
-		showNoRecordsInSelectedTimeRangeMessage,
-		showTableLoadingState,
-	});
-
-	if (emptyOrLoadingView) {
-		return <>{emptyOrLoadingView}</>;
-	}
-
-	return (
-		<Table
-			className="hosts-list-table"
-			dataSource={showTableLoadingState ? [] : formattedHostMetricsData}
-			columns={columns}
-			pagination={{
-				current: currentPage,
-				pageSize,
-				total: totalCount,
-				showSizeChanger: true,
-				hideOnSinglePage: false,
-				onChange: (page, pageSize): void => {
-					setCurrentPage(page);
-					setPageSize(pageSize);
-				},
-			}}
-			scroll={{ x: true }}
-			loading={{
-				spinning: showTableLoadingState,
-				indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-			}}
-			tableLayout="fixed"
-			rowKey={(record): string =>
-				(record as HostRowData & { key: string }).key ?? record.hostName
-			}
-			onChange={handleTableChange}
-			onRow={(record: HostRowData): Record<string, unknown> => ({
-				onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-				className: 'clickable-row',
-			})}
-		/>
-	);
-}
--- a/frontend/src/container/InfraMonitoringHosts/InfraMonitoring.styles.scss
+++ b/frontend/src/container/InfraMonitoringHosts/InfraMonitoring.styles.scss
@@ -1,416 +0,0 @@
-.infra-monitoring-container {
-	display: flex;
-	height: 100%;
-	flex-direction: column;
-
-	.infra-monitoring-header {
-		display: flex;
-		justify-content: space-between;
-		width: 100%;
-		margin-bottom: 16px;
-	}
-
-	.hosts-list-controls {
-		flex: 1;
-		padding: 8px;
-
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		gap: 16px;
-
-		.ant-select-selector {
-			border-radius: 2px;
-			border: 1px solid var(--l1-border) !important;
-			background-color: var(--l3-background) !important;
-
-			input {
-				font-size: 12px;
-			}
-
-			.ant-tag .ant-typography {
-				font-size: 12px;
-			}
-		}
-
-		.hosts-list-controls-left {
-			flex: 1;
-		}
-	}
-
-	.progress-container {
-		display: flex;
-		align-items: center;
-	}
-
-	.progress-bar {
-		flex: 1;
-		margin-right: 8px;
-	}
-
-	.clickable-row {
-		cursor: pointer;
-	}
-
-	.hosts-list-content {
-		display: flex;
-		flex-direction: row;
-		align-items: stretch;
-		height: calc(100vh - 110px);
-
-		.hosts-quick-filters-container {
-			width: 280px;
-			min-width: 280px;
-			border-right: 1px solid var(--l1-border);
-			height: 100%;
-
-			.hosts-quick-filters-container-header {
-				padding: 8px;
-				border-bottom: 1px solid var(--l1-border);
-
-				display: flex;
-				align-items: center;
-				justify-content: space-between;
-			}
-		}
-	}
-
-	.hosts-list-table-container {
-		flex: 1;
-
-		.hosts-list-table-header {
-			display: flex;
-			justify-content: space-between;
-			align-items: center;
-
-			.quick-filters-toggle-container {
-				padding: 0 8px;
-			}
-		}
-	}
-
-	.hosts-list-table {
-		.ant-table {
-			.ant-table-thead > tr > th {
-				padding: 12px;
-				font-weight: 500;
-				font-size: 12px;
-				line-height: 18px;
-
-				background: var(--l1-background);
-				border-bottom: none;
-
-				color: var(--muted-foreground);
-				font-family: Inter;
-				font-size: 11px;
-				font-style: normal;
-				font-weight: 600;
-				line-height: 18px; /* 163.636% */
-				letter-spacing: 0.44px;
-				text-transform: uppercase;
-
-				&::before {
-					background-color: transparent;
-				}
-			}
-
-			.ant-table-thead > tr > th:has(.hostname-column-header) {
-				background: var(--l2-background);
-			}
-
-			.ant-table-cell {
-				padding: 12px;
-				font-size: 13px;
-				line-height: 20px;
-				color: var(--l1-foreground);
-				background: var(--l1-background);
-			}
-
-			.ant-table-cell:has(.hostname-column-value),
-			.ant-table-cell:has(.hostname-cell-missing) {
-				background: var(--l2-background);
-			}
-
-			.hostname-column-value {
-				color: var(--l1-foreground);
-				font-family: 'Geist Mono';
-				font-style: normal;
-				font-weight: 600;
-				line-height: 20px; /* 142.857% */
-				letter-spacing: -0.07px;
-			}
-
-			.hostname-cell-missing {
-				display: flex;
-				align-items: center;
-				gap: 4px;
-			}
-
-			.hostname-cell-placeholder {
-				color: var(--muted-foreground);
-			}
-
-			.hostname-cell-warning-icon {
-				display: inline-flex;
-				align-items: center;
-				margin-left: 4px;
-				cursor: help;
-			}
-
-			.status-cell {
-				.active-tag {
-					color: var(--bg-forest-500);
-					padding: 4px 8px;
-					border-radius: 4px;
-					font-size: 12px;
-					font-weight: 500;
-				}
-			}
-
-			.progress-container {
-				.ant-progress-bg {
-					height: 8px !important;
-					border-radius: 4px;
-				}
-			}
-
-			.ant-table-tbody > tr:hover > td {
-				background: color-mix(in srgb, var(--l1-foreground) 4%, transparent);
-			}
-
-			.ant-table-cell:first-child {
-				text-align: justify;
-			}
-
-			.ant-table-cell:nth-child(2) {
-				padding-left: 16px;
-				padding-right: 16px;
-			}
-
-			.ant-table-cell:nth-child(n + 3) {
-				padding-right: 24px;
-			}
-			.status-header {
-				display: flex;
-				align-items: center;
-				gap: 4px;
-			}
-			.memory-usage-header {
-				display: flex;
-				align-items: center;
-				justify-content: flex-end;
-				gap: 4px;
-				margin-right: 4px;
-			}
-			.column-header-right {
-				text-align: right;
-			}
-			.column-header-left {
-				text-align: left;
-			}
-			.ant-table-tbody > tr > td {
-				border-bottom: none;
-			}
-
-			.ant-table-thead
-				> tr
-				> th:not(:last-child):not(.ant-table-selection-column):not(.ant-table-row-expand-icon-cell):not([colspan])::before {
-				background-color: transparent;
-			}
-
-			.ant-empty-normal {
-				visibility: hidden;
-			}
-		}
-
-		.ant-pagination {
-			position: fixed;
-			bottom: 0;
-			width: calc(100% - 364px);
-			background: var(--l1-background);
-			padding: 16px;
-			margin: 0;
-
-			// this is to offset chat support icon till we improve the design
-			right: 20px;
-
-			.ant-pagination-item {
-				border-radius: 4px;
-
-				&-active {
-					background: var(--primary-background);
-					border-color: var(--primary-background);
-
-					a {
-						color: var(--l1-foreground) !important;
-					}
-				}
-			}
-		}
-	}
-}
-
-.infra-monitoring-tags {
-	width: fit-content;
-
-	font-family: Inter;
-	font-size: 11px;
-	font-style: normal;
-	font-weight: 500;
-	line-height: 18px; /* 163.636% */
-	letter-spacing: 0.44px;
-	text-transform: uppercase;
-
-	border-radius: 50px;
-	padding: 2px 8px;
-
-	&.active {
-		color: var(--bg-forest-500);
-		border: 1px solid color-mix(in srgb, var(--bg-forest-500) 20%, transparent);
-		background: color-mix(in srgb, var(--bg-forest-500) 10%, transparent);
-	}
-
-	&.inactive {
-		color: var(--l3-foreground);
-		border: 1px solid color-mix(in srgb, var(--bg-slate-50) 20%, transparent);
-		background: color-mix(in srgb, var(--bg-slate-50) 10%, transparent);
-	}
-}
-
-.hosts-list-loading-state {
-	padding: 8px;
-	display: flex;
-	flex-direction: column;
-	gap: 2px;
-	flex: 1;
-
-	.hosts-list-loading-state-item {
-		height: 48px;
-		width: 100%;
-	}
-}
-
-.no-filtered-hosts-message-container {
-	flex: 1;
-	height: 30vh;
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-
-	.no-filtered-hosts-message-content {
-		display: flex;
-		flex-direction: column;
-		align-items: flex-start;
-		justify-content: center;
-
-		width: fit-content;
-		padding: 24px;
-	}
-
-	.no-filtered-hosts-message {
-		margin-top: 8px;
-	}
-}
-
-.hosts-empty-state-container {
-	padding: 16px;
-	height: 40vh;
-	flex: 1;
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-
-	.hosts-empty-state-container-content {
-		padding: 16px;
-		display: flex;
-		flex-direction: column;
-		align-items: flex-start;
-		justify-content: center;
-
-		width: fit-content;
-
-		.no-hosts-message {
-			margin-bottom: 16px;
-
-			.no-hosts-message-title {
-				margin-top: 8px;
-				margin-bottom: 4px;
-			}
-		}
-	}
-}
-
-.lightMode {
-	.infra-monitoring-container {
-		.ant-table-thead > tr > th {
-			background: var(--l1-background);
-			color: var(--l1-foreground);
-		}
-
-		.ant-table-cell {
-			color: var(--l1-foreground);
-		}
-		.hosts-list-controls {
-			border-top: 1px solid var(--l1-border);
-			border-bottom: 1px solid var(--l1-border);
-
-			.ant-select-selector {
-				border-color: var(--l1-border) !important;
-				background-color: var(--l1-background) !important;
-				color: var(--l2-foreground);
-			}
-		}
-	}
-
-	.hosts-list-table {
-		.ant-table {
-			.ant-table-thead > tr > th {
-				background: var(--l1-background);
-				color: var(--l2-foreground);
-			}
-
-			.ant-table-thead > tr > th:has(.hostname-column-header) {
-				background: var(--l1-background);
-			}
-
-			.ant-table-cell {
-				background: var(--l1-background);
-				color: var(--l1-foreground);
-			}
-
-			.ant-table-cell:has(.hostname-column-value),
-			.ant-table-cell:has(.hostname-cell-missing) {
-				background: var(--l1-background);
-			}
-
-			.hostname-column-value {
-				color: var(--l1-foreground);
-			}
-
-			.hostname-cell-placeholder {
-				color: var(--l2-foreground);
-			}
-
-			.ant-table-tbody > tr:hover > td {
-				background: rgba(0, 0, 0, 0.04);
-			}
-		}
-
-		.ant-pagination {
-			background: var(--l1-background);
-
-			.ant-pagination-item {
-				&-active {
-					background: var(--primary-background);
-					border-color: var(--primary-background);
-
-					a {
-						color: var(--l1-background) !important;
-					}
-				}
-			}
-		}
-	}
-}
--- a/frontend/src/container/InfraMonitoringHosts/InfraMonitoringHosts.module.scss
+++ b/frontend/src/container/InfraMonitoringHosts/InfraMonitoringHosts.module.scss
@@ -0,0 +1,175 @@
+.infraMonitoringContainer {
+	display: flex;
+	height: 100%;
+	flex-direction: column;
+}
+
+.infraContentRow {
+	display: flex;
+	flex-direction: row;
+	height: calc(100vh - 45px);
+	width: 100%;
+	position: relative;
+	overflow-y: auto;
+
+	:global(.periscope-btn) {
+		&.ghost:not(:disabled) {
+			border: none;
+			background: transparent;
+
+			&:hover {
+				background: transparent;
+				color: var(--bg-robin-500) !important;
+				font-weight: 500;
+			}
+		}
+	}
+
+	&::-webkit-scrollbar {
+		width: 0.1rem;
+		height: 0.1rem;
+	}
+
+	&::-webkit-scrollbar-track {
+		background: transparent;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background: var(--accent-primary);
+	}
+
+	&::-webkit-scrollbar-thumb:hover {
+		background: colox-mix(var(--accent-primary), var(--bg-vanilla-100), 20%);
+	}
+}
+
+.quickFiltersContainer {
+	width: 280px;
+	min-width: 280px;
+	border-right: 1px solid var(--l1-border);
+	overflow-y: auto;
+
+	&::-webkit-scrollbar {
+		width: 0.1rem;
+		height: 0.1rem;
+	}
+
+	&::-webkit-scrollbar-track {
+		background: transparent;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background: var(--accent-primary);
+	}
+
+	&::-webkit-scrollbar-thumb:hover {
+		background: colox-mix(var(--accent-primary), var(--bg-vanilla-100), 20%);
+	}
+
+	:global(.ant-collapse-header) {
+		border-bottom: 1px solid var(--l1-border);
+		padding: 12px 8px;
+	}
+
+	:global(.ant-collapse-content-box) {
+		padding: 0 !important;
+		padding-block: 0 !important;
+
+		:global(.quick-filters .checkbox-filter) {
+			padding-left: 18px;
+		}
+	}
+
+	:global(.quick-filters) {
+		overflow-y: auto;
+		overflow-x: hidden;
+
+		&::-webkit-scrollbar {
+			width: 0.1rem;
+			height: 0.1rem;
+		}
+
+		&::-webkit-scrollbar-track {
+			background: transparent;
+		}
+
+		&::-webkit-scrollbar-thumb {
+			background: var(--accent-primary);
+		}
+
+		&::-webkit-scrollbar-thumb:hover {
+			background: colox-mix(var(--accent-primary), var(--bg-vanilla-100), 20%);
+		}
+	}
+}
+
+.quickFiltersContainerHeader {
+	padding: 8px;
+	border-bottom: 1px solid var(--l1-border);
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+}
+
+.listContainer {
+	flex: 1;
+	min-width: 0;
+	max-width: 100%;
+	display: flex;
+	flex-direction: column;
+	align-items: stretch;
+
+	> * {
+		min-width: 0;
+		max-width: 100%;
+		box-sizing: border-box;
+	}
+
+	> :global(.ant-table-wrapper) {
+		width: 100%;
+		max-width: 100%;
+
+		:global(.ant-spin-container) {
+			display: flex !important;
+			flex-direction: column;
+		}
+
+		:global(.ant-table),
+		:global(.ant-table-container) {
+			max-width: 100%;
+		}
+	}
+}
+
+.listContainerFiltersVisible {
+	max-width: calc(100% - 280px);
+}
+
+.quickFiltersToggleContainer {
+	padding: 0 8px;
+}
+
+.infraMonitoringTags {
+	width: fit-content;
+	font-family: Inter;
+	font-size: 11px;
+	font-style: normal;
+	font-weight: 500;
+	line-height: 18px;
+	letter-spacing: 0.44px;
+	text-transform: uppercase;
+	border-radius: 50px;
+	padding: 2px 8px;
+}
+
+.tagsActive {
+	color: var(--bg-forest-500, #25e192);
+	border: 1px solid rgba(37, 225, 146, 0.2);
+	background: rgba(37, 225, 146, 0.1);
+}
+
+.tagsInactive {
+	color: var(--bg-slate-50, #62687c);
+	border: 1px solid rgba(98, 104, 124, 0.2);
+	background: rgba(98, 104, 124, 0.1);
+}
--- a/frontend/src/container/InfraMonitoringHosts/tests/HostsEmptyOrIncorrectMetrics.test.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/tests/HostsEmptyOrIncorrectMetrics.test.tsx
@@ -1,43 +0,0 @@
-import { render, screen } from '@testing-library/react';
-
-import HostsEmptyOrIncorrectMetrics from '../HostsEmptyOrIncorrectMetrics';
-
-describe('HostsEmptyOrIncorrectMetrics', () => {
-	it('shows no data message when noData is true', () => {
-		render(<HostsEmptyOrIncorrectMetrics noData incorrectData={false} />);
-		expect(
-			screen.getByText('No host metrics data received yet.'),
-		).toBeInTheDocument();
-		expect(
-			screen.getByText(/Infrastructure monitoring requires the/),
-		).toBeInTheDocument();
-	});
-
-	it('shows incorrect data message when incorrectData is true', () => {
-		render(<HostsEmptyOrIncorrectMetrics noData={false} incorrectData />);
-		expect(
-			screen.getByText(
-				'To see host metrics, upgrade to the latest version of SigNoz k8s-infra chart. Please contact support if you need help.',
-			),
-		).toBeInTheDocument();
-	});
-
-	it('does not show no data message when noData is false', () => {
-		render(<HostsEmptyOrIncorrectMetrics noData={false} incorrectData={false} />);
-		expect(
-			screen.queryByText('No host metrics data received yet.'),
-		).not.toBeInTheDocument();
-		expect(
-			screen.queryByText(/Infrastructure monitoring requires the/),
-		).not.toBeInTheDocument();
-	});
-
-	it('does not show incorrect data message when incorrectData is false', () => {
-		render(<HostsEmptyOrIncorrectMetrics noData={false} incorrectData={false} />);
-		expect(
-			screen.queryByText(
-				'To see host metrics, upgrade to the latest version of SigNoz k8s-infra chart. Please contact support if you need help.',
-			),
-		).not.toBeInTheDocument();
-	});
-});
--- a/frontend/src/container/InfraMonitoringHosts/tests/HostsList.test.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/tests/HostsList.test.tsx
@@ -4,13 +4,16 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { render, waitFor } from '@testing-library/react';
 import * as getHostListsApi from 'api/infraMonitoring/getHostLists';
+import { initialQueriesMap } from 'constants/queryBuilder';
+import * as useQueryBuilderHooks from 'hooks/queryBuilder/useQueryBuilder';
+import * as useQueryBuilderOperations from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import * as appContextHooks from 'providers/App/App';
 import * as timezoneHooks from 'providers/Timezone';
 import store from 'store';
 import { LicenseEvent } from 'types/api/licensesV3/getActive';

-import HostsList from '../HostsList';
+import Hosts from '../Hosts';

 jest.mock('lib/getMinMax', () => ({
 	__esModule: true,
@@ -30,10 +33,6 @@ jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
 		<div data-testid="date-time-selection">Date Time</div>
 	),
 }));
-jest.mock('components/HostMetricsDetail', () => ({
-	__esModule: true,
-	default: (): null => null,
-}));
 jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
 	__esModule: true,
 	default: ({ onSelect, selectedTime, selectedValue }: any): JSX.Element => (
@@ -53,20 +52,6 @@ const queryClient = new QueryClient({
 	},
 });

-jest.mock('react-redux', () => ({
-	...jest.requireActual('react-redux'),
-	useSelector: (): any => ({
-		globalTime: {
-			selectedTime: {
-				startTime: 1713734400000,
-				endTime: 1713738000000,
-			},
-			maxTime: 1713738000000,
-			minTime: 1713734400000,
-		},
-	}),
-}));
-
 jest.mock('react-router-dom', () => {
 	const ROUTES = jest.requireActual('constants/routes').default;
 	return {
@@ -128,6 +113,7 @@ jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
 	user: {
 		role: 'admin',
 	},
+	featureFlags: [],
 	activeLicenseV3: {
 		event_queue: {
 			created_at: '0',
@@ -148,9 +134,22 @@ jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
 	},
 } as any);

+jest.spyOn(useQueryBuilderHooks, 'useQueryBuilder').mockReturnValue({
+	currentQuery: initialQueriesMap.metrics,
+	setSupersetQuery: jest.fn(),
+	setLastUsedQuery: jest.fn(),
+	handleSetConfig: jest.fn(),
+	resetQuery: jest.fn(),
+	updateAllQueriesOperators: jest.fn(),
+} as any);
+
+jest.spyOn(useQueryBuilderOperations, 'useQueryOperations').mockReturnValue({
+	handleChangeQueryData: jest.fn(),
+} as any);
+
 const Wrapper = withNuqsTestingAdapter({ searchParams: {} });

-describe('HostsList', () => {
+describe('Hosts', () => {
 	beforeEach(() => {
 		queryClient.clear();
 	});
@@ -161,14 +160,14 @@ describe('HostsList', () => {
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter>
 						<Provider store={store}>
-							<HostsList />
+							<Hosts />
 						</Provider>
 					</MemoryRouter>
 				</QueryClientProvider>
 			</Wrapper>,
 		);
 		await waitFor(() => {
-			expect(container.querySelector('.hosts-list-table')).toBeInTheDocument();
+			expect(container.querySelector('.ant-table')).toBeInTheDocument();
 		});
 	});

@@ -178,7 +177,7 @@ describe('HostsList', () => {
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter>
 						<Provider store={store}>
-							<HostsList />
+							<Hosts />
 						</Provider>
 					</MemoryRouter>
 				</QueryClientProvider>
--- a/frontend/src/container/InfraMonitoringHosts/tests/HostsListControl.test.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/tests/HostsListControl.test.tsx
@@ -1,38 +0,0 @@
-import { render, screen } from '@testing-library/react';
-
-import HostsListControls from '../HostsListControls';
-
-jest.mock('container/QueryBuilder/filters/QueryBuilderSearch', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="query-builder-search">Search</div>
-	),
-}));
-
-jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="date-time-selection">Date Time</div>
-	),
-}));
-
-describe('HostsListControls', () => {
-	const mockHandleFiltersChange = jest.fn();
-	const mockFilters = {
-		items: [],
-		op: 'AND',
-	};
-
-	it('renders search and date time filters', () => {
-		render(
-			<HostsListControls
-				handleFiltersChange={mockHandleFiltersChange}
-				filters={mockFilters}
-				showAutoRefresh={false}
-			/>,
-		);
-
-		expect(screen.getByTestId('query-builder-search')).toBeInTheDocument();
-		expect(screen.getByTestId('date-time-selection')).toBeInTheDocument();
-	});
-});
--- a/frontend/src/container/InfraMonitoringHosts/tests/HostsListTable.test.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/tests/HostsListTable.test.tsx
@@ -1,276 +0,0 @@
-import { render, screen } from '@testing-library/react';
-import { HostData, HostListResponse } from 'api/infraMonitoring/getHostLists';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-
-import HostsListTable from '../HostsListTable';
-import { HostsListTableProps } from '../utils';
-
-const EMPTY_STATE_CONTAINER_CLASS = '.hosts-empty-state-container';
-
-const createMockHost = (): HostData =>
-	({
-		hostName: 'test-host-1',
-		active: true,
-		cpu: 0.75,
-		memory: 0.65,
-		wait: 0.03,
-		load15: 1.5,
-		os: 'linux',
-		cpuTimeSeries: { labels: {}, labelsArray: [], values: [] },
-		memoryTimeSeries: { labels: {}, labelsArray: [], values: [] },
-		waitTimeSeries: { labels: {}, labelsArray: [], values: [] },
-		load15TimeSeries: { labels: {}, labelsArray: [], values: [] },
-	} as HostData);
-
-const createMockTableData = (
-	overrides: Partial<HostListResponse['data']> = {},
-): SuccessResponse<HostListResponse> => {
-	const mockHost = createMockHost();
-	return {
-		statusCode: 200,
-		message: 'Success',
-		error: null,
-		payload: {
-			status: 'success',
-			data: {
-				type: 'list',
-				records: [mockHost],
-				groups: null,
-				total: 1,
-				sentAnyHostMetricsData: true,
-				isSendingK8SAgentMetrics: false,
-				endTimeBeforeRetention: false,
-				...overrides,
-			},
-		},
-	};
-};
-
-describe('HostsListTable', () => {
-	const mockHost = createMockHost();
-	const mockTableData = createMockTableData();
-
-	const mockOnHostClick = jest.fn();
-	const mockSetCurrentPage = jest.fn();
-	const mockSetOrderBy = jest.fn();
-	const mockSetPageSize = jest.fn();
-
-	const mockProps: HostsListTableProps = {
-		isLoading: false,
-		isError: false,
-		isFetching: false,
-		tableData: mockTableData,
-		hostMetricsData: [mockHost],
-		filters: {
-			items: [],
-			op: 'AND',
-		},
-		onHostClick: mockOnHostClick,
-		currentPage: 1,
-		setCurrentPage: mockSetCurrentPage,
-		pageSize: 10,
-		setOrderBy: mockSetOrderBy,
-		setPageSize: mockSetPageSize,
-		orderBy: null,
-	};
-
-	it('renders loading state if isLoading is true and tableData is empty', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				isLoading
-				hostMetricsData={[]}
-				tableData={createMockTableData({ records: [] })}
-			/>,
-		);
-		expect(container.querySelector('.hosts-list-loading-state')).toBeTruthy();
-	});
-
-	it('renders loading state if isFetching is true and tableData is empty', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				isFetching
-				hostMetricsData={[]}
-				tableData={createMockTableData({ records: [] })}
-			/>,
-		);
-		expect(container.querySelector('.hosts-list-loading-state')).toBeTruthy();
-	});
-
-	it('renders error state if isError is true', () => {
-		render(<HostsListTable {...mockProps} isError />);
-		expect(screen.getByText('Something went wrong')).toBeTruthy();
-	});
-
-	it('renders "Something went wrong" fallback when isError is true and error message is empty', () => {
-		const tableDataWithEmptyError: ErrorResponse = {
-			statusCode: 500,
-			payload: null,
-			error: '',
-			message: null,
-		};
-		render(
-			<HostsListTable
-				{...mockProps}
-				isError
-				hostMetricsData={[]}
-				tableData={tableDataWithEmptyError}
-			/>,
-		);
-		expect(screen.getByText('Something went wrong')).toBeInTheDocument();
-	});
-
-	it('renders custom error message when isError is true and error message is provided', () => {
-		const customErrorMessage = 'Failed to fetch host metrics';
-		const tableDataWithError: ErrorResponse = {
-			statusCode: 500,
-			payload: null,
-			error: customErrorMessage,
-			message: null,
-		};
-		render(
-			<HostsListTable
-				{...mockProps}
-				isError
-				hostMetricsData={[]}
-				tableData={tableDataWithError}
-			/>,
-		);
-		expect(screen.getByText(customErrorMessage)).toBeInTheDocument();
-	});
-
-	it('renders empty state if no hosts are found', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				tableData={createMockTableData({
-					records: [],
-				})}
-			/>,
-		);
-		expect(
-			container.querySelector('.no-filtered-hosts-message-container'),
-		).toBeTruthy();
-	});
-
-	it('renders empty state if sentAnyHostMetricsData is false', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				tableData={createMockTableData({
-					sentAnyHostMetricsData: false,
-					records: [],
-				})}
-			/>,
-		);
-		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
-	});
-
-	it('renders empty state if isSendingK8SAgentMetrics is true', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				tableData={createMockTableData({
-					isSendingK8SAgentMetrics: true,
-					records: [],
-				})}
-			/>,
-		);
-		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
-	});
-
-	it('renders end time before retention message when endTimeBeforeRetention is true', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				tableData={createMockTableData({
-					sentAnyHostMetricsData: true,
-					isSendingK8SAgentMetrics: false,
-					endTimeBeforeRetention: true,
-					records: [],
-				})}
-			/>,
-		);
-		expect(container.querySelector(EMPTY_STATE_CONTAINER_CLASS)).toBeTruthy();
-		expect(
-			screen.getByText(
-				/Your requested end time is earlier than the earliest detected time of host metrics data, please adjust your end time\./,
-			),
-		).toBeInTheDocument();
-	});
-
-	it('renders no records message when noRecordsInSelectedTimeRangeAndFilters is true', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				tableData={createMockTableData({
-					sentAnyHostMetricsData: true,
-					isSendingK8SAgentMetrics: false,
-					records: [],
-				})}
-			/>,
-		);
-		expect(
-			container.querySelector('.no-filtered-hosts-message-container'),
-		).toBeTruthy();
-		expect(
-			screen.getByText(/No host metrics in the selected time range and filters/),
-		).toBeInTheDocument();
-	});
-
-	it('renders no filtered hosts message when filters are present and no hosts are found', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				hostMetricsData={[]}
-				filters={{
-					items: [
-						{
-							id: 'host_name',
-							key: {
-								key: 'host_name',
-								dataType: DataTypes.String,
-								type: 'tag',
-								isIndexed: true,
-							},
-							op: '=',
-							value: 'unknown',
-						},
-					],
-					op: 'AND',
-				}}
-				tableData={createMockTableData({
-					sentAnyHostMetricsData: true,
-					isSendingK8SAgentMetrics: false,
-					records: [],
-				})}
-			/>,
-		);
-		expect(container.querySelector('.no-filtered-hosts-message')).toBeTruthy();
-		expect(
-			screen.getByText(
-				/No host metrics in the selected time range and filters\. Please adjust your time range or filters\./,
-			),
-		).toBeInTheDocument();
-	});
-
-	it('renders table data', () => {
-		const { container } = render(
-			<HostsListTable
-				{...mockProps}
-				tableData={createMockTableData({
-					isSendingK8SAgentMetrics: false,
-					sentAnyHostMetricsData: true,
-				})}
-			/>,
-		);
-		expect(container.querySelector('.hosts-list-table')).toBeTruthy();
-	});
-});
--- a/frontend/src/container/InfraMonitoringHosts/tests/utilts.test.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/tests/utilts.test.tsx
@@ -1,13 +1,8 @@
 import { render, screen } from '@testing-library/react';
 import { HostData, TimeSeries } from 'api/infraMonitoring/getHostLists';

-import {
-	formatDataForTable,
-	GetHostsQuickFiltersConfig,
-	HostnameCell,
-} from '../utils';
-
-const PROGRESS_BAR_CLASS = '.progress-bar';
+import { hostRenderRowData } from '../table.config';
+import { getHostsQuickFiltersConfig, HostnameCell } from '../utils';

 const emptyTimeSeries: TimeSeries = {
 	labels: {},
@@ -16,94 +11,79 @@ const emptyTimeSeries: TimeSeries = {
 };

 describe('InfraMonitoringHosts utils', () => {
-	describe('formatDataForTable', () => {
+	describe('hostRenderRowData', () => {
 		it('should format host data correctly', () => {
-			const mockData: HostData[] = [
-				{
-					hostName: 'test-host',
-					active: true,
-					cpu: 0.95,
-					memory: 0.85,
-					wait: 0.05,
-					load15: 2.5,
-					os: 'linux',
-					cpuTimeSeries: emptyTimeSeries,
-					memoryTimeSeries: emptyTimeSeries,
-					waitTimeSeries: emptyTimeSeries,
-					load15TimeSeries: emptyTimeSeries,
-				},
-			];
+			const host: HostData = {
+				hostName: 'test-host',
+				active: true,
+				cpu: 0.95,
+				memory: 0.85,
+				wait: 0.05,
+				load15: 2.5,
+				os: 'linux',
+				cpuTimeSeries: emptyTimeSeries,
+				memoryTimeSeries: emptyTimeSeries,
+				waitTimeSeries: emptyTimeSeries,
+				load15TimeSeries: emptyTimeSeries,
+			};

-			const result = formatDataForTable(mockData);
+			const result = hostRenderRowData(host, []);

-			expect(result[0].hostName).toBe('test-host');
-			expect(result[0].wait).toBe('5%');
-			expect(result[0].load15).toBe(2.5);
+			expect(result.wait).toBe('5%');
+			expect(result.load15).toBe(2.5);
+			expect(result.itemKey).toBe('test-host');
+			expect(result.hostName).toBe('test-host');

-			// Test active tag rendering
-			const activeTag = render(result[0].active as JSX.Element);
+			const activeTag = render(result.active as JSX.Element);
 			expect(activeTag.container.textContent).toBe('ACTIVE');
-			expect(activeTag.container.querySelector('.active')).toBeTruthy();
+			expect(activeTag.getByText('ACTIVE')).toBeTruthy();

-			// Test CPU progress bar
-			const cpuProgress = render(result[0].cpu as JSX.Element);
-			const cpuProgressBar = cpuProgress.container.querySelector(
-				PROGRESS_BAR_CLASS,
-			);
-			expect(cpuProgressBar).toBeTruthy();
+			const cpuProgress = render(result.cpu as JSX.Element);
+			expect(cpuProgress.container.querySelector('.ant-progress')).toBeTruthy();

-			// Test memory progress bar
-			const memoryProgress = render(result[0].memory as JSX.Element);
-			const memoryProgressBar = memoryProgress.container.querySelector(
-				PROGRESS_BAR_CLASS,
-			);
-			expect(memoryProgressBar).toBeTruthy();
+			const memoryProgress = render(result.memory as JSX.Element);
+			expect(memoryProgress.container.querySelector('.ant-progress')).toBeTruthy();
 		});

 		it('should handle inactive hosts', () => {
-			const mockData: HostData[] = [
-				{
-					hostName: 'test-host',
-					active: false,
-					cpu: 0.3,
-					memory: 0.4,
-					wait: 0.02,
-					load15: 1.2,
-					os: 'linux',
-					cpuTimeSeries: emptyTimeSeries,
-					memoryTimeSeries: emptyTimeSeries,
-					waitTimeSeries: emptyTimeSeries,
-					load15TimeSeries: emptyTimeSeries,
-				},
-			];
+			const host: HostData = {
+				hostName: 'test-host',
+				active: false,
+				cpu: 0.3,
+				memory: 0.4,
+				wait: 0.02,
+				load15: 1.2,
+				os: 'linux',
+				cpuTimeSeries: emptyTimeSeries,
+				memoryTimeSeries: emptyTimeSeries,
+				waitTimeSeries: emptyTimeSeries,
+				load15TimeSeries: emptyTimeSeries,
+			};

-			const result = formatDataForTable(mockData);
+			const result = hostRenderRowData(host, []);

-			const inactiveTag = render(result[0].active as JSX.Element);
+			const inactiveTag = render(result.active as JSX.Element);
 			expect(inactiveTag.container.textContent).toBe('INACTIVE');
-			expect(inactiveTag.container.querySelector('.inactive')).toBeTruthy();
+			expect(inactiveTag.getByText('INACTIVE')).toBeTruthy();
 		});

-		it('should set hostName to empty string when host has no hostname', () => {
-			const mockData: HostData[] = [
-				{
-					hostName: '',
-					active: true,
-					cpu: 0.5,
-					memory: 0.4,
-					wait: 0.01,
-					load15: 1.0,
-					os: 'linux',
-					cpuTimeSeries: emptyTimeSeries,
-					memoryTimeSeries: emptyTimeSeries,
-					waitTimeSeries: emptyTimeSeries,
-					load15TimeSeries: emptyTimeSeries,
-				},
-			];
+		it('should use empty itemKey when host has no hostname', () => {
+			const host: HostData = {
+				hostName: '',
+				active: true,
+				cpu: 0.5,
+				memory: 0.4,
+				wait: 0.01,
+				load15: 1.0,
+				os: 'linux',
+				cpuTimeSeries: emptyTimeSeries,
+				memoryTimeSeries: emptyTimeSeries,
+				waitTimeSeries: emptyTimeSeries,
+				load15TimeSeries: emptyTimeSeries,
+			};

-			const result = formatDataForTable(mockData);
-			expect(result[0].hostName).toBe('');
-			expect(result[0].key).toBe('-0');
+			const result = hostRenderRowData(host, []);
+			expect(result.itemKey).toBe('');
 		});
 	});

@@ -126,7 +106,6 @@ describe('InfraMonitoringHosts utils', () => {
 				'Missing host.name metadata',
 			);
 			expect(iconWrapper?.getAttribute('tabindex')).toBe('0');
-			// Tooltip with "Learn how to configure →" link is shown on hover/focus
 		});

 		it('should render placeholder and icon when hostName is whitespace only (case C)', () => {
@@ -144,9 +123,9 @@ describe('InfraMonitoringHosts utils', () => {
 		});
 	});

-	describe('GetHostsQuickFiltersConfig', () => {
+	describe('getHostsQuickFiltersConfig', () => {
 		it('should return correct config when dotMetricsEnabled is true', () => {
-			const result = GetHostsQuickFiltersConfig(true);
+			const result = getHostsQuickFiltersConfig(true);

 			expect(result[0].attributeKey.key).toBe('host.name');
 			expect(result[1].attributeKey.key).toBe('os.type');
@@ -154,7 +133,7 @@ describe('InfraMonitoringHosts utils', () => {
 		});

 		it('should return correct config when dotMetricsEnabled is false', () => {
-			const result = GetHostsQuickFiltersConfig(false);
+			const result = getHostsQuickFiltersConfig(false);

 			expect(result[0].attributeKey.key).toBe('host_name');
 			expect(result[1].attributeKey.key).toBe('os_type');
--- a/frontend/src/container/InfraMonitoringHosts/constants.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/constants.tsx
@@ -0,0 +1,189 @@
+import React from 'react';
+import { Color } from '@signozhq/design-tokens';
+import { Progress, Tag, Typography } from 'antd';
+import {
+	getHostLists,
+	HostData,
+	HostListPayload,
+} from 'api/infraMonitoring/getHostLists';
+import {
+	createFilterItem,
+	K8sDetailsFilters,
+	K8sDetailsMetadataConfig,
+} from 'container/InfraMonitoringK8s/Base/K8sBaseDetails';
+import { K8sBaseFilters } from 'container/InfraMonitoringK8s/Base/types';
+import {
+	getHostQueryPayload,
+	hostWidgetInfo,
+} from 'container/LogDetailedView/InfraMetrics/constants';
+import {
+	TagFilter,
+	TagFilterItem,
+} from 'types/api/queryBuilder/queryBuilderData';
+
+import { getHostListsQuery } from './utils';
+
+import infraHostsStyles from './InfraMonitoringHosts.module.scss';
+
+export function getProgressColor(percent: number): string {
+	if (percent >= 90) {
+		return Color.BG_SAKURA_500;
+	}
+	if (percent >= 60) {
+		return Color.BG_AMBER_500;
+	}
+	return Color.BG_FOREST_500;
+}
+
+export function getMemoryProgressColor(percent: number): string {
+	if (percent >= 90) {
+		return Color.BG_CHERRY_500;
+	}
+	if (percent >= 60) {
+		return Color.BG_AMBER_500;
+	}
+	return Color.BG_FOREST_500;
+}
+
+export const hostDetailsMetadataConfig: K8sDetailsMetadataConfig<HostData>[] = [
+	{
+		label: 'STATUS',
+		getValue: (h): string => (h.active ? 'ACTIVE' : 'INACTIVE'),
+		render: (value, h): React.ReactNode => (
+			<Tag
+				className={`${infraHostsStyles.infraMonitoringTags} ${
+					h.active ? infraHostsStyles.tagsActive : infraHostsStyles.tagsInactive
+				}`}
+				bordered
+			>
+				{value}
+			</Tag>
+		),
+	},
+	{
+		label: 'OPERATING SYSTEM',
+		getValue: (h): string => h.os || '-',
+		render: (value): React.ReactNode =>
+			value !== '-' ? (
+				<Tag className={infraHostsStyles.infraMonitoringTags} bordered>
+					{value}
+				</Tag>
+			) : (
+				<Typography.Text>-</Typography.Text>
+			),
+	},
+	{
+		label: 'CPU USAGE',
+		getValue: (h): number => h.cpu * 100,
+		render: (value): React.ReactNode => (
+			<Progress
+				percent={Number(Number(value).toFixed(1))}
+				size="small"
+				strokeColor={getProgressColor(Number(value))}
+			/>
+		),
+	},
+	{
+		label: 'MEMORY USAGE',
+		getValue: (h): number => h.memory * 100,
+		render: (value): React.ReactNode => (
+			<Progress
+				percent={Number(Number(value).toFixed(1))}
+				size="small"
+				strokeColor={getMemoryProgressColor(Number(value))}
+			/>
+		),
+	},
+];
+
+export function getHostMetricsQueryPayload(
+	host: HostData,
+	start: number,
+	end: number,
+	dotMetricsEnabled: boolean,
+): ReturnType<typeof getHostQueryPayload> {
+	return getHostQueryPayload(host.hostName, start, end, dotMetricsEnabled);
+}
+
+export { hostWidgetInfo };
+
+export function hostGetSelectedItemFilters(
+	selectedItem: string,
+	dotMetricsEnabled: boolean,
+): TagFilter {
+	const hostKey = dotMetricsEnabled ? 'host.name' : 'host_name';
+	return {
+		op: 'AND',
+		items: [createFilterItem(hostKey, selectedItem)],
+	};
+}
+
+export function hostInitialLogTracesFilter(
+	host: HostData,
+	dotMetricsEnabled: boolean,
+): TagFilterItem[] {
+	const hostKey = dotMetricsEnabled ? 'host.name' : 'host_name';
+	return [createFilterItem(hostKey, host.hostName || '')];
+}
+
+export function hostInitialEventsFilter(_host: HostData): TagFilterItem[] {
+	return [];
+}
+
+export const hostGetEntityName = (host: HostData): string => host.hostName;
+
+export async function fetchHostListData(
+	filters: K8sBaseFilters,
+	signal?: AbortSignal,
+): Promise<{
+	data: HostData[];
+	total: number;
+	error?: string | null;
+	rawData?: unknown;
+}> {
+	const baseQuery = getHostListsQuery();
+	const payload: HostListPayload = {
+		...baseQuery,
+		limit: filters.limit,
+		offset: filters.offset,
+		filters: filters.filters ?? { items: [], op: 'and' },
+		orderBy: filters.orderBy,
+		start: filters.start,
+		end: filters.end,
+		groupBy: filters.groupBy ?? [],
+	};
+
+	const response = await getHostLists(payload, signal);
+
+	return {
+		data: response.payload?.data?.records || [],
+		total: response.payload?.data?.total || 0,
+		error: response.error,
+		rawData: response.payload?.data,
+	};
+}
+
+export async function fetchHostEntityData(
+	filters: K8sDetailsFilters,
+	signal?: AbortSignal,
+): Promise<{ data: HostData | null; error?: string | null }> {
+	const response = await getHostLists(
+		{
+			...getHostListsQuery(),
+			filters: filters.filters,
+			start: filters.start,
+			end: filters.end,
+			limit: 1,
+			offset: 0,
+			groupBy: [],
+		},
+		signal,
+	);
+
+	const records = response.payload?.data?.records || [];
+
+	return {
+		data: records.length > 0 ? records[0] : null,
+		error: response.error,
+	};
+}
--- a/frontend/src/container/InfraMonitoringHosts/index.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/index.tsx
@@ -5,9 +5,7 @@ import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
 import { DataSource } from 'types/common/queryBuilder';

-import HostsList from './HostsList';
-
-import './InfraMonitoring.styles.scss';
+import Hosts from './Hosts';

 function InfraMonitoringHosts(): JSX.Element {
 	const {
@@ -63,11 +61,7 @@ function InfraMonitoringHosts(): JSX.Element {

 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
-			<div className="infra-monitoring-container">
-				<div className="hosts-list-container">
-					<HostsList />
-				</div>
-			</div>
+			<Hosts />
 		</Sentry.ErrorBoundary>
 	);
 }
--- a/frontend/src/container/InfraMonitoringHosts/table.config.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/table.config.tsx
@@ -0,0 +1,234 @@
+import React from 'react';
+import { InfoCircleOutlined } from '@ant-design/icons';
+import { Progress, TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { HostData } from 'api/infraMonitoring/getHostLists';
+import { K8sRenderedRowData } from 'container/InfraMonitoringK8s/Base/types';
+import { IEntityColumn } from 'container/InfraMonitoringK8s/Base/useInfraMonitoringTableColumnsStore';
+import {
+	getGroupByEl,
+	getGroupedByMeta,
+	getRowKey,
+} from 'container/InfraMonitoringK8s/Base/utils';
+import { ValidateColumnValueWrapper } from 'container/InfraMonitoringK8s/commonUtils';
+import { InfraMonitoringEntity } from 'container/InfraMonitoringK8s/constants';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { getMemoryProgressColor, getProgressColor } from './constants';
+import { HostnameCell } from './utils';
+
+import styles from './table.module.scss';
+
+export const hostColumns: IEntityColumn[] = [
+	{
+		label: 'Host group',
+		value: 'hostGroup',
+		id: 'hostGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Hostname',
+		value: 'hostName',
+		id: 'hostName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Status',
+		value: 'active',
+		id: 'active',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'IOWait',
+		value: 'wait',
+		id: 'wait',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Load Avg',
+		value: 'load15',
+		id: 'load15',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const hostColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> HOST GROUP
+			</div>
+		),
+		dataIndex: 'hostGroup',
+		key: 'hostGroup',
+		ellipsis: true,
+		width: 180,
+		sorter: false,
+	},
+	{
+		title: <div className={styles.hostnameColumnHeader}>Hostname</div>,
+		dataIndex: 'hostName',
+		key: 'hostName',
+		width: 250,
+		render: (_value, record): React.ReactNode => (
+			<HostnameCell
+				hostName={typeof record.hostName === 'string' ? record.hostName : ''}
+			/>
+		),
+	},
+	{
+		title: (
+			<div className={styles.statusHeader}>
+				Status
+				<Tooltip title="Sent system metrics in last 10 mins">
+					<InfoCircleOutlined />
+				</Tooltip>
+			</div>
+		),
+		dataIndex: 'active',
+		key: 'active',
+		width: 100,
+	},
+	{
+		title: <div className={styles.columnHeaderRight}>CPU Usage</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 100,
+		sorter: true,
+		align: 'right',
+	},
+	{
+		title: (
+			<div className={`${styles.columnHeaderRight} ${styles.memoryUsageHeader}`}>
+				Memory Usage
+				<Tooltip title="Excluding cache memory">
+					<InfoCircleOutlined />
+				</Tooltip>
+			</div>
+		),
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 100,
+		sorter: true,
+		align: 'right',
+	},
+	{
+		title: <div className={styles.columnHeaderRight}>IOWait</div>,
+		dataIndex: 'wait',
+		key: 'wait',
+		width: 100,
+		sorter: true,
+		align: 'right',
+	},
+	{
+		title: <div className={styles.columnHeaderRight}>Load Avg</div>,
+		dataIndex: 'load15',
+		key: 'load15',
+		width: 100,
+		sorter: true,
+		align: 'right',
+	},
+];
+
+function hostRowSource(host: HostData): { meta: Record<string, string> } {
+	return {
+		meta: {
+			...(host.meta ?? {}),
+			host_name: host.hostName ?? '',
+			'host.name': host.hostName ?? '',
+			os_type: host.os ?? '',
+			'os.type': host.os ?? '',
+		},
+	};
+}
+
+export const hostRenderRowData = (
+	host: HostData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => {
+	const synthetic = hostRowSource(host);
+	const rowKey = getRowKey(synthetic, () => host.hostName || 'unknown', groupBy);
+	const groupedByMeta = getGroupedByMeta(synthetic, groupBy);
+	const cpuPercent = Number((host.cpu * 100).toFixed(1));
+	const memoryPercent = Number((host.memory * 100).toFixed(1));
+
+	return {
+		key: rowKey,
+		itemKey: host.hostName ?? '',
+		groupedByMeta,
+		meta: synthetic.meta,
+		hostGroup: getGroupByEl(synthetic, groupBy),
+		...synthetic.meta,
+		hostName: host.hostName ?? '',
+		active: (
+			<Tag
+				bordered
+				className={`${styles.statusTag} ${
+					host.active ? styles.statusTagActive : styles.statusTagInactive
+				}`}
+			>
+				{host.active ? 'ACTIVE' : 'INACTIVE'}
+			</Tag>
+		),
+		cpu: (
+			<div className={styles.progressContainer}>
+				<ValidateColumnValueWrapper
+					value={host.cpu}
+					entity={InfraMonitoringEntity.HOSTS}
+				>
+					<Progress
+						percent={cpuPercent}
+						strokeLinecap="butt"
+						size="small"
+						strokeColor={getProgressColor(cpuPercent)}
+						className={styles.progressBar}
+					/>
+				</ValidateColumnValueWrapper>
+			</div>
+		),
+		memory: (
+			<div className={styles.progressContainer}>
+				<ValidateColumnValueWrapper
+					value={host.memory}
+					entity={InfraMonitoringEntity.HOSTS}
+				>
+					<Progress
+						percent={memoryPercent}
+						strokeLinecap="butt"
+						size="small"
+						strokeColor={getMemoryProgressColor(memoryPercent)}
+						className={styles.progressBar}
+					/>
+				</ValidateColumnValueWrapper>
+			</div>
+		),
+		wait: `${Number((host.wait * 100).toFixed(1))}%`,
+		load15: host.load15,
+	};
+};
--- a/frontend/src/container/InfraMonitoringHosts/table.module.scss
+++ b/frontend/src/container/InfraMonitoringHosts/table.module.scss
@@ -0,0 +1,73 @@
+.entityGroupHeader {
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+	display: flex;
+	align-items: center;
+}
+
+.hostnameColumnHeader {
+	display: block;
+}
+
+.statusHeader {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--spacing-2);
+	width: 100%;
+}
+
+.columnHeaderRight {
+	text-align: right;
+}
+
+.memoryUsageHeader {
+	display: inline-flex;
+	align-items: center;
+	justify-content: flex-end;
+	gap: var(--spacing-2);
+	width: 100%;
+}
+
+.statusTag {
+	width: fit-content;
+	font-family: Inter, sans-serif;
+	font-size: 11px;
+	font-style: normal;
+	font-weight: 500;
+	line-height: 18px;
+	letter-spacing: 0.44px;
+	text-transform: uppercase;
+	border-radius: 50px;
+	padding: 2px 8px;
+}
+
+.statusTagActive {
+	color: var(--Forest-500, #25e192);
+	border: 1px solid rgba(37, 225, 146, 0.2);
+	background: rgba(37, 225, 146, 0.1);
+}
+
+.statusTagInactive {
+	color: var(--Slate-50, #62687c);
+	border: 1px solid rgba(98, 104, 124, 0.2);
+	background: rgba(98, 104, 124, 0.1);
+}
+
+.progressContainer {
+	display: flex;
+	align-items: center;
+
+	& > div {
+		width: 100%;
+	}
+
+	:global(.ant-progress-bg) {
+		height: 8px !important;
+		border-radius: 4px;
+	}
+}
+
+.progressBar {
+	flex: 1;
+	margin-right: 8px;
+}
--- a/frontend/src/container/InfraMonitoringHosts/utils.tsx
+++ b/frontend/src/container/InfraMonitoringHosts/utils.tsx
@@ -1,41 +1,15 @@
-import { Dispatch, SetStateAction } from 'react';
-import { InfoCircleOutlined } from '@ant-design/icons';
+import React from 'react';
 import { Color } from '@signozhq/design-tokens';
-import {
-	Progress,
-	TableColumnType as ColumnType,
-	Tag,
-	Tooltip,
-	Typography,
-} from 'antd';
-import { SortOrder } from 'antd/lib/table/interface';
-import {
-	HostData,
-	HostListPayload,
-	HostListResponse,
-} from 'api/infraMonitoring/getHostLists';
+import { Tooltip, Typography } from 'antd';
+import { HostListPayload } from 'api/infraMonitoring/getHostLists';
 import {
 	FiltersType,
 	IQuickFiltersConfig,
 } from 'components/QuickFilters/types';
 import { TriangleAlert } from 'lucide-react';
-import { ErrorResponse, SuccessResponse } from 'types/api';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';

-import { OrderBySchemaType } from '../InfraMonitoringK8s/schemas';
-
-export interface HostRowData {
-	key?: string;
-	hostName: string;
-	cpu: React.ReactNode;
-	memory: React.ReactNode;
-	wait: string;
-	load15: number;
-	active: React.ReactNode;
-}
-
 const HOSTNAME_DOCS_URL =
 	'https://signoz.io/docs/infrastructure-monitoring/hostmetrics/#host-name-is-blankempty';

@@ -89,41 +63,6 @@ export function HostnameCell({
 	);
 }

-export interface HostsListTableProps {
-	isLoading: boolean;
-	isError: boolean;
-	isFetching: boolean;
-	tableData:
-		| SuccessResponse<HostListResponse, unknown>
-		| ErrorResponse
-		| undefined;
-	hostMetricsData: HostData[];
-	filters: TagFilter;
-	onHostClick: (hostName: string) => void;
-	currentPage: number;
-	setCurrentPage: Dispatch<SetStateAction<number>>;
-	pageSize: number;
-	setOrderBy: (
-		orderBy: { columnName: string; order: 'asc' | 'desc' } | null,
-	) => void;
-	setPageSize: (pageSize: number) => void;
-	orderBy: OrderBySchemaType;
-}
-
-export interface EmptyOrLoadingViewProps {
-	isError: boolean;
-	data:
-		| ErrorResponse<string>
-		| SuccessResponse<HostListResponse, unknown>
-		| undefined;
-	showHostsEmptyState: boolean;
-	sentAnyHostMetricsData: boolean;
-	isSendingIncorrectK8SAgentMetrics: boolean;
-	showEndTimeBeforeRetentionMessage: boolean;
-	showNoRecordsInSelectedTimeRangeMessage: boolean;
-	showTableLoadingState: boolean;
-}
-
 export const getHostListsQuery = (): HostListPayload => ({
 	filters: {
 		items: [],
@@ -133,143 +72,6 @@ export const getHostListsQuery = (): HostListPayload => ({
 	orderBy: { columnName: 'cpu', order: 'desc' },
 });

-function mapOrderByToSortOrder(
-	column: string,
-	orderBy: OrderBySchemaType,
-): SortOrder | undefined {
-	return orderBy?.columnName === column
-		? orderBy?.order === 'asc'
-			? 'ascend'
-			: 'descend'
-		: undefined;
-}
-
-export const getHostsListColumns = (
-	orderBy: OrderBySchemaType,
-): ColumnType<HostRowData>[] => [
-	{
-		title: <div className="hostname-column-header">Hostname</div>,
-		dataIndex: 'hostName',
-		key: 'hostName',
-		width: 250,
-		render: (value: string | undefined): React.ReactNode => (
-			<HostnameCell hostName={value ?? ''} />
-		),
-	},
-	{
-		title: (
-			<div className="status-header">
-				Status
-				<Tooltip title="Sent system metrics in last 10 mins">
-					<InfoCircleOutlined />
-				</Tooltip>
-			</div>
-		),
-		dataIndex: 'active',
-		key: 'active',
-		width: 100,
-	},
-	{
-		title: <div className="column-header-right">CPU Usage</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 100,
-		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('cpu', orderBy),
-		align: 'right',
-	},
-	{
-		title: (
-			<div className="column-header-right memory-usage-header">
-				Memory Usage
-				<Tooltip title="Excluding cache memory">
-					<InfoCircleOutlined />
-				</Tooltip>
-			</div>
-		),
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 100,
-		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('memory', orderBy),
-		align: 'right',
-	},
-	{
-		title: <div className="column-header-right">IOWait</div>,
-		dataIndex: 'wait',
-		key: 'wait',
-		width: 100,
-		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('wait', orderBy),
-		align: 'right',
-	},
-	{
-		title: <div className="column-header-right">Load Avg</div>,
-		dataIndex: 'load15',
-		key: 'load15',
-		width: 100,
-		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('load15', orderBy),
-		align: 'right',
-	},
-];
-
-export const formatDataForTable = (data: HostData[]): HostRowData[] =>
-	data.map((host, index) => ({
-		key: `${host.hostName}-${index}`,
-		hostName: host.hostName || '',
-		active: (
-			<Tag
-				bordered
-				className={`infra-monitoring-tags ${host.active ? 'active' : 'inactive'}`}
-			>
-				{host.active ? 'ACTIVE' : 'INACTIVE'}
-			</Tag>
-		),
-		cpu: (
-			<div className="progress-container">
-				<Progress
-					percent={Number((host.cpu * 100).toFixed(1))}
-					strokeLinecap="butt"
-					size="small"
-					strokeColor={((): string => {
-						const cpuPercent = Number((host.cpu * 100).toFixed(1));
-						if (cpuPercent >= 90) {
-							return Color.BG_SAKURA_500;
-						}
-						if (cpuPercent >= 60) {
-							return Color.BG_AMBER_500;
-						}
-						return Color.BG_FOREST_500;
-					})()}
-					className="progress-bar"
-				/>
-			</div>
-		),
-		memory: (
-			<div className="progress-container">
-				<Progress
-					percent={Number((host.memory * 100).toFixed(1))}
-					strokeLinecap="butt"
-					size="small"
-					strokeColor={((): string => {
-						const memoryPercent = Number((host.memory * 100).toFixed(1));
-						if (memoryPercent >= 90) {
-							return Color.BG_CHERRY_500;
-						}
-						if (memoryPercent >= 60) {
-							return Color.BG_AMBER_500;
-						}
-						return Color.BG_FOREST_500;
-					})()}
-					className="progress-bar"
-				/>
-			</div>
-		),
-		wait: `${Number((host.wait * 100).toFixed(1))}%`,
-		load15: host.load15,
-	}));
-
 export const HostsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
@@ -299,13 +101,11 @@ export const HostsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 ];

-export function GetHostsQuickFiltersConfig(
+export function getHostsQuickFiltersConfig(
 	dotMetricsEnabled: boolean,
 ): IQuickFiltersConfig[] {
-	// These keys don’t change with dotMetricsEnabled
 	const hostNameKey = dotMetricsEnabled ? 'host.name' : 'host_name';
 	const osTypeKey = dotMetricsEnabled ? 'os.type' : 'os_type';
-	// This metric stays the same regardless of notation
 	const metricName = dotMetricsEnabled
 		? 'system.cpu.load_average.15m'
 		: 'system_cpu_load_average_15m';
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseDetails.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseDetails.tsx
@@ -0,0 +1,860 @@
+import React, {
+	useCallback,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from 'react';
+import { useQuery } from 'react-query';
+// eslint-disable-next-line no-restricted-imports
+import { Color, Spacing } from '@signozhq/design-tokens';
+import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
+import type { RadioChangeEvent } from 'antd/lib';
+import logEvent from 'api/common/logEvent';
+import { InfraMonitoringEvents } from 'constants/events';
+import { QueryParams } from 'constants/query';
+import {
+	initialQueryBuilderFormValuesMap,
+	initialQueryState,
+} from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
+import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import useUrlQuery from 'hooks/useUrlQuery';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import GetMinMax from 'lib/getMinMax';
+import {
+	BarChart2,
+	ChevronsLeftRight,
+	Compass,
+	DraftingCompass,
+	Package2,
+	ScrollText,
+	X,
+} from 'lucide-react';
+import { isCustomTimeRange, useGlobalTimeStore } from 'store/globalTime';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import {
+	IBuilderQuery,
+	TagFilter,
+	TagFilterItem,
+} from 'types/api/queryBuilder/queryBuilderData';
+import {
+	LogsAggregatorOperator,
+	TracesAggregatorOperator,
+} from 'types/common/queryBuilder';
+import { v4 as uuidv4 } from 'uuid';
+
+import { filterDuplicateFilters } from '../commonUtils';
+import { InfraMonitoringEntity, VIEW_TYPES, VIEWS } from '../constants';
+import EntityContainers from '../EntityDetailsUtils/EntityContainers';
+import EntityEvents from '../EntityDetailsUtils/EntityEvents';
+import EntityLogs from '../EntityDetailsUtils/EntityLogs';
+import EntityMetrics from '../EntityDetailsUtils/EntityMetrics';
+import EntityProcesses from '../EntityDetailsUtils/EntityProcesses';
+import EntityTraces from '../EntityDetailsUtils/EntityTraces';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import {
+	useInfraMonitoringEventsFilters,
+	useInfraMonitoringLogFilters,
+	useInfraMonitoringSelectedItem,
+	useInfraMonitoringTracesFilters,
+	useInfraMonitoringView,
+} from '../hooks';
+import LoadingContainer from '../LoadingContainer';
+
+import '../EntityDetailsUtils/entityDetails.styles.scss';
+
+const TimeRangeOffset = 1000000000;
+
+export interface K8sDetailsMetadataConfig<T> {
+	label: string;
+	getValue: (entity: T) => string | number;
+	render?: (value: string | number, entity: T) => React.ReactNode;
+}
+
+export interface K8sDetailsFilters {
+	filters: TagFilter;
+	start: number;
+	end: number;
+}
+
+export interface K8sBaseDetailsProps<T> {
+	category: InfraMonitoringEntity;
+	eventCategory: string;
+	// Data fetching configuration
+	getSelectedItemFilters: (selectedItem: string) => TagFilter;
+	fetchEntityData: (
+		filters: K8sDetailsFilters,
+		signal?: AbortSignal,
+	) => Promise<{ data: T | null; error?: string | null }>;
+	// Entity configuration
+	getEntityName: (entity: T) => string;
+	getInitialLogTracesFilters: (entity: T) => TagFilterItem[];
+	getInitialEventsFilters: (entity: T) => TagFilterItem[];
+	primaryFilterKeys: string[];
+	metadataConfig: K8sDetailsMetadataConfig<T>[];
+	entityWidgetInfo: {
+		title: string;
+		yAxisUnit: string;
+	}[];
+	getEntityQueryPayload: (
+		entity: T,
+		start: number,
+		end: number,
+		dotMetricsEnabled: boolean,
+	) => GetQueryResultsProps[];
+	queryKeyPrefix: string;
+	/** When true, only metrics are shown and the Metrics/Logs/Traces/Events tab bar is hidden. */
+	hideDetailViewTabs?: boolean;
+	tabsConfig?: {
+		showMetrics?: boolean;
+		showLogs?: boolean;
+		showTraces?: boolean;
+		showEvents?: boolean;
+		showContainers?: boolean;
+		showProcesses?: boolean;
+	};
+	customTabs?: Array<{
+		key: string;
+		label: string;
+		icon: React.ReactNode;
+		render: (props: {
+			entity: T;
+			timeRange: { startTime: number; endTime: number };
+			selectedInterval: Time;
+			handleTimeChange: (
+				interval: Time | CustomTimeType,
+				dateTimeRange?: [number, number],
+			) => void;
+		}) => React.ReactNode;
+	}>;
+}
+
+export function createFilterItem(
+	key: string,
+	value: string,
+	dataType: DataTypes = DataTypes.String,
+): TagFilterItem {
+	return {
+		id: uuidv4(),
+		key: {
+			key,
+			dataType,
+			type: 'resource',
+			id: `${key}--string--resource--false`,
+		},
+		op: '=',
+		value,
+	};
+}
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function K8sBaseDetails<T>({
+	category,
+	eventCategory,
+	getSelectedItemFilters,
+	fetchEntityData,
+	getEntityName,
+	getInitialLogTracesFilters,
+	getInitialEventsFilters,
+	primaryFilterKeys,
+	metadataConfig,
+	entityWidgetInfo,
+	getEntityQueryPayload,
+	queryKeyPrefix,
+	hideDetailViewTabs = false,
+	tabsConfig,
+	customTabs,
+}: K8sBaseDetailsProps<T>): JSX.Element {
+	const tabVisibility = useMemo(
+		() => ({
+			showMetrics: true,
+			showLogs: true,
+			showTraces: true,
+			showEvents: true,
+			showContainers: false,
+			showProcesses: false,
+			...tabsConfig,
+		}),
+		[tabsConfig],
+	);
+
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const { startMs, endMs } = useMemo(() => {
+		const { minTime: startNs, maxTime: endNs } = getMinMaxTime(selectedTime);
+
+		return {
+			startMs: Math.floor(startNs / NANO_SECOND_MULTIPLIER),
+			endMs: Math.floor(endNs / NANO_SECOND_MULTIPLIER),
+		};
+	}, [getMinMaxTime, selectedTime]);
+
+	const [modalTimeRange, setModalTimeRange] = useState(() => ({
+		startTime: startMs,
+		endTime: endMs,
+	}));
+
+	// TODO(h4ad): Remove this and use context/zustand
+	const lastSelectedInterval = useRef<Time | null>(null);
+	const [selectedInterval, setSelectedInterval] = useState<Time>(
+		lastSelectedInterval.current
+			? lastSelectedInterval.current
+			: isCustomTimeRange(selectedTime)
+			? DEFAULT_TIME_RANGE
+			: selectedTime,
+	);
+
+	const [selectedView, setSelectedView] = useInfraMonitoringView();
+	const effectiveView = hideDetailViewTabs ? VIEW_TYPES.METRICS : selectedView;
+
+	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
+	const [
+		tracesFiltersParam,
+		setTracesFiltersParam,
+	] = useInfraMonitoringTracesFilters();
+	const [
+		eventsFiltersParam,
+		setEventsFiltersParam,
+	] = useInfraMonitoringEventsFilters();
+	const isDarkMode = useIsDarkMode();
+
+	const [selectedItem, setSelectedItem] = useInfraMonitoringSelectedItem();
+	const urlQuery = useUrlQuery();
+
+	useEffect(() => {
+		if (
+			hideDetailViewTabs &&
+			selectedItem &&
+			selectedView !== VIEW_TYPES.METRICS
+		) {
+			setSelectedView(VIEW_TYPES.METRICS);
+		}
+	}, [hideDetailViewTabs, selectedItem, selectedView, setSelectedView]);
+
+	const entityQueryKey = useMemo(
+		() =>
+			getAutoRefreshQueryKey(
+				selectedTime,
+				`${queryKeyPrefix}EntityDetails`,
+				selectedItem,
+			),
+		[queryKeyPrefix, selectedItem, selectedTime],
+	);
+
+	const {
+		data: entityResponse,
+		isLoading: isEntityLoading,
+		isError: isEntityError,
+	} = useQuery({
+		queryKey: entityQueryKey,
+		queryFn: ({ signal }) => {
+			if (!selectedItem) {
+				return { data: null };
+			}
+			const filters = getSelectedItemFilters(selectedItem);
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchEntityData(
+				{
+					filters,
+					start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
+					end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
+				},
+				signal,
+			);
+		},
+		enabled: !!selectedItem,
+	});
+
+	const entity = entityResponse?.data ?? null;
+
+	const initialFilters = useMemo(() => {
+		const filters =
+			effectiveView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		if (filters) {
+			return filters;
+		}
+		if (!entity) {
+			return { op: 'AND', items: [] };
+		}
+		return {
+			op: 'AND',
+			items: getInitialLogTracesFilters(entity),
+		};
+	}, [
+		entity,
+		effectiveView,
+		logFiltersParam,
+		tracesFiltersParam,
+		getInitialLogTracesFilters,
+	]);
+
+	const initialEventsFilters = useMemo(() => {
+		if (eventsFiltersParam) {
+			return eventsFiltersParam;
+		}
+		if (!entity) {
+			return { op: 'AND', items: [] };
+		}
+		return {
+			op: 'AND',
+			items: getInitialEventsFilters(entity),
+		};
+	}, [entity, eventsFiltersParam, getInitialEventsFilters]);
+
+	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
+		IBuilderQuery['filters']
+	>(initialFilters);
+
+	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
+		initialEventsFilters,
+	);
+
+	useEffect(() => {
+		if (entity) {
+			logEvent(InfraMonitoringEvents.PageVisited, {
+				entity: InfraMonitoringEvents.K8sEntity,
+				page: InfraMonitoringEvents.DetailedPage,
+				category: eventCategory,
+			});
+		}
+	}, [entity, eventCategory]);
+
+	useEffect(() => {
+		setLogsAndTracesFilters(initialFilters);
+		setEventsFilters(initialEventsFilters);
+	}, [initialFilters, initialEventsFilters]);
+
+	useEffect(() => {
+		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
+		if (!isCustomTimeRange(currentSelectedInterval)) {
+			setSelectedInterval(currentSelectedInterval);
+			const { minTime, maxTime } = getMinMaxTime();
+
+			setModalTimeRange({
+				startTime: Math.floor(minTime / TimeRangeOffset),
+				endTime: Math.floor(maxTime / TimeRangeOffset),
+			});
+		}
+	}, [getMinMaxTime, selectedTime]);
+
+	const handleTabChange = (e: RadioChangeEvent): void => {
+		setSelectedView(e.target.value);
+		setLogFiltersParam(null);
+		setTracesFiltersParam(null);
+		setEventsFiltersParam(null);
+		logEvent(InfraMonitoringEvents.TabChanged, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.DetailedPage,
+			category: eventCategory,
+			view: e.target.value,
+		});
+	};
+
+	const handleTimeChange = useCallback(
+		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
+			lastSelectedInterval.current = interval as Time;
+			setSelectedInterval(interval as Time);
+
+			if (interval === 'custom' && dateTimeRange) {
+				setModalTimeRange({
+					startTime: Math.floor(dateTimeRange[0] / 1000),
+					endTime: Math.floor(dateTimeRange[1] / 1000),
+				});
+			} else {
+				const { maxTime, minTime } = GetMinMax(interval);
+
+				setModalTimeRange({
+					startTime: Math.floor(minTime / TimeRangeOffset),
+					endTime: Math.floor(maxTime / TimeRangeOffset),
+				});
+			}
+
+			logEvent(InfraMonitoringEvents.TimeUpdated, {
+				entity: InfraMonitoringEvents.K8sEntity,
+				page: InfraMonitoringEvents.DetailedPage,
+				category: eventCategory,
+				interval,
+				view: effectiveView,
+			});
+		},
+		[eventCategory, effectiveView],
+	);
+
+	const handleChangeLogFilters = useCallback(
+		(value: IBuilderQuery['filters'], view: VIEWS) => {
+			setLogsAndTracesFilters((prevFilters) => {
+				const primaryFilters = prevFilters?.items?.filter((item) =>
+					primaryFilterKeys.includes(item.key?.key ?? ''),
+				);
+				const paginationFilter = value?.items?.find(
+					(item) => item.key?.key === 'id',
+				);
+				const newFilters = value?.items?.filter(
+					(item) =>
+						item.key?.key !== 'id' &&
+						!primaryFilterKeys.includes(item.key?.key ?? ''),
+				);
+
+				if (newFilters && newFilters?.length > 0) {
+					logEvent(InfraMonitoringEvents.FilterApplied, {
+						entity: InfraMonitoringEvents.K8sEntity,
+						page: InfraMonitoringEvents.DetailedPage,
+						category: eventCategory,
+						view: selectedView,
+					});
+				}
+
+				const updatedFilters = {
+					op: 'AND',
+					items: filterDuplicateFilters(
+						[
+							...(primaryFilters || []),
+							...(newFilters || []),
+							...(paginationFilter ? [paginationFilter] : []),
+						].filter((item): item is TagFilterItem => item !== undefined),
+					),
+				};
+
+				setLogFiltersParam(updatedFilters);
+				setSelectedView(view);
+
+				return updatedFilters;
+			});
+		},
+		[
+			setLogFiltersParam,
+			setSelectedView,
+			primaryFilterKeys,
+			eventCategory,
+			selectedView,
+		],
+	);
+
+	const handleChangeTracesFilters = useCallback(
+		(value: IBuilderQuery['filters'], view: VIEWS) => {
+			setLogsAndTracesFilters((prevFilters) => {
+				const primaryFilters = prevFilters?.items?.filter((item) =>
+					primaryFilterKeys.includes(item.key?.key ?? ''),
+				);
+
+				if (value?.items && value?.items?.length > 0) {
+					logEvent(InfraMonitoringEvents.FilterApplied, {
+						entity: InfraMonitoringEvents.K8sEntity,
+						page: InfraMonitoringEvents.DetailedPage,
+						category: eventCategory,
+						view: selectedView,
+					});
+				}
+
+				const updatedFilters = {
+					op: 'AND',
+					items: filterDuplicateFilters(
+						[
+							...(primaryFilters || []),
+							...(value?.items?.filter(
+								(item) => !primaryFilterKeys.includes(item.key?.key ?? ''),
+							) || []),
+						].filter((item): item is TagFilterItem => item !== undefined),
+					),
+				};
+
+				setTracesFiltersParam(updatedFilters);
+				setSelectedView(view);
+
+				return updatedFilters;
+			});
+		},
+		[
+			setTracesFiltersParam,
+			setSelectedView,
+			primaryFilterKeys,
+			eventCategory,
+			selectedView,
+		],
+	);
+
+	const handleChangeEventsFilters = useCallback(
+		(value: IBuilderQuery['filters'], view: VIEWS) => {
+			setEventsFilters((prevFilters) => {
+				const kindFilter = prevFilters?.items?.find(
+					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
+				);
+				const nameFilter = prevFilters?.items?.find(
+					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
+				);
+
+				if (value?.items && value?.items?.length > 0) {
+					logEvent(InfraMonitoringEvents.FilterApplied, {
+						entity: InfraMonitoringEvents.K8sEntity,
+						page: InfraMonitoringEvents.DetailedPage,
+						category: eventCategory,
+						view: selectedView,
+					});
+				}
+
+				const updatedFilters = {
+					op: 'AND',
+					items: filterDuplicateFilters(
+						[
+							kindFilter,
+							nameFilter,
+							...(value?.items?.filter(
+								(item) =>
+									item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
+									item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
+							) || []),
+						].filter((item): item is TagFilterItem => item !== undefined),
+					),
+				};
+
+				setEventsFiltersParam(updatedFilters);
+				setSelectedView(view);
+
+				return updatedFilters;
+			});
+		},
+		[eventCategory, selectedView, setEventsFiltersParam, setSelectedView],
+	);
+
+	const handleExplorePagesRedirect = (): void => {
+		if (selectedInterval !== 'custom') {
+			urlQuery.set(QueryParams.relativeTime, selectedInterval);
+		} else {
+			urlQuery.delete(QueryParams.relativeTime);
+			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
+			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
+		}
+
+		logEvent(InfraMonitoringEvents.ExploreClicked, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.DetailedPage,
+			category: eventCategory,
+			view: selectedView,
+		});
+
+		if (selectedView === VIEW_TYPES.LOGS) {
+			const filtersWithoutPagination = {
+				...logsAndTracesFilters,
+				items:
+					logsAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') ||
+					[],
+			};
+
+			const compositeQuery = {
+				...initialQueryState,
+				queryType: 'builder',
+				builder: {
+					...initialQueryState.builder,
+					queryData: [
+						{
+							...initialQueryBuilderFormValuesMap.logs,
+							aggregateOperator: LogsAggregatorOperator.NOOP,
+							filters: filtersWithoutPagination,
+						},
+					],
+				},
+			};
+
+			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
+
+			window.open(
+				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
+				'_blank',
+			);
+		} else if (selectedView === VIEW_TYPES.TRACES) {
+			const compositeQuery = {
+				...initialQueryState,
+				queryType: 'builder',
+				builder: {
+					...initialQueryState.builder,
+					queryData: [
+						{
+							...initialQueryBuilderFormValuesMap.traces,
+							aggregateOperator: TracesAggregatorOperator.NOOP,
+							filters: logsAndTracesFilters,
+						},
+					],
+				},
+			};
+
+			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
+
+			window.open(
+				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
+				'_blank',
+			);
+		}
+	};
+
+	const handleClose = (): void => {
+		lastSelectedInterval.current = null;
+
+		setSelectedItem(null);
+		setSelectedView(null);
+		setTracesFiltersParam(null);
+		setEventsFiltersParam(null);
+		setLogFiltersParam(null);
+	};
+
+	const entityName = entity ? getEntityName(entity) : '';
+
+	return (
+		<Drawer
+			width="70%"
+			title={
+				<>
+					<Divider type="vertical" />
+					<Typography.Text className="title">{entityName}</Typography.Text>
+				</>
+			}
+			placement="right"
+			onClose={handleClose}
+			open={!!selectedItem}
+			style={{
+				overscrollBehavior: 'contain',
+				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
+			}}
+			className="entity-detail-drawer"
+			destroyOnClose
+			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
+		>
+			{isEntityLoading && <LoadingContainer />}
+			{isEntityError && (
+				<Typography.Text type="danger">
+					{entityResponse?.error || 'Failed to load entity details'}
+				</Typography.Text>
+			)}
+			{entity && !isEntityLoading && (
+				<>
+					<div className="entity-detail-drawer__entity">
+						<div className="entity-details-grid">
+							<div className="labels-row">
+								{metadataConfig.map((config) => (
+									<Typography.Text
+										key={config.label}
+										type="secondary"
+										className="entity-details-metadata-label"
+									>
+										{config.label}
+									</Typography.Text>
+								))}
+							</div>
+
+							<div className="values-row">
+								{metadataConfig.map((config) => {
+									const value = config.getValue(entity);
+									const displayValue = String(value);
+									return (
+										<Typography.Text
+											key={config.label}
+											className="entity-details-metadata-value"
+										>
+											{config.render ? (
+												config.render(value, entity)
+											) : (
+												<Tooltip title={displayValue}>{displayValue}</Tooltip>
+											)}
+										</Typography.Text>
+									);
+								})}
+							</div>
+						</div>
+					</div>
+
+					{!hideDetailViewTabs && (
+						<div className="views-tabs-container">
+							<Radio.Group
+								className="views-tabs"
+								onChange={handleTabChange}
+								value={selectedView}
+							>
+								{tabVisibility.showMetrics && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.METRICS}
+									>
+										<div className="view-title">
+											<BarChart2 size={14} />
+											Metrics
+										</div>
+									</Radio.Button>
+								)}
+								{tabVisibility.showLogs && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.LOGS}
+									>
+										<div className="view-title">
+											<ScrollText size={14} />
+											Logs
+										</div>
+									</Radio.Button>
+								)}
+								{tabVisibility.showTraces && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.TRACES}
+									>
+										<div className="view-title">
+											<DraftingCompass size={14} />
+											Traces
+										</div>
+									</Radio.Button>
+								)}
+								{tabVisibility.showEvents && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.EVENTS}
+									>
+										<div className="view-title">
+											<ChevronsLeftRight size={14} />
+											Events
+										</div>
+									</Radio.Button>
+								)}
+								{tabVisibility.showContainers && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.CONTAINERS ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.CONTAINERS}
+									>
+										<div className="view-title">
+											<Package2 size={14} />
+											Containers
+										</div>
+									</Radio.Button>
+								)}
+								{tabVisibility.showProcesses && (
+									<Radio.Button
+										className={
+											selectedView === VIEW_TYPES.PROCESSES ? 'selected_view tab' : 'tab'
+										}
+										value={VIEW_TYPES.PROCESSES}
+									>
+										<div className="view-title">
+											<ChevronsLeftRight size={14} />
+											Processes
+										</div>
+									</Radio.Button>
+								)}
+								{customTabs?.map((tab) => (
+									<Radio.Button
+										key={tab.key}
+										className={selectedView === tab.key ? 'selected_view tab' : 'tab'}
+										value={tab.key}
+									>
+										<div className="view-title">
+											{tab.icon}
+											{tab.label}
+										</div>
+									</Radio.Button>
+								))}
+							</Radio.Group>
+
+							{(selectedView === VIEW_TYPES.LOGS ||
+								selectedView === VIEW_TYPES.TRACES) && (
+								<Button
+									icon={<Compass size={18} />}
+									className="compass-button"
+									onClick={handleExplorePagesRedirect}
+								/>
+							)}
+						</div>
+					)}
+
+					{effectiveView === VIEW_TYPES.METRICS && (
+						<EntityMetrics<T>
+							entity={entity}
+							selectedInterval={selectedInterval}
+							timeRange={modalTimeRange}
+							handleTimeChange={handleTimeChange}
+							isModalTimeSelection
+							entityWidgetInfo={entityWidgetInfo}
+							getEntityQueryPayload={getEntityQueryPayload}
+							category={category}
+							queryKey={`${queryKeyPrefix}Metrics`}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.LOGS && (
+						<EntityLogs
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							handleChangeLogFilters={handleChangeLogFilters}
+							logFilters={logsAndTracesFilters}
+							selectedInterval={selectedInterval}
+							queryKeyFilters={primaryFilterKeys}
+							queryKey={`${queryKeyPrefix}Logs`}
+							category={category}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.TRACES && (
+						<EntityTraces
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							handleChangeTracesFilters={handleChangeTracesFilters}
+							tracesFilters={logsAndTracesFilters}
+							selectedInterval={selectedInterval}
+							queryKey={`${queryKeyPrefix}Traces`}
+							category={eventCategory}
+							queryKeyFilters={primaryFilterKeys}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.EVENTS && tabVisibility.showEvents && (
+						<EntityEvents
+							timeRange={modalTimeRange}
+							isModalTimeSelection
+							handleTimeChange={handleTimeChange}
+							handleChangeEventFilters={handleChangeEventsFilters}
+							filters={eventsFilters}
+							selectedInterval={selectedInterval}
+							category={category}
+							queryKey={`${queryKeyPrefix}Events`}
+						/>
+					)}
+					{effectiveView === VIEW_TYPES.CONTAINERS &&
+						tabVisibility.showContainers && <EntityContainers />}
+					{effectiveView === VIEW_TYPES.PROCESSES && tabVisibility.showProcesses && (
+						<EntityProcesses />
+					)}
+					{customTabs?.map((tab) =>
+						selectedView === tab.key ? (
+							<React.Fragment key={tab.key}>
+								{tab.render({
+									entity,
+									timeRange: modalTimeRange,
+									selectedInterval,
+									handleTimeChange,
+								})}
+							</React.Fragment>
+						) : null,
+					)}
+				</>
+			)}
+		</Drawer>
+	);
+}
+
+export default K8sBaseDetails;
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.module.scss
@@ -0,0 +1,173 @@
+.clickableRow {
+	cursor: pointer;
+}
+
+.k8SListTable {
+	--k8s-base-list-pagination-offset: 64px;
+
+	display: flex;
+	flex-direction: column;
+
+	:global(.ant-spin-nested-loading) {
+		flex: 1;
+		display: flex;
+		flex-direction: column;
+	}
+
+	:global(.ant-spin-container) {
+		position: relative;
+		flex: 1;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+		padding-bottom: var(--k8s-base-list-pagination-offset);
+	}
+
+	:global(.ant-table-container) {
+		flex: 1;
+		display: flex;
+		flex-direction: column;
+	}
+
+	:global(.ant-table-header) {
+		flex-shrink: 0;
+	}
+
+	:global(.ant-table-body) {
+		flex: 1;
+		min-height: 0;
+		overflow: auto !important;
+	}
+
+	:global(.ant-table) {
+		flex: 1;
+		background: var(--l1-background) !important;
+
+		:global(.ant-table-thead > tr > th) {
+			padding: 12px;
+			font-weight: 500;
+			font-size: 12px;
+			line-height: 18px;
+
+			border-bottom: none;
+
+			color: var(--l2-foreground);
+			font-family: Inter;
+			font-size: 11px;
+			font-style: normal;
+			font-weight: 600;
+			line-height: 18px;
+			letter-spacing: 0.44px;
+			text-transform: uppercase;
+			background: var(--l1-background) !important;
+
+			&::before {
+				background: transparent !important;
+			}
+		}
+
+		:global(.ant-table-cell) {
+			padding: 12px;
+			font-size: 13px;
+			line-height: 20px;
+			color: var(--l1-foreground);
+			background: var(--l1-background);
+			border-bottom: none;
+
+			&:before,
+			&:after {
+				display: none;
+			}
+		}
+
+		:global(.progress-container) {
+			:global(.ant-progress-bg) {
+				height: 8px !important;
+				border-radius: 4px;
+			}
+		}
+
+		:global(.ant-table-tbody > tr:hover > td) {
+			background: var(--l1-background-hover);
+		}
+
+		:global(.ant-table-tbody > tr:not(.ant-table-expanded-row):hover > td) {
+			background: var(--l1-background-hover) !important;
+		}
+
+		:global(.ant-table-tbody > tr.ant-table-expanded-row:hover > td) {
+			background: var(--l1-background);
+		}
+
+		:global(.ant-table-tbody > tr > td) {
+			border-bottom: none;
+		}
+
+		:global(.ant-empty-normal) {
+			visibility: hidden;
+		}
+
+		:global(.ant-table-cell) {
+			min-width: 180px !important;
+			max-width: 180px !important;
+		}
+
+		:global(.ant-table-cell:first-of-type):not(:global(.ant-table-row-expand-icon-cell)) {
+			min-width: 250px !important;
+			max-width: 250px !important;
+		}
+
+		:global(.ant-table-row-expand-icon-cell) {
+			min-width: 40px !important;
+			max-width: 40px !important;
+		}
+
+		:global(.ant-table-content) {
+			flex: 1;
+			min-height: 0;
+			display: flex;
+			flex-direction: column;
+
+			&::-webkit-scrollbar {
+				width: 4px;
+				height: 4px;
+			}
+
+			&::-webkit-scrollbar-track {
+				background: transparent;
+			}
+
+			&::-webkit-scrollbar-thumb {
+				background: var(--accent-primary);
+			}
+
+			&::-webkit-scrollbar-thumb:hover {
+				background: color-mix(var(--accent-primary), transparent 40%);
+			}
+		}
+	}
+}
+
+.paginationDock {
+	position: fixed;
+	bottom: 0;
+	right: 0;
+	width: calc(100% - 340px) !important;
+	margin: 0 !important;
+	padding: 16px;
+	background-color: var(--l1-background);
+	z-index: 1;
+
+	:global(.ant-pagination-item) {
+		border-radius: 4px;
+	}
+
+	:global(.ant-pagination-item-active) {
+		background: var(--l2-background);
+		border-color: var(--l2-border);
+
+		a {
+			color: var(--l1-foreground) !important;
+		}
+	}
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sBaseList.tsx
@@ -0,0 +1,437 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+// eslint-disable-next-line no-restricted-imports
+import { LoadingOutlined } from '@ant-design/icons';
+import {
+	Button,
+	Spin,
+	Table,
+	TableColumnType as ColumnType,
+	TablePaginationConfig,
+	TableProps,
+} from 'antd';
+import type { SorterResult } from 'antd/es/table/interface';
+import logEvent from 'api/common/logEvent';
+import { InfraMonitoringEvents } from 'constants/events';
+import { ChevronDown, ChevronRight } from 'lucide-react';
+import { parseAsString, useQueryState } from 'nuqs';
+import { useGlobalTimeStore } from 'store/globalTime';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
+import { openInNewTab } from 'utils/navigation';
+
+import { InfraMonitoringEntity } from '../constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFilters,
+	useInfraMonitoringGroupBy,
+	useInfraMonitoringOrderBy,
+} from '../hooks';
+import { usePageSize } from '../utils';
+import { K8sEmptyState } from './K8sEmptyState';
+import { K8sExpandedRow } from './K8sExpandedRow';
+import K8sHeader from './K8sHeader';
+import { K8sBaseFilters, K8sRenderedRowData } from './types';
+import {
+	IEntityColumn,
+	useInfraMonitoringTableColumnsForPage,
+	useInfraMonitoringTableColumnsStore,
+} from './useInfraMonitoringTableColumnsStore';
+
+import styles from './K8sBaseList.module.scss';
+
+export type K8sBaseListEmptyStateContext = {
+	isError: boolean;
+	error?: string | null;
+	totalCount: number;
+	hasFilters: boolean;
+	isLoading: boolean;
+	rawData?: unknown;
+};
+
+export type K8sBaseListProps<T = unknown> = {
+	controlListPrefix?: React.ReactNode;
+	entity: InfraMonitoringEntity;
+	tableColumnsDefinitions: IEntityColumn[];
+	tableColumns: ColumnType<K8sRenderedRowData>[];
+	fetchListData: (
+		filters: K8sBaseFilters,
+		signal?: AbortSignal,
+	) => Promise<{
+		data: T[];
+		total: number;
+		error?: string | null;
+		rawData?: unknown;
+	}>;
+	renderRowData: (
+		record: T,
+		groupBy: BaseAutocompleteData[],
+	) => K8sRenderedRowData;
+	eventCategory: InfraMonitoringEvents;
+	renderEmptyState?: (
+		context: K8sBaseListEmptyStateContext,
+	) => React.ReactNode | null;
+};
+
+export function K8sBaseList<T>({
+	controlListPrefix,
+	entity,
+	tableColumnsDefinitions,
+	tableColumns,
+	fetchListData,
+	renderRowData,
+	eventCategory,
+	renderEmptyState,
+}: K8sBaseListProps<T>): JSX.Element {
+	const [queryFilters] = useInfraMonitoringFilters();
+	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [groupBy] = useInfraMonitoringGroupBy();
+	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [initialOrderBy] = useState(orderBy);
+	const [selectedItem, setSelectedItem] = useQueryState(
+		'selectedItem',
+		parseAsString,
+	);
+
+	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
+	useEffect(() => {
+		setExpandedRowKeys([]);
+	}, [groupBy, currentPage]);
+	const { pageSize, setPageSize } = usePageSize(entity);
+
+	const initializeTableColumns = useInfraMonitoringTableColumnsStore(
+		(state) => state.initializePageColumns,
+	);
+	useEffect(() => {
+		initializeTableColumns(entity, tableColumnsDefinitions);
+	}, [initializeTableColumns, entity, tableColumnsDefinitions]);
+
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
+	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const queryKey = useMemo(() => {
+		return getAutoRefreshQueryKey(
+			selectedTime,
+			'k8sBaseList',
+			entity,
+			String(pageSize),
+			String(currentPage),
+			JSON.stringify(queryFilters),
+			JSON.stringify(orderBy),
+			JSON.stringify(groupBy),
+		);
+	}, [
+		selectedTime,
+		entity,
+		pageSize,
+		currentPage,
+		queryFilters,
+		orderBy,
+		groupBy,
+	]);
+
+	const { data, isLoading, isError } = useQuery({
+		queryKey,
+		queryFn: ({ signal }) => {
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchListData(
+				{
+					limit: pageSize,
+					offset: (currentPage - 1) * pageSize,
+					filters: queryFilters || { items: [], op: 'AND' },
+					start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
+					end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
+					orderBy: orderBy || undefined,
+					groupBy: groupBy?.length > 0 ? groupBy : undefined,
+				},
+				signal,
+			);
+		},
+		refetchInterval: isRefreshEnabled ? refreshInterval : false,
+	});
+
+	const pageData = data?.data;
+	const totalCount = data?.total || 0;
+	const hasFilters = (queryFilters?.items?.length ?? 0) > 0;
+
+	const formattedItemsData = useMemo(() => {
+		if (!pageData) {
+			return undefined;
+		}
+
+		const rows = pageData.map((item) => renderRowData(item, groupBy));
+
+		// Without handling duplicated keys, the table became unpredictable/unstable
+		const keyCount = new Map<string, number>();
+		return rows.map(
+			// eslint-disable-next-line sonarjs/no-identical-functions
+			(row): K8sRenderedRowData => {
+				const count = keyCount.get(row.key) || 0;
+				keyCount.set(row.key, count + 1);
+
+				if (count > 0) {
+					return { ...row, key: `${row.key}-${count}` };
+				}
+				return row;
+			},
+		);
+	}, [pageData, renderRowData, groupBy]);
+
+	const handleTableChange: TableProps<K8sRenderedRowData>['onChange'] = useCallback(
+		(
+			pagination: TablePaginationConfig,
+			_filters: Record<string, (string | number | boolean)[] | null>,
+			sorter:
+				| SorterResult<K8sRenderedRowData>
+				| SorterResult<K8sRenderedRowData>[],
+		): void => {
+			if (pagination.current) {
+				setCurrentPage(pagination.current);
+				logEvent(InfraMonitoringEvents.PageNumberChanged, {
+					entity: InfraMonitoringEvents.K8sEntity,
+					page: InfraMonitoringEvents.ListPage,
+					category: eventCategory,
+				});
+			}
+
+			if ('field' in sorter && sorter.order) {
+				setOrderBy({
+					columnName: sorter.field as string,
+					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				});
+			} else {
+				setOrderBy(null);
+			}
+		},
+		[eventCategory, setCurrentPage, setOrderBy],
+	);
+
+	useEffect(() => {
+		logEvent(InfraMonitoringEvents.PageVisited, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+			total: totalCount,
+		});
+	}, [eventCategory, totalCount]);
+
+	const handleGroupByRowClick = (record: K8sRenderedRowData): void => {
+		if (expandedRowKeys.includes(record.key)) {
+			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
+		} else {
+			setExpandedRowKeys([record.key]);
+		}
+	};
+
+	const openItemInNewTab = (record: K8sRenderedRowData): void => {
+		const newParams = new URLSearchParams(document.location.search);
+		newParams.set('selectedItem', record.itemKey);
+		openInNewTab(
+			buildAbsolutePath({
+				relativePath: '',
+				urlQueryString: newParams.toString(),
+			}),
+		);
+	};
+
+	const handleRowClick = (
+		record: K8sRenderedRowData,
+		event: React.MouseEvent,
+	): void => {
+		if (event && isModifierKeyPressed(event)) {
+			openItemInNewTab(record);
+			return;
+		}
+		if (groupBy.length === 0) {
+			setSelectedItem(record.itemKey);
+		} else {
+			handleGroupByRowClick(record);
+		}
+
+		logEvent(InfraMonitoringEvents.ItemClicked, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+		});
+	};
+
+	const [
+		columnsDefinitions,
+		columnsHidden,
+	] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const hiddenColumnIdsOnList = useMemo(
+		() =>
+			columnsDefinitions
+				.filter(
+					(col) =>
+						(groupBy?.length > 0 && col.behavior === 'hidden-on-expand') ||
+						(!groupBy?.length && col.behavior === 'hidden-on-collapse'),
+				)
+				.map((col) => col.id),
+		[columnsDefinitions, groupBy?.length],
+	);
+
+	const mapDefaultSort = useCallback(
+		(
+			tableColumn: ColumnType<K8sRenderedRowData>,
+		): ColumnType<K8sRenderedRowData> => {
+			if (tableColumn.key === initialOrderBy?.columnName) {
+				return {
+					...tableColumn,
+					defaultSortOrder: initialOrderBy?.order === 'asc' ? 'ascend' : 'descend',
+				};
+			}
+
+			return tableColumn;
+		},
+		[initialOrderBy?.columnName, initialOrderBy?.order],
+	);
+
+	const columns = useMemo(
+		() =>
+			tableColumns
+				.filter(
+					(c) =>
+						!hiddenColumnIdsOnList.includes(c.key?.toString() || '') &&
+						!columnsHidden.includes(c.key?.toString() || ''),
+				)
+				.map(mapDefaultSort),
+		[columnsHidden, hiddenColumnIdsOnList, mapDefaultSort, tableColumns],
+	);
+
+	const isGroupedByAttribute = groupBy.length > 0;
+
+	const expandedRowRender = (record: K8sRenderedRowData): JSX.Element => (
+		<K8sExpandedRow<T>
+			record={record}
+			entity={entity}
+			tableColumns={tableColumns}
+			fetchListData={fetchListData}
+			renderRowData={renderRowData}
+		/>
+	);
+
+	const expandRowIconRenderer = ({
+		expanded,
+		onExpand,
+		record,
+	}: {
+		expanded: boolean;
+		onExpand: (
+			record: K8sRenderedRowData,
+			e: React.MouseEvent<HTMLButtonElement>,
+		) => void;
+		record: K8sRenderedRowData;
+	}): JSX.Element | null => {
+		if (!isGroupedByAttribute) {
+			return null;
+		}
+
+		return expanded ? (
+			<Button
+				className="periscope-btn ghost"
+				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
+					onExpand(record, e)
+				}
+				role="button"
+			>
+				<ChevronDown size={14} />
+			</Button>
+		) : (
+			<Button
+				className="periscope-btn ghost"
+				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
+					onExpand(record, e)
+				}
+				role="button"
+			>
+				<ChevronRight size={14} />
+			</Button>
+		);
+	};
+
+	const onPaginationChange = (page: number, pageSize: number): void => {
+		setCurrentPage(page);
+		setPageSize(pageSize);
+		logEvent(InfraMonitoringEvents.PageNumberChanged, {
+			entity: InfraMonitoringEvents.K8sEntity,
+			page: InfraMonitoringEvents.ListPage,
+			category: eventCategory,
+		});
+	};
+
+	const showTableLoadingState = isLoading;
+
+	const emptyStateContext: K8sBaseListEmptyStateContext = {
+		isError: isError || !!data?.error,
+		error: data?.error,
+		totalCount,
+		hasFilters,
+		isLoading: showTableLoadingState,
+		rawData: data?.rawData,
+	};
+
+	const emptyTableMessage: React.ReactNode = renderEmptyState?.(
+		emptyStateContext,
+	) || (
+		<K8sEmptyState
+			isError={emptyStateContext.isError}
+			error={emptyStateContext.error}
+			isLoading={emptyStateContext.isLoading}
+			rawData={emptyStateContext.rawData}
+		/>
+	);
+
+	return (
+		<>
+			<K8sHeader
+				controlListPrefix={controlListPrefix}
+				entity={entity}
+				showAutoRefresh={!selectedItem}
+			/>
+			<Table
+				className={styles.k8SListTable}
+				dataSource={showTableLoadingState ? [] : formattedItemsData}
+				columns={columns}
+				pagination={{
+					current: currentPage,
+					pageSize,
+					total: totalCount,
+					showSizeChanger: true,
+					hideOnSinglePage: false,
+					onChange: onPaginationChange,
+					className: styles.paginationDock,
+				}}
+				loading={{
+					spinning: showTableLoadingState,
+					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+				}}
+				locale={{
+					emptyText: showTableLoadingState ? null : emptyTableMessage,
+				}}
+				scroll={{ x: true }}
+				tableLayout="fixed"
+				onChange={handleTableChange}
+				onRow={(
+					record,
+				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
+					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+					className: styles.clickableRow,
+				})}
+				expandable={{
+					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
+					expandIcon: expandRowIconRenderer,
+					expandedRowKeys,
+				}}
+			/>
+		</>
+	);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sEmptyState.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sEmptyState.module.scss
@@ -0,0 +1,55 @@
+.container {
+	height: 30vh;
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+}
+
+.content {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	gap: var(--spacing-3);
+	width: fit-content;
+	max-width: 500px;
+	padding: 24px;
+	text-align: center;
+}
+
+.title {
+	font-weight: 500;
+	margin: 0;
+}
+
+.message {
+	max-width: 400px;
+}
+
+.noDataMessage {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-1);
+}
+
+.emptyStateSvg {
+	width: 32px;
+	max-width: 100%;
+}
+
+.eyesEmoji {
+	height: 32px;
+	width: 32px;
+}
+
+.errorIcon {
+	color: var(--bg-cherry-500);
+}
+
+.actions {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	margin-top: 16px;
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sEmptyState.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sEmptyState.tsx
@@ -0,0 +1,146 @@
+import { useCallback } from 'react';
+import { Button } from '@signozhq/ui';
+import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
+import history from 'lib/history';
+import { AlertTriangle, LifeBuoy } from 'lucide-react';
+
+import emptyStateUrl from '@/assets/Icons/emptyState.svg';
+import eyesEmojiUrl from '@/assets/Images/eyesEmoji.svg';
+
+import { K8sBaseListEmptyStateContext } from './K8sBaseList';
+
+import styles from './K8sEmptyState.module.scss';
+
+export interface K8sListResponseMetadata {
+	sentAnyHostMetricsData?: boolean;
+	isSendingK8SAgentMetrics?: boolean;
+	endTimeBeforeRetention?: boolean;
+}
+
+type K8sEmptyStateProps = Partial<K8sBaseListEmptyStateContext>;
+
+const handleContactSupport = (isCloudUser: boolean): void => {
+	if (isCloudUser) {
+		history.push('/support');
+	} else {
+		window.open('https://signoz.io/slack', '_blank');
+	}
+};
+
+export function K8sEmptyState({
+	isError,
+	error,
+	isLoading,
+	rawData,
+}: K8sEmptyStateProps): JSX.Element | null {
+	const { isCloudUser } = useGetTenantLicense();
+
+	const handleSupport = useCallback(() => {
+		handleContactSupport(isCloudUser);
+	}, [isCloudUser]);
+
+	if (isLoading) {
+		return null;
+	}
+
+	if (isError || error) {
+		return (
+			<div className={styles.container}>
+				<div className={styles.content}>
+					<AlertTriangle size={32} className={styles.errorIcon} />
+					<span className={styles.message}>
+						{error || 'An error occurred while fetching data.'}
+					</span>
+					<p>
+						Our team is getting on top to resolve this. Please reach out to support if
+						the issue persists.
+					</p>
+					<div className={styles.actions}>
+						<Button
+							onClick={handleSupport}
+							variant="solid"
+							color="secondary"
+							prefix={<LifeBuoy size={14} />}
+						>
+							Contact Support
+						</Button>
+					</div>
+				</div>
+			</div>
+		);
+	}
+
+	const metadata = rawData as K8sListResponseMetadata | undefined;
+
+	if (metadata?.sentAnyHostMetricsData === false) {
+		return (
+			<div className={styles.container}>
+				<div className={styles.content}>
+					<img className={styles.eyesEmoji} src={eyesEmojiUrl} alt="eyes emoji" />
+					<div className={styles.noDataMessage}>
+						<h5 className={styles.title}>No host metrics data received yet</h5>
+						<span className={styles.message}>
+							Please refer to{' '}
+							<a
+								href="https://signoz.io/docs/userguide/hostmetrics/"
+								target="_blank"
+								rel="noreferrer"
+							>
+								our documentation
+							</a>{' '}
+							to learn how to send host metrics.
+						</span>
+					</div>
+				</div>
+			</div>
+		);
+	}
+
+	if (metadata?.isSendingK8SAgentMetrics) {
+		return (
+			<div className={styles.container}>
+				<div className={styles.content}>
+					<img className={styles.eyesEmoji} src={eyesEmojiUrl} alt="eyes emoji" />
+					<span className={styles.message}>
+						To see K8s metrics, upgrade to the latest version of SigNoz k8s-infra
+						chart. Please contact support if you need help.
+					</span>
+				</div>
+			</div>
+		);
+	}
+
+	if (metadata?.endTimeBeforeRetention) {
+		return (
+			<div className={styles.container}>
+				<div className={styles.content}>
+					<img className={styles.eyesEmoji} src={eyesEmojiUrl} alt="eyes emoji" />
+					<div className={styles.noDataMessage}>
+						<h5 className={styles.title}>
+							Queried time range is before earliest K8s metrics
+						</h5>
+						<span className={styles.message}>
+							Your requested end time is earlier than the earliest detected time of K8s
+							metrics data, please adjust your end time.
+						</span>
+					</div>
+				</div>
+			</div>
+		);
+	}
+
+	return (
+		<div className={styles.container}>
+			<div className={styles.content}>
+				<img
+					src={emptyStateUrl}
+					alt="empty-state"
+					className={styles.emptyStateSvg}
+				/>
+				<span className={styles.message}>
+					This query had no results. Edit your query and try again!
+				</span>
+			</div>
+		</div>
+	);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sExpandedRow.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sExpandedRow.module.scss
@@ -0,0 +1,28 @@
+.expandedClickableRow {
+	cursor: pointer;
+}
+
+.expandedTableContainer {
+	border: 1px solid var(--l1-border);
+	overflow-x: auto;
+	padding-left: 48px;
+
+	:global(.ant-table-tbody > tr:hover > td) {
+		background: none !important;
+	}
+}
+
+.expandedTableFooter {
+	display: flex;
+	justify-content: flex-start;
+	gap: 8px;
+	padding: 8px;
+	padding-left: 42px;
+	margin-top: 8px;
+}
+
+.viewAllButton {
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sExpandedRow.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sExpandedRow.tsx
@@ -0,0 +1,250 @@
+import React, { useCallback, useMemo } from 'react';
+import { useQuery } from 'react-query';
+// eslint-disable-next-line no-restricted-imports
+import { LoadingOutlined } from '@ant-design/icons';
+import {
+	Button,
+	Spin,
+	Table,
+	TableColumnType as ColumnType,
+	Typography,
+} from 'antd';
+import { CornerDownRight } from 'lucide-react';
+import { useGlobalTimeStore } from 'store/globalTime';
+import {
+	getAutoRefreshQueryKey,
+	NANO_SECOND_MULTIPLIER,
+} from 'store/globalTime/utils';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
+import { openInNewTab } from 'utils/navigation';
+
+import { InfraMonitoringEntity } from '../constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFilters,
+	useInfraMonitoringGroupBy,
+	useInfraMonitoringOrderBy,
+	useInfraMonitoringSelectedItem,
+} from '../hooks';
+import LoadingContainer from '../LoadingContainer';
+import { K8sBaseFilters, K8sRenderedRowData } from './types';
+import { useInfraMonitoringTableColumnsForPage } from './useInfraMonitoringTableColumnsStore';
+
+import styles from './K8sExpandedRow.module.scss';
+
+export type K8sExpandedRowProps<T> = {
+	record: K8sRenderedRowData;
+	entity: InfraMonitoringEntity;
+	tableColumns: ColumnType<K8sRenderedRowData>[];
+	fetchListData: (
+		filters: K8sBaseFilters,
+		signal?: AbortSignal,
+	) => Promise<{
+		data: T[];
+		total: number;
+		error?: string | null;
+		rawData?: unknown;
+	}>;
+	renderRowData: (
+		record: T,
+		groupBy: BaseAutocompleteData[],
+	) => K8sRenderedRowData;
+};
+
+export const MAX_ITEMS_TO_FETCH_WHEN_GROUP_BY = 10;
+
+export function K8sExpandedRow<T>({
+	record,
+	entity,
+	tableColumns,
+	fetchListData,
+	renderRowData,
+}: K8sExpandedRowProps<T>): JSX.Element {
+	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
+	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [queryFilters, setFilters] = useInfraMonitoringFilters();
+	const [, setSelectedItem] = useInfraMonitoringSelectedItem();
+
+	const [
+		columnsDefinitions,
+		columnsHidden,
+	] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const hiddenColumnIdsForNested = useMemo(
+		() =>
+			columnsDefinitions
+				.filter((col) => col.behavior === 'hidden-on-collapse')
+				.map((col) => col.id),
+		[columnsDefinitions],
+	);
+
+	const nestedColumns = useMemo(
+		() =>
+			tableColumns.filter(
+				(c) =>
+					!columnsHidden.includes(c.key?.toString() || '') &&
+					!hiddenColumnIdsForNested.includes(c.key?.toString() || ''),
+			),
+		[tableColumns, columnsHidden, hiddenColumnIdsForNested],
+	);
+
+	const createFiltersForRecord = useCallback((): NonNullable<
+		IBuilderQuery['filters']
+	> => {
+		const baseFilters: IBuilderQuery['filters'] = {
+			items: [...(queryFilters?.items || [])],
+			op: 'and',
+		};
+
+		const { groupedByMeta } = record;
+
+		for (const key of Object.keys(groupedByMeta)) {
+			baseFilters.items.push({
+				key: {
+					key,
+					type: null,
+				},
+				op: '=',
+				value: groupedByMeta[key],
+				id: key,
+			});
+		}
+
+		return baseFilters;
+	}, [queryFilters?.items, record]);
+
+	const selectedTime = useGlobalTimeStore((s) => s.selectedTime);
+	const refreshInterval = useGlobalTimeStore((s) => s.refreshInterval);
+	const isRefreshEnabled = useGlobalTimeStore((s) => s.isRefreshEnabled);
+	const getMinMaxTime = useGlobalTimeStore((s) => s.getMinMaxTime);
+
+	const queryKey = useMemo(() => {
+		return getAutoRefreshQueryKey(selectedTime, [
+			'k8sExpandedRow',
+			record.key,
+			JSON.stringify(queryFilters),
+			JSON.stringify(orderBy),
+		]);
+	}, [selectedTime, record.key, queryFilters, orderBy]);
+
+	const { data, isFetching, isLoading, isError } = useQuery({
+		queryKey,
+		queryFn: ({ signal }) => {
+			const { minTime, maxTime } = getMinMaxTime();
+
+			return fetchListData(
+				{
+					limit: MAX_ITEMS_TO_FETCH_WHEN_GROUP_BY,
+					offset: 0,
+					filters: createFiltersForRecord(),
+					start: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
+					end: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
+					orderBy: orderBy || undefined,
+					groupBy: undefined,
+				},
+				signal,
+			);
+		},
+		refetchInterval: isRefreshEnabled ? refreshInterval : false,
+	});
+
+	const formattedData = useMemo(() => {
+		if (!data?.data) {
+			return undefined;
+		}
+
+		const rows = data.data.map((item) => renderRowData(item, groupBy));
+
+		// Without handling duplicated keys, the table became unpredictable/unstable
+		const keyCount = new Map<string, number>();
+		return rows.map(
+			(row): K8sRenderedRowData => {
+				const count = keyCount.get(row.key) || 0;
+				keyCount.set(row.key, count + 1);
+
+				if (count > 0) {
+					return { ...row, key: `${row.key}-${count}` };
+				}
+				return row;
+			},
+		);
+	}, [data?.data, renderRowData, groupBy]);
+
+	const openRecordInNewTab = (rowRecord: K8sRenderedRowData): void => {
+		const newParams = new URLSearchParams(document.location.search);
+		newParams.set('selectedItem', rowRecord.itemKey);
+		openInNewTab(
+			buildAbsolutePath({
+				relativePath: '',
+				urlQueryString: newParams.toString(),
+			}),
+		);
+	};
+
+	const handleViewAllClick = (): void => {
+		const filters = createFiltersForRecord();
+		setFilters(filters);
+		setCurrentPage(1);
+		setGroupBy([]);
+		setOrderBy(null);
+	};
+
+	return (
+		<div
+			className={styles.expandedTableContainer}
+			data-testid="expanded-table-container"
+		>
+			{isError && (
+				<Typography>{data?.error?.toString() || 'Something went wrong'}</Typography>
+			)}
+
+			{isFetching || isLoading ? (
+				<LoadingContainer />
+			) : (
+				<div data-testid="expanded-table">
+					<Table
+						columns={nestedColumns}
+						dataSource={formattedData}
+						pagination={false}
+						scroll={{ x: true }}
+						tableLayout="fixed"
+						showHeader={false}
+						loading={{
+							spinning: isFetching || isLoading,
+							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+						}}
+						onRow={(
+							rowRecord: K8sRenderedRowData,
+						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
+							onClick: (event: React.MouseEvent): void => {
+								if (isModifierKeyPressed(event)) {
+									openRecordInNewTab(rowRecord);
+									return;
+								}
+								setSelectedItem(rowRecord.itemKey);
+							},
+							className: styles.expandedClickableRow,
+						})}
+					/>
+
+					{data?.total && data?.total > MAX_ITEMS_TO_FETCH_WHEN_GROUP_BY && (
+						<div className={styles.expandedTableFooter}>
+							<Button
+								type="default"
+								size="small"
+								className={styles.viewAllButton}
+								onClick={handleViewAllClick}
+							>
+								<CornerDownRight size={14} />
+								View All
+							</Button>
+						</div>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.module.scss
@@ -0,0 +1,36 @@
+.drawer {
+	--dialog-description-padding: 0px 0px var(--spacing-8) 0px;
+}
+
+.columnItem {
+	display: flex;
+	align-items: center;
+}
+
+.columnsTitle {
+	color: var(--l2-foreground);
+	font-size: var(--periscope-font-size-small, 11px);
+	font-weight: var(--periscope-font-weight-medium, 500);
+	text-transform: uppercase;
+
+	padding: var(--spacing-4) var(--spacing-8);
+	border-bottom: 1px solid var(--l2-border);
+
+	&:not(:first-of-type) {
+		border-top: 1px solid var(--l2-border);
+	}
+}
+
+.columnsList {
+	display: flex;
+	flex-direction: column;
+}
+
+.columnItem {
+	justify-content: flex-start !important;
+	width: 100%;
+}
+
+.horizontalDivider {
+	border-top: 1px solid var(--l1-border);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sFiltersSidePanel.tsx
@@ -0,0 +1,102 @@
+import { Button, DrawerWrapper } from '@signozhq/ui';
+
+import { InfraMonitoringEntity } from '../constants';
+import {
+	useInfraMonitoringTableColumnsForPage,
+	useInfraMonitoringTableColumnsStore,
+} from './useInfraMonitoringTableColumnsStore';
+
+import styles from './K8sFiltersSidePanel.module.scss';
+
+function K8sFiltersSidePanel({
+	open,
+	onClose,
+	entity,
+}: {
+	open: boolean;
+	onClose: () => void;
+	entity: InfraMonitoringEntity;
+}): JSX.Element {
+	const addColumn = useInfraMonitoringTableColumnsStore(
+		(state) => state.addColumn,
+	);
+	const removeColumn = useInfraMonitoringTableColumnsStore(
+		(state) => state.removeColumn,
+	);
+
+	const [columns, columnsHidden] = useInfraMonitoringTableColumnsForPage(entity);
+
+	const drawerContent = (
+		<>
+			<div className={styles.columnsTitle}>Added Columns (Click to remove)</div>
+
+			<div className={styles.columnsList}>
+				{columns
+					.filter(
+						(column) =>
+							!columnsHidden.includes(column.id) &&
+							column.behavior !== 'hidden-on-collapse',
+					)
+					.map((column) => (
+						<div className={styles.columnItem} key={column.value}>
+							{/*<GripVertical size={16} /> TODO: Add support back when update the table component */}
+							<Button
+								variant="ghost"
+								color="none"
+								className={styles.columnItem}
+								disabled={!column.canBeHidden}
+								data-testid={`remove-column-${column.id}`}
+								onClick={(): void => removeColumn(entity, column.id)}
+							>
+								{column.label}
+							</Button>
+						</div>
+					))}
+			</div>
+
+			<div className={styles.horizontalDivider} />
+
+			<div className={styles.columnsTitle}>Other Columns (Click to add)</div>
+
+			<div className={styles.columnsList}>
+				{columns
+					.filter((column) => columnsHidden.includes(column.id))
+					.map((column) => (
+						<div className={styles.columnItem} key={column.value}>
+							<Button
+								variant="ghost"
+								color="none"
+								className={styles.columnItem}
+								data-can-be-added="true"
+								data-testid={`add-column-${column.id}`}
+								onClick={(): void => addColumn(entity, column.id)}
+								tabIndex={0}
+							>
+								{column.label}
+							</Button>
+						</div>
+					))}
+			</div>
+		</>
+	);
+
+	return (
+		<DrawerWrapper
+			open={open}
+			onOpenChange={(isOpen): void => {
+				if (!isOpen) {
+					onClose();
+				}
+			}}
+			title="Columns"
+			direction="right"
+			showCloseButton
+			showOverlay={false}
+			className={styles.drawer}
+		>
+			{drawerContent}
+		</DrawerWrapper>
+	);
+}
+
+export default K8sFiltersSidePanel;
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.module.scss
@@ -0,0 +1,80 @@
+.k8SListControls {
+	padding: var(--spacing-4);
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	gap: var(--spacing-4);
+
+	:global(.ant-select-selector) {
+		border-radius: 2px;
+		border: 1px solid var(--border) !important;
+		background-color: var(--l2-background) !important;
+
+		input {
+			font-size: 12px;
+		}
+
+		:global(.ant-tag .ant-typography) {
+			font-size: 12px;
+		}
+	}
+}
+
+.k8SListControlsLeft {
+	flex: 1;
+	display: flex;
+	align-items: center;
+	flex-wrap: wrap;
+	gap: var(--spacing-4);
+
+	.k8SQbSearchContainer {
+		flex: 1;
+		min-width: 240px;
+		max-width: 60%;
+	}
+}
+
+.k8SAttributeSearchContainer {
+	flex: 1;
+	min-width: 240px;
+	max-width: 40%;
+	display: flex;
+	align-items: center;
+}
+
+.groupByLabel {
+	min-width: max-content;
+	font-size: var(--periscope-font-size-base, 13px);
+	font-weight: var(--periscope-font-weight-regular, 400);
+	line-height: 18px;
+	letter-spacing: -0.07px;
+
+	border-radius: 2px 0px 0px 2px;
+	border: 1px solid var(--border);
+	border-right: none;
+	border-top-right-radius: 0px;
+	border-bottom-right-radius: 0px;
+
+	display: flex;
+	height: 32px;
+	padding: var(--spacing-3) var(--spacing-3) var(--spacing-3) var(--spacing-4);
+	justify-content: center;
+	align-items: center;
+	gap: var(--spacing-2);
+}
+
+.groupBySelect {
+	:global(.ant-select-selector) {
+		border-left: none;
+		border-top-left-radius: 0px;
+		border-bottom-left-radius: 0px;
+	}
+}
+
+.k8SListControlsRight {
+	min-width: 240px;
+
+	display: flex;
+	align-items: center;
+	gap: var(--spacing-2);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/K8sHeader.tsx
@@ -0,0 +1,229 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { Button } from '@signozhq/button';
+import { Select } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { InfraMonitoringEvents } from 'constants/events';
+import { FeatureKeys } from 'constants/features';
+import { initialQueriesMap } from 'constants/queryBuilder';
+import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
+import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
+import { SlidersHorizontal } from 'lucide-react';
+import { useAppContext } from 'providers/App/App';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import {
+	GetK8sEntityToAggregateAttribute,
+	InfraMonitoringEntity,
+} from '../constants';
+import {
+	useInfraMonitoringCurrentPage,
+	useInfraMonitoringFilters,
+	useInfraMonitoringGroupBy,
+} from '../hooks';
+import K8sFiltersSidePanel from './K8sFiltersSidePanel';
+
+import styles from './K8sHeader.module.scss';
+
+interface K8sHeaderProps {
+	controlListPrefix?: React.ReactNode;
+	entity: InfraMonitoringEntity;
+	showAutoRefresh: boolean;
+}
+
+function K8sHeader({
+	controlListPrefix,
+	entity,
+	showAutoRefresh,
+}: K8sHeaderProps): JSX.Element {
+	const [isFiltersSidePanelOpen, setIsFiltersSidePanelOpen] = useState(false);
+	const [urlFilters, setUrlFilters] = useInfraMonitoringFilters();
+
+	const currentQuery = initialQueriesMap[DataSource.METRICS];
+
+	const updatedCurrentQuery = useMemo(() => {
+		let { filters } = currentQuery.builder.queryData[0];
+		if (urlFilters) {
+			filters = urlFilters;
+		}
+		return {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: [
+					{
+						...currentQuery.builder.queryData[0],
+						aggregateOperator: 'noop',
+						aggregateAttribute: {
+							...currentQuery.builder.queryData[0].aggregateAttribute,
+						},
+						filters,
+					},
+				],
+			},
+		};
+	}, [currentQuery, urlFilters]);
+
+	const query = useMemo(
+		() => updatedCurrentQuery?.builder?.queryData[0] || null,
+		[updatedCurrentQuery],
+	);
+
+	const { handleChangeQueryData } = useQueryOperations({
+		index: 0,
+		query: currentQuery.builder.queryData[0],
+		entityVersion: '',
+	});
+
+	const [, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const handleChangeTagFilters = useCallback(
+		(value: IBuilderQuery['filters']) => {
+			setUrlFilters(value || null);
+			handleChangeQueryData('filters', value);
+			setCurrentPage(1);
+
+			if (value?.items && value?.items?.length > 0) {
+				logEvent(InfraMonitoringEvents.FilterApplied, {
+					entity: InfraMonitoringEvents.K8sEntity,
+					page: InfraMonitoringEvents.ListPage,
+					category: InfraMonitoringEvents.Pod,
+				});
+			}
+		},
+		[handleChangeQueryData, setCurrentPage, setUrlFilters],
+	);
+
+	const { featureFlags } = useAppContext();
+	const dotMetricsEnabled =
+		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
+			?.active || false;
+
+	const {
+		data: groupByFiltersData,
+		isLoading: isLoadingGroupByFilters,
+	} = useGetAggregateKeys(
+		{
+			dataSource: currentQuery.builder.queryData[0].dataSource,
+			aggregateAttribute: GetK8sEntityToAggregateAttribute(
+				entity,
+				dotMetricsEnabled,
+			),
+			aggregateOperator: 'noop',
+			searchText: '',
+			tagType: '',
+		},
+		{
+			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
+		},
+		true,
+		entity,
+	);
+
+	const groupByOptions = useMemo(
+		() =>
+			groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
+				value: filter.key,
+				label: filter.key,
+			})) || [],
+		[groupByFiltersData],
+	);
+
+	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
+
+	const handleGroupByChange = useCallback(
+		(value: IBuilderQuery['groupBy']) => {
+			const newGroupBy = [];
+
+			for (let index = 0; index < value.length; index++) {
+				const element = (value[index] as unknown) as string;
+
+				const key = groupByFiltersData?.payload?.attributeKeys?.find(
+					(k) => k.key === element,
+				);
+
+				if (key) {
+					newGroupBy.push(key);
+				}
+			}
+
+			// Reset pagination on switching to groupBy
+			setCurrentPage(1);
+			setGroupBy(newGroupBy);
+
+			logEvent(InfraMonitoringEvents.GroupByChanged, {
+				entity: InfraMonitoringEvents.K8sEntity,
+				page: InfraMonitoringEvents.ListPage,
+				category: InfraMonitoringEvents.Pod,
+			});
+		},
+		[groupByFiltersData, setCurrentPage, setGroupBy],
+	);
+
+	const onClickOutside = useCallback(() => {
+		setIsFiltersSidePanelOpen(false);
+	}, []);
+
+	return (
+		<div className={styles.k8SListControls}>
+			<div className={styles.k8SListControlsLeft}>
+				{controlListPrefix}
+
+				<div className={styles.k8SQbSearchContainer}>
+					<QueryBuilderSearch
+						query={query as IBuilderQuery}
+						onChange={handleChangeTagFilters}
+						isInfraMonitoring
+						disableNavigationShortcuts
+						entity={entity}
+					/>
+				</div>
+
+				<div className={styles.k8SAttributeSearchContainer}>
+					<div className={styles.groupByLabel}> Group by </div>
+					<Select
+						className={styles.groupBySelect}
+						loading={isLoadingGroupByFilters}
+						mode="multiple"
+						value={groupBy}
+						allowClear
+						maxTagCount="responsive"
+						placeholder="Search for attribute"
+						style={{ width: '100%' }}
+						options={groupByOptions}
+						onChange={handleGroupByChange}
+					/>
+				</div>
+			</div>
+
+			<div className={styles.k8SListControlsRight}>
+				<DateTimeSelectionV2
+					showAutoRefresh={showAutoRefresh}
+					showRefreshText={false}
+					hideShareModal
+				/>
+
+				<Button
+					type="button"
+					variant="ghost"
+					size="icon"
+					color="none"
+					disabled={groupBy?.length > 0}
+					data-testid="k8s-list-filters-button"
+					onClick={(): void => setIsFiltersSidePanelOpen(true)}
+				>
+					<SlidersHorizontal size={14} />
+				</Button>
+			</div>
+
+			<K8sFiltersSidePanel
+				open={isFiltersSidePanelOpen}
+				entity={entity}
+				onClose={onClickOutside}
+			/>
+		</div>
+	);
+}
+
+export default K8sHeader;
--- a/frontend/src/container/InfraMonitoringK8s/Base/tests/K8sBaseList.test.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/tests/K8sBaseList.test.tsx
--- a/frontend/src/container/InfraMonitoringK8s/Base/types.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Base/types.ts
@@ -0,0 +1,27 @@
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+import { OrderBySchemaType } from '../schemas';
+
+export type K8sBaseFilters = {
+	filters: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	start: number;
+	end: number;
+	orderBy?: OrderBySchemaType;
+};
+
+export type K8sRenderedRowData = {
+	/**
+	 * The unique ID for the row
+	 */
+	key: string;
+	/**
+	 * The ID to the selectedItem
+	 */
+	itemKey: string;
+	groupedByMeta: Record<string, string>;
+	[key: string]: unknown;
+};
--- a/frontend/src/container/InfraMonitoringK8s/Base/useInfraMonitoringTableColumnsStore.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Base/useInfraMonitoringTableColumnsStore.ts
@@ -0,0 +1,113 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+export interface IEntityColumn {
+	label: string;
+	value: string;
+	id: string;
+	defaultVisibility: boolean;
+	canBeHidden: boolean;
+	behavior: 'hidden-on-expand' | 'hidden-on-collapse' | 'always-visible';
+}
+
+export interface IInfraMonitoringTableColumnsStore {
+	columns: Record<string, IEntityColumn[]>;
+	columnsHidden: Record<string, string[]>;
+	addColumn: (page: string, columnId: string) => void;
+	removeColumn: (page: string, columnId: string) => void;
+	initializePageColumns: (page: string, columns: IEntityColumn[]) => void;
+}
+
+export const useInfraMonitoringTableColumnsStore = create<IInfraMonitoringTableColumnsStore>()(
+	persist(
+		(set, get) => ({
+			columns: {},
+			columnsHidden: {},
+			addColumn: (page, columnId): void => {
+				const state = get();
+				const columnDefinition = state.columns[page]?.find(
+					(c) => c.id === columnId,
+				);
+
+				if (!columnDefinition) {
+					return;
+				}
+
+				if (!columnDefinition.canBeHidden) {
+					return;
+				}
+
+				const columnsHidden = state.columnsHidden[page];
+
+				if (columnsHidden.includes(columnId)) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: columnsHidden.filter((id) => id !== columnId),
+						},
+					});
+				}
+			},
+			removeColumn: (page, columnId): void => {
+				const state = get();
+				const columnDefinition = state.columns[page]?.find(
+					(c) => c.id === columnId,
+				);
+
+				if (!columnDefinition) {
+					return;
+				}
+
+				if (!columnDefinition.canBeHidden) {
+					return;
+				}
+
+				const columnsHidden = state.columnsHidden[page];
+
+				if (!columnsHidden.includes(columnId)) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: [...columnsHidden, columnId],
+						},
+					});
+				}
+			},
+			initializePageColumns: (page, columns): void => {
+				const state = get();
+
+				set({
+					columns: {
+						...state.columns,
+						[page]: columns,
+					},
+				});
+
+				if (state.columnsHidden[page] === undefined) {
+					set({
+						columnsHidden: {
+							...state.columnsHidden,
+							[page]: columns
+								.filter((c) => c.defaultVisibility === false)
+								.map((c) => c.id),
+						},
+					});
+				}
+			},
+		}),
+		{
+			name: '@signoz/infra-monitoring-columns',
+		},
+	),
+);
+
+export const useInfraMonitoringTableColumnsForPage = (
+	page: string,
+): [columns: IEntityColumn[], columnsHidden: string[]] => {
+	const state = useInfraMonitoringTableColumnsStore((s) => s.columns);
+	const columnsHidden = useInfraMonitoringTableColumnsStore(
+		(s) => s.columnsHidden,
+	);
+
+	return [state[page] ?? [], columnsHidden[page] ?? []];
+};
--- a/frontend/src/container/InfraMonitoringK8s/Base/utils.module.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Base/utils.module.scss
@@ -0,0 +1,18 @@
+.itemDataGroup {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	flex-wrap: wrap;
+
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.itemDataGroupTagItem {
+	display: block !important;
+	max-width: 100%;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
--- a/frontend/src/container/InfraMonitoringK8s/Base/utils.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Base/utils.tsx
@@ -0,0 +1,96 @@
+import { Badge } from '@signozhq/ui';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+import styles from './utils.module.scss';
+
+const dotToUnder: Record<string, string> = {
+	'os.type': 'os_type',
+	'host.name': 'host_name',
+	'deployment.environment': 'deployment_environment',
+	'k8s.node.name': 'k8s_node_name',
+	'k8s.cluster.name': 'k8s_cluster_name',
+	'k8s.node.uid': 'k8s_node_uid',
+	'k8s.cronjob.name': 'k8s_cronjob_name',
+	'k8s.daemonset.name': 'k8s_daemonset_name',
+	'k8s.deployment.name': 'k8s_deployment_name',
+	'k8s.job.name': 'k8s_job_name',
+	'k8s.namespace.name': 'k8s_namespace_name',
+	'k8s.pod.name': 'k8s_pod_name',
+	'k8s.pod.uid': 'k8s_pod_uid',
+	'k8s.statefulset.name': 'k8s_statefulset_name',
+	'k8s.persistentvolumeclaim.name': 'k8s_persistentvolumeclaim_name',
+};
+
+export function getGroupedByMeta<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	groupBy: BaseAutocompleteData[],
+): Record<string, string> {
+	const result: Record<string, string> = {};
+
+	groupBy.forEach((group) => {
+		const rawKey = group.key as string;
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof itemData.meta;
+		result[rawKey] = (itemData.meta[metaKey] || itemData.meta[rawKey]) ?? '';
+	});
+
+	return result;
+}
+
+export function getRowKey<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	getItemIdentifier: () => string,
+	groupBy: BaseAutocompleteData[],
+): string {
+	const nodeIdentifier = getItemIdentifier();
+
+	if (groupBy.length === 0) {
+		return nodeIdentifier || JSON.stringify(itemData.meta);
+	}
+
+	const groupedMeta = getGroupedByMeta(itemData, groupBy);
+	const groupKey = Object.values(groupedMeta).join('-');
+
+	if (groupKey && nodeIdentifier) {
+		return `${groupKey}-${nodeIdentifier}`;
+	}
+	if (groupKey) {
+		return groupKey;
+	}
+	if (nodeIdentifier) {
+		return nodeIdentifier;
+	}
+
+	return JSON.stringify(itemData.meta);
+}
+
+export function getGroupByEl<T extends { meta: Record<string, string> }>(
+	itemData: T,
+	groupBy: IBuilderQuery['groupBy'],
+): React.ReactNode {
+	const groupByValues: string[] = [];
+
+	groupBy.forEach((group) => {
+		const rawKey = group.key as string;
+
+		// Choose mapped key if present, otherwise use rawKey
+		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof itemData.meta;
+		const value = itemData.meta[metaKey] || itemData.meta[rawKey] || '<no-value>';
+
+		groupByValues.push(value);
+	});
+
+	return (
+		<div className={styles.itemDataGroup}>
+			{groupByValues.map((value) => (
+				<Badge
+					key={value}
+					color="secondary"
+					className={styles.itemDataGroupTagItem}
+				>
+					{value === '' ? '<no-value>' : value}
+				</Badge>
+			))}
+		</div>
+	);
+}
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.interfaces.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.interfaces.ts
@@ -1,7 +0,0 @@
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
-
-export type ClusterDetailsProps = {
-	cluster: K8sClustersData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.tsx
@@ -1,624 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import ClusterEvents from '../../EntityDetailsUtils/EntityEvents';
-import ClusterLogs from '../../EntityDetailsUtils/EntityLogs';
-import ClusterMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import ClusterTraces from '../../EntityDetailsUtils/EntityTraces';
-import { ClusterDetailsProps } from './ClusterDetails.interfaces';
-import { clusterWidgetInfo, getClusterMetricsQueryPayload } from './constants';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function ClusterDetails({
-	cluster,
-	onClose,
-	isModalTimeSelection,
-}: ClusterDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_CLUSTER_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_cluster_name--string--resource--false',
-					},
-					op: '=',
-					value: cluster?.meta.k8s_cluster_name || '',
-				},
-			],
-		};
-	}, [
-		cluster?.meta.k8s_cluster_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Cluster',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: cluster?.meta.k8s_cluster_name || '',
-				},
-			],
-		};
-	}, [cluster?.meta.k8s_cluster_name, eventsFiltersParam]);
-
-	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (cluster) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Cluster,
-			});
-		}
-	}, [cluster]);
-
-	useEffect(() => {
-		setLogsAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Cluster,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Cluster,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogsAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_CLUSTER_NAME].includes(item.key?.key ?? ''),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.LogsView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogsAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_CLUSTER_NAME].includes(item.key?.key ?? ''),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.TracesView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const clusterKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const clusterNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						view: InfraMonitoringEvents.EventsView,
-						category: InfraMonitoringEvents.Cluster,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							clusterKindFilter,
-							clusterNameFilter,
-							...(value?.items?.filter(
-								(item) =>
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-									item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Cluster,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logsAndTracesFilters,
-				items:
-					logsAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') ||
-					[],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logsAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{cluster?.meta.k8s_cluster_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!cluster}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{cluster && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={cluster.meta.k8s_cluster_name}>
-										{cluster.meta.k8s_cluster_name}
-									</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<ClusterMetrics<K8sClustersData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={cluster}
-							entityWidgetInfo={clusterWidgetInfo}
-							getEntityQueryPayload={getClusterMetricsQueryPayload}
-							category={K8sCategory.CLUSTERS}
-							queryKey="clusterMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<ClusterLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logsAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="clusterLogs"
-							category={K8sCategory.CLUSTERS}
-							queryKeyFilters={[QUERY_KEYS.K8S_CLUSTER_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<ClusterTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logsAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKey="clusterTraces"
-							category={InfraMonitoringEvents.Cluster}
-							queryKeyFilters={[QUERY_KEYS.K8S_CLUSTER_NAME]}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<ClusterEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.CLUSTERS}
-							queryKey="clusterEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default ClusterDetails;
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/index.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/index.ts
@@ -1,3 +0,0 @@
-import ClusterDetails from './ClusterDetails';
-
-export default ClusterDetails;
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.styles.scss
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.styles.scss
@@ -1,17 +0,0 @@
-.infra-monitoring-container {
-	.clusters-list-table {
-		.expanded-table-container {
-			padding-left: 40px;
-		}
-
-		.ant-table-cell {
-			min-width: 223px !important;
-			max-width: 223px !important;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.tsx
@@ -1,695 +1,118 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sClustersListPayload } from 'api/infraMonitoring/getK8sClustersList';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
-import { useGetK8sClustersList } from 'hooks/infraMonitoring/useGetK8sClustersList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
+import { FeatureKeys } from 'constants/features';
+import { useAppContext } from 'providers/App/App';

-import emptyStateUrl from '@/assets/Icons/emptyState.svg';
-
-import { FeatureKeys } from '../../../constants/features';
-import { useAppContext } from '../../../providers/App/App';
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseList } from '../Base/K8sBaseList';
+import { K8sBaseFilters } from '../Base/types';
+import { InfraMonitoringEntity } from '../constants';
+import { getK8sClustersList, K8sClusterData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	clusterWidgetInfo,
+	getClusterMetricsQueryPayload,
+	k8sClusterDetailsMetadataConfig,
+	k8sClusterGetEntityName,
+	k8sClusterGetSelectedItemFilters,
+	k8sClusterInitialEventsFilter,
+	k8sClusterInitialFilters,
+	k8sClusterInitialLogTracesFilter,
+} from './constants';
 import {
-	useInfraMonitoringClusterName,
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import ClusterDetails from './ClusterDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sClustersListColumns,
-	getK8sClustersListQuery,
-	K8sClustersRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sClustersList.styles.scss';
+	k8sClustersColumns,
+	k8sClustersColumnsConfig,
+	k8sClustersRenderRowData,
+} from './table.config';

 function K8sClustersList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-	const [
-		selectedClusterName,
-		setselectedClusterName,
-	] = useInfraMonitoringClusterName();
-
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.CLUSTERS);
-
-	const [
-		selectedRowData,
-		setSelectedRowData,
-	] = useState<K8sClustersRowData | null>(null);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;

-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sClustersRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};

-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sClustersListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedClusterName) {
-			return [
-				'clusterList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'clusterList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedClusterName,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sClustersList(
-		fetchGroupedByRowDataQuery as K8sClustersListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.CLUSTERS,
+			const response = await getK8sClustersList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sClustersListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const formattedGroupedByClustersData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const nestedClustersData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const queryKey = useMemo(() => {
-		if (selectedClusterName) {
-			return [
-				'clusterList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'clusterList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedClusterName,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sClustersList(
-		query as K8sClustersListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const clustersData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedClustersData = useMemo(
-		() => formatDataForTable(clustersData, groupBy),
-		[clustersData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sClustersListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sClustersRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sClustersRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter:
-				| SorterResult<K8sClustersRowData>
-				| SorterResult<K8sClustersRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Cluster,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					category: InfraMonitoringEvents.Cluster,
-					page: InfraMonitoringEvents.ListPage,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			category: InfraMonitoringEvents.Cluster,
-			page: InfraMonitoringEvents.ListPage,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedClusterData = useMemo(() => {
-		if (!selectedClusterName) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the cluster from the formatted grouped by clusters data
-			return (
-				nestedClustersData.find(
-					(cluster) => cluster.meta.k8s_cluster_name === selectedClusterName,
-				) || null
 			);
-		}
-		// If not grouped by, return the cluster from the clusters data
-		return (
-			clustersData.find(
-				(cluster) => cluster.meta.k8s_cluster_name === selectedClusterName,
-			) || null
-		);
-	}, [selectedClusterName, groupBy.length, clustersData, nestedClustersData]);

-	const openClusterInNewTab = (record: K8sClustersRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
-			record.clusterUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sClustersRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openClusterInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setselectedClusterName(record.clusterUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Cluster,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sClustersListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						columns={nestedColumns as ColumnType<K8sClustersRowData>[]}
-						dataSource={formattedGroupedByClustersData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openClusterInNewTab(record);
-									return;
-								}
-								setselectedClusterName(record.clusterUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sClustersRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sClustersRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseClusterDetail = (): void => {
-		setselectedClusterName(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(key) => key.key === element,
-				);
-
-				if (key) {
-					newGroupBy.push(key);
-				}
-			}
-
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(newGroupBy);
-			setExpandedRowKeys([]);
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Cluster,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+				rawData: response.payload?.data,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);

-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sClusterData | null; error?: string | null }> => {
+			const response = await getK8sClustersList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);

-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Cluster,
-		});
-	};
+			const records = response.payload?.data.records || [];

-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedClustersData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);

 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
-				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedClusterData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className="k8s-list-table clusters-list-table"
-				dataSource={showTableLoadingState ? [] : formattedClustersData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src={emptyStateUrl}
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+		<>
+			<K8sBaseList<K8sClusterData>
+				controlListPrefix={controlListPrefix}
+				entity={InfraMonitoringEntity.CLUSTERS}
+				tableColumnsDefinitions={k8sClustersColumns}
+				tableColumns={k8sClustersColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sClustersRenderRowData}
+				eventCategory={InfraMonitoringEvents.Cluster}
 			/>

-			<ClusterDetails
-				cluster={selectedClusterData}
-				isModalTimeSelection
-				onClose={handleCloseClusterDetail}
+			<K8sBaseDetails<K8sClusterData>
+				category={InfraMonitoringEntity.CLUSTERS}
+				eventCategory={InfraMonitoringEvents.Cluster}
+				getSelectedItemFilters={k8sClusterGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sClusterGetEntityName}
+				getInitialLogTracesFilters={k8sClusterInitialLogTracesFilter}
+				getInitialEventsFilters={k8sClusterInitialEventsFilter}
+				primaryFilterKeys={k8sClusterInitialFilters}
+				metadataConfig={k8sClusterDetailsMetadataConfig}
+				entityWidgetInfo={clusterWidgetInfo}
+				getEntityQueryPayload={getClusterMetricsQueryPayload}
+				queryKeyPrefix="cluster"
 			/>
-		</div>
+		</>
 	);
 }

--- a/frontend/src/container/InfraMonitoringK8s/Clusters/api.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/api.ts
@@ -0,0 +1,125 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+import { K8sBaseFilters } from '../Base/types';
+
+export interface K8sClustersListPayload {
+	filters: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	orderBy?: {
+		columnName: string;
+		order: 'asc' | 'desc';
+	};
+}
+
+export interface K8sClusterData {
+	clusterUID: string;
+	cpuUsage: number;
+	cpuAllocatable: number;
+	memoryUsage: number;
+	memoryAllocatable: number;
+	meta: {
+		k8s_cluster_name: string;
+		k8s_cluster_uid: string;
+	};
+}
+
+export interface K8sClustersListResponse {
+	status: string;
+	data: {
+		type: string;
+		records: K8sClusterData[];
+		groups: null;
+		total: number;
+		sentAnyHostMetricsData: boolean;
+		isSendingK8SAgentMetrics: boolean;
+	};
+}
+
+// TODO(H4ad): Erase this whole file when migrating to openapi
+export const clustersMetaMap = [
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+	{ dot: 'k8s.cluster.uid', under: 'k8s_cluster_uid' },
+] as const;
+
+export function mapClustersMeta(
+	raw: Record<string, unknown>,
+): K8sClusterData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	clustersMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sClusterData['meta'];
+}
+
+export const getK8sClustersList = async (
+	props: K8sBaseFilters,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
+): Promise<SuccessResponse<K8sClustersListResponse> | ErrorResponse> => {
+	try {
+		const requestProps = dotMetricsEnabled
+			? {
+					...props,
+					filters: {
+						...props.filters,
+						items: props.filters.items.reduce<typeof props.filters.items>(
+							(acc, item) => {
+								if (item.value === undefined) {
+									return acc;
+								}
+								if (
+									item.key &&
+									typeof item.key === 'object' &&
+									'key' in item.key &&
+									typeof item.key.key === 'string'
+								) {
+									const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+									acc.push({
+										...item,
+										key: { ...item.key, key: mappedKey },
+									});
+								} else {
+									acc.push(item);
+								}
+								return acc;
+							},
+							[] as typeof props.filters.items,
+						),
+					},
+			  }
+			: props;
+
+		const response = await axios.post('/clusters/list', requestProps, {
+			signal,
+			headers,
+		});
+		const payload: K8sClustersListResponse = response.data;
+
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapClustersMeta(record.meta as Record<string, unknown>),
+		}));
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: 'Success',
+			payload,
+			params: requestProps,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/constants.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/constants.ts
@@ -1,11 +1,57 @@
-import { K8sClustersData } from 'api/infraMonitoring/getK8sClustersList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';

+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sClusterData } from './api';
+
+export const k8sClusterGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => ({
+	op: 'AND',
+	items: [
+		{
+			id: 'k8s_cluster_name',
+			key: {
+				key: 'k8s_cluster_name',
+				type: null,
+			},
+			op: '=',
+			value: selectedItemId,
+		},
+	],
+});
+
+export const k8sClusterDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sClusterData>[] = [
+	{ label: 'Cluster Name', getValue: (p): string => p.meta.k8s_cluster_name },
+];
+
+export const k8sClusterInitialFilters = [QUERY_KEYS.K8S_CLUSTER_NAME];
+
+export const k8sClusterInitialEventsFilter = (
+	item: K8sClusterData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Cluster'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sClusterInitialLogTracesFilter = (
+	item: K8sClusterData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_CLUSTER_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sClusterGetEntityName = (item: K8sClusterData): string =>
+	item.meta.k8s_cluster_name;
+
 export const clusterWidgetInfo = [
 	{
 		title: 'CPU Usage, allocatable',
@@ -42,7 +88,7 @@ export const clusterWidgetInfo = [
 ];

 export const getClusterMetricsQueryPayload = (
-	cluster: K8sClustersData,
+	cluster: K8sClusterData,
 	start: number,
 	end: number,
 	dotMetricsEnabled: boolean,
--- a/frontend/src/container/InfraMonitoringK8s/Clusters/table.config.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Clusters/table.config.tsx
@@ -0,0 +1,183 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/types';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { K8sClusterData, K8sClustersListPayload } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sClustersRowData {
+	key: string;
+	itemKey: string;
+	clusterUID: string;
+	clusterName: React.ReactNode;
+	cpu: React.ReactNode;
+	cpu_allocatable: React.ReactNode;
+	memory: React.ReactNode;
+	memory_allocatable: React.ReactNode;
+	groupedByMeta?: Record<string, string>;
+}
+
+export const k8sClustersColumns: IEntityColumn[] = [
+	{
+		label: 'Cluster Group',
+		value: 'clusterGroup',
+		id: 'clusterGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterName',
+		id: 'clusterName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Alloc (cores)',
+		value: 'cpu_allocatable',
+		id: 'cpu_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Alloc (bytes)',
+		value: 'memory_allocatable',
+		id: 'memory_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const getK8sClustersListQuery = (): K8sClustersListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+export const k8sClustersColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> CLUSTER GROUP
+			</div>
+		),
+		dataIndex: 'clusterGroup',
+		key: 'clusterGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 150,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Alloc (cores)</div>,
+		dataIndex: 'cpu_allocatable',
+		key: 'cpu_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Allocatable</div>,
+		dataIndex: 'memory_allocatable',
+		key: 'memory_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sClustersRenderRowData = (
+	cluster: K8sClusterData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		cluster,
+		() =>
+			cluster.clusterUID ||
+			cluster.meta.k8s_cluster_uid ||
+			cluster.meta.k8s_cluster_name,
+		groupBy,
+	),
+	itemKey: cluster.meta.k8s_cluster_name,
+	clusterUID: cluster.clusterUID || cluster.meta.k8s_cluster_uid,
+	clusterName: (
+		<Tooltip title={cluster.meta.k8s_cluster_name}>
+			{cluster.meta.k8s_cluster_name || ''}
+		</Tooltip>
+	),
+	cpu: (
+		<ValidateColumnValueWrapper value={cluster.cpuUsage}>
+			{cluster.cpuUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={cluster.memoryUsage}>
+			{formatBytes(cluster.memoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	cpu_allocatable: (
+		<ValidateColumnValueWrapper value={cluster.cpuAllocatable}>
+			{cluster.cpuAllocatable}
+		</ValidateColumnValueWrapper>
+	),
+	memory_allocatable: (
+		<ValidateColumnValueWrapper value={cluster.memoryAllocatable}>
+			{formatBytes(cluster.memoryAllocatable)}
+		</ValidateColumnValueWrapper>
+	),
+	clusterGroup: getGroupByEl(cluster, groupBy),
+	...cluster.meta,
+	groupedByMeta: getGroupedByMeta(cluster, groupBy),
+});
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ashwin Bhatkal	368c6cd724	refactor: rename selectedDashboard to dashboardData Renames the `selectedDashboard` store field (and related setters/getters `setSelectedDashboard`, `getSelectedDashboard`) to `dashboardData` across the frontend. Also renames incidental locals (`updatedSelectedDashboard`, `mockSelectedDashboard`, and the ExportPanel's local `selectedDashboardId`).	2026-04-21 19:50:08 +05:30
Ashwin Bhatkal	7917540662	fix: alerts creation for query types other than builder (#11030 ) * fix: alerts creation for query types other than builder * chore: add tests	2026-04-21 11:33:32 +00:00
Vinicius Lourenço	addb234c8c	test(infra-monitoring): fix flaky test (#11021 )	2026-04-21 11:06:49 +00:00
Prakhar Dewan	be6a663e4b	refactor: migrate CreateFunnel input to @signozhq/ui (#10996 ) Refs SigNoz#10615	2026-04-21 11:04:32 +00:00
Abhi kumar	ed17003329	fix: y-axis crosshair sync for tooltip (#10944 ) Some checks failed build-staging / staging (push) Has been cancelled Details build-staging / prepare (push) Has been cancelled Details build-staging / js-build (push) Has been cancelled Details build-staging / go-build (push) Has been cancelled Details Release Drafter / update_release_draft (push) Has been cancelled Details * chore: added changes for crosshair sync for tooltip * chore: minor cleanup * chore: updated the core structure * chore: updated the types * chore: minor cleanup * chore: minor changes	2026-04-21 08:36:04 +00:00
Piyush Singariya	50b452080f	chore: Removal of JSONDataType field (#10925 ) * fix: tons of changes * chore: remove redundent comparison * ci: tests fixed * fix: upgraded collector version * fix: qbtoexpr tests * fix: go sum * chore: upgrade collector version v0.144.3-rc.4 * fix: tests * ci: test fix * revert: remove db binaries * test: selectField tests added * fix: added safeguards in plan generation * fix: name changed to field_map * fix: json access plan remval of AvailableTypes * fix: invalid index usage on terminal condition * fix: branches should tell missing array types * fix: comment removed * fix: issue with FuzzyMatching and API failing * fix: int64 mapping * ci: test and lint fix * fix: test VisitKey * test: running test for sku * fix: buildFieldForJSON works * fix: few minor changes * fix: refactor tag vs field_key table * fix: minor changes based on review * revert: minor variable change * fix: added more membership testcases * revert: minor var names reverted * ci: tests aligned * fix: indexed expressions	2026-04-21 05:11:50 +00:00
Vinicius Lourenço	c1a35808d9	feat(infrastructure-monitoring-k8s-and-hosts): add shared component for list/details (#10800 ) Some checks failed build-staging / prepare (push) Has been cancelled Details build-staging / js-build (push) Has been cancelled Details build-staging / go-build (push) Has been cancelled Details build-staging / staging (push) Has been cancelled Details Release Drafter / update_release_draft (push) Has been cancelled Details * feat(infra-monitoring): single component to be reused across pages * feat(pod-details): extract to a common generic component * refactor(k8s-filters-panel): use our components & css modules * refactor(k8s-pods): split pod new components into more config files * refactor(list): split expanded row into own component & change how the selected item is rendered * refactor(infra-monitoring): add tests & migrate all css to css modules * fix(empty-state): rendering svg too big * fix(css): use more semantic tokens * fix(prettify): ensure all components are correct formatted * fix(dead-code): remove unused code * fix(table.tsx): ensure all classes are on css modules * test(k8s-base-list): add more details why the test fails * fix(k8s-base-details): remove eslint ignore * chore(k8s-base-list): cleaning up comments * refactor(infra-monitoring): create hook for selected item * refactor(base-details): move close to inside component * chore(table.scss): fix prettify * fix(k8s-base-details): auto-refresh causing the entire modal to refresh * feat(global-time-adapter): adopt new global time adapter * fix(css): table with wrong background color * test(k8s-base-list): fix count of fetch times * fix(table-module): css of the group header not correct * refactor(utils): better organization for common code * fix(k8s-base): not showing ellipsis * fix(k8s-base-list): ensure loading always appear when loading data * fix(k8s-base-details): issue with floating division * refactor(infra-k8s): use constant for NANO_SECOND_MULTIPLIER * fix(k8s): fallback to rawKey when meta via dot to under is not found * fix(k8s-base-list): not rendering correctly when keys are duplicated * chore(utils): change no value label to be consistent with previous behavior * fix(k8s-base-list): add min size for columns * fix(k8s-base-list): adjust size of first cell on group * refactor(k8s-base-list): create const for max items to fetch on group by * feat(infra-monitoring): migrate nodes to shared component (#10850) * feat(infra-monitoring): migrate clusters to shared component (#10851) * feat(infra-monitoring): migrate namespaces to shared component (#10852) * feat(infra-monitoring): migrate deployments to shared component (#10854) * feat(infra-monitoring): migrate deployments to shared component * fix(table): ensure widths do not wrap text * feat(infra-monitoring): migrate jobs to shared component (#10857) * feat(infra-monitoring): migrate daemonsets to shared component (#10858) * feat(infra-monitoring): migrate daemonsets to shared component * fix(infra-monitoring-k8s): included more code change than needed * feat(infra-monitoring): migrate volumes to shared component (#10859) * feat(infra-monitoring): migrate volumes to shared component * fix(infra-monitoring-k8s): missing code change than needed * feat(infra-monitoring): migrate statefulsets to shared component (#10853) * refactor(infra-monitoring): remove dead-code (#10865) * refactor(infra-monitoring-k8s): code cleanup (#10867) * refactor(expanded-row): move to own component file * refactor(filters): use correct type for filters * refactor(api): add deprecate comments * refactor(table): rename to config * refactor(k8s-empty): remove unused file * fix(k8s-expanded-row): fix prettify * fix(css): broken css due to update on css modules config * feat(infra-monitoring-hosts): migrate to use shared component (#10874) * feat(infra-monitoring-hosts): use shared component on hosts container * fix(infra-monitoring): migrate to css modules * refactor(k8s-base-list): extract empty state component * fix(img): to correct import * fix(infra-monitoring): state + url desync on quick filters (#10930) * test(k8s-base-list): fix flaky test * refactor(infra-monitoring): better error feedback and fix custom range (#10991) * fix(infra-monitoring): not being able to set custom date * refactor(infra-monitoring): ensure error message is displayed correctly & empty states * fix(infra-monitoring): ensure we can close modal when custom date is defined by parent * refactor(k8s-empty-state): add better error message * fix(k8s-empty-state): try fix issue with import	2026-04-20 15:13:20 +00:00
Pandey	52992c0e80	chore(switch): switch for some time to @therealpandey (#11017 )	2026-04-20 13:29:03 +00:00
Yunus M	5d6ada7a5b	fix: semantic token issues in aws refactor (#11014 ) * fix: semantic token issues in aws refactor * fix: semantic token issues in aws refactor * chore: remove unnecessary light mode styles	2026-04-20 12:34:25 +00:00