diff --git a/ui/api/topics/actions.ts b/ui/api/topics/actions.ts
index 8b8209ffc..c98032ed6 100644
--- a/ui/api/topics/actions.ts
+++ b/ui/api/topics/actions.ts
@@ -80,7 +80,7 @@ export async function getTopic(
     },
   });
   const rawData = await res.json();
-  //log.debug("getTopic", url, JSON.stringify(rawData, null, 2));
+  log.debug(rawData, "getTopic");
   return TopicResponse.parse(rawData).data;
 }
 
diff --git a/ui/api/topics/schema.ts b/ui/api/topics/schema.ts
index 5cb1aa12a..0042778c4 100644
--- a/ui/api/topics/schema.ts
+++ b/ui/api/topics/schema.ts
@@ -9,9 +9,15 @@ const OffsetSchema = z.object({
   timestamp: z.string().optional(),
   leaderEpoch: z.number().optional(),
 });
+const PartitionStatusSchema = z.union([
+  z.literal("FullyReplicated"),
+  z.literal("UnderReplicated"),
+  z.literal("Offline"),
+]);
+export type PartitionStatus = z.infer<typeof PartitionStatusSchema>;
 const PartitionSchema = z.object({
   partition: z.number(),
-  status: z.string(),
+  status: PartitionStatusSchema,
   leaderId: z.number().optional(),
   replicas: z.array(
     z.object({
diff --git a/ui/app/[locale]/kafka/[kafkaId]/@header/topics/[topicId]/TopicHeader.tsx b/ui/app/[locale]/kafka/[kafkaId]/@header/topics/[topicId]/TopicHeader.tsx
index fcd3f60ac..104f396ac 100644
--- a/ui/app/[locale]/kafka/[kafkaId]/@header/topics/[topicId]/TopicHeader.tsx
+++ b/ui/app/[locale]/kafka/[kafkaId]/@header/topics/[topicId]/TopicHeader.tsx
@@ -40,26 +40,28 @@ export function TopicHeader({
                     </Label>
                   </NavItemLink>
                   <NavItemLink
-                    url={`/kafka/${kafkaId}/topics/${topicId}/consumer-groups`}
+                    url={`/kafka/${kafkaId}/topics/${topicId}/partitions`}
                   >
-                    Consumer groups&nbsp;
+                    Partitions&nbsp;
                     <Label isCompact={true}>
                       <Spinner size="sm" />
                     </Label>
                   </NavItemLink>
                   <NavItemLink
-                    url={`/kafka/${kafkaId}/topics/${topicId}/partitions`}
+                    url={`/kafka/${kafkaId}/topics/${topicId}/consumer-groups`}
                   >
-                    Partitions&nbsp;
+                    Consumer groups&nbsp;
                     <Label isCompact={true}>
                       <Spinner size="sm" />
                     </Label>
                   </NavItemLink>
+                  {/*
                   <NavItemLink
                     url={`/kafka/${kafkaId}/topics/${topicId}/schema-registry`}
                   >
                     Schema
                   </NavItemLink>
+*/}
                   <NavItemLink
                     url={`/kafka/${kafkaId}/topics/${topicId}/configuration`}
                   >
@@ -97,16 +99,6 @@ async function ConnectedTopicHeader({
               <NavItemLink url={`/kafka/${kafkaId}/topics/${topicId}/messages`}>
                 Messages&nbsp;
               </NavItemLink>
-              <NavItemLink
-                url={`/kafka/${kafkaId}/topics/${topicId}/consumer-groups`}
-              >
-                Consumer groups&nbsp;
-                <Label isCompact={true}>
-                  <Number
-                    value={topic.relationships.consumerGroups.data.length}
-                  />
-                </Label>
-              </NavItemLink>
               <NavItemLink
                 url={`/kafka/${kafkaId}/topics/${topicId}/partitions`}
               >
@@ -117,11 +109,23 @@ async function ConnectedTopicHeader({
                   </Suspense>
                 </Label>
               </NavItemLink>
+              <NavItemLink
+                url={`/kafka/${kafkaId}/topics/${topicId}/consumer-groups`}
+              >
+                Consumer groups&nbsp;
+                <Label isCompact={true}>
+                  <Number
+                    value={topic.relationships.consumerGroups.data.length}
+                  />
+                </Label>
+              </NavItemLink>
+              {/*
               <NavItemLink
                 url={`/kafka/${kafkaId}/topics/${topicId}/schema-registry`}
               >
                 Schema
               </NavItemLink>
+              */}
               <NavItemLink
                 url={`/kafka/${kafkaId}/topics/${topicId}/configuration`}
               >
diff --git a/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/NoResultsEmptyState.tsx b/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/NoResultsEmptyState.tsx
new file mode 100644
index 000000000..8c06a84f3
--- /dev/null
+++ b/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/NoResultsEmptyState.tsx
@@ -0,0 +1,24 @@
+"use client";
+import {
+  Button,
+  EmptyState,
+  EmptyStateBody,
+  EmptyStateIcon,
+  Title,
+} from "@/libs/patternfly/react-core";
+import { SearchIcon } from "@/libs/patternfly/react-icons";
+
+export function NoResultsEmptyState({ onReset }: { onReset: () => void }) {
+  return (
+    <EmptyState variant={"lg"}>
+      <EmptyStateIcon icon={SearchIcon} />
+      <Title headingLevel="h4" size="lg">
+        No results
+      </Title>
+      <EmptyStateBody>No partitions matching the filter.</EmptyStateBody>
+      <Button variant={"link"} onClick={onReset}>
+        Reset filters
+      </Button>
+    </EmptyState>
+  );
+}
diff --git a/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/PartitionsTable.tsx b/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/PartitionsTable.tsx
index d3222be11..787877cad 100644
--- a/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/PartitionsTable.tsx
+++ b/ui/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/PartitionsTable.tsx
@@ -1,14 +1,70 @@
 "use client";
 import { getTopic } from "@/api/topics/actions";
-import { Topic } from "@/api/topics/schema";
+import { PartitionStatus, Topic } from "@/api/topics/schema";
+import { NoResultsEmptyState } from "@/app/[locale]/kafka/[kafkaId]/topics/[topicId]/partitions/NoResultsEmptyState";
 import { Bytes } from "@/components/Bytes";
-import { Number } from "@/components/Number";
 import { TableView } from "@/components/table";
-import { Label, LabelGroup, PageSection } from "@/libs/patternfly/react-core";
-import { WarningTriangleIcon } from "@/libs/patternfly/react-icons";
-import { CodeBranchIcon, ServerIcon } from "@patternfly/react-icons";
-import Link from "next/link";
-import { useEffect, useState } from "react";
+import {
+  Icon,
+  Label,
+  LabelGroup,
+  PageSection,
+  ToggleGroup,
+  ToggleGroupItem,
+  Tooltip,
+} from "@/libs/patternfly/react-core";
+import {
+  CheckCircleIcon,
+  FlagIcon,
+  HelpIcon,
+} from "@/libs/patternfly/react-icons";
+import {
+  ExclamationCircleIcon,
+  ExclamationTriangleIcon,
+} from "@patternfly/react-icons";
+import { ReactNode, useEffect, useState } from "react";
+
+const Columns = [
+  "id",
+  "status",
+  "leader",
+  "preferredLeader",
+  "replicas",
+  "storage",
+] as const;
+const SortColumns = [
+  "id",
+  "leader",
+  "preferredLeader",
+  "status",
+  "storage",
+] as const;
+const StatusLabel: Record<PartitionStatus, ReactNode> = {
+  FullyReplicated: (
+    <>
+      <Icon status={"success"}>
+        <CheckCircleIcon />
+      </Icon>{" "}
+      In-sync
+    </>
+  ),
+  UnderReplicated: (
+    <>
+      <Icon status={"warning"}>
+        <ExclamationTriangleIcon />
+      </Icon>{" "}
+      Under replicated
+    </>
+  ),
+  Offline: (
+    <>
+      <Icon status={"danger"}>
+        <ExclamationCircleIcon />
+      </Icon>{" "}
+      Offline
+    </>
+  ),
+};
 
 export function PartitionsTable({
   topic: initialData,
@@ -18,6 +74,11 @@ export function PartitionsTable({
   topic: Topic | undefined;
 }) {
   const [topic, setTopic] = useState(initialData);
+  const [filter, setFilter] = useState<"all" | PartitionStatus>("all");
+  const [sort, setSort] = useState<{
+    sort: (typeof SortColumns)[number];
+    dir: "asc" | "desc";
+  }>({ sort: "id", dir: "asc" });
   useEffect(() => {
     let interval: ReturnType<typeof setInterval>;
     if (initialData) {
@@ -28,48 +89,98 @@ export function PartitionsTable({
     }
     return () => clearInterval(interval);
   }, [kafkaId, initialData]);
+  const filteredData = topic?.attributes.partitions
+    ?.filter((p) => (filter !== "all" ? p.status === filter : true))
+    .sort((a, b) => {
+      switch (sort.sort) {
+        case "id":
+          return a.partition - b.partition;
+        case "leader":
+          return (a.leaderId ?? 0) - (b.leaderId ?? 0);
+        case "status":
+          return a.status.localeCompare(b.status);
+        case "preferredLeader":
+          const apl = a.leaderId === a.replicas[0]?.nodeId;
+          const bpl = b.leaderId === b.replicas[0]?.nodeId;
+          return Number(apl) - Number(bpl);
+        case "storage":
+          return (a.leaderLocalStorage ?? 0) - (b.leaderLocalStorage ?? 0);
+      }
+    });
+  const sortedData =
+    sort.dir === "asc" ? filteredData : filteredData?.reverse();
   return (
     <PageSection isFilled>
       <TableView
-        itemCount={topic?.attributes.partitions?.length}
+        itemCount={sortedData?.length}
         page={1}
         onPageChange={() => {}}
-        data={topic?.attributes.partitions}
+        data={sortedData}
         emptyStateNoData={<div>No partitions</div>}
-        emptyStateNoResults={<div>todo</div>}
-        ariaLabel={"Partitions"}
-        columns={
-          [
-            "id",
-            "replications",
-            "offsets",
-            "leaderLocalStorage",
-          ] as const
+        emptyStateNoResults={
+          <NoResultsEmptyState onReset={() => setFilter("all")} />
         }
+        isFiltered={filter !== "all"}
+        ariaLabel={"Partitions"}
+        columns={Columns}
         renderHeader={({ column, key, Th }) => {
           switch (column) {
             case "id":
               return (
-                <Th key={key} dataLabel={"Partition Id"}>
-                  Partition Id
+                <Th key={key} dataLabel={"Partition Id"} width={15}>
+                  Partition ID
                 </Th>
               );
-            case "replications":
+            case "status":
               return (
-                <Th key={key} dataLabel={"Replicas"}>
-                  Replications
+                <Th key={key} dataLabel={"Status"} width={15}>
+                  Status
                 </Th>
               );
-            case "offsets":
+            case "preferredLeader":
               return (
-                <Th key={key} dataLabel={"Offsets"}>
-                  Offsets (Earliest/Latest)
+                <Th key={key} dataLabel={"Preferred leader"} width={20}>
+                  Preferred leader{" "}
+                  <Tooltip
+                    content={
+                      "Whenever a new topic is created, Kafka runs its leader election algorithm to figure out the preferred leader of a partition from a list of replicas."
+                    }
+                  >
+                    <HelpIcon />
+                  </Tooltip>
                 </Th>
               );
-            case "leaderLocalStorage":
+            case "leader":
+              return (
+                <Th key={key} dataLabel={"Leader"} width={15}>
+                  Leader{" "}
+                  <Tooltip
+                    content={
+                      "The ID of the partition leader.\n" +
+                      "For a given partition, a broker is elected as the leader, handling all produce requests. Followers on other brokers replicate the leader's data. A follower is considered in sync if it catches up with the leader's latest committed message. Under-replication occurs when the replicas for a partition fall below the configured replication factor."
+                    }
+                  >
+                    <HelpIcon />
+                  </Tooltip>
+                </Th>
+              );
+            case "replicas":
+              return (
+                <Th key={key} dataLabel={"Replicas"} width={20}>
+                  Replicas{" "}
+                  <Tooltip
+                    content={
+                      "Each partition has designated replicas, with one being the 'leader' and the rest as 'follower' or `in-sync` partitions. The leader handles produce requests, and followers replicate the leader's data."
+                    }
+                  >
+                    <HelpIcon />
+                  </Tooltip>
+                </Th>
+              );
+            case "storage":
               return (
                 <Th key={key} dataLabel={"Storage"}>
-                  Storage
+                  Size
                 </Th>
               );
           }
@@ -79,76 +190,176 @@ export function PartitionsTable({
             case "id":
               return (
                 <Td key={key} dataLabel={"Partition Id"}>
-                  <Label color={"blue"} icon={<CodeBranchIcon />}>
-                    {row.partition}
-                  </Label>
+                  {row.partition}
+                </Td>
+              );
+            case "status":
+              return (
+                <Td key={key} dataLabel={"Status"}>
+                  {StatusLabel[row.status]}
+                </Td>
+              );
+            case "preferredLeader":
+              return (
+                <Td key={key} dataLabel={"Preferred leader"}>
+                  {row.leaderId !== undefined
+                    ? row.leaderId === row.replicas[0]?.nodeId
+                      ? "Yes"
+                      : "No"
+                    : "n/a"}
                 </Td>
               );
-            case "replications":
+            case "leader":
               const leader = row.replicas.find(
                 (r) => r.nodeId === row.leaderId,
-              )!;
+              );
               return (
-                <Td key={key} dataLabel={"Replicas"}>
-                  {leader !== undefined && (
-                    <LabelGroup categoryName={"Leader"}>
+                <Td key={key} dataLabel={"Leader"}>
+                  {leader ? (
+                    <Tooltip
+                      content={
+                        <>
+                          Broker ID: {leader.nodeId}
+                          <br />
+                          Partition leader
+                        </>
+                      }
+                    >
                       <Label
-                        color={"orange"}
-                        render={({ className, content }) => (
-                          <>
-                            <Link
-                              className={className}
-                              href={`../../nodes/${leader.nodeId}`}
-                            >
-                              {content}
-                            </Link>
-                          </>
-                        )}
-                        icon={<ServerIcon />}
+                        color={"cyan"}
+                        isCompact={true}
+                        icon={<FlagIcon />}
                       >
                         {leader.nodeId}
                       </Label>
-                    </LabelGroup>
+                    </Tooltip>
+                  ) : (
+                    "n/a"
                   )}
-                  <LabelGroup categoryName={"Replicas"}>
+                </Td>
+              );
+            case "replicas":
+              return (
+                <Td key={key} dataLabel={"Replicas"}>
+                  <LabelGroup>
                     {row.replicas
                       .filter((r) => r.nodeId !== row.leaderId)
                       .map((r, idx) => (
-                        <Label
+                        <Tooltip
                           key={idx}
-                          color={!r.inSync ? "red" : "orange"}
-                          render={({ className, content }) => (
+                          content={
                             <>
-                              <Link className={className} href={"../../nodes"}>
-                                {content}
-                              </Link>
+                              Broker ID: {r.nodeId}
+                              <br />
+                              Replica{" "}
+                              {r.inSync ? "in-sync" : "under replicated"}
                             </>
-                          )}
-                          icon={
-                            !r.inSync ? <WarningTriangleIcon /> : <ServerIcon />
                           }
                         >
-                          {r.nodeId}
-                        </Label>
+                          <Label
+                            color={!r.inSync ? "red" : undefined}
+                            isCompact={true}
+                            icon={
+                              !r.inSync ? (
+                                <Icon status={"warning"}>
+                                  <ExclamationTriangleIcon />
+                                </Icon>
+                              ) : (
+                                <Icon status={"success"}>
+                                  <CheckCircleIcon />
+                                </Icon>
+                              )
+                            }
+                          >
+                            {r.nodeId}
+                          </Label>
+                        </Tooltip>
                       ))}
                   </LabelGroup>
                 </Td>
               );
-            case "offsets":
-              return (
-                <Td key={key} dataLabel={"Offset"}>
-                  <Number value={row.offsets?.earliest?.offset} />/
-                  <Number value={row.offsets?.latest?.offset} />
-                </Td>
-              );
-            case "leaderLocalStorage":
+            case "storage":
               return (
-                <Td key={key} dataLabel={"Storage"}>
+                <Td key={key} dataLabel={"Size"}>
                   <Bytes value={row.leaderLocalStorage} />
                 </Td>
               );
           }
         }}
+        tools={[
+          <ToggleGroup key="filter" aria-label="Filter partitions by state">
+            <ToggleGroupItem
+              text={`All partitions (${topic?.attributes.partitions?.length})`}
+              buttonId="all"
+              isSelected={filter === "all"}
+              onChange={() => {
+                setFilter("all");
+              }}
+            />
+            <ToggleGroupItem
+              text={
+                <>
+                  {StatusLabel.FullyReplicated} (
+                  {topic?.attributes.partitions?.filter(
+                    (p) => p.status === "FullyReplicated",
+                  ).length || 0}
+                  )
+                </>
+              }
+              buttonId="in-sync"
+              isSelected={filter === "FullyReplicated"}
+              onChange={() => {
+                setFilter("FullyReplicated");
+              }}
+            />
+            <ToggleGroupItem
+              text={
+                <>
+                  {StatusLabel.UnderReplicated} (
+                  {topic?.attributes.partitions?.filter(
+                    (p) => p.status === "UnderReplicated",
+                  ).length || 0}
+                  )
+                </>
+              }
+              buttonId="under-replicated"
+              isSelected={filter === "UnderReplicated"}
+              onChange={() => {
+                setFilter("UnderReplicated");
+              }}
+            />
+            <ToggleGroupItem
+              text={
+                <>
+                  {StatusLabel.Offline} (
+                  {topic?.attributes.partitions?.filter(
+                    (p) => p.status === "Offline",
+                  ).length || 0}
+                  )
+                </>
+              }
+              buttonId="offline"
+              isSelected={filter === "Offline"}
+              onChange={() => {
+                setFilter("Offline");
+              }}
+            />
+          </ToggleGroup>,
+        ]}
+        isColumnSortable={(column) => {
+          if (column !== "replicas") {
+            return {
+              columnIndex: SortColumns.indexOf(column),
+              label: "",
+              onSort: (_, __, dir) => setSort({ sort: column, dir }),
+              sortBy: {
+                index: SortColumns.indexOf(sort.sort),
+                direction: sort.dir,
+              },
+            };
+          }
+          return undefined;
+        }}
       />
     </PageSection>
   );
diff --git a/ui/components/table/TableView.tsx b/ui/components/table/TableView.tsx
index 378cc53db..a6a161b5c 100644
--- a/ui/components/table/TableView.tsx
+++ b/ui/components/table/TableView.tsx
@@ -247,7 +247,7 @@ export const TableView = <TRow, TCol>({
           {/* icon buttons */}
           {tools && (
             <>
-              <ToolbarItem variant="separator"></ToolbarItem>
+              {actions && <ToolbarItem variant="separator"></ToolbarItem>}
               <ToolbarGroup variant="icon-button-group">
                 {tools.map((t, idx) => (
                   <ToolbarItem key={idx}>{t}</ToolbarItem>