diff --git a/packages/app/src/DBDashboardPage.tsx b/packages/app/src/DBDashboardPage.tsx
index 1be5bd4938..7d30013a74 100644
--- a/packages/app/src/DBDashboardPage.tsx
+++ b/packages/app/src/DBDashboardPage.tsx
@@ -82,7 +82,7 @@ import {
 import { ContactSupportText } from '@/components/ContactSupportText';
 import {
   EmptyContainerPlaceholder,
-  SortableSectionWrapper,
+  SortableContainerWrapper,
 } from '@/components/DashboardDndComponents';
 import {
   DashboardDndProvider,
@@ -94,7 +94,6 @@ import DBTableChart from '@/components/DBTableChart';
 import { DBTimeChart } from '@/components/DBTimeChart';
 import FullscreenPanelModal from '@/components/FullscreenPanelModal';
 import GroupContainer from '@/components/GroupContainer';
-import SectionHeader from '@/components/SectionHeader';
 import { TimePicker } from '@/components/TimePicker';
 import {
   Dashboard,
@@ -175,7 +174,7 @@ const Tile = forwardRef(
       onEditClick,
       onDeleteClick,
       onUpdateChart,
-      onMoveToSection,
+      onMoveToGroup,
       moveTargets,
       granularity,
       onTimeRangeSelect,
@@ -199,10 +198,7 @@ const Tile = forwardRef(
       onAddAlertClick?: () => void;
       onDeleteClick: () => void;
       onUpdateChart?: (chart: Tile) => void;
-      onMoveToSection?: (
-        containerId: string | undefined,
-        tabId?: string,
-      ) => void;
+      onMoveToGroup?: (containerId: string | undefined, tabId?: string) => void;
       moveTargets?: MoveTarget[];
       onSettled?: () => void;
       granularity: SQLInterval | undefined;
@@ -422,22 +418,22 @@ const Tile = forwardRef(
           >
             <IconPencil size={14} />
           </ActionIcon>
-          {onMoveToSection && moveTargets && moveTargets.length > 0 && (
+          {onMoveToGroup && moveTargets && moveTargets.length > 0 && (
             <Menu width={200} position="bottom-end">
               <Menu.Target>
                 <ActionIcon
-                  data-testid={`tile-move-section-button-${chart.id}`}
+                  data-testid={`tile-move-group-button-${chart.id}`}
                   variant="subtle"
                   size="sm"
-                  title="Move to Section"
+                  title="Move to Group"
                 >
                   <IconLayoutList size={14} />
                 </ActionIcon>
               </Menu.Target>
               <Menu.Dropdown>
-                <Menu.Label>Move to Section</Menu.Label>
+                <Menu.Label>Move to Group</Menu.Label>
                 {chart.containerId && (
-                  <Menu.Item onClick={() => onMoveToSection(undefined)}>
+                  <Menu.Item onClick={() => onMoveToGroup(undefined)}>
                     (Ungrouped)
                   </Menu.Item>
                 )}
@@ -452,7 +448,7 @@ const Tile = forwardRef(
                   .map(t => (
                     <Menu.Item
                       key={`${t.containerId}-${t.tabId ?? ''}`}
-                      onClick={() => onMoveToSection(t.containerId, t.tabId)}
+                      onClick={() => onMoveToGroup(t.containerId, t.tabId)}
                     >
                       {t.allTabs ? (
                         <span>
@@ -513,7 +509,7 @@ const Tile = forwardRef(
       onDeleteClick,
       onDuplicateClick,
       onEditClick,
-      onMoveToSection,
+      onMoveToGroup,
     ]);
 
     const title = useMemo(
@@ -1186,11 +1182,11 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
 
   const [editedTile, setEditedTile] = useState<undefined | Tile>();
 
-  const sections = useMemo(
+  const containers = useMemo(
     () => dashboard?.containers ?? [],
     [dashboard?.containers],
   );
-  // URL-based collapse state: tracks which sections the current viewer has
+  // URL-based collapse state: tracks which containers the current viewer has
   // explicitly collapsed/expanded. Falls back to the DB-stored default.
   const [urlCollapsedIds, setUrlCollapsedIds] = useQueryState(
     'collapsed',
@@ -1210,22 +1206,22 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
     [urlExpandedIds],
   );
 
-  const isSectionCollapsed = useCallback(
-    (section: DashboardContainer): boolean => {
+  const isContainerCollapsed = useCallback(
+    (container: DashboardContainer): boolean => {
       // URL state takes precedence over DB default
-      if (collapsedIdSet.has(section.id)) return true;
-      if (expandedIdSet.has(section.id)) return false;
-      return section.collapsed ?? false;
+      if (collapsedIdSet.has(container.id)) return true;
+      if (expandedIdSet.has(container.id)) return false;
+      return container.collapsed ?? false;
     },
     [collapsedIdSet, expandedIdSet],
   );
 
-  // Valid move targets: sections, groups, and individual tabs within groups
+  // Valid move targets: groups and individual tabs within groups
   const moveTargetContainers = useMemo<MoveTarget[]>(() => {
     const targets: MoveTarget[] = [];
-    for (const c of sections) {
+    for (const c of containers) {
       const cTabs = c.tabs ?? [];
-      if (c.type === 'group' && cTabs.length >= 2) {
+      if (cTabs.length >= 2) {
         for (const tab of cTabs) {
           targets.push({
             containerId: c.id,
@@ -1234,7 +1230,7 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
             allTabs: cTabs.map(t => ({ id: t.id, title: t.title })),
           });
         }
-      } else if (c.type === 'group' && cTabs.length === 1) {
+      } else if (cTabs.length === 1) {
         // 1-tab group: show just the group name, target the single tab
         targets.push({
           containerId: c.id,
@@ -1246,11 +1242,9 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
       }
     }
     return targets;
-  }, [sections]);
+  }, [containers]);
 
-  const hasContainers = sections.length > 0;
-  // Keep backward-compatible alias
-  const hasSections = hasContainers;
+  const hasContainers = containers.length > 0;
   const allTiles = useMemo(() => dashboard?.tiles ?? [], [dashboard?.tiles]);
 
   // --- Select-and-group workflow (Shift+click → Cmd+G) ---
@@ -1261,7 +1255,7 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
     handleGroupSelected,
   } = useTileSelection({ dashboard, setDashboard });
 
-  const handleMoveTileToSection = useCallback(
+  const handleMoveTileToGroup = useCallback(
     (tileId: string, containerId: string | undefined, tabId?: string) => {
       if (!dashboard) return;
       setDashboard(
@@ -1378,8 +1372,8 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
           }
         }}
         moveTargets={moveTargetContainers}
-        onMoveToSection={(containerId, tabId) =>
-          handleMoveTileToSection(chart.id, containerId, tabId)
+        onMoveToGroup={(containerId, tabId) =>
+          handleMoveTileToGroup(chart.id, containerId, tabId)
         }
         isSelected={selectedTileIds.has(chart.id)}
         onSelect={handleTileSelect}
@@ -1399,7 +1393,7 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
       onTimeRangeSelect,
       filterQueries,
       moveTargetContainers,
-      handleMoveTileToSection,
+      handleMoveTileToGroup,
       selectedTileIds,
       handleTileSelect,
     ],
@@ -1457,10 +1451,12 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
 
   // Toggle collapse in URL state only (per-viewer, shareable via link).
   // Does NOT persist to DB — the DB `collapsed` field is the default.
-  const handleToggleSection = useCallback(
+  const handleToggleCollapse = useCallback(
     (containerId: string) => {
-      const section = dashboard?.containers?.find(s => s.id === containerId);
-      const currentlyCollapsed = section ? isSectionCollapsed(section) : false;
+      const container = dashboard?.containers?.find(s => s.id === containerId);
+      const currentlyCollapsed = container
+        ? isContainerCollapsed(container)
+        : false;
 
       if (currentlyCollapsed) {
         addToUrlSet(setUrlExpandedIds, containerId);
@@ -1472,7 +1468,7 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
     },
     [
       dashboard?.containers,
-      isSectionCollapsed,
+      isContainerCollapsed,
       addToUrlSet,
       removeFromUrlSet,
       setUrlCollapsedIds,
@@ -1487,8 +1483,8 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
       if (!dashboard) return;
       setDashboard(
         produce(dashboard, draft => {
-          const section = draft.containers?.find(s => s.id === containerId);
-          if (section) section.collapsed = !section.collapsed;
+          const c = draft.containers?.find(s => s.id === containerId);
+          if (c) c.collapsed = !c.collapsed;
         }),
       );
     },
@@ -1496,13 +1492,13 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
   );
 
   // Use the hook for container/tab CRUD operations, but override
-  // handleToggleSection with the URL-based version above.
+  // handleToggleCollapsed with the URL-based version above.
   const {
     handleAddContainer,
-    handleToggleSection: _handleToggleSectionDB,
-    handleRenameSection,
-    handleDeleteSection,
-    handleReorderSections,
+    handleToggleCollapsed: _handleToggleCollapsedDB,
+    handleRenameContainer,
+    handleDeleteContainer,
+    handleReorderContainers,
     handleAddTab,
     handleRenameTab,
     handleDeleteTab,
@@ -1510,11 +1506,11 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
   } = useDashboardContainers({ dashboard, setDashboard, confirm });
 
   const onAddTile = (containerId?: string, tabId?: string) => {
-    // Auto-expand collapsed section via URL state so the new tile is visible
+    // Auto-expand collapsed container via URL state so the new tile is visible
     if (containerId) {
-      const section = dashboard?.containers?.find(s => s.id === containerId);
-      if (section && isSectionCollapsed(section)) {
-        handleToggleSection(containerId);
+      const container = dashboard?.containers?.find(s => s.id === containerId);
+      if (container && isContainerCollapsed(container)) {
+        handleToggleCollapse(containerId);
       }
     }
     // Default new tile size: w=8 (1/3 width), h=10 — matches original behavior
@@ -1548,23 +1544,23 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
   // Orphaned tiles (containerId not matching any container) become ungrouped.
   const tilesByContainerId = useMemo(() => {
     const map = new Map<string, Tile[]>();
-    for (const c of sections) {
+    for (const c of containers) {
       map.set(
         c.id,
         allTiles.filter(t => t.containerId === c.id),
       );
     }
     return map;
-  }, [sections, allTiles]);
+  }, [containers, allTiles]);
 
   const ungroupedTiles = useMemo(
     () =>
-      hasSections
+      hasContainers
         ? allTiles.filter(
             t => !t.containerId || !tilesByContainerId.has(t.containerId),
           )
         : allTiles,
-    [hasSections, allTiles, tilesByContainerId],
+    [hasContainers, allTiles, tilesByContainerId],
   );
 
   const onUngroupedLayoutChange = useMemo(
@@ -1572,14 +1568,14 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
     [makeOnLayoutChange, ungroupedTiles],
   );
 
-  const sectionLayoutChangeHandlers = useMemo(() => {
+  const containerLayoutChangeHandlers = useMemo(() => {
     const map = new Map<string, (newLayout: RGL.Layout[]) => void>();
-    for (const section of sections) {
-      const tiles = tilesByContainerId.get(section.id) ?? [];
-      map.set(section.id, makeOnLayoutChange(tiles));
+    for (const c of containers) {
+      const tiles = tilesByContainerId.get(c.id) ?? [];
+      map.set(c.id, makeOnLayoutChange(tiles));
     }
     return map;
-  }, [sections, tilesByContainerId, makeOnLayoutChange]);
+  }, [containers, tilesByContainerId, makeOnLayoutChange]);
 
   const deleteDashboard = useDeleteDashboard();
 
@@ -1916,9 +1912,9 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
               size="xs"
               variant="primary"
               onClick={handleGroupSelected}
-              title="Group selected tiles into a new section (Cmd+G)"
+              title="Group selected tiles (Cmd+G)"
             >
-              Group into Section
+              Group
             </Button>
             <Button
               size="xs"
@@ -1941,8 +1937,8 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
             }
           >
             <DashboardDndProvider
-              containers={sections}
-              onReorderSections={handleReorderSections}
+              containers={containers}
+              onReorderContainers={handleReorderContainers}
             >
               {hasContainers ? (
                 <>
@@ -1957,139 +1953,89 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
                       {ungroupedTiles.map(renderTileComponent)}
                     </ReactGridLayout>
                   )}
-                  {sections.map(container => {
+                  {containers.map(container => {
                     const containerTiles =
                       tilesByContainerId.get(container.id) ?? [];
-                    const isEmpty =
-                      containerTiles.length === 0 &&
-                      !isSectionCollapsed(container);
-
-                    // Render based on container type
-                    if (container.type === 'group') {
-                      const groupTabs = container.tabs ?? [];
-                      const groupActiveTabId =
-                        container.activeTabId ?? groupTabs[0]?.id;
-                      const hasTabs = groupTabs.length >= 2;
-
-                      return (
-                        <SortableSectionWrapper
-                          key={container.id}
-                          sectionId={container.id}
-                          sectionTitle={container.title}
-                        >
-                          {(dragHandleProps: DragHandleProps) => (
-                            <GroupContainer
-                              container={container}
-                              onDelete={() => handleDeleteSection(container.id)}
-                              onAddTile={() =>
-                                onAddTile(
-                                  container.id,
-                                  hasTabs ? groupActiveTabId : undefined,
-                                )
-                              }
-                              activeTabId={groupActiveTabId}
-                              onTabChange={tabId =>
-                                handleTabChange(container.id, tabId)
-                              }
-                              onAddTab={() => handleAddTab(container.id)}
-                              onRenameTab={(tabId, newTitle) =>
-                                handleRenameTab(container.id, tabId, newTitle)
-                              }
-                              onDeleteTab={tabId =>
-                                handleDeleteTab(container.id, tabId)
-                              }
-                              dragHandleProps={dragHandleProps}
-                            >
-                              {(currentTabId: string | undefined) => {
-                                const visibleTiles = currentTabId
-                                  ? containerTiles.filter(
-                                      t => t.tabId === currentTabId,
-                                    )
-                                  : containerTiles;
-                                const visibleIsEmpty =
-                                  visibleTiles.length === 0;
-                                return (
-                                  <EmptyContainerPlaceholder
-                                    sectionId={currentTabId ?? container.id}
-                                    isEmpty={visibleIsEmpty}
-                                    onAddTile={() =>
-                                      onAddTile(container.id, currentTabId)
-                                    }
-                                  >
-                                    {visibleTiles.length > 0 && (
-                                      <ReactGridLayout
-                                        layout={visibleTiles.map(
-                                          tileToLayoutItem,
-                                        )}
-                                        containerPadding={[0, 0]}
-                                        onLayoutChange={sectionLayoutChangeHandlers.get(
-                                          container.id,
-                                        )}
-                                        cols={24}
-                                        rowHeight={32}
-                                      >
-                                        {visibleTiles.map(renderTileComponent)}
-                                      </ReactGridLayout>
-                                    )}
-                                  </EmptyContainerPlaceholder>
-                                );
-                              }}
-                            </GroupContainer>
-                          )}
-                        </SortableSectionWrapper>
-                      );
-                    }
+                    const groupTabs = container.tabs ?? [];
+                    const groupActiveTabId =
+                      container.activeTabId ?? groupTabs[0]?.id;
+                    const hasTabs = groupTabs.length >= 2;
+                    const containerCollapsed = isContainerCollapsed(container);
 
-                    // Default: section type
                     return (
-                      <SortableSectionWrapper
+                      <SortableContainerWrapper
                         key={container.id}
-                        sectionId={container.id}
-                        sectionTitle={container.title}
+                        containerId={container.id}
+                        containerTitle={container.title}
                       >
                         {(dragHandleProps: DragHandleProps) => (
-                          <div>
-                            <SectionHeader
-                              section={container}
-                              tileCount={containerTiles.length}
-                              collapsed={isSectionCollapsed(container)}
-                              defaultCollapsed={container.collapsed ?? false}
-                              onToggle={() => handleToggleSection(container.id)}
-                              onToggleDefaultCollapsed={() =>
-                                handleToggleDefaultCollapsed(container.id)
-                              }
-                              onRename={newTitle =>
-                                handleRenameSection(container.id, newTitle)
-                              }
-                              onDelete={() => handleDeleteSection(container.id)}
-                              onAddTile={() => onAddTile(container.id)}
-                              dragHandleProps={dragHandleProps}
-                            />
-                            <EmptyContainerPlaceholder
-                              sectionId={container.id}
-                              isEmpty={isEmpty}
-                              onAddTile={() => onAddTile(container.id)}
-                            >
-                              {!isSectionCollapsed(container) &&
-                                containerTiles.length > 0 && (
-                                  <ReactGridLayout
-                                    layout={containerTiles.map(
-                                      tileToLayoutItem,
-                                    )}
-                                    containerPadding={[0, 0]}
-                                    onLayoutChange={sectionLayoutChangeHandlers.get(
-                                      container.id,
-                                    )}
-                                    cols={24}
-                                    rowHeight={32}
-                                  >
-                                    {containerTiles.map(renderTileComponent)}
-                                  </ReactGridLayout>
-                                )}
-                            </EmptyContainerPlaceholder>
-                          </div>
+                          <GroupContainer
+                            container={container}
+                            collapsed={containerCollapsed}
+                            defaultCollapsed={container.collapsed ?? false}
+                            onToggle={() => handleToggleCollapse(container.id)}
+                            onToggleDefaultCollapsed={() =>
+                              handleToggleDefaultCollapsed(container.id)
+                            }
+                            onDelete={() => handleDeleteContainer(container.id)}
+                            onAddTile={() =>
+                              onAddTile(
+                                container.id,
+                                hasTabs ? groupActiveTabId : undefined,
+                              )
+                            }
+                            activeTabId={groupActiveTabId}
+                            onTabChange={tabId =>
+                              handleTabChange(container.id, tabId)
+                            }
+                            onAddTab={() => handleAddTab(container.id)}
+                            onRenameTab={(tabId, newTitle) =>
+                              handleRenameTab(container.id, tabId, newTitle)
+                            }
+                            onDeleteTab={tabId =>
+                              handleDeleteTab(container.id, tabId)
+                            }
+                            onRename={newTitle =>
+                              handleRenameContainer(container.id, newTitle)
+                            }
+                            dragHandleProps={dragHandleProps}
+                          >
+                            {(currentTabId: string | undefined) => {
+                              const visibleTiles = currentTabId
+                                ? containerTiles.filter(
+                                    t => t.tabId === currentTabId,
+                                  )
+                                : containerTiles;
+                              const visibleIsEmpty = visibleTiles.length === 0;
+                              return (
+                                <EmptyContainerPlaceholder
+                                  containerId={currentTabId ?? container.id}
+                                  isEmpty={visibleIsEmpty}
+                                  onAddTile={() =>
+                                    onAddTile(container.id, currentTabId)
+                                  }
+                                >
+                                  {visibleTiles.length > 0 && (
+                                    <ReactGridLayout
+                                      layout={visibleTiles.map(
+                                        tileToLayoutItem,
+                                      )}
+                                      containerPadding={[0, 0]}
+                                      onLayoutChange={containerLayoutChangeHandlers.get(
+                                        container.id,
+                                      )}
+                                      cols={24}
+                                      rowHeight={32}
+                                    >
+                                      {visibleTiles.map(renderTileComponent)}
+                                    </ReactGridLayout>
+                                  )}
+                                </EmptyContainerPlaceholder>
+                              );
+                            }}
+                          </GroupContainer>
                         )}
-                      </SortableSectionWrapper>
+                      </SortableContainerWrapper>
                     );
                   })}
                 </>
@@ -2130,18 +2076,10 @@ function DBDashboardPage({ presetConfig }: { presetConfig?: Dashboard }) {
             New Tile
           </Menu.Item>
           <Menu.Divider />
-          <Menu.Label>Containers</Menu.Label>
-          <Menu.Item
-            data-testid="add-new-section-menu-item"
-            leftSection={<IconLayoutList size={16} />}
-            onClick={() => handleAddContainer('section')}
-          >
-            New Section
-          </Menu.Item>
           <Menu.Item
             data-testid="add-new-group-menu-item"
             leftSection={<IconSquaresDiagonal size={16} />}
-            onClick={() => handleAddContainer('group')}
+            onClick={() => handleAddContainer()}
           >
             New Group
           </Menu.Item>
diff --git a/packages/app/src/__tests__/dashboardSections.test.tsx b/packages/app/src/__tests__/dashboardSections.test.tsx
index 7954b41113..e89ed19ace 100644
--- a/packages/app/src/__tests__/dashboardSections.test.tsx
+++ b/packages/app/src/__tests__/dashboardSections.test.tsx
@@ -5,39 +5,52 @@ import {
 } from '@hyperdx/common-utils/dist/types';
 
 describe('DashboardContainer schema', () => {
-  it('validates a valid section', () => {
+  it('validates a valid group', () => {
     const result = DashboardContainerSchema.safeParse({
-      id: 'section-1',
-      type: 'section',
+      id: 'group-1',
+      type: 'group',
       title: 'Infrastructure',
       collapsed: false,
     });
     expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.type).toBe('group');
+    }
   });
 
-  it('validates a collapsed section', () => {
+  it('accepts legacy section type for backward compatibility', () => {
     const result = DashboardContainerSchema.safeParse({
-      id: 'section-2',
+      id: 'section-1',
       type: 'section',
+      title: 'Legacy Section',
+      collapsed: false,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('validates a collapsed group', () => {
+    const result = DashboardContainerSchema.safeParse({
+      id: 'group-2',
+      type: 'group',
       title: 'Database Metrics',
       collapsed: true,
     });
     expect(result.success).toBe(true);
   });
 
-  it('rejects a section missing required fields', () => {
+  it('rejects a container missing required fields', () => {
     const result = DashboardContainerSchema.safeParse({
-      id: 'section-3',
+      id: 'group-3',
       // missing title and collapsed
     });
     expect(result.success).toBe(false);
   });
 
-  it('rejects a section with empty id or title', () => {
+  it('rejects a container with empty id or title', () => {
     expect(
       DashboardContainerSchema.safeParse({
         id: '',
-        type: 'section',
+        type: 'group',
         title: 'Valid',
         collapsed: false,
       }).success,
@@ -45,7 +58,7 @@ describe('DashboardContainer schema', () => {
     expect(
       DashboardContainerSchema.safeParse({
         id: 'valid',
-        type: 'section',
+        type: 'group',
         title: '',
         collapsed: false,
       }).success,
@@ -206,7 +219,7 @@ describe('Tile schema with containerId and tabId', () => {
   });
 });
 
-describe('Dashboard schema with sections', () => {
+describe('Dashboard schema with containers', () => {
   const baseDashboard = {
     id: 'dash-1',
     name: 'My Dashboard',
@@ -233,28 +246,28 @@ describe('Dashboard schema with sections', () => {
     }
   });
 
-  it('rejects duplicate section IDs', () => {
+  it('rejects duplicate container IDs', () => {
     const result = DashboardSchema.safeParse({
       ...baseDashboard,
       containers: [
-        { id: 's1', type: 'section', title: 'Section A', collapsed: false },
-        { id: 's1', type: 'section', title: 'Section B', collapsed: true },
+        { id: 's1', type: 'group', title: 'Group A', collapsed: false },
+        { id: 's1', type: 'group', title: 'Group B', collapsed: true },
       ],
     });
     expect(result.success).toBe(false);
   });
 
-  it('validates a dashboard with sections', () => {
+  it('validates a dashboard with groups', () => {
     const result = DashboardSchema.safeParse({
       ...baseDashboard,
       containers: [
         {
           id: 's1',
-          type: 'section',
+          type: 'group',
           title: 'Infrastructure',
           collapsed: false,
         },
-        { id: 's2', type: 'section', title: 'Application', collapsed: true },
+        { id: 's2', type: 'group', title: 'Application', collapsed: true },
       ],
     });
     expect(result.success).toBe(true);
@@ -265,7 +278,22 @@ describe('Dashboard schema with sections', () => {
     }
   });
 
-  it('validates a full dashboard with sections and tiles referencing them', () => {
+  it('accepts legacy section type in dashboard containers', () => {
+    const result = DashboardSchema.safeParse({
+      ...baseDashboard,
+      containers: [
+        {
+          id: 's1',
+          type: 'section',
+          title: 'Legacy',
+          collapsed: false,
+        },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('validates a full dashboard with groups and tiles referencing them', () => {
     const tile = {
       id: 'tile-1',
       x: 0,
@@ -293,7 +321,7 @@ describe('Dashboard schema with sections', () => {
       containers: [
         {
           id: 's1',
-          type: 'section',
+          type: 'group',
           title: 'Infrastructure',
           collapsed: false,
         },
@@ -354,7 +382,7 @@ describe('Dashboard schema with sections', () => {
   });
 });
 
-describe('section tile grouping logic', () => {
+describe('container tile grouping logic', () => {
   // Test the grouping logic used in DBDashboardPage
   type SimpleTile = { id: string; containerId?: string; tabId?: string };
   type SimpleSection = { id: string; title: string; collapsed: boolean };
@@ -518,7 +546,7 @@ describe('section tile grouping logic', () => {
   });
 });
 
-describe('section authoring operations', () => {
+describe('container authoring operations', () => {
   type SimpleTile = { id: string; containerId?: string; tabId?: string };
   type SimpleSection = { id: string; title: string; collapsed: boolean };
   type SimpleDashboard = {
diff --git a/packages/app/src/components/DashboardDndComponents.tsx b/packages/app/src/components/DashboardDndComponents.tsx
index f93b978b73..f890163b31 100644
--- a/packages/app/src/components/DashboardDndComponents.tsx
+++ b/packages/app/src/components/DashboardDndComponents.tsx
@@ -7,22 +7,22 @@ import { IconPlus } from '@tabler/icons-react';
 import { type DragData, type DragHandleProps } from './DashboardDndContext';
 
 // --- Empty container placeholder ---
-// Visual placeholder for empty sections/groups/tabs with optional add-tile click.
+// Visual placeholder for empty groups/tabs with optional add-tile click.
 
 export function EmptyContainerPlaceholder({
-  sectionId,
+  containerId,
   children,
   isEmpty,
   onAddTile,
 }: {
-  sectionId: string;
+  containerId: string;
   children?: React.ReactNode;
   isEmpty?: boolean;
   onAddTile?: () => void;
 }) {
   return (
     <div
-      data-testid={`container-placeholder-${sectionId}`}
+      data-testid={`container-placeholder-${containerId}`}
       style={{
         minHeight: isEmpty ? 80 : undefined,
         borderRadius: 4,
@@ -59,15 +59,15 @@ export function EmptyContainerPlaceholder({
   );
 }
 
-// --- Sortable section wrapper (for container reordering) ---
+// --- Sortable container wrapper (for container reordering) ---
 
-export function SortableSectionWrapper({
-  sectionId,
-  sectionTitle,
+export function SortableContainerWrapper({
+  containerId,
+  containerTitle,
   children,
 }: {
-  sectionId: string;
-  sectionTitle: string;
+  containerId: string;
+  containerTitle: string;
   children: (dragHandleProps: DragHandleProps) => React.ReactNode;
 }) {
   const {
@@ -78,11 +78,11 @@ export function SortableSectionWrapper({
     transition,
     isDragging,
   } = useSortable({
-    id: `section-sort-${sectionId}`,
+    id: `container-sort-${containerId}`,
     data: {
-      type: 'section',
-      sectionId,
-      sectionTitle,
+      type: 'container',
+      containerId,
+      containerTitle,
     } satisfies DragData,
   });
 
diff --git a/packages/app/src/components/DashboardDndContext.tsx b/packages/app/src/components/DashboardDndContext.tsx
index bd6113326f..26145d0168 100644
--- a/packages/app/src/components/DashboardDndContext.tsx
+++ b/packages/app/src/components/DashboardDndContext.tsx
@@ -21,23 +21,23 @@ import { Box, Text } from '@mantine/core';
 export type DragHandleProps = React.HTMLAttributes<HTMLElement>;
 
 export type DragData = {
-  type: 'section';
-  sectionId: string;
-  sectionTitle: string;
+  type: 'container';
+  containerId: string;
+  containerTitle: string;
 };
 
 type Props = {
   children: React.ReactNode;
   containers: DashboardContainer[];
-  onReorderSections: (fromIndex: number, toIndex: number) => void;
+  onReorderContainers: (fromIndex: number, toIndex: number) => void;
 };
 
-// --- Provider (section reorder only) ---
+// --- Provider (container reorder only) ---
 
 export function DashboardDndProvider({
   children,
   containers,
-  onReorderSections,
+  onReorderContainers,
 }: Props) {
   const [activeDrag, setActiveDrag] = useState<DragData | null>(null);
 
@@ -49,8 +49,8 @@ export function DashboardDndProvider({
   });
   const sensors = useSensors(mouseSensor, touchSensor);
 
-  const sectionSortableIds = useMemo(
-    () => containers.map(c => `section-sort-${c.id}`),
+  const containerSortableIds = useMemo(
+    () => containers.map(c => `container-sort-${c.id}`),
     [containers],
   );
 
@@ -67,18 +67,18 @@ export function DashboardDndProvider({
       const activeData = active.data.current as DragData | undefined;
       if (!activeData) return;
 
-      // Section reorder via sortable
+      // Container reorder via sortable
       const overData = over.data.current as DragData | undefined;
       if (
-        overData?.type === 'section' &&
-        activeData.sectionId !== overData.sectionId
+        overData?.type === 'container' &&
+        activeData.containerId !== overData.containerId
       ) {
-        const from = containers.findIndex(c => c.id === activeData.sectionId);
-        const to = containers.findIndex(c => c.id === overData.sectionId);
-        if (from !== -1 && to !== -1) onReorderSections(from, to);
+        const from = containers.findIndex(c => c.id === activeData.containerId);
+        const to = containers.findIndex(c => c.id === overData.containerId);
+        if (from !== -1 && to !== -1) onReorderContainers(from, to);
       }
     },
-    [containers, onReorderSections],
+    [containers, onReorderContainers],
   );
 
   return (
@@ -88,7 +88,7 @@ export function DashboardDndProvider({
       onDragEnd={handleDragEnd}
     >
       <SortableContext
-        items={sectionSortableIds}
+        items={containerSortableIds}
         strategy={verticalListSortingStrategy}
       >
         {children}
@@ -106,7 +106,7 @@ export function DashboardDndProvider({
             }}
           >
             <Text size="sm" fw={500}>
-              {activeDrag.sectionTitle}
+              {activeDrag.containerTitle}
             </Text>
           </Box>
         )}
diff --git a/packages/app/src/components/GroupContainer.tsx b/packages/app/src/components/GroupContainer.tsx
index cbd1a542fd..9461c0132a 100644
--- a/packages/app/src/components/GroupContainer.tsx
+++ b/packages/app/src/components/GroupContainer.tsx
@@ -10,7 +10,10 @@ import {
   Text,
 } from '@mantine/core';
 import {
+  IconChevronRight,
   IconDotsVertical,
+  IconEye,
+  IconEyeOff,
   IconGripVertical,
   IconPlus,
   IconTrash,
@@ -20,6 +23,10 @@ import { type DragHandleProps } from '@/components/DashboardDndContext';
 
 type GroupContainerProps = {
   container: DashboardContainer;
+  collapsed: boolean;
+  defaultCollapsed: boolean;
+  onToggle: () => void;
+  onToggleDefaultCollapsed?: () => void;
   onDelete?: () => void;
   onAddTile?: () => void;
   activeTabId?: string;
@@ -27,12 +34,17 @@ type GroupContainerProps = {
   onAddTab?: () => void;
   onRenameTab?: (tabId: string, newTitle: string) => void;
   onDeleteTab?: (tabId: string) => void;
+  onRename?: (newTitle: string) => void;
   children: (activeTabId: string | undefined) => React.ReactNode;
   dragHandleProps?: DragHandleProps;
 };
 
 export default function GroupContainer({
   container,
+  collapsed,
+  defaultCollapsed,
+  onToggle,
+  onToggleDefaultCollapsed,
   onDelete,
   onAddTile,
   activeTabId,
@@ -40,6 +52,7 @@ export default function GroupContainer({
   onAddTab,
   onRenameTab,
   onDeleteTab,
+  onRename,
   children,
   dragHandleProps,
 }: GroupContainerProps) {
@@ -49,10 +62,11 @@ export default function GroupContainer({
   const [editingTabId, setEditingTabId] = useState<string | null>(null);
   const [editedTabTitle, setEditedTabTitle] = useState('');
   const [hoveredTabId, setHoveredTabId] = useState<string | null>(null);
+  const [menuOpen, setMenuOpen] = useState(false);
 
   const tabs = container.tabs ?? [];
   const hasTabs = tabs.length >= 2;
-  const showControls = hovered;
+  const showControls = hovered || menuOpen;
   const resolvedActiveTabId = activeTabId ?? tabs[0]?.id;
 
   const firstTab = tabs[0];
@@ -60,8 +74,12 @@ export default function GroupContainer({
 
   const handleSaveRename = () => {
     const trimmed = editedTitle.trim();
-    if (trimmed && firstTab && trimmed !== firstTab.title) {
-      onRenameTab?.(firstTab.id, trimmed);
+    if (trimmed && trimmed !== headerTitle) {
+      if (firstTab) {
+        onRenameTab?.(firstTab.id, trimmed);
+      } else {
+        onRename?.(trimmed);
+      }
     } else {
       setEditedTitle(headerTitle);
     }
@@ -77,7 +95,22 @@ export default function GroupContainer({
     setEditingTabId(null);
   };
 
-  const addMenu = (
+  const chevron = (
+    <IconChevronRight
+      size={16}
+      style={{
+        transform: collapsed ? 'rotate(0deg)' : 'rotate(90deg)',
+        transition: 'transform 150ms ease',
+        flexShrink: 0,
+        color: 'var(--mantine-color-dimmed)',
+        cursor: 'pointer',
+      }}
+      onClick={onToggle}
+      data-testid={`group-chevron-${container.id}`}
+    />
+  );
+
+  const addMenu = !collapsed && (
     <Menu width={200} position="bottom-end">
       <Menu.Target>
         <ActionIcon
@@ -99,8 +132,8 @@ export default function GroupContainer({
     </Menu>
   );
 
-  const deleteMenu = onDelete && (
-    <Menu width={200} position="bottom-end">
+  const overflowMenu = (
+    <Menu width={200} position="bottom-end" onChange={setMenuOpen}>
       <Menu.Target>
         <ActionIcon
           variant="subtle"
@@ -114,13 +147,33 @@ export default function GroupContainer({
         </ActionIcon>
       </Menu.Target>
       <Menu.Dropdown>
-        <Menu.Item
-          leftSection={<IconTrash size={14} />}
-          color="red"
-          onClick={onDelete}
-        >
-          Delete Group
-        </Menu.Item>
+        {onToggleDefaultCollapsed && (
+          <Menu.Item
+            leftSection={
+              defaultCollapsed ? (
+                <IconEye size={14} />
+              ) : (
+                <IconEyeOff size={14} />
+              )
+            }
+            onClick={onToggleDefaultCollapsed}
+            data-testid={`group-toggle-default-${container.id}`}
+          >
+            {defaultCollapsed ? 'Expand by Default' : 'Collapse by Default'}
+          </Menu.Item>
+        )}
+        {onDelete && (
+          <>
+            {onToggleDefaultCollapsed && <Menu.Divider />}
+            <Menu.Item
+              leftSection={<IconTrash size={14} />}
+              color="red"
+              onClick={onDelete}
+            >
+              Delete Group
+            </Menu.Item>
+          </>
+        )}
       </Menu.Dropdown>
     </Menu>
   );
@@ -157,8 +210,8 @@ export default function GroupContainer({
         marginTop: 8,
       }}
     >
-      {hasTabs ? (
-        /* Tab bar header (2+ tabs) — no separate title */
+      {hasTabs && !collapsed ? (
+        /* Tab bar header (2+ tabs, expanded) */
         <Tabs
           value={resolvedActiveTabId}
           onChange={val => val && onTabChange?.(val)}
@@ -171,6 +224,7 @@ export default function GroupContainer({
             }}
           >
             {dragHandle}
+            {chevron}
             <Tabs.List style={{ flex: 1, border: 'none' }}>
               {tabs.map(tab => (
                 <Tabs.Tab
@@ -234,21 +288,24 @@ export default function GroupContainer({
               ))}
             </Tabs.List>
             {addMenu}
-            {deleteMenu}
+            {overflowMenu}
           </Flex>
         </Tabs>
       ) : (
-        /* Plain group header (1 tab) — uses tabs[0].title */
+        /* Plain header (1 tab or collapsed) — shows title + chevron */
         <Flex
           align="center"
           gap="xs"
           px="sm"
           py={4}
           style={{
-            borderBottom: '1px solid var(--mantine-color-default-border)',
+            borderBottom: collapsed
+              ? undefined
+              : '1px solid var(--mantine-color-default-border)',
           }}
         >
           {dragHandle}
+          {chevron}
           {editing ? (
             <form
               onSubmit={e => {
@@ -274,31 +331,42 @@ export default function GroupContainer({
               />
             </form>
           ) : (
-            <Text
-              size="sm"
-              fw={500}
-              truncate
-              style={{ flex: 1, cursor: onRenameTab ? 'text' : undefined }}
-              onClick={
-                onRenameTab
-                  ? e => {
-                      e.stopPropagation();
-                      setEditedTitle(headerTitle);
-                      setEditing(true);
-                    }
-                  : undefined
-              }
+            <Flex
+              align="center"
+              gap="xs"
+              style={{ flex: 1, minWidth: 0, cursor: 'pointer' }}
+              onClick={onToggle}
             >
-              {headerTitle}
-            </Text>
+              <Text
+                size="sm"
+                fw={500}
+                truncate
+                style={{
+                  cursor: onRenameTab || onRename ? 'text' : undefined,
+                }}
+                onClick={
+                  onRenameTab || onRename
+                    ? e => {
+                        e.stopPropagation();
+                        setEditedTitle(headerTitle);
+                        setEditing(true);
+                      }
+                    : undefined
+                }
+              >
+                {headerTitle}
+              </Text>
+            </Flex>
           )}
           {addMenu}
-          {deleteMenu}
+          {overflowMenu}
         </Flex>
       )}
-      <div style={{ padding: 0 }}>
-        {children(hasTabs ? resolvedActiveTabId : undefined)}
-      </div>
+      {!collapsed && (
+        <div style={{ padding: 0 }}>
+          {children(hasTabs ? resolvedActiveTabId : undefined)}
+        </div>
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/SectionHeader.tsx b/packages/app/src/components/SectionHeader.tsx
deleted file mode 100644
index 80a9ac8ebc..0000000000
--- a/packages/app/src/components/SectionHeader.tsx
+++ /dev/null
@@ -1,243 +0,0 @@
-import { useState } from 'react';
-import { DashboardContainer } from '@hyperdx/common-utils/dist/types';
-import { ActionIcon, Flex, Input, Menu, Text } from '@mantine/core';
-import {
-  IconChevronRight,
-  IconDotsVertical,
-  IconEye,
-  IconEyeOff,
-  IconGripVertical,
-  IconPlus,
-  IconTrash,
-} from '@tabler/icons-react';
-
-import { type DragHandleProps } from '@/components/DashboardDndContext';
-
-export default function SectionHeader({
-  section,
-  tileCount,
-  collapsed,
-  defaultCollapsed,
-  onToggle,
-  onToggleDefaultCollapsed,
-  onRename,
-  onDelete,
-  onAddTile,
-  dragHandleProps,
-}: {
-  section: DashboardContainer;
-  tileCount: number;
-  /** Effective collapsed state (URL state ?? DB default). */
-  collapsed: boolean;
-  /** The DB-stored default collapsed state. */
-  defaultCollapsed: boolean;
-  /** Toggle collapse in URL state (chevron click). */
-  onToggle: () => void;
-  /** Toggle the DB-stored default collapsed state (menu action). */
-  onToggleDefaultCollapsed?: () => void;
-  onRename?: (newTitle: string) => void;
-  onDelete?: () => void;
-  onAddTile?: () => void;
-  dragHandleProps?: DragHandleProps;
-}) {
-  const [editing, setEditing] = useState(false);
-  const [editedTitle, setEditedTitle] = useState(section.title);
-  const [hovered, setHovered] = useState(false);
-  const [menuOpen, setMenuOpen] = useState(false);
-
-  const showControls = hovered || menuOpen;
-  const hasMenuControls = onDelete != null || onToggleDefaultCollapsed != null;
-
-  const handleSaveRename = () => {
-    const trimmed = editedTitle.trim();
-    if (trimmed && trimmed !== section.title) {
-      onRename?.(trimmed);
-    } else {
-      setEditedTitle(section.title);
-    }
-    setEditing(false);
-  };
-
-  const handleTitleClick = (e: React.MouseEvent) => {
-    if (!onRename) return;
-    e.stopPropagation();
-    setEditedTitle(section.title);
-    setEditing(true);
-  };
-
-  return (
-    <Flex
-      align="center"
-      gap="xs"
-      px="sm"
-      py={4}
-      onMouseEnter={() => setHovered(true)}
-      onMouseLeave={() => setHovered(false)}
-      style={{
-        borderBottom: '1px solid var(--mantine-color-default-border)',
-        userSelect: 'none',
-      }}
-      data-testid={`section-header-${section.id}`}
-    >
-      {dragHandleProps && (
-        <div
-          {...dragHandleProps}
-          style={{
-            cursor: 'grab',
-            display: 'flex',
-            alignItems: 'center',
-            padding: 2,
-            flexShrink: 0,
-            opacity: showControls ? 1 : 0,
-            transition: 'opacity 150ms',
-          }}
-          title="Drag to reorder sections"
-          data-testid={`section-drag-handle-${section.id}`}
-        >
-          <IconGripVertical
-            size={14}
-            style={{ color: 'var(--mantine-color-dimmed)' }}
-          />
-        </div>
-      )}
-      <Flex
-        align="center"
-        gap="xs"
-        style={{ flex: 1, minWidth: 0, cursor: 'pointer' }}
-        onClick={editing ? undefined : onToggle}
-        onKeyDown={
-          editing
-            ? undefined
-            : e => {
-                if (e.key === 'Enter' || e.key === ' ') {
-                  e.preventDefault();
-                  onToggle();
-                }
-              }
-        }
-        role="button"
-        tabIndex={editing ? undefined : 0}
-        aria-expanded={!collapsed}
-        aria-label={`Toggle ${section.title} section`}
-      >
-        <IconChevronRight
-          size={16}
-          style={{
-            transform: collapsed ? 'rotate(0deg)' : 'rotate(90deg)',
-            transition: 'transform 150ms ease',
-            flexShrink: 0,
-            color: 'var(--mantine-color-dimmed)',
-          }}
-        />
-        {editing ? (
-          <form
-            onSubmit={e => {
-              e.preventDefault();
-              handleSaveRename();
-            }}
-            onClick={e => e.stopPropagation()}
-          >
-            <Input
-              size="xs"
-              value={editedTitle}
-              onChange={e => setEditedTitle(e.currentTarget.value)}
-              onBlur={handleSaveRename}
-              onKeyDown={e => {
-                e.stopPropagation();
-                if (e.key === 'Escape') {
-                  setEditedTitle(section.title);
-                  setEditing(false);
-                }
-              }}
-              autoFocus
-              data-testid={`section-rename-input-${section.id}`}
-            />
-          </form>
-        ) : (
-          <>
-            <Text
-              size="sm"
-              fw={500}
-              truncate
-              onClick={onRename ? handleTitleClick : undefined}
-              style={onRename ? { cursor: 'text' } : undefined}
-            >
-              {section.title}
-            </Text>
-            {collapsed && tileCount > 0 && (
-              <Text size="xs" c="dimmed">
-                ({tileCount} {tileCount === 1 ? 'tile' : 'tiles'})
-              </Text>
-            )}
-          </>
-        )}
-      </Flex>
-      {onAddTile && !editing && (
-        <ActionIcon
-          variant="subtle"
-          size="xs"
-          onClick={e => {
-            e.stopPropagation();
-            onAddTile();
-          }}
-          title="Add tile to section"
-          data-testid={`section-add-tile-${section.id}`}
-          style={{
-            opacity: showControls ? 1 : 0,
-            pointerEvents: showControls ? 'auto' : 'none',
-          }}
-        >
-          <IconPlus size={14} />
-        </ActionIcon>
-      )}
-      {hasMenuControls && !editing && (
-        <Menu width={200} position="bottom-end" onChange={setMenuOpen}>
-          <Menu.Target>
-            <ActionIcon
-              variant="subtle"
-              size="xs"
-              onClick={e => e.stopPropagation()}
-              data-testid={`section-menu-${section.id}`}
-              style={{
-                opacity: showControls ? 1 : 0,
-                pointerEvents: showControls ? 'auto' : 'none',
-              }}
-            >
-              <IconDotsVertical size={14} />
-            </ActionIcon>
-          </Menu.Target>
-          <Menu.Dropdown>
-            {onToggleDefaultCollapsed && (
-              <Menu.Item
-                leftSection={
-                  defaultCollapsed ? (
-                    <IconEye size={14} />
-                  ) : (
-                    <IconEyeOff size={14} />
-                  )
-                }
-                onClick={onToggleDefaultCollapsed}
-                data-testid={`section-toggle-default-${section.id}`}
-              >
-                {defaultCollapsed ? 'Expand by Default' : 'Collapse by Default'}
-              </Menu.Item>
-            )}
-            {onDelete && (
-              <>
-                <Menu.Divider />
-                <Menu.Item
-                  leftSection={<IconTrash size={14} />}
-                  color="red"
-                  onClick={onDelete}
-                  data-testid={`section-delete-${section.id}`}
-                >
-                  Delete Section
-                </Menu.Item>
-              </>
-            )}
-          </Menu.Dropdown>
-        </Menu>
-      )}
-    </Flex>
-  );
-}
diff --git a/packages/app/src/components/__tests__/SectionHeader.test.tsx b/packages/app/src/components/__tests__/SectionHeader.test.tsx
deleted file mode 100644
index 54d5a4a9b0..0000000000
--- a/packages/app/src/components/__tests__/SectionHeader.test.tsx
+++ /dev/null
@@ -1,152 +0,0 @@
-import React from 'react';
-import { DashboardContainer } from '@hyperdx/common-utils/dist/types';
-import { screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-
-import SectionHeader from '../SectionHeader';
-
-// Menu buttons have pointer-events:none when not hovered; skip that check.
-const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-const makeSection = (
-  overrides: Partial<DashboardContainer> = {},
-): DashboardContainer => ({
-  id: 'section-1',
-  type: 'section',
-  title: 'My Section',
-  collapsed: false,
-  ...overrides,
-});
-
-describe('SectionHeader', () => {
-  it('renders section title and tile count when collapsed', () => {
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection()}
-        tileCount={3}
-        collapsed={true}
-        defaultCollapsed={false}
-        onToggle={jest.fn()}
-      />,
-    );
-
-    expect(screen.getByText('My Section')).toBeInTheDocument();
-    expect(screen.getByText('(3 tiles)')).toBeInTheDocument();
-  });
-
-  it('does not show tile count when expanded', () => {
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection()}
-        tileCount={3}
-        collapsed={false}
-        defaultCollapsed={false}
-        onToggle={jest.fn()}
-      />,
-    );
-
-    expect(screen.getByText('My Section')).toBeInTheDocument();
-    expect(screen.queryByText('(3 tiles)')).not.toBeInTheDocument();
-  });
-
-  it('calls onToggle (URL state) when chevron area is clicked', async () => {
-    const onToggle = jest.fn();
-    const onToggleDefaultCollapsed = jest.fn();
-
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection()}
-        tileCount={2}
-        collapsed={false}
-        defaultCollapsed={false}
-        onToggle={onToggle}
-        onToggleDefaultCollapsed={onToggleDefaultCollapsed}
-      />,
-    );
-
-    await user.click(
-      screen.getByRole('button', { name: /Toggle My Section section/i }),
-    );
-
-    expect(onToggle).toHaveBeenCalledTimes(1);
-    expect(onToggleDefaultCollapsed).not.toHaveBeenCalled();
-  });
-
-  it('shows "Collapse by Default" when DB default is expanded', async () => {
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection()}
-        tileCount={0}
-        collapsed={false}
-        defaultCollapsed={false}
-        onToggle={jest.fn()}
-        onToggleDefaultCollapsed={jest.fn()}
-        onDelete={jest.fn()}
-      />,
-    );
-
-    // Open the menu
-    await user.click(screen.getByTestId('section-menu-section-1'));
-    expect(await screen.findByText('Collapse by Default')).toBeInTheDocument();
-  });
-
-  it('shows "Expand by Default" when DB default is collapsed', async () => {
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection({ collapsed: true })}
-        tileCount={0}
-        collapsed={true}
-        defaultCollapsed={true}
-        onToggle={jest.fn()}
-        onToggleDefaultCollapsed={jest.fn()}
-        onDelete={jest.fn()}
-      />,
-    );
-
-    await user.click(screen.getByTestId('section-menu-section-1'));
-    expect(await screen.findByText('Expand by Default')).toBeInTheDocument();
-  });
-
-  it('calls onToggleDefaultCollapsed (DB state) from menu item', async () => {
-    const onToggle = jest.fn();
-    const onToggleDefaultCollapsed = jest.fn();
-
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection()}
-        tileCount={0}
-        collapsed={false}
-        defaultCollapsed={false}
-        onToggle={onToggle}
-        onToggleDefaultCollapsed={onToggleDefaultCollapsed}
-        onDelete={jest.fn()}
-      />,
-    );
-
-    await user.click(screen.getByTestId('section-menu-section-1'));
-    await user.click(await screen.findByText('Collapse by Default'));
-
-    expect(onToggleDefaultCollapsed).toHaveBeenCalledTimes(1);
-    expect(onToggle).not.toHaveBeenCalled();
-  });
-
-  it('uses collapsed prop for visual state independent of section.collapsed', () => {
-    // section.collapsed is false (DB default), but collapsed prop is true (URL override)
-    renderWithMantine(
-      <SectionHeader
-        section={makeSection({ collapsed: false })}
-        tileCount={5}
-        collapsed={true}
-        defaultCollapsed={false}
-        onToggle={jest.fn()}
-      />,
-    );
-
-    // Should show tile count because collapsed=true (URL state takes precedence)
-    expect(screen.getByText('(5 tiles)')).toBeInTheDocument();
-    // The aria-expanded should reflect the effective state
-    expect(
-      screen.getByRole('button', { name: /Toggle My Section section/i }),
-    ).toHaveAttribute('aria-expanded', 'false');
-  });
-});
diff --git a/packages/app/src/hooks/useDashboardContainers.tsx b/packages/app/src/hooks/useDashboardContainers.tsx
index 2b4a82efaf..6231202e2d 100644
--- a/packages/app/src/hooks/useDashboardContainers.tsx
+++ b/packages/app/src/hooks/useDashboardContainers.tsx
@@ -21,68 +21,49 @@ export default function useDashboardContainers({
   setDashboard: (dashboard: Dashboard) => void;
   confirm: ConfirmFn;
 }) {
-  const handleAddContainer = useCallback(
-    (type: 'section' | 'group' = 'section') => {
-      if (!dashboard) return;
-      const titles: Record<string, string> = {
-        section: 'New Section',
-        group: 'New Group',
-      };
-      setDashboard(
-        produce(dashboard, draft => {
-          if (!draft.containers) draft.containers = [];
-          const containerId = makeId();
-          if (type === 'group') {
-            const tabId = makeId();
-            draft.containers.push({
-              id: containerId,
-              type,
-              title: titles[type],
-              collapsed: false,
-              tabs: [{ id: tabId, title: titles[type] }],
-              activeTabId: tabId,
-            });
-          } else {
-            draft.containers.push({
-              id: containerId,
-              type,
-              title: titles[type],
-              collapsed: false,
-            });
-          }
-        }),
-      );
-    },
-    [dashboard, setDashboard],
-  );
+  const handleAddContainer = useCallback(() => {
+    if (!dashboard) return;
+    setDashboard(
+      produce(dashboard, draft => {
+        if (!draft.containers) draft.containers = [];
+        const containerId = makeId();
+        const tabId = makeId();
+        draft.containers.push({
+          id: containerId,
+          type: 'group',
+          title: 'New Group',
+          collapsed: false,
+          tabs: [{ id: tabId, title: 'New Group' }],
+          activeTabId: tabId,
+        });
+      }),
+    );
+  }, [dashboard, setDashboard]);
 
-  // Intentionally persists collapsed state to the server via setDashboard
-  // (same pattern as tile drag/resize). This matches Grafana and Kibana
-  // behavior where collapsed state is saved with the dashboard for all viewers.
-  const handleToggleSection = useCallback(
+  const handleToggleCollapsed = useCallback(
     (containerId: string) => {
       if (!dashboard) return;
       setDashboard(
         produce(dashboard, draft => {
-          const section = draft.containers?.find(s => s.id === containerId);
-          if (section) section.collapsed = !section.collapsed;
+          const container = draft.containers?.find(s => s.id === containerId);
+          if (container) container.collapsed = !container.collapsed;
         }),
       );
     },
     [dashboard, setDashboard],
   );
 
-  const handleRenameSection = useCallback(
+  const handleRenameContainer = useCallback(
     (containerId: string, newTitle: string) => {
       if (!dashboard || !newTitle.trim()) return;
       setDashboard(
         produce(dashboard, draft => {
-          const section = draft.containers?.find(s => s.id === containerId);
-          if (section) {
-            section.title = newTitle.trim();
-            // For groups with 1 tab, sync tabs[0].title (they share the header)
-            if (section.type === 'group' && section.tabs?.length === 1) {
-              section.tabs[0].title = newTitle.trim();
+          const container = draft.containers?.find(s => s.id === containerId);
+          if (container) {
+            container.title = newTitle.trim();
+            // Sync tabs[0].title when there is 1 tab (they share the header)
+            if (container.tabs?.length === 1) {
+              container.tabs[0].title = newTitle.trim();
             }
           }
         }),
@@ -91,14 +72,14 @@ export default function useDashboardContainers({
     [dashboard, setDashboard],
   );
 
-  const handleDeleteSection = useCallback(
+  const handleDeleteContainer = useCallback(
     async (containerId: string) => {
       if (!dashboard) return;
       const container = dashboard.containers?.find(c => c.id === containerId);
       const tileCount = dashboard.tiles.filter(
         t => t.containerId === containerId,
       ).length;
-      const label = container?.title ?? 'this section';
+      const label = container?.title ?? 'this group';
 
       const message =
         tileCount > 0 ? (
@@ -127,10 +108,12 @@ export default function useDashboardContainers({
 
       setDashboard(
         produce(dashboard, draft => {
-          const allSectionIds = new Set(draft.containers?.map(c => c.id) ?? []);
+          const allContainerIds = new Set(
+            draft.containers?.map(c => c.id) ?? [],
+          );
           let maxUngroupedY = 0;
           for (const tile of draft.tiles) {
-            if (!tile.containerId || !allSectionIds.has(tile.containerId)) {
+            if (!tile.containerId || !allContainerIds.has(tile.containerId)) {
               maxUngroupedY = Math.max(maxUngroupedY, tile.y + tile.h);
             }
           }
@@ -152,7 +135,7 @@ export default function useDashboardContainers({
     [dashboard, setDashboard, confirm],
   );
 
-  const handleReorderSections = useCallback(
+  const handleReorderContainers = useCallback(
     (fromIndex: number, toIndex: number) => {
       if (!dashboard?.containers) return;
       setDashboard(
@@ -194,7 +177,7 @@ export default function useDashboardContainers({
               }
             }
           } else if (existingTabs.length === 0) {
-            // Legacy group with no tabs: create 2 tabs
+            // Legacy container with no tabs: create 2 tabs
             const tab1Id = makeId();
             const tab2Id = makeId();
             c.tabs = [
@@ -280,9 +263,8 @@ export default function useDashboardContainers({
   );
 
   // Intentionally persisted to server (same as collapsed state) — shared
-  // across all viewers, matching Grafana/Kibana behavior where active tab
-  // is part of the dashboard layout definition. If user-local tab state
-  // is needed later, move to useState/localStorage instead.
+  // across all viewers. If user-local tab state is needed later, move to
+  // useState/localStorage instead.
   const handleTabChange = useCallback(
     (containerId: string, tabId: string) => {
       if (!dashboard) return;
@@ -298,10 +280,10 @@ export default function useDashboardContainers({
 
   return {
     handleAddContainer,
-    handleToggleSection,
-    handleRenameSection,
-    handleDeleteSection,
-    handleReorderSections,
+    handleToggleCollapsed,
+    handleRenameContainer,
+    handleDeleteContainer,
+    handleReorderContainers,
     handleAddTab,
     handleRenameTab,
     handleDeleteTab,
diff --git a/packages/app/src/hooks/useTileSelection.ts b/packages/app/src/hooks/useTileSelection.ts
index 02ee9eb060..0a6f417320 100644
--- a/packages/app/src/hooks/useTileSelection.ts
+++ b/packages/app/src/hooks/useTileSelection.ts
@@ -26,26 +26,26 @@ export default function useTileSelection({
     });
   }, []);
 
-  // Creates a 'section' type container (not 'group') intentionally.
-  // Sections are collapsible and are the most common container type for
-  // organizing tiles on a dashboard. The function name reflects the user
-  // action (grouping selected tiles) rather than the container type created.
+  // Creates a group container and assigns selected tiles to it.
   const handleGroupSelected = useCallback(() => {
     if (!dashboard || selectedTileIds.size === 0) return;
     const groupId = makeId();
+    const tabId = makeId();
     setDashboard(
       produce(dashboard, draft => {
         if (!draft.containers) draft.containers = [];
         draft.containers.push({
           id: groupId,
-          type: 'section',
-          title: 'New Section',
+          type: 'group',
+          title: 'New Group',
           collapsed: false,
+          tabs: [{ id: tabId, title: 'New Group' }],
+          activeTabId: tabId,
         });
         for (const tile of draft.tiles) {
           if (selectedTileIds.has(tile.id)) {
             tile.containerId = groupId;
-            delete tile.tabId; // Clear tab assignment from previous group
+            tile.tabId = tabId;
           }
         }
       }),
diff --git a/packages/common-utils/src/types.ts b/packages/common-utils/src/types.ts
index 7f8e8eabbe..313bf64242 100644
--- a/packages/common-utils/src/types.ts
+++ b/packages/common-utils/src/types.ts
@@ -708,15 +708,13 @@ export const DashboardContainerTabSchema = z.object({
 
 export const DashboardContainerSchema = z.object({
   id: z.string().min(1),
-  // 'section': collapsible row with chevron toggle
-  // 'group': bordered container, optionally with tabs (2+ tabs → tab bar shows)
+  // Unified container type: always a bordered, collapsible group.
+  // Accepts 'section' for backward compatibility — new code always writes 'group'.
   type: z.enum(['section', 'group']),
   title: z.string().min(1),
   collapsed: z.boolean(),
-  // For groups with tabs: the list of tabs and which is active.
-  // Tiles reference a specific tab via tabId. When tabs has 2+ entries,
-  // the tab bar renders. When 0-1 entries, it's a plain group.
-  // Persisted to server like collapsed state (Grafana/Kibana pattern).
+  // Optional tabs: 2+ entries → tab bar renders, 0-1 → plain group header.
+  // Tiles reference a specific tab via tabId.
   tabs: z.array(DashboardContainerTabSchema).optional(),
   activeTabId: z.string().optional(),
 });