diff --git a/package.json b/package.json
index 6269f9d17..77f6963c2 100644
--- a/package.json
+++ b/package.json
@@ -76,7 +76,8 @@
     "typecheck": "tsc --noEmit",
     "prepare": "husky",
     "test:e2e:install": "npx playwright install --with-deps",
-    "test:e2e": "npx playwright test --config=playwright.config.ts"
+    "test:e2e": "npx playwright test --config=playwright.config.ts",
+    "test:e2e:local": "PLAYWRIGHT_BASE_URL=http://localhost:3000/ npm run test:e2e"
   },
   "lint-staged": {
     "*.{scss, css}": [
diff --git a/src/components/PaginatedTable/types.ts b/src/components/PaginatedTable/types.ts
index 4e4092e7f..b20b9778f 100644
--- a/src/components/PaginatedTable/types.ts
+++ b/src/components/PaginatedTable/types.ts
@@ -67,4 +67,4 @@ export type RenderControls = (params: ControlsParams) => React.ReactNode;
 export type RenderEmptyDataMessage = () => React.ReactNode;
 export type RenderErrorMessage = (error: IResponseError) => React.ReactNode;
 
-export type GetRowClassName<T> = (row: T) => string | undefined;
+export type GetRowClassName<T> = (row: T) => string;
diff --git a/src/components/Search/Search.tsx b/src/components/Search/Search.tsx
index 7beef51eb..fb259ae14 100644
--- a/src/components/Search/Search.tsx
+++ b/src/components/Search/Search.tsx
@@ -11,6 +11,7 @@ const b = cn('ydb-search');
 interface SearchProps {
     onChange: (value: string) => void;
     value?: string;
+    width?: React.CSSProperties['width'];
     className?: string;
     debounce?: number;
     placeholder?: string;
@@ -19,6 +20,7 @@ interface SearchProps {
 export const Search = ({
     onChange,
     value = '',
+    width,
     className,
     debounce = 200,
     placeholder,
@@ -50,6 +52,7 @@ export const Search = ({
         <TextInput
             hasClear
             autoFocus
+            style={{width}}
             className={b(null, className)}
             placeholder={placeholder}
             value={searchValue}
diff --git a/src/components/nodesColumns/constants.ts b/src/components/nodesColumns/constants.ts
index c3a53b990..887b3fa87 100644
--- a/src/components/nodesColumns/constants.ts
+++ b/src/components/nodesColumns/constants.ts
@@ -7,7 +7,9 @@ export const NODES_COLUMNS_WIDTH_LS_KEY = 'nodesTableColumnsWidth';
 
 export const NODES_COLUMNS_IDS = {
     NodeId: 'NodeId',
+    SystemState: 'SystemState',
     Host: 'Host',
+    Database: 'Database',
     NodeName: 'NodeName',
     DC: 'DC',
     Rack: 'Rack',
@@ -35,9 +37,15 @@ export const NODES_COLUMNS_TITLES = {
     get NodeId() {
         return i18n('node-id');
     },
+    get SystemState() {
+        return i18n('system-state');
+    },
     get Host() {
         return i18n('host');
     },
+    get Database() {
+        return i18n('database');
+    },
     get NodeName() {
         return i18n('node-name');
     },
@@ -95,7 +103,9 @@ export const NODES_COLUMNS_TITLES = {
 // Also for some columns we may use more than one field
 export const NODES_COLUMNS_TO_DATA_FIELDS: Record<NodesColumnId, NodesRequiredField[]> = {
     NodeId: ['NodeId'],
+    SystemState: ['SystemState'],
     Host: ['Host', 'Rack', 'Database', 'SystemState'],
+    Database: ['Database'],
     NodeName: ['NodeName'],
     DC: ['DC'],
     Rack: ['Rack'],
diff --git a/src/components/nodesColumns/i18n/en.json b/src/components/nodesColumns/i18n/en.json
index 78a282b59..be32e5332 100644
--- a/src/components/nodesColumns/i18n/en.json
+++ b/src/components/nodesColumns/i18n/en.json
@@ -1,6 +1,8 @@
 {
   "node-id": "Node ID",
+  "system-state": "System State",
   "host": "Host",
+  "database": "Database",
   "node-name": "Node Name",
   "dc": "DC",
   "rack": "Rack",
diff --git a/src/containers/Nodes/Nodes.scss b/src/containers/Nodes/Nodes.scss
index de91414dd..15459b7d2 100644
--- a/src/containers/Nodes/Nodes.scss
+++ b/src/containers/Nodes/Nodes.scss
@@ -15,4 +15,8 @@
     &__node_unavailable {
         opacity: 0.6;
     }
+
+    &__groups-wrapper {
+        padding-right: 20px;
+    }
 }
diff --git a/src/containers/Nodes/Nodes.tsx b/src/containers/Nodes/Nodes.tsx
index eedee76d7..c60d6ed91 100644
--- a/src/containers/Nodes/Nodes.tsx
+++ b/src/containers/Nodes/Nodes.tsx
@@ -1,51 +1,31 @@
 import React from 'react';
 
 import {ASCENDING} from '@gravity-ui/react-data-table/build/esm/lib/constants';
-import {TableColumnSetup} from '@gravity-ui/uikit';
-import {StringParam, useQueryParams} from 'use-query-params';
 
-import {EntitiesCount} from '../../components/EntitiesCount';
 import {AccessDenied} from '../../components/Errors/403';
 import {isAccessError} from '../../components/Errors/PageError/PageError';
 import {ResponseError} from '../../components/Errors/ResponseError';
 import {Illustration} from '../../components/Illustration';
-import {ProblemFilter} from '../../components/ProblemFilter';
 import {ResizeableDataTable} from '../../components/ResizeableDataTable/ResizeableDataTable';
-import {Search} from '../../components/Search';
 import {TableWithControlsLayout} from '../../components/TableWithControlsLayout/TableWithControlsLayout';
-import {UptimeFilter} from '../../components/UptimeFIlter';
 import {NODES_COLUMNS_WIDTH_LS_KEY} from '../../components/nodesColumns/constants';
 import {nodesApi} from '../../store/reducers/nodes/nodes';
 import {filterNodes} from '../../store/reducers/nodes/selectors';
 import type {NodesSortParams} from '../../store/reducers/nodes/types';
-import {
-    ProblemFilterValues,
-    changeFilter,
-    selectProblemFilter,
-} from '../../store/reducers/settings/settings';
-import type {ProblemFilterValue} from '../../store/reducers/settings/types';
+import {useProblemFilter} from '../../store/reducers/settings/hooks';
 import type {AdditionalNodesProps} from '../../types/additionalProps';
-import {cn} from '../../utils/cn';
 import {DEFAULT_TABLE_SETTINGS} from '../../utils/constants';
-import {
-    useAutoRefreshInterval,
-    useTableSort,
-    useTypedDispatch,
-    useTypedSelector,
-} from '../../utils/hooks';
-import {
-    NodesUptimeFilterValues,
-    isUnavailableNode,
-    nodesUptimeFilterValuesSchema,
-} from '../../utils/nodes';
+import {useAutoRefreshInterval, useTableSort} from '../../utils/hooks';
+import {NodesUptimeFilterValues} from '../../utils/nodes';
 
+import {NodesControls} from './NodesControls/NodesControls';
 import {useNodesSelectedColumns} from './columns/hooks';
 import i18n from './i18n';
+import {getRowClassName} from './shared';
+import {useNodesPageQueryParams} from './useNodesPageQueryParams';
 
 import './Nodes.scss';
 
-const b = cn('ydb-nodes');
-
 interface NodesProps {
     path?: string;
     database?: string;
@@ -53,16 +33,9 @@ interface NodesProps {
 }
 
 export const Nodes = ({path, database, additionalNodesProps = {}}: NodesProps) => {
-    const [queryParams, setQueryParams] = useQueryParams({
-        uptimeFilter: StringParam,
-        search: StringParam,
-    });
-    const uptimeFilter = nodesUptimeFilterValuesSchema.parse(queryParams.uptimeFilter);
-    const searchValue = queryParams.search ?? '';
-
-    const dispatch = useTypedDispatch();
+    const {searchValue, uptimeFilter} = useNodesPageQueryParams();
+    const {problemFilter} = useProblemFilter();
 
-    const problemFilter = useTypedSelector(selectProblemFilter);
     const [autoRefreshInterval] = useAutoRefreshInterval();
 
     const {columnsToShow, columnsToSelect, setColumns} = useNodesSelectedColumns({
@@ -84,18 +57,6 @@ export const Nodes = ({path, database, additionalNodesProps = {}}: NodesProps) =
         setSortValue(sortParams as NodesSortParams);
     });
 
-    const handleSearchQueryChange = (value: string) => {
-        setQueryParams({search: value || undefined}, 'replaceIn');
-    };
-
-    const handleProblemFilterChange = (value: ProblemFilterValue) => {
-        dispatch(changeFilter(value));
-    };
-
-    const handleUptimeFilterChange = (value: NodesUptimeFilterValues) => {
-        setQueryParams({uptimeFilter: value}, 'replaceIn');
-    };
-
     const nodes = React.useMemo(() => {
         return filterNodes(data?.Nodes, {searchValue, uptimeFilter, problemFilter});
     }, [data, searchValue, uptimeFilter, problemFilter]);
@@ -104,38 +65,19 @@ export const Nodes = ({path, database, additionalNodesProps = {}}: NodesProps) =
 
     const renderControls = () => {
         return (
-            <React.Fragment>
-                <Search
-                    onChange={handleSearchQueryChange}
-                    placeholder="Host name"
-                    className={b('search')}
-                    value={searchValue}
-                />
-                <ProblemFilter value={problemFilter} onChange={handleProblemFilterChange} />
-                <UptimeFilter value={uptimeFilter} onChange={handleUptimeFilterChange} />
-                <TableColumnSetup
-                    popupWidth={200}
-                    items={columnsToSelect}
-                    showStatus
-                    onUpdate={setColumns}
-                    sortable={false}
-                />
-                <EntitiesCount
-                    total={totalNodes}
-                    current={nodes.length}
-                    label={'Nodes'}
-                    loading={isLoading}
-                />
-            </React.Fragment>
+            <NodesControls
+                columnsToSelect={columnsToSelect}
+                handleSelectedColumnsUpdate={setColumns}
+                entitiesCountCurrent={nodes.length}
+                entitiesCountTotal={totalNodes}
+                entitiesLoading={isLoading}
+            />
         );
     };
 
     const renderTable = () => {
         if (nodes.length === 0) {
-            if (
-                problemFilter !== ProblemFilterValues.ALL ||
-                uptimeFilter !== NodesUptimeFilterValues.All
-            ) {
+            if (problemFilter !== 'All' || uptimeFilter !== NodesUptimeFilterValues.All) {
                 return <Illustration name="thumbsUp" width="200" />;
             }
         }
@@ -149,7 +91,7 @@ export const Nodes = ({path, database, additionalNodesProps = {}}: NodesProps) =
                 sortOrder={sort}
                 onSort={handleSort}
                 emptyDataMessage={i18n('empty.default')}
-                rowClassName={(row) => b('node', {unavailable: isUnavailableNode(row)})}
+                rowClassName={getRowClassName}
             />
         );
     };
diff --git a/src/containers/Nodes/NodesControls/NodesControls.tsx b/src/containers/Nodes/NodesControls/NodesControls.tsx
new file mode 100644
index 000000000..ebf4d851d
--- /dev/null
+++ b/src/containers/Nodes/NodesControls/NodesControls.tsx
@@ -0,0 +1,100 @@
+import React from 'react';
+
+import type {TableColumnSetupItem} from '@gravity-ui/uikit';
+import {Select, TableColumnSetup, Text} from '@gravity-ui/uikit';
+
+import {EntitiesCount} from '../../../components/EntitiesCount';
+import {ProblemFilter} from '../../../components/ProblemFilter';
+import {Search} from '../../../components/Search';
+import {UptimeFilter} from '../../../components/UptimeFIlter';
+import {useViewerNodesHandlerHasGroupingBySystemState} from '../../../store/reducers/capabilities/hooks';
+import {useProblemFilter} from '../../../store/reducers/settings/hooks';
+import {getNodesGroupByOptions} from '../columns/constants';
+import i18n from '../i18n';
+import {b} from '../shared';
+import {useNodesPageQueryParams} from '../useNodesPageQueryParams';
+
+interface NodesControlsProps {
+    withGroupBySelect?: boolean;
+
+    columnsToSelect: TableColumnSetupItem[];
+    handleSelectedColumnsUpdate: (updated: TableColumnSetupItem[]) => void;
+
+    entitiesCountCurrent: number;
+    entitiesCountTotal?: number;
+    entitiesLoading: boolean;
+}
+
+export function NodesControls({
+    withGroupBySelect,
+
+    columnsToSelect,
+    handleSelectedColumnsUpdate,
+
+    entitiesCountCurrent,
+    entitiesCountTotal,
+    entitiesLoading,
+}: NodesControlsProps) {
+    const {
+        searchValue,
+        uptimeFilter,
+        groupByParam,
+
+        handleSearchQueryChange,
+        handleUptimeFilterChange,
+        handleGroupByParamChange,
+    } = useNodesPageQueryParams();
+    const {problemFilter, handleProblemFilterChange} = useProblemFilter();
+
+    const systemStateGroupingAvailable = useViewerNodesHandlerHasGroupingBySystemState();
+    const groupByoptions = getNodesGroupByOptions(systemStateGroupingAvailable);
+
+    const handleGroupBySelectUpdate = (value: string[]) => {
+        handleGroupByParamChange(value[0]);
+    };
+
+    return (
+        <React.Fragment>
+            <Search
+                onChange={handleSearchQueryChange}
+                placeholder={i18n('controls_search-placeholder')}
+                width={238}
+                value={searchValue}
+            />
+            {systemStateGroupingAvailable && withGroupBySelect ? null : (
+                <ProblemFilter value={problemFilter} onChange={handleProblemFilterChange} />
+            )}
+            {withGroupBySelect ? null : (
+                <UptimeFilter value={uptimeFilter} onChange={handleUptimeFilterChange} />
+            )}
+            <TableColumnSetup
+                popupWidth={200}
+                items={columnsToSelect}
+                showStatus
+                onUpdate={handleSelectedColumnsUpdate}
+                sortable={false}
+            />
+            {withGroupBySelect ? (
+                <React.Fragment>
+                    <Text variant="body-2">{i18n('controls_group-by-placeholder')}</Text>
+                    <Select
+                        hasClear
+                        placeholder={'-'}
+                        width={150}
+                        defaultValue={groupByParam ? [groupByParam] : undefined}
+                        onUpdate={handleGroupBySelectUpdate}
+                        options={groupByoptions}
+                        className={b('group-by-select')}
+                        popupClassName={b('group-by-popup')}
+                    />
+                </React.Fragment>
+            ) : null}
+            <EntitiesCount
+                current={entitiesCountCurrent}
+                total={entitiesCountTotal}
+                label={i18n('nodes')}
+                loading={entitiesLoading}
+            />
+        </React.Fragment>
+    );
+}
diff --git a/src/containers/Nodes/PaginatedNodes.tsx b/src/containers/Nodes/PaginatedNodes.tsx
index 5e9ac9d21..f7b08ec09 100644
--- a/src/containers/Nodes/PaginatedNodes.tsx
+++ b/src/containers/Nodes/PaginatedNodes.tsx
@@ -1,150 +1,200 @@
 import React from 'react';
 
-import {TableColumnSetup} from '@gravity-ui/uikit';
-import {StringParam, useQueryParams} from 'use-query-params';
-
-import {EntitiesCount} from '../../components/EntitiesCount';
-import {AccessDenied} from '../../components/Errors/403';
 import {ResponseError} from '../../components/Errors/ResponseError';
-import {Illustration} from '../../components/Illustration';
-import {ResizeablePaginatedTable} from '../../components/PaginatedTable';
-import type {
-    GetRowClassName,
-    RenderControls,
-    RenderErrorMessage,
-} from '../../components/PaginatedTable';
-import {ProblemFilter} from '../../components/ProblemFilter';
-import {Search} from '../../components/Search';
-import {UptimeFilter} from '../../components/UptimeFIlter';
-import {NODES_COLUMNS_WIDTH_LS_KEY} from '../../components/nodesColumns/constants';
-import type {NodesPreparedEntity} from '../../store/reducers/nodes/types';
+import {LoaderWrapper} from '../../components/LoaderWrapper/LoaderWrapper';
+import type {RenderControls} from '../../components/PaginatedTable';
+import {TableWithControlsLayout} from '../../components/TableWithControlsLayout/TableWithControlsLayout';
 import {
-    ProblemFilterValues,
-    changeFilter,
-    selectProblemFilter,
-} from '../../store/reducers/settings/settings';
-import type {ProblemFilterValue} from '../../store/reducers/settings/types';
+    useCapabilitiesLoaded,
+    useViewerNodesHandlerHasGrouping,
+} from '../../store/reducers/capabilities/hooks';
+import {nodesApi} from '../../store/reducers/nodes/nodes';
+import {useProblemFilter} from '../../store/reducers/settings/hooks';
 import type {AdditionalNodesProps} from '../../types/additionalProps';
-import {cn} from '../../utils/cn';
-import {useTypedDispatch, useTypedSelector} from '../../utils/hooks';
-import {
-    NodesUptimeFilterValues,
-    isUnavailableNode,
-    nodesUptimeFilterValuesSchema,
-} from '../../utils/nodes';
+import {useAutoRefreshInterval} from '../../utils/hooks';
+import {NodesUptimeFilterValues} from '../../utils/nodes';
+import {TableGroup} from '../Storage/TableGroup/TableGroup';
+import {useExpandedGroups} from '../Storage/TableGroup/useExpandedTableGroups';
 
+import {NodesControls} from './NodesControls/NodesControls';
+import {PaginatedNodesTable} from './PaginatedNodesTable';
 import {useNodesSelectedColumns} from './columns/hooks';
-import {getNodes} from './getNodes';
 import i18n from './i18n';
+import {b} from './shared';
+import {useNodesPageQueryParams} from './useNodesPageQueryParams';
 
 import './Nodes.scss';
 
-const b = cn('ydb-nodes');
-
-interface NodesProps {
+interface PaginatedNodesProps {
     path?: string;
     database?: string;
     parentRef: React.RefObject<HTMLElement>;
     additionalNodesProps?: AdditionalNodesProps;
 }
 
-export const PaginatedNodes = ({path, database, parentRef, additionalNodesProps}: NodesProps) => {
-    const [queryParams, setQueryParams] = useQueryParams({
-        uptimeFilter: StringParam,
-        search: StringParam,
-    });
-    const uptimeFilter = nodesUptimeFilterValuesSchema.parse(queryParams.uptimeFilter);
-    const searchValue = queryParams.search ?? '';
+export function PaginatedNodes(props: PaginatedNodesProps) {
+    const {uptimeFilter, groupByParam, handleUptimeFilterChange} = useNodesPageQueryParams();
+    const {problemFilter, handleProblemFilterChange} = useProblemFilter();
 
-    const dispatch = useTypedDispatch();
+    const capabilitiesLoaded = useCapabilitiesLoaded();
+    const viewerNodesHandlerHasGrouping = useViewerNodesHandlerHasGrouping();
 
-    const problemFilter = useTypedSelector(selectProblemFilter);
+    // Other filters do not fit with grouping
+    // Reset them if grouping available
+    React.useEffect(() => {
+        if (
+            viewerNodesHandlerHasGrouping &&
+            (problemFilter !== 'All' || uptimeFilter !== NodesUptimeFilterValues.All)
+        ) {
+            handleProblemFilterChange('All');
+            handleUptimeFilterChange(NodesUptimeFilterValues.All);
+        }
+    }, [
+        handleProblemFilterChange,
+        handleUptimeFilterChange,
+        problemFilter,
+        uptimeFilter,
+        viewerNodesHandlerHasGrouping,
+    ]);
+
+    const renderContent = () => {
+        if (viewerNodesHandlerHasGrouping && groupByParam) {
+            return <GroupedNodesComponent {...props} />;
+        }
 
-    const tableFilters = React.useMemo(() => {
-        return {path, database, searchValue, problemFilter, uptimeFilter};
-    }, [path, database, searchValue, problemFilter, uptimeFilter]);
+        return <NodesComponent {...props} />;
+    };
+
+    return <LoaderWrapper loading={!capabilitiesLoaded}>{renderContent()}</LoaderWrapper>;
+}
+
+function NodesComponent({path, database, parentRef, additionalNodesProps}: PaginatedNodesProps) {
+    const {searchValue, uptimeFilter} = useNodesPageQueryParams();
+    const {problemFilter} = useProblemFilter();
+    const viewerNodesHandlerHasGrouping = useViewerNodesHandlerHasGrouping();
 
     const {columnsToShow, columnsToSelect, setColumns} = useNodesSelectedColumns({
         getNodeRef: additionalNodesProps?.getNodeRef,
         database,
     });
 
-    const getRowClassName: GetRowClassName<NodesPreparedEntity> = (row) => {
-        return b('node', {unavailable: isUnavailableNode(row)});
+    const renderControls: RenderControls = ({totalEntities, foundEntities, inited}) => {
+        return (
+            <NodesControls
+                withGroupBySelect={viewerNodesHandlerHasGrouping}
+                columnsToSelect={columnsToSelect}
+                handleSelectedColumnsUpdate={setColumns}
+                entitiesCountCurrent={foundEntities}
+                entitiesCountTotal={totalEntities}
+                entitiesLoading={!inited}
+            />
+        );
     };
 
-    const renderControls: RenderControls = ({totalEntities, foundEntities, inited}) => {
-        const handleSearchQueryChange = (value: string) => {
-            setQueryParams({search: value || undefined}, 'replaceIn');
-        };
+    return (
+        <PaginatedNodesTable
+            path={path}
+            database={database}
+            searchValue={searchValue}
+            problemFilter={problemFilter}
+            uptimeFilter={uptimeFilter}
+            columns={columnsToShow}
+            parentRef={parentRef}
+            renderControls={renderControls}
+        />
+    );
+}
 
-        const handleProblemFilterChange = (value: ProblemFilterValue) => {
-            dispatch(changeFilter(value));
-        };
+function GroupedNodesComponent({
+    path,
+    database,
+    parentRef,
+    additionalNodesProps,
+}: PaginatedNodesProps) {
+    const {searchValue, groupByParam} = useNodesPageQueryParams();
+    const [autoRefreshInterval] = useAutoRefreshInterval();
 
-        const handleUptimeFilterChange = (value: NodesUptimeFilterValues) => {
-            setQueryParams({uptimeFilter: value}, 'replaceIn');
-        };
+    const {columnsToShow, columnsToSelect, setColumns} = useNodesSelectedColumns({
+        getNodeRef: additionalNodesProps?.getNodeRef,
+        database,
+    });
 
-        return (
-            <React.Fragment>
-                <Search
-                    onChange={handleSearchQueryChange}
-                    placeholder="Host name"
-                    className={b('search')}
-                    value={searchValue}
-                />
-                <ProblemFilter value={problemFilter} onChange={handleProblemFilterChange} />
-                <UptimeFilter value={uptimeFilter} onChange={handleUptimeFilterChange} />
-                <TableColumnSetup
-                    popupWidth={200}
-                    items={columnsToSelect}
-                    showStatus
-                    onUpdate={setColumns}
-                    sortable={false}
-                />
-                <EntitiesCount
-                    total={totalEntities}
-                    current={foundEntities}
-                    label={'Nodes'}
-                    loading={!inited}
-                />
-            </React.Fragment>
-        );
-    };
+    const {currentData, isFetching, error} = nodesApi.useGetNodesQuery(
+        {
+            path,
+            database,
+            filter: searchValue,
+            group: groupByParam,
+            limit: 0,
+        },
+        {
+            pollingInterval: autoRefreshInterval,
+        },
+    );
 
-    const renderEmptyDataMessage = () => {
-        if (
-            problemFilter !== ProblemFilterValues.ALL ||
-            uptimeFilter !== NodesUptimeFilterValues.All
-        ) {
-            return <Illustration name="thumbsUp" width="200" />;
-        }
+    const isLoading = currentData === undefined && isFetching;
+    const {
+        NodeGroups: tableGroups,
+        FoundNodes: found = 0,
+        TotalNodes: total = 0,
+    } = currentData || {};
+
+    const {expandedGroups, setIsGroupExpanded} = useExpandedGroups(tableGroups);
 
-        return i18n('empty.default');
+    const renderControls = () => {
+        return (
+            <NodesControls
+                withGroupBySelect
+                columnsToSelect={columnsToSelect}
+                handleSelectedColumnsUpdate={setColumns}
+                entitiesCountCurrent={found}
+                entitiesCountTotal={total}
+                entitiesLoading={isLoading}
+            />
+        );
     };
 
-    const renderErrorMessage: RenderErrorMessage = (error) => {
-        if (error && error.status === 403) {
-            return <AccessDenied position="left" />;
+    const renderGroups = () => {
+        if (tableGroups?.length) {
+            return tableGroups.map(({name, count}) => {
+                const isExpanded = expandedGroups[name];
+
+                return (
+                    <TableGroup
+                        key={name}
+                        title={name}
+                        count={count}
+                        entityName={i18n('nodes')}
+                        expanded={isExpanded}
+                        onIsExpandedChange={setIsGroupExpanded}
+                    >
+                        <PaginatedNodesTable
+                            path={path}
+                            database={database}
+                            searchValue={searchValue}
+                            problemFilter={'All'}
+                            uptimeFilter={NodesUptimeFilterValues.All}
+                            filterGroup={name}
+                            filterGroupBy={groupByParam}
+                            initialEntitiesCount={count}
+                            columns={columnsToShow}
+                            parentRef={parentRef}
+                        />
+                    </TableGroup>
+                );
+            });
         }
 
-        return <ResponseError error={error} />;
+        return i18n('no-nodes-groups');
     };
 
     return (
-        <ResizeablePaginatedTable
-            columnsWidthLSKey={NODES_COLUMNS_WIDTH_LS_KEY}
-            parentRef={parentRef}
-            columns={columnsToShow}
-            fetchData={getNodes}
-            limit={50}
-            renderControls={renderControls}
-            renderErrorMessage={renderErrorMessage}
-            renderEmptyDataMessage={renderEmptyDataMessage}
-            getRowClassName={getRowClassName}
-            filters={tableFilters}
-            tableName="nodes"
-        />
+        <TableWithControlsLayout>
+            <TableWithControlsLayout.Controls>{renderControls()}</TableWithControlsLayout.Controls>
+            {error ? <ResponseError error={error} /> : null}
+            <TableWithControlsLayout.Table loading={isLoading} className={b('groups-wrapper')}>
+                {renderGroups()}
+            </TableWithControlsLayout.Table>
+        </TableWithControlsLayout>
     );
-};
+}
diff --git a/src/containers/Nodes/PaginatedNodesTable.tsx b/src/containers/Nodes/PaginatedNodesTable.tsx
new file mode 100644
index 000000000..91a27b301
--- /dev/null
+++ b/src/containers/Nodes/PaginatedNodesTable.tsx
@@ -0,0 +1,84 @@
+import React from 'react';
+
+import {Illustration} from '../../components/Illustration';
+import type {RenderControls} from '../../components/PaginatedTable';
+import {ResizeablePaginatedTable} from '../../components/PaginatedTable';
+import {NODES_COLUMNS_WIDTH_LS_KEY} from '../../components/nodesColumns/constants';
+import type {NodesPreparedEntity} from '../../store/reducers/nodes/types';
+import type {ProblemFilterValue} from '../../store/reducers/settings/types';
+import type {NodesGroupByField} from '../../types/api/nodes';
+import {NodesUptimeFilterValues} from '../../utils/nodes';
+import type {Column} from '../../utils/tableUtils/types';
+
+import {getNodes} from './getNodes';
+import i18n from './i18n';
+import {getRowClassName, renderPaginatedTableErrorMessage} from './shared';
+
+interface PaginatedNodesTableProps {
+    path?: string;
+    database?: string;
+
+    searchValue: string;
+    problemFilter: ProblemFilterValue;
+    uptimeFilter: NodesUptimeFilterValues;
+
+    filterGroup?: string;
+    filterGroupBy?: NodesGroupByField;
+
+    columns: Column<NodesPreparedEntity>[];
+    parentRef: React.RefObject<HTMLElement>;
+
+    renderControls?: RenderControls;
+    initialEntitiesCount?: number;
+}
+
+export function PaginatedNodesTable({
+    path,
+    database,
+    searchValue,
+    problemFilter,
+    uptimeFilter,
+    filterGroup,
+    filterGroupBy,
+    columns,
+    parentRef,
+    renderControls,
+    initialEntitiesCount,
+}: PaginatedNodesTableProps) {
+    const tableFilters = React.useMemo(() => {
+        return {
+            path,
+            database,
+            searchValue,
+            problemFilter,
+            uptimeFilter,
+            filterGroup,
+            filterGroupBy,
+        };
+    }, [path, database, searchValue, problemFilter, uptimeFilter, filterGroup, filterGroupBy]);
+
+    const renderEmptyDataMessage = () => {
+        if (problemFilter !== 'All' || uptimeFilter !== NodesUptimeFilterValues.All) {
+            return <Illustration name="thumbsUp" width="200" />;
+        }
+
+        return i18n('empty.default');
+    };
+
+    return (
+        <ResizeablePaginatedTable
+            columnsWidthLSKey={NODES_COLUMNS_WIDTH_LS_KEY}
+            parentRef={parentRef}
+            columns={columns}
+            fetchData={getNodes}
+            limit={50}
+            initialEntitiesCount={initialEntitiesCount}
+            renderControls={renderControls}
+            renderErrorMessage={renderPaginatedTableErrorMessage}
+            renderEmptyDataMessage={renderEmptyDataMessage}
+            getRowClassName={getRowClassName}
+            filters={tableFilters}
+            tableName="nodes"
+        />
+    );
+}
diff --git a/src/containers/Nodes/columns/constants.ts b/src/containers/Nodes/columns/constants.ts
index c0c701cf6..bbc4248bf 100644
--- a/src/containers/Nodes/columns/constants.ts
+++ b/src/containers/Nodes/columns/constants.ts
@@ -1,4 +1,8 @@
+import type {SelectOption} from '@gravity-ui/uikit';
+
+import {NODES_COLUMNS_TITLES} from '../../../components/nodesColumns/constants';
 import type {NodesColumnId} from '../../../components/nodesColumns/constants';
+import type {NodesGroupByField} from '../../../types/api/nodes';
 
 export const NODES_TABLE_SELECTED_COLUMNS_LS_KEY = 'nodesTableSelectedColumns';
 
@@ -16,3 +20,41 @@ export const DEFAULT_NODES_COLUMNS: NodesColumnId[] = [
 ];
 
 export const REQUIRED_NODES_COLUMNS: NodesColumnId[] = ['NodeId'];
+
+const ALL_NODES_GROUP_BY_PARAMS = [
+    'SystemState',
+    'Host',
+    'DC',
+    'Rack',
+    'Database',
+    'Version',
+    'Uptime',
+    'Missing',
+    'DiskSpaceUsage',
+] as const satisfies NodesGroupByField[];
+
+function getAvailableNodesGroupByParams(withSystemStateGroupBy?: boolean) {
+    if (!withSystemStateGroupBy) {
+        return ALL_NODES_GROUP_BY_PARAMS.filter((param) => param !== 'SystemState');
+    }
+
+    return ALL_NODES_GROUP_BY_PARAMS;
+}
+
+export function getNodesGroupByOptions(withSystemStateGroupBy?: boolean): SelectOption[] {
+    return getAvailableNodesGroupByParams(withSystemStateGroupBy).map((param) => {
+        return {
+            value: param,
+            content: NODES_COLUMNS_TITLES[param],
+        };
+    });
+}
+
+export function parseNodesGroupByParam(
+    paramToParse: unknown,
+    withSystemStateGroupBy?: boolean,
+): NodesGroupByField | undefined {
+    const availableParams = getAvailableNodesGroupByParams(withSystemStateGroupBy);
+
+    return availableParams.find((groupByField) => groupByField === paramToParse);
+}
diff --git a/src/containers/Nodes/getNodes.ts b/src/containers/Nodes/getNodes.ts
index 20d7458f2..a1f3bb370 100644
--- a/src/containers/Nodes/getNodes.ts
+++ b/src/containers/Nodes/getNodes.ts
@@ -12,10 +12,6 @@ import {
 } from '../../utils/nodes';
 import {getRequiredDataFields} from '../../utils/tableUtils/getRequiredDataFields';
 
-const getConcurrentId = (limit?: number, offset?: number) => {
-    return `getNodes|offset${offset}|limit${limit}`;
-};
-
 export const getNodes: FetchData<
     NodesPreparedEntity,
     NodesFilters,
@@ -33,7 +29,8 @@ export const getNodes: FetchData<
     } = params;
 
     const {sortOrder, columnId} = sortParams ?? {};
-    const {path, database, searchValue, problemFilter, uptimeFilter} = filters ?? {};
+    const {path, database, searchValue, problemFilter, uptimeFilter, filterGroup, filterGroupBy} =
+        filters ?? {};
 
     const sort = isSortableNodesProperty(columnId)
         ? prepareSortValue(NODES_SORT_VALUE_TO_FIELD[columnId], sortOrder)
@@ -41,23 +38,22 @@ export const getNodes: FetchData<
 
     const dataFieldsRequired = getRequiredDataFields(columnsIds, NODES_COLUMNS_TO_DATA_FIELDS);
 
-    const response = await window.api.getNodes(
-        {
-            type,
-            storage,
-            tablets,
-            limit,
-            offset,
-            sort,
-            path,
-            database,
-            filter: searchValue,
-            problems_only: getProblemParamValue(problemFilter),
-            uptime: getUptimeParamValue(uptimeFilter),
-            fieldsRequired: dataFieldsRequired,
-        },
-        {concurrentId: getConcurrentId(limit, offset), signal: params.signal},
-    );
+    const response = await window.api.getNodes({
+        type,
+        storage,
+        tablets,
+        limit,
+        offset,
+        sort,
+        path,
+        database,
+        filter: searchValue,
+        problems_only: getProblemParamValue(problemFilter),
+        uptime: getUptimeParamValue(uptimeFilter),
+        filter_group: filterGroup,
+        filter_group_by: filterGroupBy,
+        fieldsRequired: dataFieldsRequired,
+    });
     const preparedResponse = prepareNodesData(response);
 
     return {
diff --git a/src/containers/Nodes/i18n/en.json b/src/containers/Nodes/i18n/en.json
index ea9c9392f..2499e177b 100644
--- a/src/containers/Nodes/i18n/en.json
+++ b/src/containers/Nodes/i18n/en.json
@@ -1,3 +1,10 @@
 {
-  "empty.default": "No such nodes"
+  "nodes": "Nodes",
+
+  "empty.default": "No such nodes",
+
+  "no-nodes-groups": "No nodes groups",
+
+  "controls_search-placeholder": "Host name",
+  "controls_group-by-placeholder": "Group by:"
 }
diff --git a/src/containers/Nodes/i18n/index.ts b/src/containers/Nodes/i18n/index.ts
index 71b11c937..c9c5f97fb 100644
--- a/src/containers/Nodes/i18n/index.ts
+++ b/src/containers/Nodes/i18n/index.ts
@@ -1,8 +1,7 @@
 import {registerKeysets} from '../../../utils/i18n';
 
 import en from './en.json';
-import ru from './ru.json';
 
 const COMPONENT = 'ydb-nodes';
 
-export default registerKeysets(COMPONENT, {ru, en});
+export default registerKeysets(COMPONENT, {en});
diff --git a/src/containers/Nodes/i18n/ru.json b/src/containers/Nodes/i18n/ru.json
deleted file mode 100644
index 93e141977..000000000
--- a/src/containers/Nodes/i18n/ru.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "empty.default": "Нет узлов"
-}
diff --git a/src/containers/Nodes/shared.tsx b/src/containers/Nodes/shared.tsx
new file mode 100644
index 000000000..257f7e999
--- /dev/null
+++ b/src/containers/Nodes/shared.tsx
@@ -0,0 +1,20 @@
+import {AccessDenied} from '../../components/Errors/403';
+import {ResponseError} from '../../components/Errors/ResponseError';
+import type {GetRowClassName, RenderErrorMessage} from '../../components/PaginatedTable';
+import type {NodesPreparedEntity} from '../../store/reducers/nodes/types';
+import {cn} from '../../utils/cn';
+import {isUnavailableNode} from '../../utils/nodes';
+
+export const b = cn('ydb-nodes');
+
+export const getRowClassName: GetRowClassName<NodesPreparedEntity> = (row) => {
+    return b('node', {unavailable: isUnavailableNode(row)});
+};
+
+export const renderPaginatedTableErrorMessage: RenderErrorMessage = (error) => {
+    if (error && error.status === 403) {
+        return <AccessDenied position="left" />;
+    }
+
+    return <ResponseError error={error} />;
+};
diff --git a/src/containers/Nodes/useNodesPageQueryParams.ts b/src/containers/Nodes/useNodesPageQueryParams.ts
new file mode 100644
index 000000000..a3f617813
--- /dev/null
+++ b/src/containers/Nodes/useNodesPageQueryParams.ts
@@ -0,0 +1,44 @@
+import {StringParam, useQueryParams} from 'use-query-params';
+
+import {useViewerNodesHandlerHasGroupingBySystemState} from '../../store/reducers/capabilities/hooks';
+import type {NodesUptimeFilterValues} from '../../utils/nodes';
+import {nodesUptimeFilterValuesSchema} from '../../utils/nodes';
+
+import {parseNodesGroupByParam} from './columns/constants';
+
+export function useNodesPageQueryParams() {
+    const [queryParams, setQueryParams] = useQueryParams({
+        uptimeFilter: StringParam,
+        search: StringParam,
+        nodesGroupBy: StringParam,
+    });
+
+    const uptimeFilter = nodesUptimeFilterValuesSchema.parse(queryParams.uptimeFilter);
+    const searchValue = queryParams.search ?? '';
+
+    const systemStateGroupingAvailable = useViewerNodesHandlerHasGroupingBySystemState();
+    const groupByParam = parseNodesGroupByParam(
+        queryParams.nodesGroupBy,
+        systemStateGroupingAvailable,
+    );
+
+    const handleSearchQueryChange = (value: string) => {
+        setQueryParams({search: value || undefined}, 'replaceIn');
+    };
+    const handleUptimeFilterChange = (value: NodesUptimeFilterValues) => {
+        setQueryParams({uptimeFilter: value}, 'replaceIn');
+    };
+    const handleGroupByParamChange = (value: string) => {
+        setQueryParams({nodesGroupBy: value}, 'replaceIn');
+    };
+
+    return {
+        uptimeFilter,
+        searchValue,
+        groupByParam,
+
+        handleSearchQueryChange,
+        handleUptimeFilterChange,
+        handleGroupByParamChange,
+    };
+}
diff --git a/src/containers/Storage/PaginatedStorageNodes.tsx b/src/containers/Storage/PaginatedStorageNodes.tsx
index 887d9fa35..b89165d69 100644
--- a/src/containers/Storage/PaginatedStorageNodes.tsx
+++ b/src/containers/Storage/PaginatedStorageNodes.tsx
@@ -39,8 +39,7 @@ export const PaginatedStorageNodes = (props: PaginatedStorageProps) => {
     React.useEffect(() => {
         if (
             viewerNodesHandlerHasGrouping &&
-            visibleEntities !== 'all' &&
-            nodesUptimeFilter !== NodesUptimeFilterValues.All
+            (visibleEntities !== 'all' || nodesUptimeFilter !== NodesUptimeFilterValues.All)
         ) {
             handleShowAllNodes();
         }
diff --git a/src/store/reducers/capabilities/hooks.ts b/src/store/reducers/capabilities/hooks.ts
index d10f74882..f1ed542c4 100644
--- a/src/store/reducers/capabilities/hooks.ts
+++ b/src/store/reducers/capabilities/hooks.ts
@@ -58,6 +58,10 @@ export const useViewerNodesHandlerHasGrouping = () => {
     return useGetFeatureVersion('/viewer/nodes') > 6;
 };
 
+export const useViewerNodesHandlerHasGroupingBySystemState = () => {
+    return useGetFeatureVersion('/viewer/nodes') > 11;
+};
+
 export const useFeatureFlagsAvailable = () => {
     return useGetFeatureVersion('/viewer/feature_flags') > 1;
 };
diff --git a/src/store/reducers/nodes/types.ts b/src/store/reducers/nodes/types.ts
index 95f1a119e..efc7de8c3 100644
--- a/src/store/reducers/nodes/types.ts
+++ b/src/store/reducers/nodes/types.ts
@@ -1,7 +1,12 @@
 import type {OrderType} from '@gravity-ui/react-data-table';
 
 import type {EFlag} from '../../../types/api/enums';
-import type {NodesSortValue, TEndpoint, TPoolStats} from '../../../types/api/nodes';
+import type {
+    NodesGroupByField,
+    NodesSortValue,
+    TEndpoint,
+    TPoolStats,
+} from '../../../types/api/nodes';
 import type {TTabletStateInfo as TFullTabletStateInfo} from '../../../types/api/tablet';
 import type {NodesUptimeFilterValues, PreparedNodeSystemState} from '../../../utils/nodes';
 import type {ProblemFilterValue} from '../settings/types';
@@ -39,8 +44,12 @@ export interface NodesFilters {
     searchValue: string;
     problemFilter: ProblemFilterValue;
     uptimeFilter: NodesUptimeFilterValues;
+
     path?: string;
     database?: string;
+
+    filterGroup?: string;
+    filterGroupBy?: NodesGroupByField;
 }
 
 export interface NodesGroup {
diff --git a/src/store/reducers/nodes/utils.ts b/src/store/reducers/nodes/utils.ts
index 452d3b612..69c508042 100644
--- a/src/store/reducers/nodes/utils.ts
+++ b/src/store/reducers/nodes/utils.ts
@@ -2,7 +2,7 @@ import type {TNodesInfo} from '../../../types/api/nodes';
 import {generateEvaluator} from '../../../utils/generateEvaluator';
 import {prepareNodeSystemState} from '../../../utils/nodes';
 
-import type {NodesHandledResponse} from './types';
+import type {NodesGroup, NodesHandledResponse} from './types';
 
 export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
     const rawNodes = data.Nodes || [];
@@ -15,10 +15,15 @@ export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
         };
     });
 
-    const preparedGroups = data.NodeGroups?.map((group) => ({
-        name: group.GroupName,
-        count: group.NodeCount,
-    }));
+    const preparedGroups = data.NodeGroups?.map(({GroupName, NodeCount}) => {
+        if (GroupName && NodeCount) {
+            return {
+                name: GroupName,
+                count: Number(NodeCount),
+            };
+        }
+        return undefined;
+    }).filter((group): group is NodesGroup => Boolean(group));
 
     return {
         Nodes: preparedNodes,
diff --git a/src/store/reducers/settings/hooks.ts b/src/store/reducers/settings/hooks.ts
new file mode 100644
index 000000000..ebe760b40
--- /dev/null
+++ b/src/store/reducers/settings/hooks.ts
@@ -0,0 +1,19 @@
+import {useTypedDispatch, useTypedSelector} from '../../../utils/hooks';
+
+import {changeFilter, selectProblemFilter} from './settings';
+import type {ProblemFilterValue} from './types';
+
+export function useProblemFilter() {
+    const dispatch = useTypedDispatch();
+
+    const problemFilter = useTypedSelector(selectProblemFilter);
+
+    const handleProblemFilterChange = (value: ProblemFilterValue) => {
+        dispatch(changeFilter(value));
+    };
+
+    return {
+        problemFilter,
+        handleProblemFilterChange,
+    };
+}
diff --git a/src/types/api/nodes.ts b/src/types/api/nodes.ts
index be4b5e287..285b090b4 100644
--- a/src/types/api/nodes.ts
+++ b/src/types/api/nodes.ts
@@ -151,6 +151,7 @@ type NodesWithFilter = 'space' | 'missing' | 'all';
 
 export type NodesGroupByField =
     | 'NodeId'
+    | 'SystemState'
     | 'Host'
     | 'NodeName'
     | 'Database'
diff --git a/tests/suites/nodes/NodesPage.ts b/tests/suites/nodes/NodesPage.ts
index e81119d96..d6c83b51a 100644
--- a/tests/suites/nodes/NodesPage.ts
+++ b/tests/suites/nodes/NodesPage.ts
@@ -3,12 +3,53 @@ import type {Locator, Page} from '@playwright/test';
 import {PageModel} from '../../models/PageModel';
 import {nodesPage} from '../../utils/constants';
 
+type NodesGroupByOptions =
+    | 'Host'
+    | 'DC'
+    | 'Rack'
+    | 'Database'
+    | 'Version'
+    | 'Uptime'
+    | 'Missing'
+    | 'DiskSpaceUsage';
+
 export class NodesPage extends PageModel {
     readonly table: Locator;
 
+    private groupBySelect: Locator;
+    private groupByPopup: Locator;
+
+    private tableGroupsWrapper: Locator;
+
     constructor(page: Page) {
         super(page, nodesPage);
 
         this.table = this.selector.locator('.ydb-paginated-table__table');
+
+        this.groupBySelect = this.page.locator('.ydb-nodes__group-by-select');
+        this.groupByPopup = this.page.locator('.ydb-nodes__group-by-popup');
+
+        this.tableGroupsWrapper = this.page.locator('.ydb-nodes__groups-wrapper');
+    }
+
+    async selectGroupByOption(option: NodesGroupByOptions) {
+        await this.groupBySelect.click();
+        await this.groupByPopup.isVisible();
+        await this.groupByPopup.locator('.g-select-list__option').getByText(option).click();
+    }
+    async waitForTableGroupsLoaded() {
+        await this.page.locator('.table-skeleton').isHidden();
+        await this.tableGroupsWrapper.isVisible();
+    }
+    selectTableGroup(name: string) {
+        return this.tableGroupsWrapper.locator('.ydb-table-group').filter({hasText: name}).first();
+    }
+    async expandTableGroup(name: string) {
+        await this.selectTableGroup(name).getByRole('button').click();
+    }
+    selectTableGroupContent(name: string) {
+        return this.selectTableGroup(name)
+            .locator('.ydb-table-group__content')
+            .locator('.ydb-paginated-table');
     }
 }
diff --git a/tests/suites/nodes/nodes.test.ts b/tests/suites/nodes/nodes.test.ts
index d4de19d82..90d070e8e 100644
--- a/tests/suites/nodes/nodes.test.ts
+++ b/tests/suites/nodes/nodes.test.ts
@@ -61,19 +61,23 @@ test.describe('Test Nodes Paginated Table', async () => {
         expect(filteredRowCount).toBeLessThanOrEqual(initialRowCount);
     });
 
-    test('Radio button selection changes displayed data', async ({page}) => {
-        const paginatedTable = new PaginatedTable(page);
+    test('Table groups displayed correctly if group by option is selected', async ({page}) => {
+        const nodesPage = new NodesPage(page);
+        const nodesTable = new PaginatedTable(page);
 
-        await paginatedTable.waitForTableToLoad();
-        await paginatedTable.waitForTableData();
+        await nodesTable.waitForTableToLoad();
+        await nodesTable.waitForTableData();
 
-        const initialRowCount = await paginatedTable.getRowCount();
-        await paginatedTable.selectRadioOption(0, 'With problems');
+        const rowData = await nodesTable.getRowData(0);
+        const host = rowData['Host'];
 
-        await page.waitForTimeout(1000); // Wait for the table to update
+        await nodesPage.selectGroupByOption('Host');
+        await nodesPage.waitForTableGroupsLoaded();
 
-        const filteredRowCount = await paginatedTable.getRowCount();
-        expect(filteredRowCount).toBeLessThanOrEqual(initialRowCount);
+        await nodesPage.selectTableGroup(host).isVisible();
+
+        await nodesPage.expandTableGroup(host);
+        await nodesPage.selectTableGroupContent(host).isVisible();
     });
 
     test('Node count is displayed correctly', async ({page}) => {