diff --git a/packages/online-shell/src/discover/Discover.css b/packages/online-shell/src/discover/Discover.css
index 1c33945b..b4fee40b 100644
--- a/packages/online-shell/src/discover/Discover.css
+++ b/packages/online-shell/src/discover/Discover.css
@@ -38,6 +38,14 @@
   font-style: italic;
 }
 
+.discover-loading-compact {
+  margin-top: 0 !important;
+}
+
+.discover-loading-compact div {
+  padding: 0;
+}
+
 .discover-group-label {
   text-align: left;
   color: rgb(117, 117, 117);
diff --git a/packages/online-shell/src/discover/Discover.tsx b/packages/online-shell/src/discover/Discover.tsx
index 028da83d..f19eb7a7 100644
--- a/packages/online-shell/src/discover/Discover.tsx
+++ b/packages/online-shell/src/discover/Discover.tsx
@@ -1,4 +1,4 @@
-import React from 'react'
+import React, { useEffect } from 'react'
 import {
   Alert,
   Card,
@@ -6,39 +6,50 @@ import {
   EmptyState,
   EmptyStateBody,
   EmptyStateIcon,
-  List,
   PageSection,
   PageSectionVariants,
-  Panel,
-  PanelHeader,
-  PanelMain,
-  PanelMainBody,
   Title,
   EmptyStateHeader,
+  Tabs,
+  TabTitleText,
+  Tab,
 } from '@patternfly/react-core'
 import { CubesIcon } from '@patternfly/react-icons'
-import { HawtioLoadingCard } from '@hawtio/react'
 import { discoverService } from './discover-service'
 import { DiscoverToolbar } from './DiscoverToolbar'
 import { DiscoverContext, useDisplayItems } from './context'
-import { DiscoverGroupList } from './DiscoverGroupList'
-import { DiscoverPodItem } from './DiscoverPodItem'
+import { DiscoverProjectContent } from './DiscoverProjectContent'
+import { DiscoverLoadingPanel } from './DiscoverLoadingPanel'
 
 export const Discover: React.FunctionComponent = () => {
-  const { error, isLoading, discoverGroups, setDiscoverGroups, discoverPods, setDiscoverPods, filters, setFilters } =
+  const { error, isLoading, refreshing, setRefreshing, discoverProjects, setDiscoverProjects, filters, setFilters } =
     useDisplayItems()
+  const [activeTabKey, setActiveTabKey] = React.useState<string>('')
+
+  const handleTabClick = (
+    event: React.MouseEvent<unknown> | React.KeyboardEvent | MouseEvent,
+    tabIndex: string | number,
+  ) => {
+    setActiveTabKey(`${tabIndex}`)
+  }
+
+  useEffect(() => {
+    if (isLoading || error || discoverProjects.length === 0) return
+
+    setActiveTabKey(activeKey => {
+      if (activeKey.length === 0) return discoverProjects[0].name
+
+      const projects = discoverProjects.filter(p => p.name === activeKey)
+      if (projects.length === 0) return discoverProjects[0].name // active key no longer in projects
+
+      return activeKey
+    })
+  }, [isLoading, error, discoverProjects, filters])
 
   if (isLoading) {
     return (
       <PageSection variant={PageSectionVariants.light}>
-        <Panel className='discover-loading'>
-          <PanelHeader>Waiting for Hawtio Containers ...</PanelHeader>
-          <PanelMain>
-            <PanelMainBody>
-              <HawtioLoadingCard />
-            </PanelMainBody>
-          </PanelMain>
-        </Panel>
+        <DiscoverLoadingPanel />
       </PageSection>
     )
   }
@@ -63,17 +74,17 @@ export const Discover: React.FunctionComponent = () => {
 
       <DiscoverContext.Provider
         value={{
-          discoverGroups,
-          setDiscoverGroups,
-          discoverPods,
-          setDiscoverPods,
+          refreshing,
+          setRefreshing,
+          discoverProjects,
+          setDiscoverProjects,
           filters,
           setFilters,
         }}
       >
         <DiscoverToolbar />
 
-        {discoverGroups.length + discoverPods.length === 0 && (
+        {discoverProjects.length === 0 && (
           <EmptyState>
             <EmptyStateHeader
               titleText='No Hawtio Containers'
@@ -86,14 +97,18 @@ export const Discover: React.FunctionComponent = () => {
           </EmptyState>
         )}
 
-        {discoverGroups.length > 0 && <DiscoverGroupList />}
-
-        {discoverPods.length > 0 && (
-          <List isBordered={true} iconSize='large'>
-            {discoverPods.map(pod => {
-              return <DiscoverPodItem pod={pod} key={pod.uid} />
-            })}
-          </List>
+        {discoverProjects.length > 0 && (
+          <Tabs activeKey={activeTabKey} onSelect={handleTabClick} isBox>
+            {discoverProjects.map(discoverProject => (
+              <Tab
+                eventKey={discoverProject.name}
+                title={<TabTitleText>{discoverProject.name}</TabTitleText>}
+                key={`discover-project-${discoverProject.name}`}
+              >
+                <DiscoverProjectContent project={discoverProject} />
+              </Tab>
+            ))}
+          </Tabs>
         )}
       </DiscoverContext.Provider>
     </PageSection>
diff --git a/packages/online-shell/src/discover/DiscoverGroupList.tsx b/packages/online-shell/src/discover/DiscoverGroupList.tsx
index ac95b8d1..248a36de 100644
--- a/packages/online-shell/src/discover/DiscoverGroupList.tsx
+++ b/packages/online-shell/src/discover/DiscoverGroupList.tsx
@@ -1,41 +1,53 @@
-import React, { useContext } from 'react'
+import React, { useState } from 'react'
 import { Accordion, AccordionContent, AccordionItem, AccordionToggle, List } from '@patternfly/react-core'
 import { DiscoverGroup } from './globals'
 import { DiscoverGroupLabel } from './DiscoverGroupLabel'
 import { DiscoverPodItem } from './DiscoverPodItem'
 import './Discover.css'
-import { DiscoverContext } from './context'
 
-export const DiscoverGroupList: React.FunctionComponent = () => {
-  const { discoverGroups, setDiscoverGroups } = useContext(DiscoverContext)
+interface DiscoverGroupListProps {
+  groups: DiscoverGroup[]
+}
+
+export const DiscoverGroupList: React.FunctionComponent<DiscoverGroupListProps> = (props: DiscoverGroupListProps) => {
+  const [hidden, setHidden] = useState<string[]>([])
 
   const onToggle = (group: DiscoverGroup) => {
-    const groups = [...discoverGroups]
+    const newHidden = [...hidden]
 
-    groups.forEach(g => {
-      if (g.uid === group.uid) g.expanded = !g.expanded
-    })
+    const index = newHidden.indexOf(group.uid)
+    if (index === -1) {
+      // Since no uid in hidden then expanded by default
+      // then add to hidden to hide
+      newHidden.push(group.uid)
+    } else {
+      newHidden.splice(index, 1)
+    }
+
+    setHidden(newHidden)
+  }
 
-    setDiscoverGroups(groups)
+  const isHidden = (group: DiscoverGroup): boolean => {
+    return hidden.indexOf(group.uid) > -1
   }
 
-  if (discoverGroups.length === 0) return <></>
+  if (props.groups.length === 0) return <></>
 
   return (
     <Accordion asDefinitionList>
-      {discoverGroups.map(group => {
+      {props.groups.map(group => {
         return (
           <AccordionItem key={'item-' + group.name}>
             <AccordionToggle
               onClick={() => {
                 onToggle(group)
               }}
-              isExpanded={group.expanded}
+              isExpanded={!isHidden(group)}
               id={'item-' + group.name}
             >
               <DiscoverGroupLabel group={group} />
             </AccordionToggle>
-            <AccordionContent id={'item-' + group.name + 'expand'} isHidden={!group.expanded}>
+            <AccordionContent id={'item-' + group.name + 'expand'} isHidden={isHidden(group)}>
               <List isBordered={true} iconSize='large'>
                 {group.replicas.map(replica => (
                   <DiscoverPodItem key={replica.uid} pod={replica} />
diff --git a/packages/online-shell/src/discover/DiscoverLoadingPanel.tsx b/packages/online-shell/src/discover/DiscoverLoadingPanel.tsx
new file mode 100644
index 00000000..ca118764
--- /dev/null
+++ b/packages/online-shell/src/discover/DiscoverLoadingPanel.tsx
@@ -0,0 +1,25 @@
+import React from 'react'
+import { Panel, PanelHeader, PanelMain, PanelMainBody } from '@patternfly/react-core'
+import { HawtioLoadingCard } from '@hawtio/react'
+
+interface DiscoverLoadingPanelProps {
+  compact?: boolean
+}
+
+export const DiscoverLoadingPanel: React.FunctionComponent<DiscoverLoadingPanelProps> = (
+  props: DiscoverLoadingPanelProps,
+) => {
+  let classNames = 'discover-loading'
+  if (props.compact) classNames = classNames + ' discover-loading-compact'
+
+  return (
+    <Panel className={classNames}>
+      <PanelHeader>Waiting for Hawtio Containers ...</PanelHeader>
+      <PanelMain>
+        <PanelMainBody>
+          <HawtioLoadingCard />
+        </PanelMainBody>
+      </PanelMain>
+    </Panel>
+  )
+}
diff --git a/packages/online-shell/src/discover/DiscoverPodConnect.tsx b/packages/online-shell/src/discover/DiscoverPodConnect.tsx
index ea54256e..2f60aa47 100644
--- a/packages/online-shell/src/discover/DiscoverPodConnect.tsx
+++ b/packages/online-shell/src/discover/DiscoverPodConnect.tsx
@@ -22,7 +22,7 @@ export const DiscoverPodConnect: React.FunctionComponent<DiscoverPodConnectProps
   props: DiscoverPodConnectProps,
 ) => {
   const connectionNames: string[] = mgmtService.refreshConnections(props.pod.mPod)
-  const mgmtError = props.pod.mPod?.getManagementError()
+  const mgmtError = props.pod.mPod?.mgmtError
 
   const [isOpen, setIsOpen] = React.useState(false)
 
@@ -39,7 +39,7 @@ export const DiscoverPodConnect: React.FunctionComponent<DiscoverPodConnectProps
   const disableContainerButton = (): boolean => {
     return (
       mgmtService.podStatus(props.pod.mPod) !== 'Running' ||
-      !props.pod.mPod.getManagement().status.managed ||
+      !props.pod.mPod.management.status.managed ||
       connectionNames.length === 0 ||
       mgmtError !== null
     )
diff --git a/packages/online-shell/src/discover/DiscoverPodItem.tsx b/packages/online-shell/src/discover/DiscoverPodItem.tsx
index 3b458d9f..09a4aded 100644
--- a/packages/online-shell/src/discover/DiscoverPodItem.tsx
+++ b/packages/online-shell/src/discover/DiscoverPodItem.tsx
@@ -17,24 +17,24 @@ interface DiscoverPodItemProps {
 
 export const DiscoverPodItem: React.FunctionComponent<DiscoverPodItemProps> = (props: DiscoverPodItemProps) => {
   const nodeLabel = (): ReactNode => {
-    if (props.pod.mPod.getSpec()?.nodeName) {
+    if (props.pod.mPod.spec?.nodeName) {
       return (
-        <ConsoleLink type={ConsoleType.node} selector={props.pod.mPod.getSpec()?.nodeName}>
-          {props.pod.mPod.getSpec()?.nodeName}
+        <ConsoleLink type={ConsoleType.node} selector={props.pod.mPod.spec?.nodeName}>
+          {props.pod.mPod.spec?.nodeName}
         </ConsoleLink>
       )
     }
 
-    return props.pod.mPod.getStatus()?.hostIP
+    return props.pod.mPod.status?.hostIP
   }
 
   const containersLabel = (): ReactNode => {
-    const total = props.pod.mPod.getSpec()?.containers.length || 0
+    const total = props.pod.mPod.spec?.containers.length || 0
     return `${total} container${total !== 1 ? 's' : ''}`
   }
 
   const routesLabel = (): ReactNode => {
-    if (!props.pod.mPod.getManagement().status.managed) {
+    if (!props.pod.mPod.management.status.managed) {
       return (
         <Label color='grey' icon={<FontAwesomeIcon icon={faSpinner} spin />} className='pod-item-routes'>
           {`querying routes ...`}
@@ -42,7 +42,7 @@ export const DiscoverPodItem: React.FunctionComponent<DiscoverPodItemProps> = (p
       )
     }
 
-    const error = props.pod.mPod.getManagement().status.error
+    const error = props.pod.mPod.management.status.error
     if (error) {
       return (
         <Label color='red' icon={<CamelRouteIcon />} className='pod-item-routes'>
@@ -51,7 +51,7 @@ export const DiscoverPodItem: React.FunctionComponent<DiscoverPodItemProps> = (p
       )
     }
 
-    const total = props.pod.mPod.getManagement().camel.routes_count
+    const total = props.pod.mPod.management.camel.routes_count
     return (
       <Label color='gold' icon={<CamelRouteIcon />} className='pod-item-routes'>
         {`${total} route${total !== 1 ? 's' : ''}`}
diff --git a/packages/online-shell/src/discover/DiscoverProjectContent.tsx b/packages/online-shell/src/discover/DiscoverProjectContent.tsx
new file mode 100644
index 00000000..0b87e6c9
--- /dev/null
+++ b/packages/online-shell/src/discover/DiscoverProjectContent.tsx
@@ -0,0 +1,94 @@
+import React, { useContext } from 'react'
+import {
+  Button,
+  List,
+  Panel,
+  PanelHeader,
+  PanelMain,
+  PanelMainBody,
+  Toolbar,
+  ToolbarContent,
+  ToolbarGroup,
+  ToolbarItem,
+} from '@patternfly/react-core'
+import { DiscoverProject } from './discover-project'
+import { DiscoverGroupList } from './DiscoverGroupList'
+import { DiscoverPodItem } from './DiscoverPodItem'
+import { mgmtService } from '@hawtio/online-management-api'
+import { DiscoverLoadingPanel } from './DiscoverLoadingPanel'
+import { DiscoverContext } from './context'
+
+interface DiscoverProjectCntProps {
+  project: DiscoverProject
+}
+
+export const DiscoverProjectContent: React.FunctionComponent<DiscoverProjectCntProps> = (
+  props: DiscoverProjectCntProps,
+) => {
+  const { refreshing, setRefreshing } = useContext(DiscoverContext)
+
+  const hasPrevPods = (): boolean => {
+    return mgmtService.hasPrevious(props.project.name)
+  }
+
+  const prevPods = () => {
+    setRefreshing(true)
+    mgmtService.previous(props.project.name)
+  }
+
+  const hasNextPods = (): boolean => {
+    return mgmtService.hasNext(props.project.name)
+  }
+
+  const nextPods = () => {
+    setRefreshing(true)
+    mgmtService.next(props.project.name)
+  }
+
+  return (
+    <Panel>
+      <PanelHeader>
+        <Toolbar id='pagination-toolbar-items' className='paginated-pods-toolbar-content' isSticky>
+          <ToolbarContent>
+            <ToolbarGroup variant='button-group' align={{ default: 'alignLeft' }}>
+              <ToolbarItem>
+                <Button variant='control' onClick={() => prevPods()} isDisabled={!hasPrevPods()}>
+                  &lt;&lt; Previous
+                </Button>
+              </ToolbarItem>
+            </ToolbarGroup>
+
+            {refreshing && (
+              <ToolbarGroup isOverflowContainer>
+                <ToolbarItem widths={{ default: '100%' }}>
+                  <DiscoverLoadingPanel compact={true} />
+                </ToolbarItem>
+              </ToolbarGroup>
+            )}
+
+            <ToolbarGroup variant='button-group' align={{ default: 'alignRight' }}>
+              <ToolbarItem>
+                <Button variant='control' onClick={() => nextPods()} isDisabled={!hasNextPods()}>
+                  Next &gt;&gt;
+                </Button>
+              </ToolbarItem>
+            </ToolbarGroup>
+          </ToolbarContent>
+        </Toolbar>
+      </PanelHeader>
+      <PanelMain>
+        <PanelMainBody>
+          {props.project.groups.length > 0 && <DiscoverGroupList groups={props.project.groups} />}
+
+          {props.project.pods.length > 0 && (
+            <List isBordered={true} iconSize='large'>
+              {props.project.pods.map(pod => {
+                return <DiscoverPodItem pod={pod} key={pod.uid} />
+              })}
+            </List>
+          )}
+        </PanelMainBody>
+      </PanelMain>
+    </Panel>
+  )
+}
diff --git a/packages/online-shell/src/discover/DiscoverToolbar.tsx b/packages/online-shell/src/discover/DiscoverToolbar.tsx
index 42f7eda5..ebf10b54 100644
--- a/packages/online-shell/src/discover/DiscoverToolbar.tsx
+++ b/packages/online-shell/src/discover/DiscoverToolbar.tsx
@@ -15,11 +15,11 @@ import {
 } from '@patternfly/react-core'
 
 import { LongArrowAltUpIcon, LongArrowAltDownIcon } from '@patternfly/react-icons'
+import { TypeFilterType, TypeFilter, typeFilterTypeValueOf } from '@hawtio/online-management-api'
 import { DiscoverContext } from './context'
-import { DiscoverItem, TypeFilter } from './globals'
+import { DiscoverProject } from './discover-project'
 
 const defaultFilterInputPlaceholder = 'Filter by Name...'
-const headers = ['Name', 'Namespace']
 
 interface SortOrder {
   id: string
@@ -29,14 +29,42 @@ interface SortOrder {
 const ascending: SortOrder = { id: 'ascending', icon: <LongArrowAltUpIcon /> }
 const descending: SortOrder = { id: 'descending', icon: <LongArrowAltDownIcon /> }
 
+interface SortMetaType {
+  id: string
+  order: SortOrder
+}
+
+type FilterMeta = {
+  [name: string]: TypeFilterType
+}
+
+type SortMeta = {
+  [name: string]: SortMetaType
+}
+
+const filterMeta: FilterMeta = {
+  name: TypeFilterType.NAME,
+  namespace: TypeFilterType.NAMESPACE,
+}
+
+const sortMeta: SortMeta = {
+  name: {
+    id: 'Name',
+    order: ascending,
+  },
+  namespace: {
+    id: 'Namespace',
+    order: ascending,
+  },
+}
+
 export const DiscoverToolbar: React.FunctionComponent = () => {
-  const { discoverGroups, setDiscoverGroups, discoverPods, setDiscoverPods, filters, setFilters } =
-    useContext(DiscoverContext)
+  const { discoverProjects, setDiscoverProjects, filters, setFilters } = useContext(DiscoverContext)
   // Ref for toggle of filter type Select control
   const filterTypeToggleRef = useRef<HTMLButtonElement | null>()
 
   // The type of filter to be created - chosen by the Select control
-  const [filterType, setFilterType] = useState(headers[0] ?? '')
+  const [filterType, setFilterType] = useState<TypeFilterType>(filterMeta.name)
   // Flag to determine whether the Filter Select control is open or closed
   const [isFilterTypeOpen, setIsFilterTypeOpen] = useState(false)
   // The text value of the filter to be created
@@ -47,11 +75,11 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
   // Ref for toggle of sort type Select control
   useRef<HTMLButtonElement | null>()
   // The type of sort to be created - chosen by the Select control
-  const [sortType, setSortType] = useState(headers[0] ?? '')
+  const [sortType, setSortType] = useState(sortMeta.name.id || '')
   // Flag to determine whether the Sort Select control is open or closed
   const [isSortTypeOpen, setIsSortTypeOpen] = useState(false)
   // Icon showing the sort
-  const [sortOrder, setSortOrder] = useState<SortOrder>(ascending)
+  const [sortOrder, setSortOrder] = useState<SortOrder>(sortMeta.name.order)
 
   const clearFilters = () => {
     const emptyFilters: TypeFilter[] = []
@@ -62,16 +90,18 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
   const onSelectFilterType = (_event?: ChangeEvent<Element> | MouseEvent<Element>, value?: string | number) => {
     if (!value) return
 
-    setFilterType(value as string)
-    setFilterInputPlaceholder('Filter by ' + value + ' ...')
+    const type = typeFilterTypeValueOf(`${value}`)
+    setFilterType(type as TypeFilterType)
+    setFilterInputPlaceholder('Filter by ' + value.toString() + ' ...')
     setIsFilterTypeOpen(false)
     filterTypeToggleRef?.current?.focus()
   }
 
   const filterChips = (): string[] => {
     const chips: string[] = []
+
     filters.forEach(filter => {
-      chips.push(filter.type + ':' + filter.value)
+      Array.from(filter.values).map(v => chips.push(filter.type + ':' + v))
     })
 
     return chips
@@ -82,20 +112,31 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
 
     if (!filterType) return
 
-    const filter = {
-      type: filterType.toLowerCase(),
-      value: value,
-    }
+    const newFilters = [...filters]
 
-    if (filters.includes(filter)) return
+    const typeFilter = newFilters.filter(f => f.type === filterType)
+    if (typeFilter.length === 0) {
+      const filter: TypeFilter = {
+        type: filterType,
+        values: new Set([value]),
+      }
+      newFilters.push(filter)
+    } else {
+      typeFilter[0].values.add(value)
+    }
 
-    const newFilters = filters.concat(filter)
     setFilters(newFilters)
   }
 
   const deleteFilter = (filterChip: string) => {
     const remaining = filters.filter(filter => {
-      return filterChip !== filter.type + ':' + filter.value
+      const [typeId, value] = filterChip.split(':')
+      const type = typeFilterTypeValueOf(typeId)
+
+      if (filter.type !== type) return true
+
+      filter.values.delete(value)
+      return filter.values.size > 0
     })
 
     setFilters(remaining)
@@ -104,37 +145,38 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
   const onSelectSortType = (_event?: MouseEvent<Element>, value?: string | number) => {
     if (!value) return
 
+    // Updates the sort type either Name or Namespace
     setSortType(value as string)
+
+    // Updates the sort order to whichever the sort type is set to
+    setSortOrder(value === sortMeta.name.id ? sortMeta.name.order : sortMeta.namespace.order)
     setIsSortTypeOpen(false)
     filterTypeToggleRef?.current?.focus()
   }
 
-  const compareDiscoverItems = (item1: DiscoverItem, item2: DiscoverItem) => {
-    let value = 0
-
-    type FilterKey = keyof typeof item1 // name or namespace
-
-    const item1Prop = item1[sortType.toLowerCase() as FilterKey] as string
-    const item2Prop = item2[sortType.toLowerCase() as FilterKey] as string
-
-    value = item1Prop.localeCompare(item2Prop)
-    if (sortOrder === ascending) value *= -1
-
-    return value
-  }
-
   const sortItems = () => {
-    const sortedGroups = [...discoverGroups]
-    const sortedPods = [...discoverPods]
-
-    sortedGroups.sort(compareDiscoverItems)
-    sortedPods.sort(compareDiscoverItems)
+    const sortedProjects = [...discoverProjects]
+    const newSortOrder = sortOrder === ascending ? descending : ascending
 
-    setDiscoverGroups(sortedGroups)
-    setDiscoverPods(sortedPods)
+    switch (sortType) {
+      case sortMeta.name.id:
+        // Sorting via name
+        sortMeta.name.order = newSortOrder
+        sortedProjects.forEach(project => {
+          project.sort(newSortOrder === ascending ? 1 : -1)
+        })
+        break
+      case sortMeta.namespace.id:
+        // Sorting via namespace
+        sortMeta.namespace.order = newSortOrder
+        sortedProjects.sort((ns1: DiscoverProject, ns2: DiscoverProject) => {
+          let value = ns1.name.localeCompare(ns2.name)
+          return newSortOrder === descending ? (value *= -1) : value
+        })
+    }
 
-    if (sortOrder === ascending) setSortOrder(descending)
-    else setSortOrder(ascending)
+    setDiscoverProjects(sortedProjects)
+    setSortOrder(newSortOrder)
   }
 
   return (
@@ -156,11 +198,12 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
               onOpenChange={setIsFilterTypeOpen}
             >
               <SelectList>
-                {headers.map((name, index) => (
-                  <SelectOption key={name + '-' + index} value={name}>
-                    {name}
-                  </SelectOption>
-                ))}
+                <SelectOption key={filterMeta.name + '-0'} value={filterMeta.name}>
+                  {filterMeta.name}
+                </SelectOption>
+                <SelectOption key={filterMeta.namespace + '-0'} value={filterMeta.namespace}>
+                  {filterMeta.namespace}
+                </SelectOption>
               </SelectList>
             </Select>
           </ToolbarItem>
@@ -190,7 +233,7 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
               aria-label='select-sort-type'
               toggle={(toggleRef: React.Ref<MenuToggleElement>) => (
                 <MenuToggle
-                  disabled={discoverGroups.length + discoverPods.length <= 1}
+                  disabled={Object.values(discoverProjects).length <= 1}
                   ref={toggleRef}
                   onClick={() => setIsSortTypeOpen(!isSortTypeOpen)}
                 >
@@ -201,14 +244,14 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
               isOpen={isSortTypeOpen}
               onOpenChange={setIsSortTypeOpen}
               onSelect={onSelectSortType}
-              // direction={SelectDirection.down}
             >
               <SelectList>
-                {headers.map((name, index) => (
-                  <SelectOption key={name + '-' + index} value={name}>
-                    {name}
-                  </SelectOption>
-                ))}
+                <SelectOption key={sortMeta.name.id + '-0'} value={sortMeta.name.id}>
+                  {sortMeta.name.id}
+                </SelectOption>
+                <SelectOption key={sortMeta.namespace.id + '-0'} value={sortMeta.namespace.id}>
+                  {sortMeta.namespace.id}
+                </SelectOption>
               </SelectList>
             </Select>
           </ToolbarItem>
@@ -217,7 +260,7 @@ export const DiscoverToolbar: React.FunctionComponent = () => {
               variant='control'
               aria-label='Sort'
               onClick={sortItems}
-              isDisabled={discoverGroups.length + discoverPods.length <= 1}
+              isDisabled={Object.values(discoverProjects).length <= 1}
             >
               {sortOrder.icon}
             </Button>
diff --git a/packages/online-shell/src/discover/HeaderMenuDropDown.tsx b/packages/online-shell/src/discover/HeaderMenuDropDown.tsx
index 83e1408a..bfdda7f8 100644
--- a/packages/online-shell/src/discover/HeaderMenuDropDown.tsx
+++ b/packages/online-shell/src/discover/HeaderMenuDropDown.tsx
@@ -1,24 +1,29 @@
 import React, { ReactNode, useEffect, useState } from 'react'
-import { ThIcon } from '@patternfly/react-icons'
-import { ConsoleLink, ConsoleType } from '../console'
-import { ManagedPod, MgmtActions, mgmtService } from '@hawtio/online-management-api'
+import { CubesIcon, ThIcon, UsersIcon } from '@patternfly/react-icons'
 import {
   Divider,
   Dropdown,
   DropdownGroup,
   DropdownItem,
   DropdownList,
+  Menu,
+  MenuContent,
+  MenuGroup,
+  MenuItem,
+  MenuList,
   MenuToggle,
   MenuToggleElement,
 } from '@patternfly/react-core'
+import { ManagedProject, MgmtActions, mgmtService } from '@hawtio/online-management-api'
+import { ConsoleLink, ConsoleType } from '../console'
 
 export const HeaderMenuDropDown: React.FunctionComponent = () => {
-  const [pods, setPods] = useState<ManagedPod[]>(mgmtService.pods)
-  const [isOpen, setIsOpen] = useState(false)
+  const [projects, setProjects] = useState<ManagedProject[]>(Object.values(mgmtService.projects))
+  const [isOpen, setIsOpen] = React.useState<boolean>(false)
 
   useEffect(() => {
     mgmtService.on(MgmtActions.UPDATED, () => {
-      setPods([...mgmtService.pods])
+      setProjects([...Object.values(mgmtService.projects)])
     })
   }, [])
 
@@ -32,36 +37,65 @@ export const HeaderMenuDropDown: React.FunctionComponent = () => {
     onFocus()
   }
 
-  const podEntries = (): ReactNode => (
-    <DropdownGroup label='Containers' key='header-menu-dropdown-pod-group'>
+  const podEntries = (project: ManagedProject): ReactNode => {
+    return Object.values(project.pods).map(pod => {
+      const connNames = mgmtService.refreshConnections(pod)
+      return connNames.map(connName => (
+        <MenuList key={`header-menu-dropdown-pod-${connName}-menu-list`}>
+          <MenuItem
+            key={`header-menu-dropdown-pod-${connName}-menu-list-item`}
+            itemId={`header-menu-dropdown-pod-${connName}`}
+            component='button'
+            onClick={() => mgmtService.connect(connName)}
+            value={connName}
+            icon={<CubesIcon aria-hidden />}
+          >
+            {connName}
+          </MenuItem>
+        </MenuList>
+      ))
+    })
+  }
+
+  const projectItems = (
+    <DropdownGroup label='Projects' key='header-menu-dropdown-pod-group'>
       <DropdownList>
-        {pods.map(pod => {
-          const connNames = mgmtService.refreshConnections(pod)
-          return connNames.map(connName => (
+        {projects.map(project => {
+          return (
             <DropdownItem
-              key={`header-menu-dropdown-pod-${connName}`}
-              component='button'
-              onClick={() => mgmtService.connect(connName)}
-              value={connName}
+              key={`project-${project.name}`}
+              itemId={`project-${project.name}`}
+              icon={<UsersIcon aria-hidden />}
+              direction='down'
+              flyoutMenu={
+                <Menu id={`project-${project.name}-pod-menu`} isScrollable>
+                  <MenuGroup label='Containers' key='header-menu-dropdown-pod-group'>
+                    {podEntries(project)}
+                  </MenuGroup>
+                </Menu>
+              }
             >
-              {connName}
+              {project.name}
             </DropdownItem>
-          ))
+          )
         })}
       </DropdownList>
     </DropdownGroup>
   )
 
-  const dropdownItems = [
-    <DropdownList key='header-menu-dropdown-list'>
-      <DropdownItem key='header-menu-dropdown-os-action' description='Open the cluster console' component='button'>
-        <ConsoleLink type={ConsoleType.console}>Cluster Console</ConsoleLink>
-      </DropdownItem>
-    </DropdownList>,
-
-    <Divider key='header-menu-dropdown-separator' />,
-    podEntries(),
-  ]
+  const menu = (
+    <Menu id='header-menu-dropdown-root-menu' containsFlyout>
+      <MenuContent>
+        <MenuList>
+          <MenuItem itemId='open-cluster-console-item' description='Open the cluster console' component='button'>
+            <ConsoleLink type={ConsoleType.console}>Cluster Console</ConsoleLink>
+          </MenuItem>
+          <Divider key='header-menu-dropdown-separator' />
+          {projectItems}
+        </MenuList>
+      </MenuContent>
+    </Menu>
+  )
 
   return (
     <Dropdown
@@ -74,6 +108,7 @@ export const HeaderMenuDropDown: React.FunctionComponent = () => {
           variant={'plain'}
           ref={toggleRef}
           onClick={() => setIsOpen(!isOpen)}
+          isExpanded={isOpen}
         >
           <ThIcon />
         </MenuToggle>
@@ -81,7 +116,7 @@ export const HeaderMenuDropDown: React.FunctionComponent = () => {
       isOpen={isOpen}
       onOpenChange={setIsOpen}
     >
-      {dropdownItems}
+      {menu}
     </Dropdown>
   )
 }
diff --git a/packages/online-shell/src/discover/context.ts b/packages/online-shell/src/discover/context.ts
index 5bf0398d..602abce3 100644
--- a/packages/online-shell/src/discover/context.ts
+++ b/packages/online-shell/src/discover/context.ts
@@ -1,7 +1,7 @@
 import { createContext, useCallback, useEffect, useRef, useState } from 'react'
-import { MgmtActions, isMgmtApiRegistered, mgmtService } from '@hawtio/online-management-api'
+import { MgmtActions, isMgmtApiRegistered, mgmtService, TypeFilter } from '@hawtio/online-management-api'
 import { discoverService } from './discover-service'
-import { DiscoverGroup, DiscoverPod, TypeFilter } from './globals'
+import { DiscoverProject } from './discover-project'
 
 type UpdateListener = () => void
 
@@ -13,19 +13,19 @@ export function useDisplayItems() {
   const updateListenerRef = useRef<UpdateListener>()
 
   const [isLoading, setIsLoading] = useState(true)
+  const [refreshing, setRefreshing] = useState(true)
   const [error, setError] = useState<Error | null>()
-  const [discoverGroups, setDiscoverGroups] = useState<DiscoverGroup[]>([])
-  const [discoverPods, setDiscoverPods] = useState<DiscoverPod[]>([])
+  const [discoverProjects, setDiscoverProjects] = useState<DiscoverProject[]>([])
 
   // Set of filters created by filter control and displayed as chips
   const [filters, setFilters] = useState<TypeFilter[]>([])
 
   const organisePods = useCallback(() => {
-    const [discoverGroups, discoverPods] = discoverService.filterAndGroupPods(filters)
-    setDiscoverGroups([...discoverGroups])
-    setDiscoverPods([...discoverPods])
+    const discoverProjects = discoverService.filterAndGroupPods(filters)
+    setDiscoverProjects([...discoverProjects])
 
     setIsLoading(false)
+    setRefreshing(false)
   }, [filters])
 
   useEffect(() => {
@@ -34,6 +34,7 @@ export function useDisplayItems() {
       if (mgmtService.hasError()) {
         setError(mgmtService.error)
         setIsLoading(false)
+        setRefreshing(false)
         return
       }
 
@@ -45,6 +46,7 @@ export function useDisplayItems() {
       organisePods()
 
       const updateListener = () => {
+        setRefreshing(true)
         organisePods()
       }
 
@@ -61,25 +63,25 @@ export function useDisplayItems() {
     }
   }, [organisePods])
 
-  return { error, isLoading, discoverGroups, setDiscoverGroups, discoverPods, setDiscoverPods, filters, setFilters }
+  return { error, isLoading, refreshing, setRefreshing, discoverProjects, setDiscoverProjects, filters, setFilters }
 }
 
 type DiscoverContext = {
-  discoverGroups: DiscoverGroup[]
-  setDiscoverGroups: (items: DiscoverGroup[]) => void
-  discoverPods: DiscoverPod[]
-  setDiscoverPods: (items: DiscoverPod[]) => void
+  refreshing: boolean
+  setRefreshing: (refresh: boolean) => void
+  discoverProjects: DiscoverProject[]
+  setDiscoverProjects: (projects: DiscoverProject[]) => void
   filters: TypeFilter[]
   setFilters: (filters: TypeFilter[]) => void
 }
 
 export const DiscoverContext = createContext<DiscoverContext>({
-  discoverGroups: [],
-  setDiscoverGroups: () => {
+  refreshing: false,
+  setRefreshing: (refresh: boolean) => {
     // no-op
   },
-  discoverPods: [],
-  setDiscoverPods: () => {
+  discoverProjects: [],
+  setDiscoverProjects: () => {
     // no-op
   },
   filters: [],
diff --git a/packages/online-shell/src/discover/discover-project.ts b/packages/online-shell/src/discover/discover-project.ts
new file mode 100644
index 00000000..a5e4fb5a
--- /dev/null
+++ b/packages/online-shell/src/discover/discover-project.ts
@@ -0,0 +1,131 @@
+import { ManagedPod } from '@hawtio/online-management-api'
+import { DiscoverGroup, DiscoverPod, DiscoverType } from './globals'
+import { OwnerReference } from '@hawtio/online-kubernetes-api'
+
+export type DiscoverProjects = {
+  [name: string]: DiscoverProject
+}
+
+type SortOrderType = 1 | -1
+
+export class DiscoverProject {
+  private discoverGroups: DiscoverGroup[] = []
+  private discoverPods: DiscoverPod[] = []
+
+  constructor(
+    private projectName: string,
+    mgmtPods: ManagedPod[],
+  ) {
+    this.refresh(mgmtPods)
+  }
+
+  private podOwner(pod: ManagedPod): OwnerReference | null {
+    const metadata = pod.metadata
+    if (!metadata || !metadata.ownerReferences) return null
+
+    if (metadata.ownerReferences.length === 0) return null
+    return metadata.ownerReferences[0]
+  }
+
+  private createDiscoverPod(pod: ManagedPod): DiscoverPod {
+    return {
+      type: DiscoverType.Pod,
+      name: pod.metadata?.name || '<unknown>',
+      uid: pod.metadata?.uid || '<unknown>',
+      namespace: pod.metadata?.namespace || '<unknown>',
+      labels: pod.metadata?.labels || {},
+      annotations: pod.metadata?.annotations || {},
+      mPod: pod,
+    }
+  }
+
+  private podsWithOwner(remainingPods: ManagedPod[], ownerRef: OwnerReference): ManagedPod[] {
+    if (!remainingPods) return []
+
+    return remainingPods.filter(pod => {
+      const oRef = this.podOwner(pod)
+      return oRef?.uid === ownerRef.uid
+    })
+  }
+
+  private toDiscoverGroup(pod: ManagedPod, owner: OwnerReference, replicas: ManagedPod[]): DiscoverGroup {
+    const discoverReplicas = [pod, ...replicas].map(replica => this.createDiscoverPod(replica))
+    return {
+      type: DiscoverType.Group,
+      name: owner.name,
+      uid: owner.uid,
+      namespace: pod.metadata?.namespace || '<unknown>',
+      replicas: discoverReplicas || [],
+      config: this.recordValue(pod.metadata?.annotations, 'openshift.io/deployment-config.name'),
+      version: this.recordValue(pod.metadata?.annotations, 'openshift.io/deployment-config.latest-version'),
+      statefulset: this.recordValue(pod.metadata?.labels, 'statefulset.kubernetes.io/pod-name'),
+    }
+  }
+
+  private recordValue(values: Record<string, string> | undefined, key: string): string | undefined {
+    if (!values) return undefined
+    return values[key]
+  }
+
+  refresh(pods: ManagedPod[]) {
+    const discoverPods: DiscoverPod[] = []
+    const discoverGroups: DiscoverGroup[] = []
+
+    for (let i = 0; i < pods.length; ++i) {
+      const pod = pods[i]
+      const ownerRef = this.podOwner(pod)
+
+      if (!ownerRef || !ownerRef?.uid) {
+        discoverPods.push(this.createDiscoverPod(pod))
+        continue
+      }
+
+      const groups = discoverGroups.filter(group => group.uid === ownerRef.uid)
+      if (groups.length > 0) continue // pod already processed into a display group
+
+      /*
+       * Pod has an owner uid but not yet processed
+       */
+
+      // find pods with same owner uid as this one
+      const remainingPods = i < pods.length - 1 ? pods.slice(i + 1) : []
+      const replicas = this.podsWithOwner(remainingPods, ownerRef)
+
+      discoverGroups.push(this.toDiscoverGroup(pod, ownerRef, replicas))
+    }
+
+    this.discoverGroups = discoverGroups
+    this.discoverPods = discoverPods
+
+    /**
+     * Notify event service of any errors in the groups and pods
+     */
+    this.discoverGroups.flatMap(discoverGroup =>
+      discoverGroup.replicas.map(discoverPod => discoverPod.mPod.errorNotify()),
+    )
+
+    this.discoverPods.map(discoverPod => discoverPod.mPod.errorNotify())
+  }
+
+  get name(): string {
+    return this.projectName
+  }
+
+  get pods(): DiscoverPod[] {
+    return this.discoverPods
+  }
+
+  get groups(): DiscoverGroup[] {
+    return this.discoverGroups
+  }
+
+  sort(sortOrder: SortOrderType) {
+    this.discoverGroups.sort((a: DiscoverGroup, b: DiscoverGroup) => {
+      return a.name.localeCompare(b.name) * sortOrder
+    })
+
+    this.discoverPods.sort((a: DiscoverPod, b: DiscoverPod) => {
+      return a.name.localeCompare(b.name) * sortOrder
+    })
+  }
+}
diff --git a/packages/online-shell/src/discover/discover-service.ts b/packages/online-shell/src/discover/discover-service.ts
index 45263f32..c0dd020e 100644
--- a/packages/online-shell/src/discover/discover-service.ts
+++ b/packages/online-shell/src/discover/discover-service.ts
@@ -1,6 +1,7 @@
-import { OwnerReference } from '@hawtio/online-kubernetes-api'
-import { ManagedPod, mgmtService } from '@hawtio/online-management-api'
-import { DiscoverGroup, DiscoverPod, DiscoverType, TypeFilter } from './globals'
+import { mgmtService, MPodsByUid, TypeFilterType, TypeFilter } from '@hawtio/online-management-api'
+import { DiscoverPod } from './globals'
+import { DiscoverProject, DiscoverProjects } from './discover-project'
+import { ManagedProject } from '@hawtio/online-management-api'
 
 export enum ViewType {
   listView = 'listView',
@@ -8,155 +9,91 @@ export enum ViewType {
 }
 
 class DiscoverService {
-  private discoverGroups: DiscoverGroup[] = []
-  private discoverPods: DiscoverPod[] = []
+  private discoverProjects: DiscoverProjects = {}
 
-  private recordValue(values: Record<string, string> | undefined, key: string): string | undefined {
-    if (!values) return undefined
-    return values[key]
-  }
-
-  private toDiscoverGroup(
-    pod: ManagedPod,
-    owner: OwnerReference,
-    replicas: ManagedPod[],
-    expanded: boolean,
-  ): DiscoverGroup {
-    const discoverReplicas = [pod, ...replicas].map(replica => this.createDiscoverPod(replica))
-    return {
-      type: DiscoverType.Group,
-      name: owner.name,
-      uid: owner.uid,
-      namespace: pod.getMetadata()?.namespace || '<unknown>',
-      replicas: discoverReplicas || [],
-      expanded: expanded,
-      config: this.recordValue(pod.getMetadata()?.annotations, 'openshift.io/deployment-config.name'),
-      version: this.recordValue(pod.getMetadata()?.annotations, 'openshift.io/deployment-config.latest-version'),
-      statefulset: this.recordValue(pod.getMetadata()?.labels, 'statefulset.kubernetes.io/pod-name'),
-    }
-  }
-
-  private createDiscoverPod(pod: ManagedPod): DiscoverPod {
-    return {
-      type: DiscoverType.Pod,
-      name: pod.getMetadata()?.name || '<unknown>',
-      uid: pod.getMetadata()?.uid || '<unknown>',
-      namespace: pod.getMetadata()?.namespace || '<unknown>',
-      labels: pod.getMetadata()?.labels || {},
-      annotations: pod.getMetadata()?.annotations || {},
-      mPod: pod,
+  filterAndGroupPods(filters: TypeFilter[]): DiscoverProject[] {
+    /*
+     * Find all the namespace filters and reduce them together
+     */
+    const nsFilters = filters.filter(f => f.type === TypeFilterType.NAMESPACE)
+    let nsFilter: TypeFilter | undefined
+    if (nsFilters.length === 0) nsFilter = undefined
+    else {
+      nsFilter = nsFilters.reduceRight((accumulator, currentValue, currentIndex, array) => {
+        currentValue.values.forEach(v => accumulator.values.add(v))
+        return accumulator
+      })
     }
-  }
-
-  private podOwner(pod: ManagedPod): OwnerReference | null {
-    const metadata = pod.getMetadata()
-    if (!metadata || !metadata.ownerReferences) return null
-
-    if (metadata.ownerReferences.length === 0) return null
 
-    return metadata.ownerReferences[0]
-  }
-
-  private podsWithOwner(remainingPods: ManagedPod[], ownerRef: OwnerReference): ManagedPod[] {
-    if (!remainingPods) return []
-
-    return remainingPods.filter(pod => {
-      const oRef = this.podOwner(pod)
-      return oRef?.uid === ownerRef.uid
-    })
-  }
+    const podFilters = filters.filter(f => f.type === TypeFilterType.NAME)
 
-  private groupPodsByDeployment(pods: ManagedPod[]) {
-    const discoverPods: DiscoverPod[] = []
-    const discoverGroups: DiscoverGroup[] = []
+    const filteredProjects: ManagedProject[] = []
 
-    for (let i = 0; i < pods.length; ++i) {
-      const pod = pods[i]
-      const ownerRef = this.podOwner(pod)
-
-      if (!ownerRef || !ownerRef?.uid) {
-        discoverPods.push(this.createDiscoverPod(pod))
-        continue
+    Object.values(mgmtService.projects).forEach(mgmtProject => {
+      if (!nsFilter) {
+        filteredProjects.push(mgmtProject)
+        return
       }
 
-      const groups = discoverGroups.filter(group => group.uid === ownerRef.uid)
-      if (groups.length > 0) continue // pod already processed into a display group
-
       /*
-       * Pod has an owner uid but not yet processed
+       * Namespace filter values will be tested as an OR filter
+       * This corresponds to Patternfly design guidelines that
+       * "[...] there is an "AND" relationship between facets,
+       *  and an "OR" relationship between values."
+       * (https://www.patternfly.org/patterns/filters/design-guidelines/#filter-group)
        */
-
-      // find pods with same owner uid as this one
-      const remainingPods = i < pods.length - 1 ? pods.slice(i + 1) : []
-      const replicas = this.podsWithOwner(remainingPods, ownerRef)
-
-      const oldDiscoverGroups = this.discoverGroups.filter(group => {
-        return (
-          group.uid === pod.getMetadata()?.uid &&
-          group.namespace === pod.getMetadata()?.namespace &&
-          group.name === ownerRef?.name
-        )
+      let exclude = true
+      nsFilter.values.forEach(v => {
+        if (mgmtProject.name.includes(v)) {
+          filteredProjects.push(mgmtProject)
+          exclude = false
+        }
       })
 
-      // Determine if group previously expanded
-      const expanded = oldDiscoverGroups.length > 0 ? oldDiscoverGroups[0].expanded : true
-
-      discoverGroups.push(this.toDiscoverGroup(pod, ownerRef, replicas, expanded))
-    }
-
-    this.discoverGroups = discoverGroups
-    this.discoverPods = discoverPods
-  }
-
-  private applyFilter(filter: TypeFilter, pod: ManagedPod): boolean {
-    if (!pod.getMetadata()) return false
-
-    const metadata = pod.getMetadata()
-    if (!metadata) return false
-
-    type KubeObjKey = keyof typeof metadata
-
-    const podProp = metadata[filter.type.toLowerCase() as KubeObjKey] as string
+      if (exclude) {
+        /*
+         * By removing any projects that do not correspond to the namespace
+         * filter we are effectively doing an AND test with the name filter below
+         *
+         * ie. if the project fails the namespace filter then it should not
+         *     even be tested against the name filter
+         */
+        delete this.discoverProjects[mgmtProject.name]
+      }
+    })
 
-    // Want to filter on this property but value
-    // is null so filter fails
-    if (!podProp) return false
+    filteredProjects.forEach(mgmtProject => {
+      const podsByUid: MPodsByUid = mgmtProject.pods
 
-    return podProp.toLowerCase().includes(filter.value.toLowerCase())
-  }
+      const filtered = Object.values(podsByUid).filter(pod => {
+        if (podFilters.length === 0) return true
 
-  filterAndGroupPods(theFilters: TypeFilter[]): [discoverGroups: DiscoverGroup[], discoverPods: DiscoverPod[]] {
-    const pods: ManagedPod[] = mgmtService.pods || []
-
-    let filtered = pods
-    if (theFilters && theFilters.length > 0) {
-      filtered = pods.filter(pod => {
-        let status = true
-        for (const filter of theFilters) {
-          if (!this.applyFilter(filter, pod)) {
-            // service fails filter so return
-            status = false
-            break
+        for (const f of podFilters) {
+          if (pod.filter(f)) {
+            return true // Include as it conforms to at least one filter
           }
-
-          // service passes this filter so continue
         }
-        return status
-      })
-    }
 
-    this.groupPodsByDeployment(filtered)
+        return false
+      })
 
-    /**
-     * Notify event service of any errors in the groups and pods
-     */
-    this.discoverGroups.flatMap(discoverGroup =>
-      discoverGroup.replicas.map(discoverPod => discoverPod.mPod.errorNotify()),
-    )
+      if (filtered.length === 0) {
+        // Remove the project as no longer contains any pods
+        if (this.discoverProjects[mgmtProject.name]) {
+          delete this.discoverProjects[mgmtProject.name]
+        }
+        return
+      }
 
-    this.discoverPods.map(discoverPod => discoverPod.mPod.errorNotify())
+      if (!this.discoverProjects[mgmtProject.name]) {
+        const discoverProject = new DiscoverProject(mgmtProject.name, filtered)
+        this.discoverProjects[mgmtProject.name] = discoverProject
+      } else {
+        this.discoverProjects[mgmtProject.name].refresh(filtered)
+      }
+    })
 
-    return [this.discoverGroups, this.discoverPods]
+    return Object.values(this.discoverProjects)
   }
 
   getStatus(pod: DiscoverPod): string {
diff --git a/packages/online-shell/src/discover/globals.ts b/packages/online-shell/src/discover/globals.ts
index 9407a685..f751980f 100644
--- a/packages/online-shell/src/discover/globals.ts
+++ b/packages/online-shell/src/discover/globals.ts
@@ -5,11 +5,6 @@ export const pluginPath = '/discover'
 export const pluginName = 'hawtio-online-discover'
 export const log = Logger.get(pluginName)
 
-export interface TypeFilter {
-  type: string
-  value: string
-}
-
 export enum DiscoverType {
   Group = 0,
   Pod = 1,
@@ -24,7 +19,6 @@ export interface DiscoverItem {
 
 export interface DiscoverGroup extends DiscoverItem {
   replicas: DiscoverPod[]
-  expanded: boolean
   config?: string
   version?: string
   statefulset?: string