diff --git a/frontend/src/api/infra/getHostAttributeKeys.ts b/frontend/src/api/infra/getHostAttributeKeys.ts
index 2cdaf14efc..1a34cd4479 100644
--- a/frontend/src/api/infra/getHostAttributeKeys.ts
+++ b/frontend/src/api/infra/getHostAttributeKeys.ts
@@ -19,6 +19,11 @@ export const getHostAttributeKeys = async (
 			data: IQueryAutocompleteResponse;
 		}> = await ApiBaseInstance.get(
 			`/${entity}/attribute_keys?dataSource=metrics&searchText=${searchText}`,
+			{
+				params: {
+					limit: 500,
+				},
+			},
 		);
 
 		const payload: BaseAutocompleteData[] =
diff --git a/frontend/src/api/infraMonitoring/getK8sNodesList.ts b/frontend/src/api/infraMonitoring/getK8sNodesList.ts
new file mode 100644
index 0000000000..e3c411b1d0
--- /dev/null
+++ b/frontend/src/api/infraMonitoring/getK8sNodesList.ts
@@ -0,0 +1,65 @@
+import { ApiBaseInstance } 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';
+
+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 getK8sNodesList = async (
+	props: K8sNodesListPayload,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
+	try {
+		const response = await ApiBaseInstance.post('/nodes/list', props, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: 'Success',
+			payload: response.data,
+			params: props,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
diff --git a/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.styles.scss b/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.styles.scss
index bdb508058d..f2f0334e7f 100644
--- a/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.styles.scss
+++ b/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.styles.scss
@@ -325,13 +325,19 @@
 	.progress-container {
 		display: flex;
 		align-items: center;
-		flex-direction: column;
+		justify-content: center;
+	}
+
+	.entity-progress-bar {
+		display: flex;
+		align-items: center;
 	}
 
 	.progress-bar {
 		flex: 1;
 		margin-right: 8px;
 		margin-bottom: 0px;
+		min-width: 100px;
 	}
 
 	.clickable-row {
@@ -482,7 +488,7 @@
 		.expanded-table-container {
 			border: 1px solid var(--bg-ink-400);
 			overflow-x: auto;
-			padding: 8px;
+			padding-left: 16px;
 
 			&::-webkit-scrollbar {
 				width: 0.1rem;
@@ -702,3 +708,127 @@
 		}
 	}
 }
+
+.ant-table-cell {
+	min-width: 170px !important;
+	max-width: 170px !important;
+}
+
+.ant-table-row-expand-icon-cell {
+	min-width: 30px !important;
+	max-width: 30px !important;
+}
+
+.event-content-container {
+	.ant-table {
+		background: var(--bg-ink-400);
+
+		.ant-table-row:hover {
+			.ant-table-cell {
+				.value-field {
+					.action-btn {
+						display: flex;
+						position: absolute;
+						top: 50%;
+						right: 16px;
+						transform: translateY(-50%);
+						gap: 4px;
+					}
+				}
+			}
+		}
+
+		.ant-table-cell {
+			border: 1px solid var(--bg-slate-500);
+		}
+
+		.attribute-name {
+			.ant-btn {
+				&:hover {
+					background-color: none !important;
+				}
+			}
+		}
+
+		.attribute-pin {
+			cursor: pointer;
+
+			padding: 0;
+			vertical-align: middle;
+			text-align: center;
+
+			.log-attribute-pin {
+				padding: 8px;
+
+				display: flex;
+				justify-content: center;
+				align-items: center;
+
+				.pin-attribute-icon {
+					border: none;
+
+					&.pinned svg {
+						fill: var(--bg-robin-500);
+					}
+				}
+			}
+		}
+
+		.value-field-container {
+			background: rgba(22, 25, 34, 0.4);
+
+			.value-field {
+				font-family: 'Geist Mono';
+
+				position: relative;
+			}
+
+			.action-btn {
+				display: none;
+				width: max-content;
+				position: absolute;
+				// padding: 0 16px;
+				right: 0;
+
+				.filter-btn {
+					display: flex;
+					align-items: center;
+					border: none;
+					box-shadow: none;
+					border-radius: 2px;
+					background: var(--bg-slate-400);
+					padding: 2px 3px;
+					gap: 3px;
+					height: 18px;
+					width: 20px;
+				}
+			}
+		}
+	}
+}
+
+.lightMode {
+	.event-content-container {
+		.ant-table {
+			background: var(--bg-vanilla-100);
+		}
+
+		.ant-table-cell {
+			border: 1px solid var(--bg-vanilla-200);
+		}
+
+		.value-field-container {
+			background: var(--bg-vanilla-300);
+
+			&.attribute-pin {
+				background: var(--bg-vanilla-100);
+			}
+
+			.action-btn {
+				.filter-btn {
+					background: var(--bg-vanilla-300);
+				}
+			}
+		}
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx b/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx
index edbbad1461..d639b327f5 100644
--- a/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx
@@ -7,40 +7,22 @@ import { Collapse, Tooltip, Typography } from 'antd';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import {
-	ArrowUpDown,
-	Bolt,
-	Boxes,
-	Computer,
-	Container,
-	FilePenLine,
-	Group,
-	HardDrive,
-	PackageOpen,
-	Workflow,
-} from 'lucide-react';
+import { Container, Workflow } from 'lucide-react';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
 import { useCallback, useState } from 'react';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import {
-	ClustersQuickFiltersConfig,
-	ContainersQuickFiltersConfig,
-	DaemonSetsQuickFiltersConfig,
-	DeploymentsQuickFiltersConfig,
-	JobsQuickFiltersConfig,
 	K8sCategories,
-	NamespaceQuickFiltersConfig,
 	NodesQuickFiltersConfig,
 	PodsQuickFiltersConfig,
-	StatefulsetsQuickFiltersConfig,
-	VolumesQuickFiltersConfig,
 } from './constants';
+import K8sNodesList from './Nodes/K8sNodesList';
 import K8sPodLists from './Pods/K8sPodLists';
 import Volumes from './Volumes/Volumes';
 
 export default function InfraMonitoringK8s(): JSX.Element {
-	const [showFilters, setShowFilters] = useState(false);
+	const [showFilters, setShowFilters] = useState(true);
 
 	const [selectedCategory, setSelectedCategory] = useState(K8sCategories.PODS);
 
@@ -106,175 +88,176 @@ export default function InfraMonitoringK8s(): JSX.Element {
 				/>
 			),
 		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<FilePenLine
-							size={14}
-							className="k8s-quick-filters-category-label-icon"
-						/>
-						<Typography.Text>Namespace</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.NAMESPACES,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={NamespaceQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<Boxes size={14} className="k8s-quick-filters-category-label-icon" />
-						<Typography.Text>Clusters</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.CLUSTERS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={ClustersQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<PackageOpen
-							size={14}
-							className="k8s-quick-filters-category-label-icon"
-						/>
-						<Typography.Text>Containers</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.CONTAINERS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={ContainersQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<HardDrive size={14} className="k8s-quick-filters-category-label-icon" />
-						<Typography.Text>Volumes</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.VOLUMES,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={VolumesQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<Computer size={14} className="k8s-quick-filters-category-label-icon" />
-						<Typography.Text>Deployments</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.DEPLOYMENTS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={DeploymentsQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<Bolt size={14} className="k8s-quick-filters-category-label-icon" />
-						<Typography.Text>Jobs</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.JOBS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={JobsQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<Group size={14} className="k8s-quick-filters-category-label-icon" />
-						<Typography.Text>DaemonSets</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.DAEMONSETS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={DaemonSetsQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
-		{
-			label: (
-				<div className="k8s-quick-filters-category-label">
-					<div className="k8s-quick-filters-category-label-container">
-						<ArrowUpDown
-							size={14}
-							className="k8s-quick-filters-category-label-icon"
-						/>
-						<Typography.Text>StatefulSets</Typography.Text>
-					</div>
-				</div>
-			),
-			key: K8sCategories.STATEFULSETS,
-			showArrow: false,
-			children: (
-				<QuickFilters
-					source="infra-monitoring"
-					config={StatefulsetsQuickFiltersConfig}
-					handleFilterVisibilityChange={handleFilterVisibilityChange}
-					onFilterChange={handleFilterChange}
-				/>
-			),
-		},
+		// NOTE - Enabled these as we release new entities
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<FilePenLine
+		// 					size={14}
+		// 					className="k8s-quick-filters-category-label-icon"
+		// 				/>
+		// 				<Typography.Text>Namespace</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.NAMESPACES,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={NamespaceQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<Boxes size={14} className="k8s-quick-filters-category-label-icon" />
+		// 				<Typography.Text>Clusters</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.CLUSTERS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={ClustersQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<PackageOpen
+		// 					size={14}
+		// 					className="k8s-quick-filters-category-label-icon"
+		// 				/>
+		// 				<Typography.Text>Containers</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.CONTAINERS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={ContainersQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<HardDrive size={14} className="k8s-quick-filters-category-label-icon" />
+		// 				<Typography.Text>Volumes</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.VOLUMES,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={VolumesQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<Computer size={14} className="k8s-quick-filters-category-label-icon" />
+		// 				<Typography.Text>Deployments</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.DEPLOYMENTS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={DeploymentsQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<Bolt size={14} className="k8s-quick-filters-category-label-icon" />
+		// 				<Typography.Text>Jobs</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.JOBS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={JobsQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<Group size={14} className="k8s-quick-filters-category-label-icon" />
+		// 				<Typography.Text>DaemonSets</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.DAEMONSETS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={DaemonSetsQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
+		// {
+		// 	label: (
+		// 		<div className="k8s-quick-filters-category-label">
+		// 			<div className="k8s-quick-filters-category-label-container">
+		// 				<ArrowUpDown
+		// 					size={14}
+		// 					className="k8s-quick-filters-category-label-icon"
+		// 				/>
+		// 				<Typography.Text>StatefulSets</Typography.Text>
+		// 			</div>
+		// 		</div>
+		// 	),
+		// 	key: K8sCategories.STATEFULSETS,
+		// 	showArrow: false,
+		// 	children: (
+		// 		<QuickFilters
+		// 			source="infra-monitoring"
+		// 			config={StatefulsetsQuickFiltersConfig}
+		// 			handleFilterVisibilityChange={handleFilterVisibilityChange}
+		// 			onFilterChange={handleFilterChange}
+		// 		/>
+		// 	),
+		// },
 	];
 
 	const handleCategoryChange = (key: string | string[]): void => {
@@ -323,6 +306,13 @@ export default function InfraMonitoringK8s(): JSX.Element {
 							/>
 						)}
 
+						{selectedCategory === K8sCategories.NODES && (
+							<K8sNodesList
+								isFiltersVisible={showFilters}
+								handleFilterVisibilityChange={handleFilterVisibilityChange}
+							/>
+						)}
+
 						{selectedCategory === K8sCategories.VOLUMES && <Volumes />}
 					</div>
 				</div>
diff --git a/frontend/src/container/InfraMonitoringK8s/K8sFiltersSidePanel/K8sFiltersSidePanel.tsx b/frontend/src/container/InfraMonitoringK8s/K8sFiltersSidePanel/K8sFiltersSidePanel.tsx
index 3b8beabb69..8062f338b0 100644
--- a/frontend/src/container/InfraMonitoringK8s/K8sFiltersSidePanel/K8sFiltersSidePanel.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/K8sFiltersSidePanel/K8sFiltersSidePanel.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable jsx-a11y/no-static-element-interactions */
 /* eslint-disable jsx-a11y/click-events-have-key-events */
 import './K8sFiltersSidePanel.styles.scss';
@@ -8,20 +9,20 @@ import { useEffect, useRef, useState } from 'react';
 
 import { IPodColumn } from '../utils';
 
-export default function K8sFiltersSidePanel({
+function K8sFiltersSidePanel({
 	defaultAddedColumns,
 	onClose,
-	addedColumns,
-	availableColumns,
-	onAddColumn,
-	onRemoveColumn,
+	addedColumns = [],
+	availableColumns = [],
+	onAddColumn = () => {},
+	onRemoveColumn = () => {},
 }: {
 	defaultAddedColumns: IPodColumn[];
 	onClose: () => void;
-	addedColumns: IPodColumn[];
-	availableColumns: IPodColumn[];
-	onAddColumn: (column: IPodColumn) => void;
-	onRemoveColumn: (column: IPodColumn) => void;
+	addedColumns?: IPodColumn[];
+	availableColumns?: IPodColumn[];
+	onAddColumn?: (column: IPodColumn) => void;
+	onRemoveColumn?: (column: IPodColumn) => void;
 }): JSX.Element {
 	const [searchValue, setSearchValue] = useState('');
 	const sidePanelRef = useRef<HTMLDivElement>(null);
@@ -117,3 +118,12 @@ export default function K8sFiltersSidePanel({
 		</div>
 	);
 }
+
+K8sFiltersSidePanel.defaultProps = {
+	addedColumns: [],
+	availableColumns: [],
+	onAddColumn: () => {},
+	onRemoveColumn: () => {},
+};
+
+export default K8sFiltersSidePanel;
diff --git a/frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx b/frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx
index 25638f68cf..748cb205b3 100644
--- a/frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
 import './InfraMonitoringK8s.styles.scss';
 
 import { Button, Select } from 'antd';
@@ -15,17 +16,18 @@ import { IPodColumn } from './utils';
 
 interface K8sHeaderProps {
 	selectedGroupBy: BaseAutocompleteData[];
-	defaultAddedColumns: IPodColumn[];
 	groupByOptions: { value: string; label: string }[];
-	addedColumns: IPodColumn[];
 	isLoadingGroupByFilters: boolean;
-	availableColumns: IPodColumn[];
 	handleFiltersChange: (value: IBuilderQuery['filters']) => void;
 	handleGroupByChange: (value: IBuilderQuery['groupBy']) => void;
-	onAddColumn: (column: IPodColumn) => void;
-	onRemoveColumn: (column: IPodColumn) => void;
+	defaultAddedColumns: IPodColumn[];
+	addedColumns?: IPodColumn[];
+	availableColumns?: IPodColumn[];
+	onAddColumn?: (column: IPodColumn) => void;
+	onRemoveColumn?: (column: IPodColumn) => void;
 	handleFilterVisibilityChange: () => void;
 	isFiltersVisible: boolean;
+	entity: K8sCategory;
 }
 
 function K8sHeader({
@@ -41,6 +43,7 @@ function K8sHeader({
 	onRemoveColumn,
 	handleFilterVisibilityChange,
 	isFiltersVisible,
+	entity,
 }: K8sHeaderProps): JSX.Element {
 	const [isFiltersSidePanelOpen, setIsFiltersSidePanelOpen] = useState(false);
 
@@ -96,7 +99,7 @@ function K8sHeader({
 						onChange={handleChangeTagFilters}
 						isInfraMonitoring
 						disableNavigationShortcuts
-						entity={K8sCategory.PODS}
+						entity={entity}
 					/>
 				</div>
 
@@ -127,7 +130,7 @@ function K8sHeader({
 				<Button
 					type="text"
 					className="periscope-btn ghost"
-					disabled={selectedGroupBy.length > 0}
+					disabled={selectedGroupBy?.length > 0}
 					onClick={(): void => setIsFiltersSidePanelOpen(true)}
 				>
 					<SlidersHorizontal size={14} />
@@ -152,4 +155,11 @@ function K8sHeader({
 	);
 }
 
+K8sHeader.defaultProps = {
+	addedColumns: [],
+	availableColumns: [],
+	onAddColumn: () => {},
+	onRemoveColumn: () => {},
+};
+
 export default K8sHeader;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.styles.scss
new file mode 100644
index 0000000000..c09c569a03
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.styles.scss
@@ -0,0 +1,17 @@
+.infra-monitoring-container {
+	.nodes-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;
+		}
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx
new file mode 100644
index 0000000000..c8db90deb2
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx
@@ -0,0 +1,500 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import '../InfraMonitoringK8s.styles.scss';
+import './K8sNodesList.styles.scss';
+
+import { LoadingOutlined } from '@ant-design/icons';
+import {
+	Button,
+	Spin,
+	Table,
+	TablePaginationConfig,
+	TableProps,
+	Typography,
+} from 'antd';
+import { ColumnType, SorterResult } from 'antd/es/table/interface';
+import logEvent from 'api/common/logEvent';
+import { K8sNodesListPayload } from 'api/infraMonitoring/getK8sNodesList';
+import { useGetK8sNodesList } from 'hooks/infraMonitoring/useGetK8sNodesList';
+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 { useCallback, useEffect, useMemo, useState } from 'react';
+import { useSelector } from 'react-redux';
+import { AppState } from 'store/reducers';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { GlobalReducer } from 'types/reducer/globalTime';
+
+import {
+	K8sCategory,
+	K8sEntityToAggregateAttributeMapping,
+} from '../constants';
+import K8sHeader from '../K8sHeader';
+import LoadingContainer from '../LoadingContainer';
+import NodeDetails from './NodeDetails';
+import {
+	defaultAddedColumns,
+	formatDataForTable,
+	getK8sNodesListColumns,
+	getK8sNodesListQuery,
+	K8sNodesRowData,
+} from './utils';
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function K8sNodesList({
+	isFiltersVisible,
+	handleFilterVisibilityChange,
+}: {
+	isFiltersVisible: boolean;
+	handleFilterVisibilityChange: () => void;
+}): JSX.Element {
+	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
+		(state) => state.globalTime,
+	);
+
+	const [currentPage, setCurrentPage] = useState(1);
+
+	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
+
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(null);
+
+	const [selectedNodeUID, setselectedNodeUID] = useState<string | null>(null);
+
+	const pageSize = 10;
+
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>([]);
+
+	const [selectedRowData, setSelectedRowData] = useState<K8sNodesRowData | null>(
+		null,
+	);
+
+	const [groupByOptions, setGroupByOptions] = useState<
+		{ value: string; label: string }[]
+	>([]);
+
+	const createFiltersForSelectedRowData = (
+		selectedRowData: K8sNodesRowData,
+		groupBy: IBuilderQuery['groupBy'],
+	): IBuilderQuery['filters'] => {
+		const baseFilters: IBuilderQuery['filters'] = {
+			items: [],
+			op: 'and',
+		};
+
+		if (!selectedRowData) return baseFilters;
+
+		const { groupedByMeta } = selectedRowData;
+
+		for (const key of groupBy) {
+			baseFilters.items.push({
+				key: {
+					key: key.key,
+				},
+				op: '=',
+				value: groupedByMeta[key.key],
+			});
+		}
+
+		return baseFilters;
+	};
+
+	const fetchGroupedByRowDataQuery = useMemo(() => {
+		if (!selectedRowData) return null;
+
+		const baseQuery = getK8sNodesListQuery();
+
+		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
+
+		return {
+			...baseQuery,
+			limit: 10,
+			offset: 0,
+			filters,
+			start: Math.floor(minTime / 1000000),
+			end: Math.floor(maxTime / 1000000),
+			orderBy,
+		};
+	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
+
+	const {
+		data: groupedByRowData,
+		isFetching: isFetchingGroupedByRowData,
+		isLoading: isLoadingGroupedByRowData,
+		isError: isErrorGroupedByRowData,
+		refetch: fetchGroupedByRowData,
+	} = useGetK8sNodesList(fetchGroupedByRowDataQuery as K8sNodesListPayload, {
+		queryKey: ['nodeList', fetchGroupedByRowDataQuery],
+		enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
+	});
+
+	const { currentQuery } = useQueryBuilder();
+
+	const {
+		data: groupByFiltersData,
+		isLoading: isLoadingGroupByFilters,
+	} = useGetAggregateKeys(
+		{
+			dataSource: currentQuery.builder.queryData[0].dataSource,
+			aggregateAttribute: K8sEntityToAggregateAttributeMapping[K8sCategory.NODES],
+			aggregateOperator: 'noop',
+			searchText: '',
+			tagType: '',
+		},
+		{
+			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
+		},
+		true,
+		K8sCategory.NODES,
+	);
+
+	const queryFilters = useMemo(
+		() =>
+			currentQuery?.builder?.queryData[0]?.filters || {
+				items: [],
+				op: 'and',
+			},
+		[currentQuery?.builder?.queryData],
+	);
+
+	const query = useMemo(() => {
+		const baseQuery = getK8sNodesListQuery();
+		const queryPayload = {
+			...baseQuery,
+			limit: pageSize,
+			offset: (currentPage - 1) * pageSize,
+			filters: queryFilters,
+			start: Math.floor(minTime / 1000000),
+			end: Math.floor(maxTime / 1000000),
+			orderBy,
+		};
+		if (groupBy.length > 0) {
+			queryPayload.groupBy = groupBy;
+		}
+		return queryPayload;
+	}, [currentPage, minTime, maxTime, orderBy, groupBy, queryFilters]);
+
+	const formattedGroupedByNodesData = useMemo(
+		() =>
+			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
+		[groupedByRowData, groupBy],
+	);
+
+	const { data, isFetching, isLoading, isError } = useGetK8sNodesList(
+		query as K8sNodesListPayload,
+		{
+			queryKey: ['nodeList', query],
+			enabled: !!query,
+		},
+	);
+
+	const nodesData = useMemo(() => data?.payload?.data?.records || [], [data]);
+	const totalCount = data?.payload?.data?.total || 0;
+
+	const formattedNodesData = useMemo(
+		() => formatDataForTable(nodesData, groupBy),
+		[nodesData, groupBy],
+	);
+
+	const columns = useMemo(() => getK8sNodesListColumns(groupBy), [groupBy]);
+
+	const handleGroupByRowClick = (record: K8sNodesRowData): 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<K8sNodesRowData>['onChange'] = useCallback(
+		(
+			pagination: TablePaginationConfig,
+			_filters: Record<string, (string | number | boolean)[] | null>,
+			sorter: SorterResult<K8sNodesRowData> | SorterResult<K8sNodesRowData>[],
+		): 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);
+			}
+		},
+		[],
+	);
+
+	const { handleChangeQueryData } = useQueryOperations({
+		index: 0,
+		query: currentQuery.builder.queryData[0],
+		entityVersion: '',
+	});
+
+	const handleFiltersChange = useCallback(
+		(value: IBuilderQuery['filters']): void => {
+			handleChangeQueryData('filters', value);
+			setCurrentPage(1);
+
+			logEvent('Infra Monitoring: K8s list filters applied', {
+				filters: value,
+			});
+		},
+		[handleChangeQueryData],
+	);
+
+	useEffect(() => {
+		logEvent('Infra Monitoring: K8s list page visited', {});
+	}, []);
+
+	const selectedNodeData = useMemo(() => {
+		if (!selectedNodeUID) return null;
+		return nodesData.find((node) => node.nodeUID === selectedNodeUID) || null;
+	}, [selectedNodeUID, nodesData]);
+
+	const handleRowClick = (record: K8sNodesRowData): void => {
+		if (groupBy.length === 0) {
+			setSelectedRowData(null);
+			setselectedNodeUID(record.nodeUID);
+		} else {
+			handleGroupByRowClick(record);
+		}
+
+		logEvent('Infra Monitoring: K8s node list item clicked', {
+			nodeUID: record.nodeUID,
+		});
+	};
+
+	const nestedColumns = useMemo(() => getK8sNodesListColumns([]), []);
+
+	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<K8sNodesRowData>[]}
+						dataSource={formattedGroupedByNodesData}
+						pagination={false}
+						scroll={{ x: true }}
+						tableLayout="fixed"
+						size="small"
+						loading={{
+							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
+							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+						}}
+						showHeader={false}
+					/>
+
+					{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: K8sNodesRowData,
+			e: React.MouseEvent<HTMLButtonElement>,
+		) => void;
+		record: K8sNodesRowData;
+	}): 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 handleCloseNodeDetail = (): void => {
+		setselectedNodeUID(null);
+	};
+
+	const showsNodesTable =
+		!isError &&
+		!isLoading &&
+		!isFetching &&
+		!(formattedNodesData.length === 0 && queryFilters.items.length > 0);
+
+	const showNoFilteredNodesMessage =
+		!isFetching &&
+		!isLoading &&
+		formattedNodesData.length === 0 &&
+		queryFilters.items.length > 0;
+
+	const handleGroupByChange = useCallback(
+		(value: IBuilderQuery['groupBy']) => {
+			const groupBy = [];
+
+			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) {
+					groupBy.push(key);
+				}
+			}
+
+			setGroupBy(groupBy);
+			setExpandedRowKeys([]);
+		},
+		[groupByFiltersData],
+	);
+
+	useEffect(() => {
+		if (groupByFiltersData?.payload) {
+			setGroupByOptions(
+				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
+					value: filter.key,
+					label: filter.key,
+				})) || [],
+			);
+		}
+	}, [groupByFiltersData]);
+
+	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}
+			/>
+			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
+
+			{showNoFilteredNodesMessage && (
+				<div className="no-filtered-hosts-message-container">
+					<div className="no-filtered-hosts-message-content">
+						<img
+							src="/Icons/emptyState.svg"
+							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>
+			)}
+
+			{(isFetching || isLoading) && <LoadingContainer />}
+
+			{showsNodesTable && (
+				<Table
+					className="k8s-list-table nodes-list-table"
+					dataSource={isFetching || isLoading ? [] : formattedNodesData}
+					columns={columns}
+					pagination={{
+						current: currentPage,
+						pageSize,
+						total: totalCount,
+						showSizeChanger: false,
+						hideOnSinglePage: true,
+					}}
+					scroll={{ x: true }}
+					loading={{
+						spinning: isFetching || isLoading,
+						indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
+					}}
+					tableLayout="fixed"
+					onChange={handleTableChange}
+					onRow={(record): { onClick: () => void; className: string } => ({
+						onClick: (): void => handleRowClick(record),
+						className: 'clickable-row',
+					})}
+					expandable={{
+						expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
+						expandIcon: expandRowIconRenderer,
+						expandedRowKeys,
+					}}
+				/>
+			)}
+			<NodeDetails
+				node={selectedNodeData}
+				isModalTimeSelection
+				onClose={handleCloseNodeDetail}
+			/>
+		</div>
+	);
+}
+
+export default K8sNodesList;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NoEventsContainer.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NoEventsContainer.tsx
new file mode 100644
index 0000000000..0fafb37cae
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NoEventsContainer.tsx
@@ -0,0 +1,16 @@
+import { Color } from '@signozhq/design-tokens';
+import { Typography } from 'antd';
+import { Ghost } from 'lucide-react';
+
+const { Text } = Typography;
+
+export default function NoEventsContainer(): React.ReactElement {
+	return (
+		<div className="no-logs-found">
+			<Text type="secondary">
+				<Ghost size={24} color={Color.BG_AMBER_500} /> No events found for this node
+				in the selected time range.
+			</Text>
+		</div>
+	);
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.styles.scss
new file mode 100644
index 0000000000..badd38ed95
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.styles.scss
@@ -0,0 +1,289 @@
+.node-events-container {
+	margin-top: 1rem;
+
+	.filter-section {
+		flex: 1;
+
+		.ant-select-selector {
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400) !important;
+			background-color: var(--bg-ink-300) !important;
+
+			input {
+				font-size: 12px;
+			}
+
+			.ant-tag .ant-typography {
+				font-size: 12px;
+			}
+		}
+	}
+
+	.node-events-header {
+		display: flex;
+		justify-content: space-between;
+		gap: 8px;
+
+		padding: 12px;
+		border-radius: 3px;
+		border: 1px solid var(--bg-slate-500);
+	}
+
+	.node-events {
+		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(--bg-slate-300);
+			}
+
+			&::-webkit-scrollbar-thumb:hover {
+				background: var(--bg-slate-200);
+			}
+
+			.ant-row {
+				width: fit-content;
+			}
+		}
+
+		.skeleton-container {
+			height: 100%;
+			padding: 16px;
+		}
+	}
+
+	.ant-table {
+		.ant-table-thead > tr > th {
+			padding: 12px;
+			font-weight: 500;
+			font-size: 12px;
+			line-height: 18px;
+
+			background: rgb(18, 19, 23);
+			border-bottom: none;
+
+			color: var(--Vanilla-400, #c0c1c3);
+			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(.nodename-column-header) {
+			background: var(--bg-ink-400);
+		}
+
+		.ant-table-cell {
+			padding: 12px;
+			font-size: 13px;
+			line-height: 20px;
+			color: var(--bg-vanilla-100);
+			background: rgb(18, 19, 23);
+			border-bottom: none;
+		}
+
+		.ant-table-cell:has(.nodename-column-value) {
+			background: var(--bg-ink-400);
+		}
+
+		.nodename-column-value {
+			color: var(--Vanilla-100, #fff);
+			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: rgba(255, 255, 255, 0.04);
+		}
+
+		.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-pagination {
+		position: fixed;
+		bottom: 0;
+		width: calc(100% - 64px);
+		background: rgb(18, 19, 23);
+		padding: 16px;
+		margin: 0;
+
+		// this is to offset intercom icon till we improve the design
+		padding-right: 72px;
+
+		.ant-pagination-item {
+			border-radius: 4px;
+
+			&-active {
+				background: var(--bg-robin-500);
+				border-color: var(--bg-robin-500);
+
+				a {
+					color: var(--bg-ink-500) !important;
+				}
+			}
+		}
+	}
+}
+
+.node-events-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;
+	}
+}
+
+.node-events-list-card {
+	width: 100%;
+	margin-top: 12px;
+
+	.ant-table-wrapper {
+		height: 100%;
+		overflow-y: auto;
+
+		&::-webkit-scrollbar {
+			width: 0.3rem;
+			height: 0.3rem;
+		}
+
+		&::-webkit-scrollbar-track {
+			background: transparent;
+		}
+
+		&::-webkit-scrollbar-thumb {
+			background: var(--bg-slate-300);
+		}
+
+		&::-webkit-scrollbar-thumb:hover {
+			background: var(--bg-slate-200);
+		}
+
+		.ant-row {
+			width: fit-content;
+		}
+	}
+
+	.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;
+	}
+}
+
+.lightMode {
+	.filter-section {
+		border-top: 1px solid var(--bg-vanilla-300);
+		border-bottom: 1px solid var(--bg-vanilla-300);
+
+		.ant-select-selector {
+			border-color: var(--bg-vanilla-300) !important;
+			background-color: var(--bg-vanilla-100) !important;
+			color: var(--bg-ink-200);
+		}
+	}
+}
+
+.periscope-btn-icon {
+	cursor: pointer;
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.tsx
new file mode 100644
index 0000000000..a3d300e085
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/NodeEvents.tsx
@@ -0,0 +1,357 @@
+/* eslint-disable no-nested-ternary */
+import './NodeEvents.styles.scss';
+
+import { Color } from '@signozhq/design-tokens';
+import { Button, Table, TableColumnsType } from 'antd';
+import { DEFAULT_ENTITY_VERSION } from 'constants/app';
+import { EventContents } from 'container/InfraMonitoringK8s/commonUtils';
+import LoadingContainer from 'container/InfraMonitoringK8s/LoadingContainer';
+import LogsError from 'container/LogsError/LogsError';
+import { ORDERBY_FILTERS } from 'container/QueryBuilder/filters/OrderByFilter/config';
+import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/config';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
+import { isArray } from 'lodash-es';
+import { ChevronDown, ChevronLeft, ChevronRight, Loader2 } from 'lucide-react';
+import { useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+import { v4 } from 'uuid';
+
+import { getNodesEventsQueryPayload } from './constants';
+import NoEventsContainer from './NoEventsContainer';
+
+interface EventDataType {
+	key: string;
+	timestamp: string;
+	body: string;
+	id: string;
+	attributes_bool?: Record<string, boolean>;
+	attributes_number?: Record<string, number>;
+	attributes_string?: Record<string, string>;
+	resources_string?: Record<string, string>;
+	scope_name?: string;
+	scope_string?: Record<string, string>;
+	scope_version?: string;
+	severity_number?: number;
+	severity_text?: string;
+	span_id?: string;
+	trace_flags?: number;
+	trace_id?: string;
+	severity?: string;
+}
+
+interface INodeEventsProps {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	handleChangeEventFilters: (filters: IBuilderQuery['filters']) => void;
+	filters: IBuilderQuery['filters'];
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
+}
+
+const EventsPageSize = 10;
+
+export default function Events({
+	timeRange,
+	handleChangeEventFilters,
+	filters,
+	isModalTimeSelection,
+	handleTimeChange,
+	selectedInterval,
+}: INodeEventsProps): JSX.Element {
+	const { currentQuery } = useQueryBuilder();
+
+	const [formattedNodeEvents, setFormattedNodeEvents] = useState<
+		EventDataType[]
+	>([]);
+
+	const [hasReachedEndOfEvents, setHasReachedEndOfEvents] = useState(false);
+
+	const [page, setPage] = useState(1);
+
+	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: [],
+							op: 'AND',
+						},
+					},
+				],
+			},
+		}),
+		[currentQuery],
+	);
+
+	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
+
+	const queryPayload = useMemo(() => {
+		const basePayload = getNodesEventsQueryPayload(
+			timeRange.startTime,
+			timeRange.endTime,
+			filters,
+		);
+
+		basePayload.query.builder.queryData[0].pageSize = 10;
+		basePayload.query.builder.queryData[0].orderBy = [
+			{ columnName: 'timestamp', order: ORDERBY_FILTERS.DESC },
+		];
+
+		return basePayload;
+	}, [timeRange.startTime, timeRange.endTime, filters]);
+
+	const { data: eventsData, isLoading, isFetching, isError } = useQuery({
+		queryKey: ['nodeEvents', timeRange.startTime, timeRange.endTime, filters],
+		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
+		enabled: !!queryPayload,
+	});
+
+	const columns: TableColumnsType<EventDataType> = [
+		{ title: 'Severity', dataIndex: 'severity', key: 'severity', width: 100 },
+		{
+			title: 'Timestamp',
+			dataIndex: 'timestamp',
+			width: 200,
+			ellipsis: true,
+			key: 'timestamp',
+		},
+		{ title: 'Body', dataIndex: 'body', key: 'body' },
+	];
+
+	useEffect(() => {
+		if (eventsData?.payload?.data?.newResult?.data?.result) {
+			const responsePayload =
+				eventsData?.payload.data.newResult.data.result[0].list || [];
+
+			const formattedData = responsePayload?.map(
+				(event): EventDataType => ({
+					timestamp: event.timestamp,
+					severity: event.data.severity_text,
+					body: event.data.body,
+					id: event.data.id,
+					key: event.data.id,
+					resources_string: event.data.resources_string,
+				}),
+			);
+
+			setFormattedNodeEvents(formattedData);
+
+			if (
+				!responsePayload ||
+				(responsePayload &&
+					isArray(responsePayload) &&
+					responsePayload.length < EventsPageSize)
+			) {
+				setHasReachedEndOfEvents(true);
+			} else {
+				setHasReachedEndOfEvents(false);
+			}
+		}
+	}, [eventsData]);
+
+	const handleExpandRow = (record: EventDataType): JSX.Element => (
+		<EventContents data={record.resources_string} />
+	);
+
+	const handlePrev = (): void => {
+		if (!formattedNodeEvents.length) return;
+
+		setPage(page - 1);
+
+		const firstEvent = formattedNodeEvents[0];
+
+		const newItems = [
+			...filters.items.filter((item) => item.key?.key !== 'id'),
+			{
+				id: v4(),
+				key: {
+					key: 'id',
+					type: '',
+					dataType: DataTypes.String,
+					isColumn: true,
+				},
+				op: '>',
+				value: firstEvent.id,
+			},
+		];
+
+		const newFilters = {
+			op: 'AND',
+			items: newItems,
+		} as IBuilderQuery['filters'];
+
+		handleChangeEventFilters(newFilters);
+	};
+
+	const handleNext = (): void => {
+		if (!formattedNodeEvents.length) return;
+
+		setPage(page + 1);
+		const lastEvent = formattedNodeEvents[formattedNodeEvents.length - 1];
+
+		const newItems = [
+			...filters.items.filter((item) => item.key?.key !== 'id'),
+			{
+				id: v4(),
+				key: {
+					key: 'id',
+					type: '',
+					dataType: DataTypes.String,
+					isColumn: true,
+				},
+				op: '<',
+				value: lastEvent.id,
+			},
+		];
+
+		const newFilters = {
+			op: 'AND',
+			items: newItems,
+		} as IBuilderQuery['filters'];
+
+		handleChangeEventFilters(newFilters);
+	};
+
+	const handleExpandRowIcon = ({
+		expanded,
+		onExpand,
+		record,
+	}: {
+		expanded: boolean;
+		onExpand: (
+			record: EventDataType,
+			e: React.MouseEvent<HTMLElement, MouseEvent>,
+		) => void;
+		record: EventDataType;
+	}): JSX.Element =>
+		expanded ? (
+			<ChevronDown
+				className="periscope-btn-icon"
+				size={14}
+				onClick={(e): void =>
+					onExpand(
+						record,
+						(e as unknown) as React.MouseEvent<HTMLElement, MouseEvent>,
+					)
+				}
+			/>
+		) : (
+			<ChevronRight
+				className="periscope-btn-icon"
+				size={14}
+				// eslint-disable-next-line sonarjs/no-identical-functions
+				onClick={(e): void =>
+					onExpand(
+						record,
+						(e as unknown) as React.MouseEvent<HTMLElement, MouseEvent>,
+					)
+				}
+			/>
+		);
+
+	return (
+		<div className="node-events-container">
+			<div className="node-events-header">
+				<div className="filter-section">
+					{query && (
+						<QueryBuilderSearch
+							query={query}
+							onChange={handleChangeEventFilters}
+							disableNavigationShortcuts
+						/>
+					)}
+				</div>
+				<div className="datetime-section">
+					<DateTimeSelectionV2
+						showAutoRefresh={false}
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+					/>
+				</div>
+			</div>
+
+			{isLoading && <LoadingContainer />}
+
+			{!isLoading && !isError && formattedNodeEvents.length === 0 && (
+				<NoEventsContainer />
+			)}
+
+			{isError && !isLoading && <LogsError />}
+
+			{!isLoading && !isError && formattedNodeEvents.length > 0 && (
+				<div className="node-events-list-container">
+					<div className="node-events-list-card">
+						<Table<EventDataType>
+							loading={isLoading && page > 1}
+							columns={columns}
+							expandable={{
+								expandedRowRender: handleExpandRow,
+								rowExpandable: (record): boolean => record.body !== 'Not Expandable',
+								expandIcon: handleExpandRowIcon,
+							}}
+							dataSource={formattedNodeEvents}
+							pagination={false}
+							rowKey={(record): string => record.id}
+						/>
+					</div>
+				</div>
+			)}
+
+			{!isError && formattedNodeEvents.length > 0 && (
+				<div className="node-events-footer">
+					<Button
+						className="node-events-footer-button periscope-btn ghost"
+						type="link"
+						onClick={handlePrev}
+						disabled={page === 1 || isFetching || isLoading}
+					>
+						{!isFetching && <ChevronLeft size={14} />}
+						Prev
+					</Button>
+
+					<Button
+						className="node-events-footer-button periscope-btn ghost"
+						type="link"
+						onClick={handleNext}
+						disabled={hasReachedEndOfEvents || isFetching || isLoading}
+					>
+						Next
+						{!isFetching && <ChevronRight size={14} />}
+					</Button>
+
+					{(isFetching || isLoading) && (
+						<Loader2 className="animate-spin" size={16} color={Color.BG_ROBIN_500} />
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/constants.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/constants.ts
new file mode 100644
index 0000000000..d4c5a13a35
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/constants.ts
@@ -0,0 +1,65 @@
+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 } from 'types/common/queryBuilder';
+import { v4 as uuidv4 } from 'uuid';
+
+export const getNodesEventsQueryPayload = (
+	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: '',
+						isColumn: false,
+						type: '',
+						isJSON: false,
+					},
+					timeAggregation: 'rate',
+					spaceAggregation: 'sum',
+					functions: [],
+					filters,
+					expression: 'A',
+					disabled: false,
+					stepInterval: 60,
+					having: [],
+					limit: null,
+					orderBy: [
+						{
+							columnName: 'timestamp',
+							order: 'desc',
+						},
+					],
+					groupBy: [],
+					legend: '',
+					reduceTo: 'avg',
+					offset: 0,
+					pageSize: 100,
+				},
+			],
+			queryFormulas: [],
+		},
+		id: uuidv4(),
+		queryType: EQueryType.QUERY_BUILDER,
+	},
+	params: {
+		lastLogLineTimestamp: null,
+	},
+	start,
+	end,
+});
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/index.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/index.ts
new file mode 100644
index 0000000000..ce518fd1b7
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Events/index.ts
@@ -0,0 +1,3 @@
+import NodeEvents from './NodeEvents';
+
+export default NodeEvents;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NoLogsContainer.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NoLogsContainer.tsx
new file mode 100644
index 0000000000..6b4e96053f
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NoLogsContainer.tsx
@@ -0,0 +1,16 @@
+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 node
+				in the selected time range.
+			</Text>
+		</div>
+	);
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.styles.scss
new file mode 100644
index 0000000000..71f6b7f3f8
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.styles.scss
@@ -0,0 +1,133 @@
+.node-logs-container {
+	margin-top: 1rem;
+
+	.filter-section {
+		flex: 1;
+
+		.ant-select-selector {
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400) !important;
+			background-color: var(--bg-ink-300) !important;
+
+			input {
+				font-size: 12px;
+			}
+
+			.ant-tag .ant-typography {
+				font-size: 12px;
+			}
+		}
+	}
+
+	.node-logs-header {
+		display: flex;
+		justify-content: space-between;
+		gap: 8px;
+
+		padding: 12px;
+		border-radius: 3px;
+		border: 1px solid var(--bg-slate-500);
+	}
+
+	.node-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(--bg-slate-300);
+			}
+
+			&::-webkit-scrollbar-thumb:hover {
+				background: var(--bg-slate-200);
+			}
+
+			.ant-row {
+				width: fit-content;
+			}
+		}
+
+		.skeleton-container {
+			height: 100%;
+			padding: 16px;
+		}
+	}
+}
+
+.node-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;
+	}
+}
+
+.node-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;
+	}
+}
+
+.lightMode {
+	.filter-section {
+		border-top: 1px solid var(--bg-vanilla-300);
+		border-bottom: 1px solid var(--bg-vanilla-300);
+
+		.ant-select-selector {
+			border-color: var(--bg-vanilla-300) !important;
+			background-color: var(--bg-vanilla-100) !important;
+			color: var(--bg-ink-200);
+		}
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.tsx
new file mode 100644
index 0000000000..c9880228f1
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogs.tsx
@@ -0,0 +1,216 @@
+/* eslint-disable no-nested-ternary */
+import './NodeLogs.styles.scss';
+
+import { Card } from 'antd';
+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 { ORDERBY_FILTERS } from 'container/QueryBuilder/filters/OrderByFilter/config';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
+import { isEqual } from 'lodash-es';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+import { Virtuoso } from 'react-virtuoso';
+import { ILog } from 'types/api/logs/log';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import {
+	IBuilderQuery,
+	TagFilterItem,
+} from 'types/api/queryBuilder/queryBuilderData';
+import { v4 } from 'uuid';
+
+import { QUERY_KEYS } from '../constants';
+import { getNodeLogsQueryPayload } from './constants';
+import NoLogsContainer from './NoLogsContainer';
+
+interface Props {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	handleChangeLogFilters: (filters: IBuilderQuery['filters']) => void;
+	filters: IBuilderQuery['filters'];
+}
+
+function PodLogs({
+	timeRange,
+	handleChangeLogFilters,
+	filters,
+}: Props): JSX.Element {
+	const [logs, setLogs] = useState<ILog[]>([]);
+	const [hasReachedEndOfLogs, setHasReachedEndOfLogs] = useState(false);
+	const [restFilters, setRestFilters] = useState<TagFilterItem[]>([]);
+	const [resetLogsList, setResetLogsList] = useState<boolean>(false);
+
+	useEffect(() => {
+		const newRestFilters = filters.items.filter(
+			(item) =>
+				item.key?.key !== 'id' &&
+				![QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
+					item.key?.key ?? '',
+				),
+		);
+
+		const areFiltersSame = isEqual(restFilters, newRestFilters);
+
+		if (!areFiltersSame) {
+			setResetLogsList(true);
+		}
+
+		setRestFilters(newRestFilters);
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [filters]);
+
+	const queryPayload = useMemo(() => {
+		const basePayload = getNodeLogsQueryPayload(
+			timeRange.startTime,
+			timeRange.endTime,
+			filters,
+		);
+
+		basePayload.query.builder.queryData[0].pageSize = 100;
+		basePayload.query.builder.queryData[0].orderBy = [
+			{ columnName: 'timestamp', order: ORDERBY_FILTERS.DESC },
+		];
+
+		return basePayload;
+	}, [timeRange.startTime, timeRange.endTime, filters]);
+
+	const [isPaginating, setIsPaginating] = useState(false);
+
+	const { data, isLoading, isFetching, isError } = useQuery({
+		queryKey: ['nodeLogs', timeRange.startTime, timeRange.endTime, filters],
+		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
+		enabled: !!queryPayload,
+		keepPreviousData: isPaginating,
+	});
+
+	useEffect(() => {
+		if (data?.payload?.data?.newResult?.data?.result) {
+			const currentData = data.payload.data.newResult.data.result;
+
+			if (resetLogsList) {
+				const currentLogs: ILog[] =
+					currentData[0].list?.map((item) => ({
+						...item.data,
+						timestamp: item.timestamp,
+					})) || [];
+
+				setLogs(currentLogs);
+
+				setResetLogsList(false);
+			}
+
+			if (currentData.length > 0 && currentData[0].list) {
+				const currentLogs: ILog[] =
+					currentData[0].list.map((item) => ({
+						...item.data,
+						timestamp: item.timestamp,
+					})) || [];
+
+				setLogs((prev) => [...prev, ...currentLogs]);
+			} else {
+				setHasReachedEndOfLogs(true);
+			}
+		}
+	}, [data, restFilters, isPaginating, resetLogsList]);
+
+	const getItemContent = useCallback(
+		(_: number, logToRender: ILog): JSX.Element => (
+			<RawLogView
+				isReadOnly
+				isTextOverflowEllipsisDisabled
+				key={logToRender.id}
+				data={logToRender}
+				linesPerRow={5}
+				fontSize={FontSize.MEDIUM}
+			/>
+		),
+		[],
+	);
+
+	const loadMoreLogs = useCallback(() => {
+		if (!logs.length) return;
+
+		setIsPaginating(true);
+		const lastLog = logs[logs.length - 1];
+
+		const newItems = [
+			...filters.items.filter((item) => item.key?.key !== 'id'),
+			{
+				id: v4(),
+				key: {
+					key: 'id',
+					type: '',
+					dataType: DataTypes.String,
+					isColumn: true,
+				},
+				op: '<',
+				value: lastLog.id,
+			},
+		];
+
+		const newFilters = {
+			op: 'AND',
+			items: newItems,
+		} as IBuilderQuery['filters'];
+
+		handleChangeLogFilters(newFilters);
+	}, [logs, filters, handleChangeLogFilters]);
+
+	useEffect(() => {
+		setIsPaginating(false);
+	}, [data]);
+
+	const renderFooter = useCallback(
+		(): JSX.Element | null => (
+			// eslint-disable-next-line react/jsx-no-useless-fragment
+			<>
+				{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="node-logs-list-card">
+				<OverlayScrollbar isVirtuoso>
+					<Virtuoso
+						className="node-logs-virtuoso"
+						key="node-logs-virtuoso"
+						data={logs}
+						endReached={loadMoreLogs}
+						totalCount={logs.length}
+						itemContent={getItemContent}
+						overscan={200}
+						components={{
+							Footer: renderFooter,
+						}}
+					/>
+				</OverlayScrollbar>
+			</Card>
+		),
+		[logs, loadMoreLogs, getItemContent, renderFooter],
+	);
+
+	return (
+		<div className="node-logs">
+			{isLoading && <LogsLoading />}
+			{!isLoading && !isError && logs.length === 0 && <NoLogsContainer />}
+			{isError && !isLoading && <LogsError />}
+			{!isLoading && !isError && logs.length > 0 && (
+				<div className="node-logs-list-container">{renderContent}</div>
+			)}
+		</div>
+	);
+}
+
+export default PodLogs;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogsDetailedView.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogsDetailedView.tsx
new file mode 100644
index 0000000000..5bbec59ade
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/NodeLogsDetailedView.tsx
@@ -0,0 +1,99 @@
+import './NodeLogs.styles.scss';
+
+import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/config';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useMemo } from 'react';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import NodeLogs from './NodeLogs';
+
+interface Props {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	handleChangeLogFilters: (value: IBuilderQuery['filters']) => void;
+	logFilters: IBuilderQuery['filters'];
+	selectedInterval: Time;
+}
+
+function NodeLogsDetailedView({
+	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: [],
+							op: 'AND',
+						},
+					},
+				],
+			},
+		}),
+		[currentQuery],
+	);
+
+	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
+
+	return (
+		<div className="node-logs-container">
+			<div className="node-logs-header">
+				<div className="filter-section">
+					{query && (
+						<QueryBuilderSearch
+							query={query}
+							onChange={handleChangeLogFilters}
+							disableNavigationShortcuts
+						/>
+					)}
+				</div>
+				<div className="datetime-section">
+					<DateTimeSelectionV2
+						showAutoRefresh={false}
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+					/>
+				</div>
+			</div>
+			<NodeLogs
+				timeRange={timeRange}
+				handleChangeLogFilters={handleChangeLogFilters}
+				filters={logFilters}
+			/>
+		</div>
+	);
+}
+
+export default NodeLogsDetailedView;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/constants.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/constants.ts
new file mode 100644
index 0000000000..64488e4db4
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/constants.ts
@@ -0,0 +1,65 @@
+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 } from 'types/common/queryBuilder';
+import { v4 as uuidv4 } from 'uuid';
+
+export const getNodeLogsQueryPayload = (
+	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: '',
+						isColumn: false,
+						type: '',
+						isJSON: false,
+					},
+					timeAggregation: 'rate',
+					spaceAggregation: 'sum',
+					functions: [],
+					filters,
+					expression: 'A',
+					disabled: false,
+					stepInterval: 60,
+					having: [],
+					limit: null,
+					orderBy: [
+						{
+							columnName: 'timestamp',
+							order: 'desc',
+						},
+					],
+					groupBy: [],
+					legend: '',
+					reduceTo: 'avg',
+					offset: 0,
+					pageSize: 100,
+				},
+			],
+			queryFormulas: [],
+		},
+		id: uuidv4(),
+		queryType: EQueryType.QUERY_BUILDER,
+	},
+	params: {
+		lastLogLineTimestamp: null,
+	},
+	start,
+	end,
+});
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/index.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/index.ts
new file mode 100644
index 0000000000..977dda6f01
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Logs/index.ts
@@ -0,0 +1,3 @@
+import NodeLogs from './NodeLogsDetailedView';
+
+export default NodeLogs;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.styles.scss
new file mode 100644
index 0000000000..bb24b9a5fe
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.styles.scss
@@ -0,0 +1,45 @@
+.empty-container {
+	display: flex;
+	justify-content: center;
+	align-items: center;
+	height: 100%;
+}
+
+.node-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(--bg-slate-500);
+}
+
+.node-metrics-card {
+	margin: 8px 0 1rem 0;
+	height: 300px;
+	padding: 10px;
+
+	border: 1px solid var(--bg-slate-500);
+
+	.ant-card-body {
+		padding: 0;
+	}
+
+	.chart-container {
+		width: 100%;
+		height: 100%;
+	}
+
+	.no-data-container {
+		position: absolute;
+		top: 50%;
+		left: 50%;
+		transform: translate(-50%, -50%);
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.tsx
new file mode 100644
index 0000000000..46d2c78cc1
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/NodeMetrics.tsx
@@ -0,0 +1,140 @@
+import './NodeMetrics.styles.scss';
+
+import { Card, Col, Row, Skeleton, Typography } from 'antd';
+import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
+import cx from 'classnames';
+import Uplot from 'components/Uplot';
+import { ENTITY_VERSION_V4 } from 'constants/app';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/config';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import { useResizeObserver } from 'hooks/useDimensions';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
+import { getUPlotChartOptions } from 'lib/uPlotLib/getUplotChartOptions';
+import { getUPlotChartData } from 'lib/uPlotLib/utils/getUplotChartData';
+import { useMemo, useRef } from 'react';
+import { useQueries, UseQueryResult } from 'react-query';
+import { SuccessResponse } from 'types/api';
+import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+
+import { getNodeQueryPayload, nodeWidgetInfo } from './constants';
+
+interface NodeMetricsProps {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	selectedInterval: Time;
+	node: K8sNodesData;
+}
+
+function NodeMetrics({
+	selectedInterval,
+	node,
+	timeRange,
+	handleTimeChange,
+	isModalTimeSelection,
+}: NodeMetricsProps): JSX.Element {
+	const queryPayloads = useMemo(
+		() => getNodeQueryPayload(node, timeRange.startTime, timeRange.endTime),
+		[node, timeRange.startTime, timeRange.endTime],
+	);
+
+	const queries = useQueries(
+		queryPayloads.map((payload) => ({
+			queryKey: ['node-metrics', payload, ENTITY_VERSION_V4, 'NODE'],
+			queryFn: (): Promise<SuccessResponse<MetricRangePayloadProps>> =>
+				GetMetricQueryRange(payload, ENTITY_VERSION_V4),
+			enabled: !!payload,
+		})),
+	);
+
+	const isDarkMode = useIsDarkMode();
+	const graphRef = useRef<HTMLDivElement>(null);
+	const dimensions = useResizeObserver(graphRef);
+
+	const chartData = useMemo(
+		() => queries.map(({ data }) => getUPlotChartData(data?.payload)),
+		[queries],
+	);
+
+	const options = useMemo(
+		() =>
+			queries.map(({ data }, idx) =>
+				getUPlotChartOptions({
+					apiResponse: data?.payload,
+					isDarkMode,
+					dimensions,
+					yAxisUnit: nodeWidgetInfo[idx].yAxisUnit,
+					softMax: null,
+					softMin: null,
+					minTimeScale: timeRange.startTime,
+					maxTimeScale: timeRange.endTime,
+				}),
+			),
+		[queries, isDarkMode, dimensions, timeRange.startTime, timeRange.endTime],
+	);
+
+	const renderCardContent = (
+		query: UseQueryResult<SuccessResponse<MetricRangePayloadProps>, unknown>,
+		idx: number,
+	): JSX.Element => {
+		if (query.isLoading) {
+			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={false}
+						showRefreshText={false}
+						hideShareModal
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						isModalTimeSelection={isModalTimeSelection}
+						modalSelectedInterval={selectedInterval}
+					/>
+				</div>
+			</div>
+			<Row gutter={24} className="node-metrics-container">
+				{queries.map((query, idx) => (
+					<Col span={12} key={nodeWidgetInfo[idx].title}>
+						<Typography.Text>{nodeWidgetInfo[idx].title}</Typography.Text>
+						<Card bordered className="node-metrics-card" ref={graphRef}>
+							{renderCardContent(query, idx)}
+						</Card>
+					</Col>
+				))}
+			</Row>
+		</>
+	);
+}
+
+export default NodeMetrics;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/constants.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/constants.ts
new file mode 100644
index 0000000000..47a3f508b4
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/constants.ts
@@ -0,0 +1,1634 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { EQueryType } from 'types/common/dashboard';
+import { DataSource } from 'types/common/queryBuilder';
+import { v4 } from 'uuid';
+
+export const nodeWidgetInfo = [
+	{
+		title: 'CPU Usage (cores)',
+		yAxisUnit: '',
+	},
+	{
+		title: 'Memory Usage (bytes)',
+		yAxisUnit: 'bytes',
+	},
+	{
+		title: 'CPU Usage (%)',
+		yAxisUnit: 'percentunit',
+	},
+	{
+		title: 'Memory Usage (%)',
+		yAxisUnit: 'percentunit',
+	},
+	{
+		title: 'Pods by CPU (top 10)',
+		yAxisUnit: '',
+	},
+	{
+		title: 'Pods by Memory (top 10)',
+		yAxisUnit: 'bytes',
+	},
+	{
+		title: 'Network error count',
+		yAxisUnit: '',
+	},
+	{
+		title: 'Network IO rate',
+		yAxisUnit: 'binBps',
+	},
+	{
+		title: 'Filesystem usage (bytes)',
+		yAxisUnit: 'bytes',
+	},
+	{
+		title: 'Filesystem usage (%)',
+		yAxisUnit: 'percentunit',
+	},
+];
+
+export const getNodeQueryPayload = (
+	node: K8sNodesData,
+	start: number,
+	end: number,
+): GetQueryResultsProps[] => [
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_cpu_utilization--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_cpu_utilization',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: '441b62d7',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (avg)',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_allocatable_cpu--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_allocatable_cpu',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: 'b205b1a3',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'allocatable',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'max',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_container_cpu_request--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_container_cpu_request',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'C',
+						filters: {
+							items: [
+								{
+									id: '884c2bf3',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'requests',
+						limit: null,
+						orderBy: [],
+						queryName: 'C',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_cpu_utilization--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_cpu_utilization',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'max',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'D',
+						filters: {
+							items: [
+								{
+									id: '98be9da1',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (max)',
+						limit: null,
+						orderBy: [],
+						queryName: 'D',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'max',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_cpu_utilization--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_cpu_utilization',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'min',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'E',
+						filters: {
+							items: [
+								{
+									id: 'ce97dd7b',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (min)',
+						limit: null,
+						orderBy: [],
+						queryName: 'E',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'min',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'fdffcbb2',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (avg)',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_allocatable_memory--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_allocatable_memory',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: '9b79a8bd',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'allocatable',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'max',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_container_memory_request--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_container_memory_request',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'C',
+						filters: {
+							items: [
+								{
+									id: '3387fb4a',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'requests',
+						limit: null,
+						orderBy: [],
+						queryName: 'C',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'max',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'D',
+						filters: {
+							items: [
+								{
+									id: 'd1ad7ccb',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (max)',
+						limit: null,
+						orderBy: [],
+						queryName: 'D',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'max',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'min',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'E',
+						filters: {
+							items: [
+								{
+									id: '5e578329',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used (min)',
+						limit: null,
+						orderBy: [],
+						queryName: 'E',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'min',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_working_set--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_working_set',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'F',
+						filters: {
+							items: [
+								{
+									id: '6ab3ec98',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'working set',
+						limit: null,
+						orderBy: [],
+						queryName: 'F',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_rss--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_rss',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'G',
+						filters: {
+							items: [
+								{
+									id: '80c9a1db',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'rss',
+						limit: null,
+						orderBy: [],
+						queryName: 'G',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_cpu_utilization--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_cpu_utilization',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: '752765ef',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_allocatable_cpu--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_allocatable_cpu',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: 'f0c5c1ed',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'allocatable',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'max',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_container_cpu_request--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_container_cpu_request',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'C',
+						filters: {
+							items: [
+								{
+									id: 'b952b389',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'requests',
+						limit: null,
+						orderBy: [],
+						queryName: 'C',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+				],
+				queryFormulas: [
+					{
+						disabled: false,
+						expression: 'A/B',
+						legend: 'used/allocatable',
+						queryName: 'F1',
+					},
+					{
+						disabled: false,
+						expression: 'A/C',
+						legend: 'used/request',
+						queryName: 'F2',
+					},
+				],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_memory_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_memory_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'c2a2c926',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_allocatable_memory--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_allocatable_memory',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: '20e6760c',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'allocatable',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'max',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_container_memory_request--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_container_memory_request',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'latest',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'C',
+						filters: {
+							items: [
+								{
+									id: 'fcc4d5e8',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'requests',
+						limit: null,
+						orderBy: [],
+						queryName: 'C',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'latest',
+					},
+				],
+				queryFormulas: [
+					{
+						disabled: false,
+						expression: 'A/B',
+						legend: 'used/allocatable',
+						queryName: 'F1',
+					},
+					{
+						disabled: false,
+						expression: 'A/C',
+						legend: 'used/request',
+						queryName: 'F2',
+					},
+				],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_pod_cpu_utilization--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_pod_cpu_utilization',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: '88d38c06',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [
+							{
+								dataType: DataTypes.String,
+								id: 'k8s_pod_name--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'k8s_pod_name',
+								type: 'tag',
+							},
+						],
+						having: [],
+						legend: '{{k8s_pod_name}}',
+						limit: 10,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_pod_memory_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_pod_memory_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: '43033387',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [
+							{
+								dataType: DataTypes.String,
+								id: 'k8s_pod_name--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'k8s_pod_name',
+								type: 'tag',
+							},
+						],
+						having: [],
+						legend: '{{k8s_pod_name}}',
+						limit: 10,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_network_errors--float64--Sum--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_network_errors',
+							type: 'Sum',
+						},
+						aggregateOperator: 'increase',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'e9ce8079',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [
+							{
+								dataType: DataTypes.String,
+								id: 'direction--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'direction',
+								type: 'tag',
+							},
+							{
+								dataType: DataTypes.String,
+								id: 'interface--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'interface',
+								type: 'tag',
+							},
+						],
+						having: [],
+						legend: '{{direction}} :: {{interface}}',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'increase',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_network_io--float64--Sum--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_network_io',
+							type: 'Sum',
+						},
+						aggregateOperator: 'rate',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'd62d103f',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [
+							{
+								dataType: DataTypes.String,
+								id: 'direction--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'direction',
+								type: 'tag',
+							},
+							{
+								dataType: DataTypes.String,
+								id: 'interface--string--tag--false',
+								isColumn: false,
+								isJSON: false,
+								key: 'interface',
+								type: 'tag',
+							},
+						],
+						having: [],
+						legend: '{{direction}} :: {{interface}}',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'rate',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_filesystem_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_filesystem_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'b85d3580',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_filesystem_capacity--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_filesystem_capacity',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: '23f502e1',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'capacity',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_filesystem_available--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_filesystem_available',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: false,
+						expression: 'C',
+						filters: {
+							items: [
+								{
+									id: 'b80650ec',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'available',
+						limit: null,
+						orderBy: [],
+						queryName: 'C',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+				],
+				queryFormulas: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TIME_SERIES,
+		query: {
+			builder: {
+				queryData: [
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_filesystem_usage--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_filesystem_usage',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'A',
+						filters: {
+							items: [
+								{
+									id: 'b85d3580',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'used',
+						limit: null,
+						orderBy: [],
+						queryName: 'A',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+					{
+						aggregateAttribute: {
+							dataType: DataTypes.Float64,
+							id: 'k8s_node_filesystem_capacity--float64--Gauge--true',
+							isColumn: true,
+							isJSON: false,
+							key: 'k8s_node_filesystem_capacity',
+							type: 'Gauge',
+						},
+						aggregateOperator: 'avg',
+						dataSource: DataSource.METRICS,
+						disabled: true,
+						expression: 'B',
+						filters: {
+							items: [
+								{
+									id: '23f502e1',
+									key: {
+										dataType: DataTypes.String,
+										id: 'k8s_node_name--string--tag--false',
+										isColumn: false,
+										isJSON: false,
+										key: 'k8s_node_name',
+										type: 'tag',
+									},
+									op: '=',
+									value: node.meta.k8s_node_name,
+								},
+							],
+							op: 'AND',
+						},
+						functions: [],
+						groupBy: [],
+						having: [],
+						legend: 'capacity',
+						limit: null,
+						orderBy: [],
+						queryName: 'B',
+						reduceTo: 'avg',
+						spaceAggregation: 'sum',
+						stepInterval: 60,
+						timeAggregation: 'avg',
+					},
+				],
+				queryFormulas: [
+					{
+						disabled: false,
+						expression: 'A/B',
+						legend: 'util %',
+						queryName: 'F1',
+					},
+				],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			id: v4(),
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
+		},
+		variables: {},
+		formatForWeb: false,
+		start,
+		end,
+	},
+];
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/index.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/index.ts
new file mode 100644
index 0000000000..3c2c065a5f
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Metrics/index.ts
@@ -0,0 +1,3 @@
+import NodeMetrics from './NodeMetrics';
+
+export default NodeMetrics;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.interfaces.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.interfaces.ts
new file mode 100644
index 0000000000..eaa2613260
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.interfaces.ts
@@ -0,0 +1,7 @@
+import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
+
+export type NodeDetailsProps = {
+	node: K8sNodesData | null;
+	isModalTimeSelection: boolean;
+	onClose: () => void;
+};
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.styles.scss
new file mode 100644
index 0000000000..76014ba387
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.styles.scss
@@ -0,0 +1,247 @@
+.node-detail-drawer {
+	border-left: 1px solid var(--bg-slate-500);
+	background: var(--bg-ink-400);
+	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(--bg-slate-500);
+		background: var(--bg-ink-400);
+	}
+
+	.ant-drawer-close {
+		margin-inline-end: 0px;
+	}
+
+	.ant-drawer-body {
+		display: flex;
+		flex-direction: column;
+		padding: 16px;
+	}
+
+	.title {
+		color: var(--text-vanilla-400);
+		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(--bg-slate-400);
+		background: var(--bg-ink-300);
+		box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
+	}
+
+	.node-detail-drawer__node {
+		.node-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;
+			}
+
+			.node-details-metadata-label {
+				color: var(--text-vanilla-400);
+				font-family: Inter;
+				font-size: 11px;
+				font-style: normal;
+				font-weight: 500;
+				line-height: 18px; /* 163.636% */
+				letter-spacing: 0.44px;
+				text-transform: uppercase;
+			}
+
+			.node-details-metadata-value {
+				color: var(--text-vanilla-400);
+				font-family: 'Geist Mono';
+				font-size: 12px;
+				font-style: normal;
+				font-weight: 500;
+				line-height: 20px; /* 142.857% */
+				letter-spacing: -0.07px;
+
+				width: 100%;
+				white-space: nowrap;
+				overflow: hidden;
+				text-overflow: ellipsis;
+			}
+
+			.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(--bg-slate-500) !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(--bg-slate-400);
+			background: var(--bg-ink-300);
+			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(--text-vanilla-400);
+
+			.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(--bg-slate-400);
+				width: 114px;
+			}
+
+			.tab::before {
+				background: var(--bg-slate-400);
+			}
+
+			.selected_view {
+				background: var(--bg-slate-300);
+				color: var(--text-vanilla-100);
+				border: 1px solid var(--bg-slate-400);
+			}
+
+			.selected_view::before {
+				background: var(--bg-slate-400);
+			}
+		}
+
+		.compass-button {
+			width: 30px;
+			height: 30px;
+
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400);
+			background: var(--bg-ink-300);
+			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
+		}
+	}
+	.ant-drawer-close {
+		padding: 0px;
+	}
+}
+
+.lightMode {
+	.ant-drawer-header {
+		border-bottom: 1px solid var(--bg-vanilla-400);
+		background: var(--bg-vanilla-100);
+	}
+
+	.node-detail-drawer {
+		.title {
+			color: var(--text-ink-300);
+		}
+
+		.node-detail-drawer__node {
+			.ant-typography {
+				color: var(--text-ink-300);
+				background: transparent;
+			}
+		}
+
+		.radio-button {
+			border: 1px solid var(--bg-vanilla-400);
+			background: var(--bg-vanilla-100);
+			color: var(--text-ink-300);
+		}
+
+		.views-tabs {
+			.tab {
+				background: var(--bg-vanilla-100);
+			}
+
+			.selected_view {
+				background: var(--bg-vanilla-300);
+				border: 1px solid var(--bg-slate-300);
+				color: var(--text-ink-400);
+			}
+
+			.selected_view::before {
+				background: var(--bg-vanilla-300);
+				border-left: 1px solid var(--bg-slate-300);
+			}
+		}
+
+		.compass-button {
+			border: 1px solid var(--bg-vanilla-300);
+			background: var(--bg-vanilla-100);
+			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
+		}
+
+		.tabs-and-search {
+			.action-btn {
+				border: 1px solid var(--bg-vanilla-400);
+				background: var(--bg-vanilla-100);
+				color: var(--text-ink-300);
+			}
+		}
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx
new file mode 100644
index 0000000000..84febfed61
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx
@@ -0,0 +1,554 @@
+/* eslint-disable sonarjs/no-identical-functions */
+import './NodeDetails.styles.scss';
+
+import { Color, Spacing } from '@signozhq/design-tokens';
+import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
+import { RadioChangeEvent } from 'antd/lib';
+import logEvent from 'api/common/logEvent';
+import { QueryParams } from 'constants/query';
+import {
+	initialQueryBuilderFormValuesMap,
+	initialQueryState,
+} from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/config';
+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 { useCallback, useEffect, useMemo, useState } from 'react';
+import { useSelector } from 'react-redux';
+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 { QUERY_KEYS, VIEW_TYPES, VIEWS } from './constants';
+import NodeEvents from './Events';
+import NodeLogs from './Logs';
+import NodeMetrics from './Metrics';
+import { NodeDetailsProps } from './NodeDetails.interfaces';
+import NodeTraces from './Traces';
+
+function NodeDetails({
+	node,
+	onClose,
+	isModalTimeSelection,
+}: NodeDetailsProps): 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 [selectedInterval, setSelectedInterval] = useState<Time>(
+		selectedTime as Time,
+	);
+
+	const [selectedView, setSelectedView] = useState<VIEWS>(VIEWS.METRICS);
+	const isDarkMode = useIsDarkMode();
+
+	const initialFilters = useMemo(
+		() => ({
+			op: 'AND',
+			items: [
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_NODE_NAME,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s_node_name--string--resource--false',
+					},
+					op: '=',
+					value: node?.meta.k8s_node_name || '',
+				},
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_CLUSTER_NAME,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s_node_name--string--resource--false',
+					},
+					op: '=',
+					value: node?.meta.k8s_cluster_name || '',
+				},
+			],
+		}),
+		[node?.meta.k8s_node_name, node?.meta.k8s_cluster_name],
+	);
+
+	const initialEventsFilters = useMemo(
+		() => ({
+			op: 'AND',
+			items: [
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_OBJECT_KIND,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s.object.kind--string--resource--false',
+					},
+					op: '=',
+					value: 'Node',
+				},
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_OBJECT_NAME,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s.object.name--string--resource--false',
+					},
+					op: '=',
+					value: node?.meta.k8s_node_name || '',
+				},
+			],
+		}),
+		[node?.meta.k8s_node_name],
+	);
+
+	const [logFilters, setLogFilters] = useState<IBuilderQuery['filters']>(
+		initialFilters,
+	);
+
+	const [tracesFilters, setTracesFilters] = useState<IBuilderQuery['filters']>(
+		initialFilters,
+	);
+
+	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
+		initialEventsFilters,
+	);
+
+	useEffect(() => {
+		logEvent('Infra Monitoring: Nodes list details page visited', {
+			node: node?.nodeUID,
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []);
+
+	useEffect(() => {
+		setLogFilters(initialFilters);
+		setTracesFilters(initialFilters);
+		setEventsFilters(initialEventsFilters);
+	}, [initialFilters, initialEventsFilters]);
+
+	useEffect(() => {
+		setSelectedInterval(selectedTime as Time);
+
+		if (selectedTime !== 'custom') {
+			const { maxTime, minTime } = GetMinMax(selectedTime);
+
+			setModalTimeRange({
+				startTime: Math.floor(minTime / 1000000000),
+				endTime: Math.floor(maxTime / 1000000000),
+			});
+		}
+	}, [selectedTime, minTime, maxTime]);
+
+	const handleTabChange = (e: RadioChangeEvent): void => {
+		setSelectedView(e.target.value);
+	};
+
+	const handleTimeChange = useCallback(
+		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
+			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('Infra Monitoring: Nodes list details time updated', {
+				node: node?.nodeUID,
+				interval,
+			});
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
+	);
+
+	const handleChangeLogFilters = useCallback(
+		(value: IBuilderQuery['filters']) => {
+			setLogFilters((prevFilters) => {
+				const primaryFilters = prevFilters.items.filter((item) =>
+					[QUERY_KEYS.K8S_NODE_NAME, 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_NODE_NAME,
+				);
+
+				logEvent('Infra Monitoring: Nodes list details logs filters applied', {
+					node: node?.nodeUID,
+				});
+
+				return {
+					op: 'AND',
+					items: [
+						...primaryFilters,
+						...newFilters,
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
+				};
+			});
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
+	);
+
+	const handleChangeTracesFilters = useCallback(
+		(value: IBuilderQuery['filters']) => {
+			setTracesFilters((prevFilters) => {
+				const primaryFilters = prevFilters.items.filter((item) =>
+					[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
+						item.key?.key ?? '',
+					),
+				);
+
+				logEvent('Infra Monitoring: Nodes list details traces filters applied', {
+					node: node?.nodeUID,
+				});
+
+				return {
+					op: 'AND',
+					items: [
+						...primaryFilters,
+						...value.items.filter(
+							(item) => item.key?.key !== QUERY_KEYS.K8S_NODE_NAME,
+						),
+					].filter((item): item is TagFilterItem => item !== undefined),
+				};
+			});
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
+	);
+
+	const handleChangeEventsFilters = useCallback(
+		(value: IBuilderQuery['filters']) => {
+			setEventsFilters((prevFilters) => {
+				const nodeKindFilter = prevFilters.items.find(
+					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
+				);
+				const nodeNameFilter = prevFilters.items.find(
+					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
+				);
+
+				logEvent('Infra Monitoring: Nodes list details events filters applied', {
+					node: node?.nodeUID,
+				});
+
+				return {
+					op: 'AND',
+					items: [
+						nodeKindFilter,
+						nodeNameFilter,
+						...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),
+				};
+			});
+		},
+		// 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('Infra Monitoring: Nodes list details explore clicked', {
+			node: node?.nodeUID,
+			view: selectedView,
+		});
+
+		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);
+
+		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">
+						{node?.meta.k8s_node_name}
+					</Typography.Text>
+				</>
+			}
+			placement="right"
+			onClose={handleClose}
+			open={!!node}
+			style={{
+				overscrollBehavior: 'contain',
+				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
+			}}
+			className="node-detail-drawer"
+			destroyOnClose
+			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
+		>
+			{node && (
+				<>
+					<div className="node-detail-drawer__node">
+						<div className="node-details-grid">
+							<div className="labels-row">
+								<Typography.Text
+									type="secondary"
+									className="node-details-metadata-label"
+								>
+									Node Name
+								</Typography.Text>
+								<Typography.Text
+									type="secondary"
+									className="node-details-metadata-label"
+								>
+									Cluster Name
+								</Typography.Text>
+							</div>
+							<div className="values-row">
+								<Typography.Text className="node-details-metadata-value">
+									<Tooltip title={node.meta.k8s_node_name}>
+										{node.meta.k8s_node_name}
+									</Tooltip>
+								</Typography.Text>
+								<Typography.Text className="node-details-metadata-value">
+									<Tooltip title="Cluster name">{node.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={
+									// eslint-disable-next-line sonarjs/no-duplicate-string
+									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 && (
+						<NodeMetrics
+							timeRange={modalTimeRange}
+							isModalTimeSelection={isModalTimeSelection}
+							handleTimeChange={handleTimeChange}
+							selectedInterval={selectedInterval}
+							node={node}
+						/>
+					)}
+					{selectedView === VIEW_TYPES.LOGS && (
+						<NodeLogs
+							timeRange={modalTimeRange}
+							isModalTimeSelection={isModalTimeSelection}
+							handleTimeChange={handleTimeChange}
+							handleChangeLogFilters={handleChangeLogFilters}
+							logFilters={logFilters}
+							selectedInterval={selectedInterval}
+						/>
+					)}
+					{selectedView === VIEW_TYPES.TRACES && (
+						<NodeTraces
+							timeRange={modalTimeRange}
+							isModalTimeSelection={isModalTimeSelection}
+							handleTimeChange={handleTimeChange}
+							handleChangeTracesFilters={handleChangeTracesFilters}
+							tracesFilters={tracesFilters}
+							selectedInterval={selectedInterval}
+						/>
+					)}
+					{selectedView === VIEW_TYPES.EVENTS && (
+						<NodeEvents
+							timeRange={modalTimeRange}
+							handleChangeEventFilters={handleChangeEventsFilters}
+							filters={eventsFilters}
+							isModalTimeSelection={isModalTimeSelection}
+							handleTimeChange={handleTimeChange}
+							selectedInterval={selectedInterval}
+						/>
+					)}
+				</>
+			)}
+		</Drawer>
+	);
+}
+
+export default NodeDetails;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.styles.scss b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.styles.scss
new file mode 100644
index 0000000000..ab082d210f
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.styles.scss
@@ -0,0 +1,193 @@
+.node-metric-traces {
+	margin-top: 1rem;
+
+	.node-metric-traces-header {
+		display: flex;
+		justify-content: space-between;
+		margin-bottom: 1rem;
+
+		gap: 8px;
+		padding: 12px;
+		border-radius: 3px;
+		border: 1px solid var(--bg-slate-500);
+
+		.filter-section {
+			flex: 1;
+
+			.ant-select-selector {
+				border-radius: 2px;
+				border: 1px solid var(--bg-slate-400) !important;
+				background-color: var(--bg-ink-300) !important;
+
+				input {
+					font-size: 12px;
+				}
+
+				.ant-tag .ant-typography {
+					font-size: 12px;
+				}
+			}
+		}
+	}
+
+	.node-metric-traces-table {
+		.ant-table-content {
+			overflow: hidden !important;
+		}
+
+		.ant-table {
+			border-radius: 3px;
+			border: 1px solid var(--bg-slate-500);
+
+			.ant-table-thead > tr > th {
+				padding: 12px;
+				font-weight: 500;
+				font-size: 12px;
+				line-height: 18px;
+
+				background: rgba(171, 189, 255, 0.01);
+				border-bottom: none;
+
+				color: var(--Vanilla-400, #c0c1c3);
+				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(--bg-ink-400);
+			}
+
+			.ant-table-cell {
+				padding: 12px;
+				font-size: 13px;
+				line-height: 20px;
+				color: var(--bg-vanilla-100);
+				background: rgba(171, 189, 255, 0.01);
+			}
+
+			.ant-table-cell:has(.hostname-column-value) {
+				background: var(--bg-ink-400);
+			}
+
+			.hostname-column-value {
+				color: var(--bg-vanilla-100);
+				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: rgba(255, 255, 255, 0.04);
+			}
+
+			.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;
+		}
+	}
+}
+
+.lightMode {
+	.host-metric-traces-header {
+		.filter-section {
+			border-top: 1px solid var(--bg-vanilla-300);
+			border-bottom: 1px solid var(--bg-vanilla-300);
+
+			.ant-select-selector {
+				border-color: var(--bg-vanilla-300) !important;
+				background-color: var(--bg-vanilla-100) !important;
+				color: var(--bg-ink-200);
+			}
+		}
+	}
+
+	.host-metric-traces-table {
+		.ant-table {
+			border-radius: 3px;
+			border: 1px solid var(--bg-vanilla-300);
+
+			.ant-table-thead > tr > th {
+				background: var(--bg-vanilla-100);
+				color: var(--text-ink-300);
+			}
+
+			.ant-table-thead > tr > th:has(.hostname-column-header) {
+				background: var(--bg-vanilla-100);
+			}
+
+			.ant-table-cell {
+				background: var(--bg-vanilla-100);
+				color: var(--bg-ink-500);
+			}
+
+			.ant-table-cell:has(.hostname-column-value) {
+				background: var(--bg-vanilla-100);
+			}
+
+			.hostname-column-value {
+				color: var(--bg-ink-300);
+			}
+
+			.ant-table-tbody > tr:hover > td {
+				background: rgba(0, 0, 0, 0.04);
+			}
+		}
+	}
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.tsx
new file mode 100644
index 0000000000..b1306432ad
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/NodeTraces.tsx
@@ -0,0 +1,199 @@
+import './NodeTraces.styles.scss';
+
+import { ResizeTable } from 'components/ResizeTable';
+import { DEFAULT_ENTITY_VERSION } from 'constants/app';
+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/config';
+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 { useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { getNodeTracesQueryPayload, selectedColumns } from './constants';
+import { getListColumns } from './utils';
+
+interface Props {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	handleChangeTracesFilters: (value: IBuilderQuery['filters']) => void;
+	tracesFilters: IBuilderQuery['filters'];
+	selectedInterval: Time;
+}
+
+function NodeTraces({
+	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: [],
+							op: 'AND',
+						},
+					},
+				],
+			},
+		}),
+		[currentQuery],
+	);
+
+	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
+
+	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
+		QueryParams.pagination,
+	);
+
+	const queryPayload = useMemo(
+		() =>
+			getNodeTracesQueryPayload(
+				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.length > 1;
+
+	const totalCount =
+		data?.payload?.data?.newResult?.data?.result?.[0]?.list?.length || 0;
+
+	return (
+		<div className="node-metric-traces">
+			<div className="node-metric-traces-header">
+				<div className="filter-section">
+					{query && (
+						<QueryBuilderSearch
+							query={query}
+							onChange={handleChangeTracesFilters}
+							disableNavigationShortcuts
+						/>
+					)}
+				</div>
+				<div className="datetime-section">
+					<DateTimeSelectionV2
+						showAutoRefresh={false}
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+					/>
+				</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="node-traces-table">
+					<TraceExplorerControls
+						isLoading={isFetching}
+						totalCount={totalCount}
+						perPageOptions={PER_PAGE_OPTIONS}
+						showSizeChanger={false}
+					/>
+					<ResizeTable
+						tableLayout="fixed"
+						pagination={false}
+						scroll={{ x: true }}
+						loading={isFetching}
+						dataSource={traces}
+						columns={traceListColumns}
+					/>
+				</div>
+			)}
+		</div>
+	);
+}
+
+export default NodeTraces;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/constants.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/constants.ts
new file mode 100644
index 0000000000..f1b5950503
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/constants.ts
@@ -0,0 +1,200 @@
+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 } 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',
+		isColumn: true,
+	},
+	{
+		key: 'serviceName',
+		dataType: DataTypes.String,
+		type: 'tag',
+		isColumn: true,
+	},
+	{
+		key: 'name',
+		dataType: DataTypes.String,
+		type: 'tag',
+		isColumn: true,
+	},
+	{
+		key: 'durationNano',
+		dataType: DataTypes.Float64,
+		type: 'tag',
+		isColumn: true,
+	},
+	{
+		key: 'httpMethod',
+		dataType: DataTypes.String,
+		type: 'tag',
+		isColumn: true,
+	},
+	{
+		key: 'responseStatusCode',
+		dataType: DataTypes.String,
+		type: 'tag',
+		isColumn: true,
+	},
+];
+
+export const getNodeTracesQueryPayload = (
+	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: '',
+						isColumn: false,
+						type: '',
+						isJSON: false,
+					},
+					timeAggregation: 'rate',
+					spaceAggregation: 'sum',
+					functions: [],
+					filters,
+					expression: 'A',
+					disabled: false,
+					stepInterval: 60,
+					having: [],
+					limit: null,
+					orderBy: [
+						{
+							columnName: 'timestamp',
+							order: 'desc',
+						},
+					],
+					groupBy: [],
+					legend: '',
+					reduceTo: 'avg',
+				},
+			],
+			queryFormulas: [],
+		},
+		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',
+				isColumn: true,
+				isJSON: false,
+				id: 'serviceName--string--tag--true',
+				isIndexed: false,
+			},
+			{
+				key: 'name',
+				dataType: 'string',
+				type: 'tag',
+				isColumn: true,
+				isJSON: false,
+				id: 'name--string--tag--true',
+				isIndexed: false,
+			},
+			{
+				key: 'durationNano',
+				dataType: 'float64',
+				type: 'tag',
+				isColumn: true,
+				isJSON: false,
+				id: 'durationNano--float64--tag--true',
+				isIndexed: false,
+			},
+			{
+				key: 'httpMethod',
+				dataType: 'string',
+				type: 'tag',
+				isColumn: true,
+				isJSON: false,
+				id: 'httpMethod--string--tag--true',
+				isIndexed: false,
+			},
+			{
+				key: 'responseStatusCode',
+				dataType: 'string',
+				type: 'tag',
+				isColumn: true,
+				isJSON: false,
+				id: 'responseStatusCode--string--tag--true',
+				isIndexed: false,
+			},
+		],
+	},
+});
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/index.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/index.ts
new file mode 100644
index 0000000000..a5bc66c59b
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/index.ts
@@ -0,0 +1,3 @@
+import NodeTraces from './NodeTraces';
+
+export default NodeTraces;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/utils.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/utils.tsx
new file mode 100644
index 0000000000..aba284586a
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/Traces/utils.tsx
@@ -0,0 +1,84 @@
+import { Tag, Typography } from 'antd';
+import { ColumnsType } from 'antd/es/table';
+import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
+import {
+	BlockLink,
+	getTraceLink,
+} from 'container/TracesExplorer/ListView/utils';
+import dayjs from 'dayjs';
+import { RowData } from 'lib/query/createTableColumnsFromQuery';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+const keyToLabelMap: Record<string, string> = {
+	timestamp: 'Timestamp',
+	serviceName: 'Service Name',
+	name: 'Name',
+	durationNano: 'Duration',
+	httpMethod: 'HTTP Method',
+	responseStatusCode: 'Status Code',
+};
+
+export const getListColumns = (
+	selectedColumns: BaseAutocompleteData[],
+): ColumnsType<RowData> => {
+	const columns: ColumnsType<RowData> =
+		selectedColumns.map(({ dataType, key, type }) => ({
+			title: keyToLabelMap[key],
+			dataIndex: key,
+			key: `${key}-${dataType}-${type}`,
+			width: 145,
+			render: (value, item): JSX.Element => {
+				const itemData = item.data as any;
+
+				if (key === 'timestamp') {
+					const date =
+						typeof value === 'string'
+							? dayjs(value).format('YYYY-MM-DD HH:mm:ss.SSS')
+							: dayjs(value / 1e6).format('YYYY-MM-DD HH:mm:ss.SSS');
+
+					return (
+						<BlockLink to={getTraceLink(item)} openInNewTab>
+							<Typography.Text>{date}</Typography.Text>
+						</BlockLink>
+					);
+				}
+
+				if (value === '') {
+					return (
+						<BlockLink to={getTraceLink(itemData)} openInNewTab>
+							<Typography data-testid={key}>N/A</Typography>
+						</BlockLink>
+					);
+				}
+
+				if (key === 'httpMethod' || key === 'responseStatusCode') {
+					return (
+						<BlockLink to={getTraceLink(itemData)} openInNewTab>
+							<Tag data-testid={key} color="magenta">
+								{itemData[key]}
+							</Tag>
+						</BlockLink>
+					);
+				}
+
+				if (key === 'durationNano') {
+					const durationNano = itemData[key];
+
+					return (
+						<BlockLink to={getTraceLink(item)} openInNewTab>
+							<Typography data-testid={key}>{getMs(durationNano)}ms</Typography>
+						</BlockLink>
+					);
+				}
+
+				return (
+					<BlockLink to={getTraceLink(itemData)} openInNewTab>
+						<Typography data-testid={key}>{itemData[key]}</Typography>
+					</BlockLink>
+				);
+			},
+			responsive: ['md'],
+		})) || [];
+
+	return columns;
+};
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/constants.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/constants.ts
new file mode 100644
index 0000000000..a737762b76
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/constants.ts
@@ -0,0 +1,20 @@
+export enum VIEWS {
+	METRICS = 'metrics',
+	LOGS = 'logs',
+	TRACES = 'traces',
+	EVENTS = 'events',
+}
+
+export const VIEW_TYPES = {
+	METRICS: VIEWS.METRICS,
+	LOGS: VIEWS.LOGS,
+	TRACES: VIEWS.TRACES,
+	EVENTS: VIEWS.EVENTS,
+};
+
+export const QUERY_KEYS = {
+	K8S_OBJECT_KIND: 'k8s.object.kind',
+	K8S_OBJECT_NAME: 'k8s.object.name',
+	K8S_NODE_NAME: 'k8s.node.name',
+	K8S_CLUSTER_NAME: 'k8s.cluster.name',
+};
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/index.ts b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/index.ts
new file mode 100644
index 0000000000..c6617c46f9
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/index.ts
@@ -0,0 +1,3 @@
+import NodeDetails from './NodeDetails';
+
+export default NodeDetails;
diff --git a/frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx b/frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx
new file mode 100644
index 0000000000..ad160c0902
--- /dev/null
+++ b/frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx
@@ -0,0 +1,211 @@
+import { Tag, Tooltip } from 'antd';
+import { ColumnType } from 'antd/es/table';
+import {
+	K8sNodesData,
+	K8sNodesListPayload,
+} from 'api/infraMonitoring/getK8sNodesList';
+import { Group } from 'lucide-react';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { IEntityColumn } from '../utils';
+
+export const defaultAddedColumns: IEntityColumn[] = [
+	{
+		label: 'Node Name',
+		value: 'nodeName',
+		id: 'nodeName',
+		canRemove: false,
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterStatus',
+		id: 'clusterStatus',
+		canRemove: false,
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canRemove: false,
+	},
+	{
+		label: 'CPU Alloc (cores)',
+		value: 'cpu_allocatable',
+		id: 'cpu_allocatable',
+		canRemove: false,
+	},
+	{
+		label: 'Memory Usage (bytes)',
+		value: 'memory',
+		id: 'memory',
+		canRemove: false,
+	},
+	{
+		label: 'Memory Alloc (bytes)',
+		value: 'memory_allocatable',
+		id: 'memory_allocatable',
+		canRemove: false,
+	},
+];
+
+export interface K8sNodesRowData {
+	key: string;
+	nodeUID: string;
+	nodeName: React.ReactNode;
+	clusterName: string;
+	cpu: React.ReactNode;
+	cpu_allocatable: React.ReactNode;
+	memory: React.ReactNode;
+	memory_allocatable: React.ReactNode;
+	groupedByMeta?: any;
+}
+
+const nodeGroupColumnConfig = {
+	title: (
+		<div className="column-header node-group-header">
+			<Group size={14} /> NODE GROUP
+		</div>
+	),
+	dataIndex: 'nodeGroup',
+	key: 'nodeGroup',
+	ellipsis: true,
+	width: 150,
+	align: 'left',
+	sorter: false,
+};
+
+export const getK8sNodesListQuery = (): K8sNodesListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+const columnsConfig = [
+	{
+		title: <div className="column-header-left">Node Name</div>,
+		dataIndex: 'nodeName',
+		key: 'nodeName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div className="column-header-left">Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div className="column-header-left">CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div className="column-header-left">CPU Alloc (cores)</div>,
+		dataIndex: 'cpu_allocatable',
+		key: 'cpu_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div className="column-header-left">Memory Usage (bytes)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div className="column-header-left">Memory Alloc (bytes)</div>,
+		dataIndex: 'memory_allocatable',
+		key: 'memory_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const getK8sNodesListColumns = (
+	groupBy: IBuilderQuery['groupBy'],
+): ColumnType<K8sNodesRowData>[] => {
+	if (groupBy.length > 0) {
+		const filteredColumns = [...columnsConfig].filter(
+			(column) => column.key !== 'nodeName',
+		);
+		filteredColumns.unshift(nodeGroupColumnConfig);
+		return filteredColumns as ColumnType<K8sNodesRowData>[];
+	}
+
+	return columnsConfig as ColumnType<K8sNodesRowData>[];
+};
+
+const getGroupByEle = (
+	node: K8sNodesData,
+	groupBy: IBuilderQuery['groupBy'],
+): React.ReactNode => {
+	const groupByValues: string[] = [];
+
+	groupBy.forEach((group) => {
+		groupByValues.push(node.meta[group.key as keyof typeof node.meta]);
+	});
+
+	return (
+		<div className="pod-group">
+			{groupByValues.map((value) => (
+				<Tag key={value} color="#1D212D" className="pod-group-tag-item">
+					{value === '' ? '<no-value>' : value}
+				</Tag>
+			))}
+		</div>
+	);
+};
+
+export const formatDataForTable = (
+	data: K8sNodesData[],
+	groupBy: IBuilderQuery['groupBy'],
+): K8sNodesRowData[] =>
+	data.map((node, index) => ({
+		key: `${node.nodeUID}-${index}`,
+		nodeUID: node.nodeUID || '',
+		nodeName: (
+			<Tooltip title={node.meta.k8s_node_name}>
+				{node.meta.k8s_node_name || ''}
+			</Tooltip>
+		),
+		clusterName: node.meta.k8s_cluster_name,
+		cpu: (
+			<ValidateColumnValueWrapper value={node.nodeCPUUsage}>
+				{node.nodeCPUUsage}
+			</ValidateColumnValueWrapper>
+		),
+		memory: (
+			<ValidateColumnValueWrapper value={node.nodeMemoryUsage}>
+				{formatBytes(node.nodeMemoryUsage)}
+			</ValidateColumnValueWrapper>
+		),
+		cpu_allocatable: (
+			<ValidateColumnValueWrapper value={node.nodeCPUAllocatable}>
+				{node.nodeCPUAllocatable}
+			</ValidateColumnValueWrapper>
+		),
+		memory_allocatable: (
+			<ValidateColumnValueWrapper value={node.nodeMemoryAllocatable}>
+				{formatBytes(node.nodeMemoryAllocatable)}
+			</ValidateColumnValueWrapper>
+		),
+		nodeGroup: getGroupByEle(node, groupBy),
+		meta: node.meta,
+		...node.meta,
+		groupedByMeta: node.meta,
+	}));
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx
index aee64ae05d..5fea3d622f 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx
@@ -37,7 +37,6 @@ import LoadingContainer from '../LoadingContainer';
 import {
 	defaultAddedColumns,
 	defaultAvailableColumns,
-	dummyColumnConfig,
 	formatDataForTable,
 	getK8sPodsListColumns,
 	getK8sPodsListQuery,
@@ -387,11 +386,9 @@ function K8sPodsList({
 		[setAddedColumns, setAvailableColumns],
 	);
 
-	const nestedColumns = useMemo(() => {
-		const nestedColumns = getK8sPodsListColumns(addedColumns, []);
-
-		return [dummyColumnConfig, ...nestedColumns];
-	}, [addedColumns]);
+	const nestedColumns = useMemo(() => getK8sPodsListColumns(addedColumns, []), [
+		addedColumns,
+	]);
 
 	const isGroupedByAttribute = groupBy.length > 0;
 
@@ -504,6 +501,7 @@ function K8sPodsList({
 				handleGroupByChange={handleGroupByChange}
 				onAddColumn={handleAddColumn}
 				onRemoveColumn={handleRemoveColumn}
+				entity={K8sCategory.PODS}
 			/>
 			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
 
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/Events/Events.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/Events/Events.tsx
index ce6b8b7538..c86fe4a9ee 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/Events/Events.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/Events/Events.tsx
@@ -4,6 +4,7 @@ import './Events.styles.scss';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Table, TableColumnsType } from 'antd';
 import { DEFAULT_ENTITY_VERSION } from 'constants/app';
+import { EventContents } from 'container/InfraMonitoringK8s/commonUtils';
 import LoadingContainer from 'container/InfraMonitoringK8s/LoadingContainer';
 import LogsError from 'container/LogsError/LogsError';
 import { ORDERBY_FILTERS } from 'container/QueryBuilder/filters/OrderByFilter/config';
@@ -95,6 +96,10 @@ export default function Events({
 						aggregateAttribute: {
 							...currentQuery.builder.queryData[0].aggregateAttribute,
 						},
+						filters: {
+							items: [],
+							op: 'AND',
+						},
 					},
 				],
 			},
@@ -149,6 +154,7 @@ export default function Events({
 					body: event.data.body,
 					id: event.data.id,
 					key: event.data.id,
+					resources_string: event.data.resources_string,
 				}),
 			);
 
@@ -168,7 +174,7 @@ export default function Events({
 	}, [eventsData]);
 
 	const handleExpandRow = (record: EventDataType): JSX.Element => (
-		<p style={{ margin: 0 }}>{record.body}</p>
+		<EventContents data={record.resources_string} />
 	);
 
 	const handlePrev = (): void => {
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx
index de90a4adaf..345f24d144 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx
@@ -1,3 +1,5 @@
+/* eslint-disable sonarjs/no-identical-functions */
+/* eslint-disable sonarjs/no-duplicate-string */
 import './PodDetails.styles.scss';
 
 import { Color, Spacing } from '@signozhq/design-tokens';
@@ -98,9 +100,39 @@ function PodDetails({
 					op: '=',
 					value: pod?.meta.k8s_pod_name || '',
 				},
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_CLUSTER_NAME,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s_pod_name--string--resource--false',
+					},
+					op: '=',
+					value: pod?.meta.k8s_cluster_name || '',
+				},
+				{
+					id: uuidv4(),
+					key: {
+						key: QUERY_KEYS.K8S_NAMESPACE_NAME,
+						dataType: DataTypes.String,
+						type: 'resource',
+						isColumn: false,
+						isJSON: false,
+						id: 'k8s_pod_name--string--resource--false',
+					},
+					op: '=',
+					value: pod?.meta.k8s_namespace_name || '',
+				},
 			],
 		}),
-		[pod?.meta.k8s_pod_name],
+		[
+			pod?.meta.k8s_cluster_name,
+			pod?.meta.k8s_namespace_name,
+			pod?.meta.k8s_pod_name,
+		],
 	);
 
 	const initialEventsFilters = useMemo(
@@ -210,13 +242,17 @@ function PodDetails({
 	const handleChangeLogFilters = useCallback(
 		(value: IBuilderQuery['filters']) => {
 			setLogFilters((prevFilters) => {
-				const hostNameFilter = prevFilters.items.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_POD_NAME,
+				const primaryFilters = prevFilters.items.filter((item) =>
+					[
+						QUERY_KEYS.K8S_POD_NAME,
+						QUERY_KEYS.K8S_CLUSTER_NAME,
+						QUERY_KEYS.K8S_NAMESPACE_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_POD_NAME,
+						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_CLUSTER_NAME,
 				);
 
 				logEvent('Infra Monitoring: Pods list details logs filters applied', {
@@ -226,7 +262,7 @@ function PodDetails({
 				return {
 					op: 'AND',
 					items: [
-						hostNameFilter,
+						...primaryFilters,
 						...newFilters,
 						...(paginationFilter ? [paginationFilter] : []),
 					].filter((item): item is TagFilterItem => item !== undefined),
@@ -240,8 +276,12 @@ function PodDetails({
 	const handleChangeTracesFilters = useCallback(
 		(value: IBuilderQuery['filters']) => {
 			setTracesFilters((prevFilters) => {
-				const hostNameFilter = prevFilters.items.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_POD_NAME,
+				const primaryFilters = prevFilters.items.filter((item) =>
+					[
+						QUERY_KEYS.K8S_POD_NAME,
+						QUERY_KEYS.K8S_CLUSTER_NAME,
+						QUERY_KEYS.K8S_NAMESPACE_NAME,
+					].includes(item.key?.key ?? ''),
 				);
 
 				logEvent('Infra Monitoring: Pods list details traces filters applied', {
@@ -251,7 +291,7 @@ function PodDetails({
 				return {
 					op: 'AND',
 					items: [
-						hostNameFilter,
+						...primaryFilters,
 						...value.items.filter(
 							(item) => item.key?.key !== QUERY_KEYS.K8S_POD_NAME,
 						),
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogs.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogs.tsx
index 2cab22ceb1..2ed0a9858b 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogs.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogs.tsx
@@ -48,7 +48,12 @@ function PodLogs({
 	useEffect(() => {
 		const newRestFilters = filters.items.filter(
 			(item) =>
-				item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_POD_NAME,
+				item.key?.key !== 'id' &&
+				![
+					QUERY_KEYS.K8S_POD_NAME,
+					QUERY_KEYS.K8S_CLUSTER_NAME,
+					QUERY_KEYS.K8S_NAMESPACE_NAME,
+				].includes(item.key?.key || ''),
 		);
 
 		const areFiltersSame = isEqual(restFilters, newRestFilters);
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogsDetailedView.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogsDetailedView.tsx
index dde84d6dcb..69e22c1c6c 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogsDetailedView.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodLogs/PodLogsDetailedView.tsx
@@ -50,6 +50,10 @@ function PodLogsDetailedView({
 						aggregateAttribute: {
 							...currentQuery.builder.queryData[0].aggregateAttribute,
 						},
+						filters: {
+							items: [],
+							op: 'AND',
+						},
 					},
 				],
 			},
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodTraces/PodTraces.tsx b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodTraces/PodTraces.tsx
index 2fe601271e..343b127367 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodTraces/PodTraces.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodTraces/PodTraces.tsx
@@ -67,6 +67,10 @@ function PodTraces({
 						aggregateAttribute: {
 							...currentQuery.builder.queryData[0].aggregateAttribute,
 						},
+						filters: {
+							items: [],
+							op: 'AND',
+						},
 					},
 				],
 			},
@@ -74,6 +78,8 @@ function PodTraces({
 		[currentQuery],
 	);
 
+	console.log({ updatedCurrentQuery });
+
 	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
 
 	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/constants.ts b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/constants.ts
index 2eb5f5eb9e..243fe50b0b 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/constants.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/constants.ts
@@ -16,4 +16,6 @@ export const QUERY_KEYS = {
 	K8S_OBJECT_KIND: 'k8s.object.kind',
 	K8S_OBJECT_NAME: 'k8s.object.name',
 	K8S_POD_NAME: 'k8s.pod.name',
+	K8S_NAMESPACE_NAME: 'k8s.namespace.name',
+	K8S_CLUSTER_NAME: 'k8s.cluster.name',
 };
diff --git a/frontend/src/container/InfraMonitoringK8s/Pods/constants.ts b/frontend/src/container/InfraMonitoringK8s/Pods/constants.ts
index a9f21696e4..7a18381c93 100644
--- a/frontend/src/container/InfraMonitoringK8s/Pods/constants.ts
+++ b/frontend/src/container/InfraMonitoringK8s/Pods/constants.ts
@@ -14,7 +14,7 @@ export const podWidgetInfo = [
 	},
 	{
 		title: 'CPU Request, Limit Utilization',
-		yAxisUnit: 'percent',
+		yAxisUnit: 'percentunit',
 	},
 	{
 		title: 'Memory Usage (bytes)',
@@ -22,7 +22,7 @@ export const podWidgetInfo = [
 	},
 	{
 		title: 'Memory Request, Limit Utilization',
-		yAxisUnit: 'percent',
+		yAxisUnit: 'percentunit',
 	},
 	{
 		title: 'Memory by State',
@@ -38,7 +38,7 @@ export const podWidgetInfo = [
 	},
 	{
 		title: 'CPU Request, Limit Utilization by Container',
-		yAxisUnit: 'percent',
+		yAxisUnit: 'percentunit',
 	},
 	{
 		title: 'Memory Usage by Container (bytes)',
@@ -46,7 +46,7 @@ export const podWidgetInfo = [
 	},
 	{
 		title: 'Memory Request, Limit Utilization by Container',
-		yAxisUnit: 'percent',
+		yAxisUnit: 'percentunit',
 	},
 	{
 		title: 'Network rate',
diff --git a/frontend/src/container/InfraMonitoringK8s/commonUtils.tsx b/frontend/src/container/InfraMonitoringK8s/commonUtils.tsx
index 280892c1d4..c7e287ad5a 100644
--- a/frontend/src/container/InfraMonitoringK8s/commonUtils.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/commonUtils.tsx
@@ -1,6 +1,16 @@
+/* eslint-disable react/require-default-props */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
 import { Color } from '@signozhq/design-tokens';
+import { Tooltip, Typography } from 'antd';
+import { ColumnsType } from 'antd/es/table';
+import { Progress } from 'antd/lib';
+import { ResizeTable } from 'components/ResizeTable';
+import FieldRenderer from 'container/LogDetailedView/FieldRenderer';
+import { DataType } from 'container/LogDetailedView/TableView';
+import { useMemo } from 'react';
+
+import { getInvalidValueTooltipText, K8sCategory } from './constants';
 
 /**
  * Converts size in bytes to a human-readable string with appropriate units
@@ -21,12 +31,25 @@ export function formatBytes(bytes: number, decimals = 2): string {
 export function ValidateColumnValueWrapper({
 	children,
 	value,
+	entity,
+	attribute,
 }: {
 	children: React.ReactNode;
 	value: number;
+	entity?: K8sCategory;
+	attribute?: string;
 }): JSX.Element {
 	if (value === -1) {
-		return <div>-</div>;
+		let element = <div>-</div>;
+		if (entity && attribute) {
+			element = (
+				<Tooltip title={getInvalidValueTooltipText(entity, attribute)}>
+					{element}
+				</Tooltip>
+			);
+		}
+
+		return element;
 	}
 
 	return <div>{children}</div>;
@@ -76,3 +99,67 @@ export function getStrokeColorForLimitUtilization(value: number): string {
 
 export const getProgressBarText = (percent: number): React.ReactNode =>
 	`${percent}%`;
+
+export function EntityProgressBar({ value }: { value: number }): JSX.Element {
+	const percentage = Number((value * 100).toFixed(1));
+
+	return (
+		<div className="entity-progress-bar">
+			<Progress
+				percent={percentage}
+				strokeLinecap="butt"
+				size="small"
+				status="normal"
+				strokeColor={getStrokeColorForLimitUtilization(value)}
+				className="progress-bar"
+				showInfo={false}
+			/>
+			<Typography.Text style={{ fontSize: '10px' }}>{percentage}%</Typography.Text>
+		</div>
+	);
+}
+
+export function EventContents({
+	data,
+}: {
+	data: Record<string, string> | undefined;
+}): JSX.Element {
+	const tableData = useMemo(
+		() =>
+			data ? Object.keys(data).map((key) => ({ key, value: data[key] })) : [],
+		[data],
+	);
+
+	const columns: ColumnsType<DataType> = [
+		{
+			title: 'Key',
+			dataIndex: 'key',
+			key: 'key',
+			width: 50,
+			align: 'left',
+			className: 'attribute-pin value-field-container',
+			render: (field: string): JSX.Element => <FieldRenderer field={field} />,
+		},
+		{
+			title: 'Value',
+			dataIndex: 'value',
+			key: 'value',
+			width: 50,
+			align: 'left',
+			ellipsis: true,
+			className: 'attribute-name',
+			render: (field: string): JSX.Element => <FieldRenderer field={field} />,
+		},
+	];
+
+	return (
+		<ResizeTable
+			columns={columns}
+			tableLayout="fixed"
+			dataSource={tableData}
+			pagination={false}
+			showHeader={false}
+			className="event-content-container"
+		/>
+	);
+}
diff --git a/frontend/src/container/InfraMonitoringK8s/constants.ts b/frontend/src/container/InfraMonitoringK8s/constants.ts
index 93a3e97956..097cfd7014 100644
--- a/frontend/src/container/InfraMonitoringK8s/constants.ts
+++ b/frontend/src/container/InfraMonitoringK8s/constants.ts
@@ -50,7 +50,7 @@ export const K8sEntityToAggregateAttributeMapping = {
 export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Pods',
+		title: 'Pod',
 		attributeKey: {
 			key: 'k8s_pod_name',
 			dataType: DataTypes.String,
@@ -81,7 +81,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Nodes',
+		title: 'Node',
 		attributeKey: {
 			key: 'k8s_node_name',
 			dataType: DataTypes.String,
@@ -112,7 +112,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Deployments',
+		title: 'Deployment',
 		attributeKey: {
 			key: 'k8s_deployment_name',
 			dataType: DataTypes.String,
@@ -127,7 +127,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Statefulsets',
+		title: 'Statefulset',
 		attributeKey: {
 			key: 'k8s_statefulset_name',
 			dataType: DataTypes.String,
@@ -142,7 +142,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'DaemonSets',
+		title: 'DaemonSet',
 		attributeKey: {
 			key: 'k8s_daemonset_name',
 			dataType: DataTypes.String,
@@ -155,7 +155,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Jobs',
+		title: 'Job',
 		attributeKey: {
 			key: 'k8s_job_name',
 			dataType: DataTypes.String,
@@ -173,7 +173,7 @@ export const PodsQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const NodesQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Nodes',
+		title: 'Node Name',
 		attributeKey: {
 			key: 'k8s_node_name',
 			dataType: DataTypes.String,
@@ -181,6 +181,24 @@ export const NodesQuickFiltersConfig: IQuickFiltersConfig[] = [
 			isColumn: false,
 			isJSON: false,
 		},
+		aggregateOperator: 'noop',
+		aggregateAttribute: 'k8s_pod_cpu_utilization',
+		dataSource: DataSource.METRICS,
+		defaultOpen: true,
+	},
+	{
+		type: FiltersType.CHECKBOX,
+		title: 'Cluster Name',
+		attributeKey: {
+			key: 'k8s_cluster_name',
+			dataType: DataTypes.String,
+			type: 'resource',
+			isColumn: false,
+			isJSON: false,
+		},
+		aggregateOperator: 'noop',
+		aggregateAttribute: 'k8s_pod_cpu_utilization',
+		dataSource: DataSource.METRICS,
 		defaultOpen: true,
 	},
 ];
@@ -203,7 +221,7 @@ export const NamespaceQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const ClustersQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Clusters',
+		title: 'Cluster',
 		attributeKey: {
 			key: 'k8s.cluster.name',
 			dataType: DataTypes.String,
@@ -218,7 +236,7 @@ export const ClustersQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const ContainersQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Containers',
+		title: 'Container',
 		attributeKey: {
 			key: 'k8s_container_name',
 			dataType: DataTypes.String,
@@ -233,7 +251,7 @@ export const ContainersQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const VolumesQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Volumes',
+		title: 'Volume',
 		attributeKey: {
 			key: 'k8s_volume_name',
 			dataType: DataTypes.String,
@@ -248,7 +266,7 @@ export const VolumesQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const DeploymentsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Deployments',
+		title: 'Deployment',
 		attributeKey: {
 			key: 'k8s_deployment_name',
 			dataType: DataTypes.String,
@@ -263,7 +281,7 @@ export const DeploymentsQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const StatefulsetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Statefulsets',
+		title: 'Statefulset',
 		attributeKey: {
 			key: 'k8s_statefulset_name',
 			dataType: DataTypes.String,
@@ -278,7 +296,7 @@ export const StatefulsetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const DaemonSetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'DaemonSets',
+		title: 'DaemonSet',
 		attributeKey: {
 			key: 'k8s_daemonset_name',
 			dataType: DataTypes.String,
@@ -293,7 +311,7 @@ export const DaemonSetsQuickFiltersConfig: IQuickFiltersConfig[] = [
 export const JobsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
-		title: 'Jobs',
+		title: 'Job',
 		attributeKey: {
 			key: 'k8s_job_name',
 			dataType: DataTypes.String,
@@ -305,5 +323,7 @@ export const JobsQuickFiltersConfig: IQuickFiltersConfig[] = [
 	},
 ];
 
-export const INVALID_MEMORY_CPU_VALUE_MESSAGE =
-	'Some pods do not have memory requests/limits.';
+export const getInvalidValueTooltipText = (
+	entity: K8sCategory,
+	attribute: string,
+): string => `Some ${entity} do not have ${attribute}s.`;
diff --git a/frontend/src/container/InfraMonitoringK8s/utils.tsx b/frontend/src/container/InfraMonitoringK8s/utils.tsx
index 8e1eb12833..4fa6fbfc71 100644
--- a/frontend/src/container/InfraMonitoringK8s/utils.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/utils.tsx
@@ -2,7 +2,7 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 import './InfraMonitoringK8s.styles.scss';
 
-import { Progress, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
 import { ColumnType } from 'antd/es/table';
 import {
 	K8sPodsData,
@@ -12,13 +12,18 @@ import { Group } from 'lucide-react';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
 import {
+	EntityProgressBar,
 	formatBytes,
-	getProgressBarText,
-	getStrokeColorForLimitUtilization,
-	getStrokeColorForRequestUtilization,
 	ValidateColumnValueWrapper,
 } from './commonUtils';
-import { INVALID_MEMORY_CPU_VALUE_MESSAGE } from './constants';
+import { K8sCategory } from './constants';
+
+export interface IEntityColumn {
+	label: string;
+	value: string;
+	id: string;
+	canRemove: boolean;
+}
 
 export interface IPodColumn {
 	label: string;
@@ -37,43 +42,43 @@ export const defaultAddedColumns: IPodColumn[] = [
 		canRemove: false,
 	},
 	{
-		label: 'CPU Request Utilization (% of limit)',
+		label: 'CPU Req Usage (%)',
 		value: 'cpu_request',
 		id: 'cpu_request',
 		canRemove: false,
 	},
 	{
-		label: 'CPU Limit Utilization (% of request)',
+		label: 'CPU Limit Usage (%)',
 		value: 'cpu_limit',
 		id: 'cpu_limit',
 		canRemove: false,
 	},
 	{
-		label: 'CPU Utilization (cores)',
+		label: 'CPU Usage (cores)',
 		value: 'cpu',
 		id: 'cpu',
 		canRemove: false,
 	},
 	{
-		label: 'Memory Request Utilization (% of limit)',
+		label: 'Mem Req Usage (%)',
 		value: 'memory_request',
 		id: 'memory_request',
 		canRemove: false,
 	},
 	{
-		label: 'Memory Limit Utilization (% of request)',
+		label: 'Mem Limit Usage (%)',
 		value: 'memory_limit',
 		id: 'memory_limit',
 		canRemove: false,
 	},
 	{
-		label: 'Memory Utilization (bytes)',
+		label: 'Mem Usage',
 		value: 'memory',
 		id: 'memory',
 		canRemove: false,
 	},
 	{
-		label: 'Container Restarts',
+		label: 'Restarts',
 		value: 'restarts',
 		id: 'restarts',
 		canRemove: false,
@@ -111,7 +116,7 @@ export interface K8sPodsRowData {
 	memory_request: React.ReactNode;
 	memory_limit: React.ReactNode;
 	memory: React.ReactNode;
-	restarts: number;
+	restarts: React.ReactNode;
 	groupedByMeta?: any;
 }
 
@@ -141,7 +146,7 @@ export const dummyColumnConfig = {
 	title: <div className="column-header dummy-column">&nbsp;</div>,
 	dataIndex: 'dummy',
 	key: 'dummy',
-	width: 26,
+	width: 40,
 	sorter: false,
 	align: 'left',
 	className: 'column column-dummy',
@@ -158,13 +163,7 @@ const columnsConfig = [
 		className: 'column column-pod-name',
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					CPU Request Utilization (% of limit)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">CPU Req Usage (%)</div>,
 		dataIndex: 'cpu_request',
 		key: 'cpu_request',
 		width: 180,
@@ -174,28 +173,16 @@ const columnsConfig = [
 		className: `column ${columnProgressBarClassName}`,
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					CPU Limit Utilization (% of request)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">CPU Limit Usage (%)</div>,
 		dataIndex: 'cpu_limit',
 		key: 'cpu_limit',
-		width: 150,
+		width: 120,
 		sorter: true,
 		align: 'left',
 		className: `column ${columnProgressBarClassName}`,
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					CPU Utilization (cores)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">CPU Usage (cores)</div>,
 		dataIndex: 'cpu',
 		key: 'cpu',
 		width: 80,
@@ -204,46 +191,28 @@ const columnsConfig = [
 		className: `column ${columnProgressBarClassName}`,
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					Memory Request Utilization (% of limit)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">Mem Req Usage (%)</div>,
 		dataIndex: 'memory_request',
 		key: 'memory_request',
-		width: 150,
+		width: 120,
 		sorter: true,
 		align: 'left',
 		className: `column ${columnProgressBarClassName}`,
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					Memory Limit Utilization (% of request)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">Mem Limit Usage (%)</div>,
 		dataIndex: 'memory_limit',
 		key: 'memory_limit',
-		width: 150,
+		width: 120,
 		sorter: true,
 		align: 'left',
 		className: `column ${columnProgressBarClassName}`,
 	},
 	{
-		title: (
-			<div className="column-header">
-				<Tooltip title={INVALID_MEMORY_CPU_VALUE_MESSAGE}>
-					Memory Utilization (bytes)
-				</Tooltip>
-			</div>
-		),
+		title: <div className="column-header">Mem Usage</div>,
 		dataIndex: 'memory',
 		key: 'memory',
-		width: 100,
+		width: 80,
 		ellipsis: true,
 		sorter: true,
 		align: 'left',
@@ -252,12 +221,12 @@ const columnsConfig = [
 	{
 		title: (
 			<div className="column-header">
-				<Tooltip title="Container Restarts">Container Restarts</Tooltip>
+				<Tooltip title="Container Restarts">Restarts</Tooltip>
 			</div>
 		),
 		dataIndex: 'restarts',
 		key: 'restarts',
-		width: 100,
+		width: 40,
 		ellipsis: true,
 		sorter: true,
 		align: 'left',
@@ -270,7 +239,7 @@ export const namespaceColumnConfig = {
 	dataIndex: 'namespace',
 	key: 'namespace',
 	width: 100,
-	sorter: true,
+	sorter: false,
 	ellipsis: true,
 	align: 'left',
 	className: 'column column-namespace',
@@ -308,16 +277,6 @@ export const getK8sPodsListColumns = (
 	addedColumns: IPodColumn[],
 	groupBy: IBuilderQuery['groupBy'],
 ): ColumnType<K8sPodsRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'podName',
-		);
-
-		filteredColumns.unshift(podGroupColumnConfig);
-
-		return filteredColumns as ColumnType<K8sPodsRowData>[];
-	}
-
 	const updatedColumnsConfig = [...columnsConfig];
 
 	// eslint-disable-next-line no-restricted-syntax
@@ -328,6 +287,16 @@ export const getK8sPodsListColumns = (
 		}
 	}
 
+	if (groupBy.length > 0) {
+		const filteredColumns = [...updatedColumnsConfig].filter(
+			(column) => column.key !== 'podName',
+		);
+
+		filteredColumns.unshift(podGroupColumnConfig);
+
+		return filteredColumns as ColumnType<K8sPodsRowData>[];
+	}
+
 	return updatedColumnsConfig as ColumnType<K8sPodsRowData>[];
 };
 
@@ -359,44 +328,30 @@ export const formatDataForTable = (
 	data.map((pod, index) => ({
 		key: `${pod.podUID}-${index}`,
 		podName: (
-			<div className="pod-name-container">
-				<Tooltip title={pod.meta.k8s_pod_name || ''}>
-					<div className="pod-name">{pod.meta.k8s_pod_name || ''}</div>
-				</Tooltip>
-			</div>
+			<Tooltip title={pod.meta.k8s_pod_name || ''}>
+				{pod.meta.k8s_pod_name || ''}
+			</Tooltip>
 		),
 		podUID: pod.podUID || '',
 		cpu_request: (
-			<ValidateColumnValueWrapper value={pod.podCPURequest}>
+			<ValidateColumnValueWrapper
+				value={pod.podCPURequest}
+				entity={K8sCategory.PODS}
+				attribute="CPU Request"
+			>
 				<div className="progress-container">
-					<Progress
-						percent={Number((pod.podCPURequest * 100).toFixed(1))}
-						strokeLinecap="butt"
-						size="small"
-						status="active"
-						strokeColor={getStrokeColorForRequestUtilization(pod.podCPURequest)}
-						className="progress-bar"
-						format={() =>
-							getProgressBarText(Number((pod.podCPURequest * 100).toFixed(1)))
-						}
-					/>
+					<EntityProgressBar value={pod.podCPURequest} />
 				</div>
 			</ValidateColumnValueWrapper>
 		),
 		cpu_limit: (
-			<ValidateColumnValueWrapper value={pod.podCPULimit}>
+			<ValidateColumnValueWrapper
+				value={pod.podCPULimit}
+				entity={K8sCategory.PODS}
+				attribute="CPU Limit"
+			>
 				<div className="progress-container">
-					<Progress
-						percent={Number((pod.podCPULimit * 100).toFixed(1))}
-						strokeLinecap="butt"
-						size="small"
-						status="active"
-						strokeColor={getStrokeColorForLimitUtilization(pod.podCPULimit)}
-						className="progress-bar"
-						format={() =>
-							getProgressBarText(Number((pod.podCPULimit * 100).toFixed(1)))
-						}
-					/>
+					<EntityProgressBar value={pod.podCPULimit} />
 				</div>
 			</ValidateColumnValueWrapper>
 		),
@@ -406,36 +361,24 @@ export const formatDataForTable = (
 			</ValidateColumnValueWrapper>
 		),
 		memory_request: (
-			<ValidateColumnValueWrapper value={pod.podMemoryRequest}>
+			<ValidateColumnValueWrapper
+				value={pod.podMemoryRequest}
+				entity={K8sCategory.PODS}
+				attribute="Memory Request"
+			>
 				<div className="progress-container">
-					<Progress
-						percent={Number((pod.podMemoryRequest * 100).toFixed(1))}
-						strokeLinecap="butt"
-						size="small"
-						status="active"
-						strokeColor={getStrokeColorForRequestUtilization(pod.podMemoryRequest)}
-						className="progress-bar"
-						format={() =>
-							getProgressBarText(Number((pod.podMemoryRequest * 100).toFixed(1)))
-						}
-					/>
+					<EntityProgressBar value={pod.podMemoryRequest} />
 				</div>
 			</ValidateColumnValueWrapper>
 		),
 		memory_limit: (
-			<ValidateColumnValueWrapper value={pod.podMemoryLimit}>
+			<ValidateColumnValueWrapper
+				value={pod.podMemoryLimit}
+				entity={K8sCategory.PODS}
+				attribute="Memory Limit"
+			>
 				<div className="progress-container">
-					<Progress
-						percent={Number((pod.podMemoryLimit * 100).toFixed(1))}
-						strokeLinecap="butt"
-						size="small"
-						status="active"
-						strokeColor={getStrokeColorForLimitUtilization(pod.podMemoryLimit)}
-						className="progress-bar"
-						format={() =>
-							getProgressBarText(Number((pod.podMemoryLimit * 100).toFixed(1)))
-						}
-					/>
+					<EntityProgressBar value={pod.podMemoryLimit} />
 				</div>
 			</ValidateColumnValueWrapper>
 		),
@@ -444,7 +387,11 @@ export const formatDataForTable = (
 				{formatBytes(pod.podMemory)}
 			</ValidateColumnValueWrapper>
 		),
-		restarts: pod.restartCount,
+		restarts: (
+			<ValidateColumnValueWrapper value={pod.restartCount}>
+				{pod.restartCount}
+			</ValidateColumnValueWrapper>
+		),
 		namespace: pod.meta.k8s_namespace_name,
 		node: pod.meta.k8s_node_name,
 		cluster: pod.meta.k8s_job_name,
diff --git a/frontend/src/hooks/infraMonitoring/useGetK8sNodesList.ts b/frontend/src/hooks/infraMonitoring/useGetK8sNodesList.ts
new file mode 100644
index 0000000000..4e2ac964d2
--- /dev/null
+++ b/frontend/src/hooks/infraMonitoring/useGetK8sNodesList.ts
@@ -0,0 +1,45 @@
+import {
+	getK8sNodesList,
+	K8sNodesListPayload,
+	K8sNodesListResponse,
+} from 'api/infraMonitoring/getK8sNodesList';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useMemo } from 'react';
+import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+type UseGetK8sNodesList = (
+	requestData: K8sNodesListPayload,
+	options?: UseQueryOptions<
+		SuccessResponse<K8sNodesListResponse> | ErrorResponse,
+		Error
+	>,
+	headers?: Record<string, string>,
+) => UseQueryResult<
+	SuccessResponse<K8sNodesListResponse> | ErrorResponse,
+	Error
+>;
+
+export const useGetK8sNodesList: UseGetK8sNodesList = (
+	requestData,
+	options,
+	headers,
+) => {
+	const queryKey = useMemo(() => {
+		if (options?.queryKey && Array.isArray(options.queryKey)) {
+			return [...options.queryKey];
+		}
+
+		if (options?.queryKey && typeof options.queryKey === 'string') {
+			return options.queryKey;
+		}
+
+		return [REACT_QUERY_KEY.GET_HOST_LIST, requestData];
+	}, [options?.queryKey, requestData]);
+
+	return useQuery<SuccessResponse<K8sNodesListResponse> | ErrorResponse, Error>({
+		queryFn: ({ signal }) => getK8sNodesList(requestData, signal, headers),
+		...options,
+		queryKey,
+	});
+};