diff --git a/app.arc b/app.arc
index 28dd2106b7..d6338aa1bf 100644
--- a/app.arc
+++ b/app.arc
@@ -94,6 +94,16 @@ legacy_users
   email *String
   PointInTimeRecovery true
 
+kafka_acls
+  topicName *String
+  cognitoGroup **String
+  PointInTimeRecovery true
+
+kafka_acl_log
+  partitionKey *Number
+  syncedOn **Number
+  PointInTimeRecovery ture
+
 @tables-indexes
 email_notification_subscription
   topic *String
@@ -143,6 +153,11 @@ synonyms
   synonymId *String
   name synonymsByUuid
 
+kafka_acls
+  cognitoGroup *String
+  permissionType **String
+  name aclsByGroup
+
 @aws
 runtime nodejs20.x
 region us-east-1
diff --git a/app/lib/kafka.server.ts b/app/lib/kafka.server.ts
index dcaa60ba04..3f4ddf9def 100644
--- a/app/lib/kafka.server.ts
+++ b/app/lib/kafka.server.ts
@@ -5,13 +5,24 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+import { tables } from '@architect/functions'
+import { paginateScan } from '@aws-sdk/lib-dynamodb'
+import type { DynamoDBDocument } from '@aws-sdk/lib-dynamodb'
 import { Kafka } from 'gcn-kafka'
+import type { AclEntry } from 'kafkajs'
+import {
+  AclOperationTypes,
+  AclPermissionTypes,
+  AclResourceTypes,
+  ResourcePatternTypes,
+} from 'kafkajs'
 import memoizee from 'memoizee'
 
-import { domain, getEnvOrDie } from './env.server'
+import { domain, getEnvOrDieInProduction } from './env.server'
+import type { User } from '~/routes/_auth/user.server'
 
-const client_id = getEnvOrDie('KAFKA_CLIENT_ID')
-const client_secret = getEnvOrDie('KAFKA_CLIENT_SECRET')
+const client_id = getEnvOrDieInProduction('KAFKA_CLIENT_ID') ?? ''
+const client_secret = getEnvOrDieInProduction('KAFKA_CLIENT_SECRET')
 const kafka = new Kafka({
   client_id,
   client_secret,
@@ -68,3 +79,267 @@ if (process.env.ARC_SANDBOX) {
     await producer.send({ topic, messages: [{ value }] })
   }
 }
+
+export type KafkaACL = {
+  topicName: string
+  permissionType: PermissionType
+  cognitoGroup: string
+  prefixed: boolean
+}
+
+export type PermissionType = 'producer' | 'consumer'
+
+export const adminGroup = 'gcn.nasa.gov/gcn-admin'
+
+const consumerOperations = [AclOperationTypes.READ, AclOperationTypes.DESCRIBE]
+const producerOperations = [
+  AclOperationTypes.CREATE,
+  AclOperationTypes.WRITE,
+  AclOperationTypes.DESCRIBE,
+]
+
+const admin_client_id = getEnvOrDieInProduction('KAFKA_ADMIN_CLIENT_ID') ?? ''
+const admin_client_secret = getEnvOrDieInProduction('KAFKA_ADMIN_CLIENT_SECRET')
+const adminKafka = new Kafka({
+  client_id: admin_client_id,
+  client_secret: admin_client_secret,
+  domain,
+})
+
+function validateUser(user: User) {
+  if (!user.groups.includes(adminGroup))
+    throw new Response(null, { status: 403 })
+}
+
+export async function createKafkaACL(user: User, acl: KafkaACL) {
+  validateUser(user)
+  // Save to db
+  const db = await tables()
+  await db.kafka_acls.put(acl)
+
+  // Add to Kafka
+  const adminClient = adminKafka.admin()
+  await adminClient.connect()
+  await adminClient.createTopics({
+    topics: [
+      {
+        topic: acl.topicName,
+      },
+    ],
+  })
+  const acls =
+    acl.permissionType == 'producer'
+      ? createProducerAcls(acl)
+      : createConsumerAcls(acl)
+  await adminClient.createAcls({ acl: acls })
+  await adminClient.disconnect()
+}
+
+export async function getKafkaACLByTopicName(user: User, topicName: string) {
+  validateUser(user)
+  const db = await tables()
+  return (await db.kafka_acls.get({ topicName })) as KafkaACL
+}
+
+export async function getKafkaACLsFromDynamoDB(user: User, filter?: string) {
+  validateUser(user)
+  const db = await tables()
+  const client = db._doc as unknown as DynamoDBDocument
+  const TableName = db.name('kafka_acls')
+  const pages = paginateScan(
+    { client },
+    {
+      TableName,
+      FilterExpression: filter
+        ? 'contains(topicName, :filter) OR contains(cognitoGroup, :filter)'
+        : undefined,
+      ExpressionAttributeValues: filter
+        ? {
+            ':filter': filter,
+          }
+        : undefined,
+    }
+  )
+
+  const acls: KafkaACL[] = []
+  for await (const page of pages) {
+    const newACL = page.Items as KafkaACL[]
+    if (newACL) acls.push(...newACL)
+  }
+  return acls
+}
+
+export async function getKafkaTopicsForUser(user: User) {
+  validateUser(user)
+  const userGroups = user.groups.filter((x) =>
+    x.startsWith('gcn.nasa.gov/kafka-')
+  )
+  const db = await tables()
+  const items = (
+    await Promise.all([
+      ...userGroups.map((cognitoGroup) =>
+        db.kafka_acls.query({
+          IndexName: 'aclsByGroup',
+          KeyConditionExpression:
+            'cognitoGroup = :group AND permissionType = :permission',
+          ProjectionExpression: 'topicName',
+          ExpressionAttributeValues: {
+            ':group': cognitoGroup,
+            ':permission': 'consumer',
+          },
+        })
+      ),
+    ])
+  )
+    .filter((x) => x.Count && x.Count > 0)
+    .flatMap((x) => x.Items)
+    .map((x) => x.topicName)
+
+  return items
+}
+export async function getAclsFromBrokers() {
+  const adminClient = adminKafka.admin()
+  await adminClient.connect()
+  const acls = await adminClient.describeAcls({
+    resourceType: AclResourceTypes.TOPIC,
+    host: '*',
+    permissionType: AclPermissionTypes.ALLOW,
+    operation: AclOperationTypes.ANY,
+    resourcePatternType: ResourcePatternTypes.ANY,
+  })
+  await adminClient.disconnect()
+  const results: KafkaACL[] = []
+  for (const item of acls.resources) {
+    const topicName = item.resourceName
+    const prefixed = item.resourcePatternType === ResourcePatternTypes.PREFIXED
+    const producerRules = producerOperations.every((op) =>
+      item.acls.map((x) => x.operation).includes(op)
+    )
+    const producerGroup =
+      producerRules &&
+      [
+        ...new Set(
+          item.acls
+            .filter((acl) => producerOperations.includes(acl.operation))
+            .map((x) => x.principal)
+        ),
+      ][0]?.replace('User:', '')
+    const consumerRules = consumerOperations.every((op) =>
+      item.acls.map((x) => x.operation).includes(op)
+    )
+    const consumerGroup =
+      consumerRules &&
+      [
+        ...new Set(
+          item.acls
+            .filter((acl) => consumerOperations.includes(acl.operation))
+            .map((x) => x.principal)
+        ),
+      ][0]?.replace('User:', '')
+    if (producerRules && producerGroup)
+      results.push({
+        topicName,
+        permissionType: 'producer',
+        cognitoGroup: producerGroup,
+        prefixed,
+      })
+    if (consumerRules && consumerGroup)
+      results.push({
+        topicName,
+        permissionType: 'consumer',
+        cognitoGroup: consumerGroup,
+        prefixed,
+      })
+  }
+  return results
+}
+
+export async function deleteKafkaACL(user: User, acl: KafkaACL) {
+  validateUser(user)
+  const db = await tables()
+  await db.kafka_acls.delete({
+    topicName: acl.topicName,
+    cognitoGroup: acl.cognitoGroup,
+  })
+
+  const acls =
+    acl.permissionType == 'producer'
+      ? createProducerAcls(acl)
+      : createConsumerAcls(acl)
+
+  const adminClient = adminKafka.admin()
+  await adminClient.connect()
+  await adminClient.deleteAcls({ filters: acls })
+  await adminClient.disconnect()
+}
+
+function createProducerAcls(acl: KafkaACL): AclEntry[] {
+  // Create, Write, and Describe operations
+  return mapAclAndOperations(acl, producerOperations)
+}
+
+function createConsumerAcls(acl: KafkaACL): AclEntry[] {
+  // Read and Describe operations
+  return mapAclAndOperations(acl, consumerOperations)
+}
+
+function mapAclAndOperations(acl: KafkaACL, operations: AclOperationTypes[]) {
+  return operations.map((operation) => {
+    return {
+      resourceType: AclResourceTypes.TOPIC,
+      resourceName: acl.topicName,
+      resourcePatternType: acl.prefixed
+        ? ResourcePatternTypes.PREFIXED
+        : ResourcePatternTypes.LITERAL,
+      principal: `User:${acl.cognitoGroup}`,
+      host: '*',
+      operation,
+      permissionType: AclPermissionTypes.ALLOW,
+    }
+  })
+}
+
+export async function updateBrokersFromDb(user: User) {
+  const dbDefinedAcls = await getKafkaACLsFromDynamoDB(user)
+  const mappedAcls = dbDefinedAcls.flatMap((x) =>
+    x.permissionType === 'producer'
+      ? createProducerAcls(x)
+      : createConsumerAcls(x)
+  )
+
+  const adminClient = adminKafka.admin()
+  await adminClient.connect()
+  await adminClient.createAcls({ acl: mappedAcls })
+  await adminClient.disconnect()
+}
+
+export async function updateDbFromBrokers(user: User) {
+  const kafkaDefinedAcls = await getAclsFromBrokers()
+  const db = await tables()
+  await Promise.all([
+    ...kafkaDefinedAcls.map((acl) => db.kafka_acls.put(acl)),
+    db.kafka_acl_log.put({
+      partitionKey: 1,
+      syncedOn: Date.now(),
+      syncedBy: user.email,
+    }),
+  ])
+}
+
+type KafkaAclSyncLog = {
+  partitionKey: number
+  syncedOn: number
+  syncedBy: string
+}
+
+export async function getLastSyncDate(): Promise<KafkaAclSyncLog> {
+  const db = await tables()
+  return (
+    await db.kafka_acl_log.query({
+      KeyConditionExpression: 'partitionKey = :1',
+      ExpressionAttributeValues: { ':1': 1 },
+      ScanIndexForward: false,
+      Limit: 1,
+    })
+  ).Items.pop() as KafkaAclSyncLog
+}
diff --git a/app/root.tsx b/app/root.tsx
index 10ac78d99a..2ddbb06d45 100644
--- a/app/root.tsx
+++ b/app/root.tsx
@@ -46,6 +46,7 @@ import { useSpinDelay } from 'spin-delay'
 import invariant from 'tiny-invariant'
 
 import { features, getEnvOrDieInProduction, origin } from './lib/env.server'
+import { adminGroup } from './lib/kafka.server'
 import { DevBanner } from './root/DevBanner'
 import { Footer } from './root/Footer'
 import NewsBanner from './root/NewsBanner'
@@ -119,6 +120,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const recaptchaSiteKey = getEnvOrDieInProduction('RECAPTCHA_SITE_KEY')
   const userIsMod = user?.groups.includes(moderatorGroup)
   const userIsVerifiedSubmitter = user?.groups.includes(submitterGroup)
+  const userIsAdmin = user?.groups.includes(adminGroup)
 
   return {
     origin,
@@ -129,6 +131,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
     idp,
     userIsMod,
     userIsVerifiedSubmitter,
+    userIsAdmin,
   }
 }
 
@@ -168,6 +171,11 @@ export function useSubmitterStatus() {
   return userIsVerifiedSubmitter
 }
 
+export function useAdminStatus() {
+  const { userIsAdmin } = useLoaderDataRoot()
+  return userIsAdmin
+}
+
 export function useRecaptchaSiteKey() {
   const { recaptchaSiteKey } = useLoaderDataRoot()
   return recaptchaSiteKey
diff --git a/app/root/header/Header.tsx b/app/root/header/Header.tsx
index dde3947adc..61e3e9fcd7 100644
--- a/app/root/header/Header.tsx
+++ b/app/root/header/Header.tsx
@@ -17,7 +17,7 @@ import { useEffect, useState } from 'react'
 import { useClickAnyWhere, useWindowSize } from 'usehooks-ts'
 
 import { Meatball } from '~/components/meatball/Meatball'
-import { useEmail, useUserIdp } from '~/root'
+import { useAdminStatus, useEmail, useUserIdp } from '~/root'
 
 import styles from './header.module.css'
 
@@ -74,6 +74,7 @@ export function Header() {
   const [expanded, setExpanded] = useState(false)
   const [userMenuIsOpen, setUserMenuIsOpen] = useState(false)
   const isMobile = useWindowSize().width < 1024
+  const userIsAdmin = useAdminStatus()
 
   function toggleMobileNav() {
     setExpanded((expanded) => !expanded)
@@ -162,6 +163,11 @@ export function Header() {
                       <NavLink end key="user" to="/user">
                         Profile
                       </NavLink>,
+                      userIsAdmin && (
+                        <NavLink key="admin" to="/admin/kafka">
+                          Admin
+                        </NavLink>
+                      ),
                       <NavLink key="endorsements" to="/user/endorsements">
                         Peer Endorsements
                       </NavLink>,
diff --git a/app/routes/admin.kafka._index.tsx b/app/routes/admin.kafka._index.tsx
new file mode 100644
index 0000000000..482799e435
--- /dev/null
+++ b/app/routes/admin.kafka._index.tsx
@@ -0,0 +1,264 @@
+/*!
+ * Copyright © 2023 United States Government as represented by the
+ * Administrator of the National Aeronautics and Space Administration.
+ * All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@remix-run/node'
+import { useFetcher, useLoaderData } from '@remix-run/react'
+import type { ModalRef } from '@trussworks/react-uswds'
+import {
+  Button,
+  Grid,
+  Icon,
+  Label,
+  Modal,
+  ModalFooter,
+  ModalHeading,
+  ModalToggleButton,
+  TextInput,
+} from '@trussworks/react-uswds'
+import { useEffect, useRef, useState } from 'react'
+
+import { getUser } from './_auth/user.server'
+import HeadingWithAddButton from '~/components/HeadingWithAddButton'
+import SegmentedCards from '~/components/SegmentedCards'
+import Spinner from '~/components/Spinner'
+import TimeAgo from '~/components/TimeAgo'
+import type { KafkaACL, PermissionType } from '~/lib/kafka.server'
+import {
+  adminGroup,
+  createKafkaACL,
+  deleteKafkaACL,
+  getKafkaACLsFromDynamoDB,
+  getLastSyncDate,
+  updateDbFromBrokers,
+} from '~/lib/kafka.server'
+import { getFormDataString } from '~/lib/utils'
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const user = await getUser(request)
+  if (!user || !user.groups.includes(adminGroup))
+    throw new Response(null, { status: 403 })
+  const { aclFilter } = Object.fromEntries(new URL(request.url).searchParams)
+  const dynamoDbAclData = await getKafkaACLsFromDynamoDB(user, aclFilter)
+  const latestSync = await getLastSyncDate()
+  return { dynamoDbAclData, latestSync }
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  const user = await getUser(request)
+  if (!user?.groups.includes(adminGroup))
+    throw new Response(null, { status: 403 })
+  const data = await request.formData()
+  const intent = getFormDataString(data, 'intent')
+  if (intent === 'migrateFromBroker') {
+    await updateDbFromBrokers(user)
+    return null
+  }
+  const topicName = getFormDataString(data, 'topicName')
+  const permissionType = getFormDataString(
+    data,
+    'permissionType'
+  ) as PermissionType
+  const group = getFormDataString(data, 'group')
+  const includePrefixed = getFormDataString(data, 'includePrefixed')
+  if (!topicName || !permissionType || !group)
+    throw new Response(null, { status: 400 })
+  const promises = []
+
+  switch (intent) {
+    case 'delete':
+      promises.push(
+        deleteKafkaACL(user, {
+          topicName,
+          permissionType,
+          cognitoGroup: group,
+          prefixed: false,
+        })
+      )
+      break
+    case 'create':
+      promises.push(
+        createKafkaACL(user, {
+          topicName,
+          permissionType,
+          cognitoGroup: group,
+          prefixed: false,
+        })
+      )
+
+      if (includePrefixed)
+        promises.push(
+          createKafkaACL(user, {
+            topicName: `${topicName}.`,
+            permissionType,
+            cognitoGroup: group,
+            prefixed: true,
+          })
+        )
+      break
+    default:
+      break
+  }
+  await Promise.all(promises)
+
+  return null
+}
+
+export default function Index() {
+  const { dynamoDbAclData, latestSync } = useLoaderData<typeof loader>()
+  const [aclData, setAclData] = useState(dynamoDbAclData)
+  const updateFetcher = useFetcher<typeof action>()
+  const aclFetcher = useFetcher<typeof loader>()
+
+  useEffect(() => {
+    setAclData(aclFetcher.data?.dynamoDbAclData ?? aclData)
+  }, [aclFetcher.data, aclData])
+
+  return (
+    <>
+      <HeadingWithAddButton headingLevel={1}>Kafka</HeadingWithAddButton>
+      <h2>Kafka ACLs</h2>
+      <p className="usa-paragraph">
+        Kafka Access Control Lists (ACLs) are a security mechanism used to
+        control access to resources within a Kafka cluster. They define which
+        users or client applications have permissions to perform specific
+        operations on Kafka resources, such as topics, consumer groups, and
+        broker resources. ACLs specify who can produce (write) or consume (read)
+        data from topics, create or delete topics, manage consumer groups, and
+        perform administrative tasks.
+      </p>
+
+      <updateFetcher.Form method="POST" action="/admin/kafka">
+        <Button
+          type="submit"
+          name="intent"
+          value="migrateFromBroker"
+          disabled={updateFetcher.state !== 'idle'}
+        >
+          Pull ACLs from Broker
+        </Button>
+        {updateFetcher.state !== 'idle' && (
+          <span className="text-middle">
+            <Spinner /> Updating...
+          </span>
+        )}
+      </updateFetcher.Form>
+      {latestSync && (
+        <p>
+          Last synced by {latestSync.syncedBy}{' '}
+          <TimeAgo time={latestSync.syncedOn} />
+        </p>
+      )}
+      {aclData && (
+        <>
+          <aclFetcher.Form method="GET">
+            <Label htmlFor="aclFilter">Filter ({aclData.length} results)</Label>
+            <TextInput id="aclFilter" name="aclFilter" type="text" />
+            <Button
+              type="submit"
+              className="margin-y-1"
+              disabled={aclFetcher.state !== 'idle'}
+            >
+              Search
+            </Button>
+            {aclFetcher.state !== 'idle' && (
+              <span className="text-middle">
+                <Spinner /> Loading...
+              </span>
+            )}
+          </aclFetcher.Form>
+          <SegmentedCards>
+            {aclData
+              .sort((a, b) => a.topicName.localeCompare(b.topicName))
+              .map((x, index) => (
+                <KafkaAclCard key={index} acl={x} />
+              ))}
+          </SegmentedCards>
+        </>
+      )}
+    </>
+  )
+}
+
+function KafkaAclCard({ acl }: { acl: KafkaACL }) {
+  const ref = useRef<ModalRef>(null)
+  const fetcher = useFetcher()
+  const disabled = fetcher.state !== 'idle'
+
+  return (
+    <>
+      <Grid row style={disabled ? { opacity: '50%' } : undefined}>
+        <div className="tablet:grid-col flex-fill">
+          <div>
+            <small>
+              <strong>Topic:</strong> {acl.topicName}
+            </small>
+          </div>
+          <div>
+            <small>
+              <strong>Permission Type:</strong> {acl.permissionType}
+            </small>
+          </div>
+          <div>
+            <small>
+              <strong>Group:</strong> {acl.cognitoGroup}
+            </small>
+          </div>
+        </div>
+        <div className="tablet:grid-col flex-auto margin-y-auto">
+          <ModalToggleButton
+            opener
+            disabled={disabled}
+            modalRef={ref}
+            type="button"
+            className="usa-button--secondary"
+          >
+            <Icon.Delete
+              role="presentation"
+              className="bottom-aligned margin-right-05"
+            />
+            Delete
+          </ModalToggleButton>
+        </div>
+      </Grid>
+      <Modal
+        id="modal-delete"
+        ref={ref}
+        aria-labelledby="modal-delete-heading"
+        aria-describedby="modal-delete-description"
+        renderToPortal={false}
+      >
+        <fetcher.Form method="POST" action="/admin/kafka">
+          <input type="hidden" name="topicName" value={acl.topicName} />
+          <input type="hidden" name="group" value={acl.cognitoGroup} />
+          <input
+            type="hidden"
+            name="permissionType"
+            value={acl.permissionType}
+          />
+          <ModalHeading id="modal-delete-heading">
+            Delete Kafka ACL
+          </ModalHeading>
+          <p id="modal-delete-description">
+            This will delete the DynamoDB entry and{' '}
+            {acl.permissionType == 'consumer'
+              ? '"read" and "describe"'
+              : '"create", "write", and "describe"'}{' '}
+            Kafka ACLs. Do you wish to continue?
+          </p>
+          <ModalFooter>
+            <ModalToggleButton modalRef={ref} closer outline>
+              Cancel
+            </ModalToggleButton>
+            <Button data-close-modal type="submit" name="intent" value="delete">
+              Delete
+            </Button>
+          </ModalFooter>
+        </fetcher.Form>
+      </Modal>
+    </>
+  )
+}
diff --git a/app/routes/admin.kafka.edit.tsx b/app/routes/admin.kafka.edit.tsx
new file mode 100644
index 0000000000..7d9af231a1
--- /dev/null
+++ b/app/routes/admin.kafka.edit.tsx
@@ -0,0 +1,95 @@
+/*!
+ * Copyright © 2023 United States Government as represented by the
+ * Administrator of the National Aeronautics and Space Administration.
+ * All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { LoaderFunctionArgs } from '@remix-run/node'
+import { Form, useLoaderData } from '@remix-run/react'
+import {
+  Button,
+  Checkbox,
+  Label,
+  Select,
+  TextInput,
+} from '@trussworks/react-uswds'
+
+import { getUser } from './_auth/user.server'
+import { getGroups } from '~/lib/cognito.server'
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const user = await getUser(request)
+  if (!user) throw new Response(null, { status: 403 })
+  const userGroups = (await getGroups())
+    .filter((group) => group.GroupName?.startsWith('gcn.nasa.gov/'))
+    .map((group) => group.GroupName)
+
+  return { userGroups }
+}
+
+export default function Kafka() {
+  const { userGroups } = useLoaderData<typeof loader>()
+  return <KafkaAclForm groups={userGroups} />
+}
+
+function KafkaAclForm({ groups }: { groups: string[] }) {
+  return (
+    <>
+      <h1>Create Kafka ACLs</h1>
+      <Form method="POST" action="/admin/kafka">
+        <Label htmlFor="name">
+          Topic
+          <span title="required" className="usa-label--required">
+            *
+          </span>
+        </Label>
+        <TextInput
+          autoFocus
+          id="topicName"
+          name="topicName"
+          type="text"
+          autoCapitalize="off"
+          autoCorrect="off"
+          required
+          onChange={(e) => console.log(e.target.value)}
+        />
+        <Label htmlFor="permissionType">Permission</Label>
+        <Select id="permissionType" name="permissionType">
+          <option value="producer">Producer</option>
+          <option value="consumer">Consumer</option>
+        </Select>
+        <small>
+          Producer will generate ACLs for the Create, Write, and Describe
+          operations. Consumer will generate ACLs for the Read and Describe
+          operations
+        </small>
+        <Label htmlFor="group">Group</Label>
+        <Select id="group" name="group">
+          {groups.map((group) => (
+            <option key={group} value={group}>
+              {group}
+            </option>
+          ))}
+        </Select>
+        <Checkbox
+          id="includePrefixed"
+          name="includePrefixed"
+          label="Generate both Prefixed and Literal Topics?"
+        />
+        <div className="margin-bottom-1">
+          <small>
+            If yes, submission will also trigger th generation of ACLs for the
+            provided topic name as a PREFIXED topic with a period included at
+            the end. For example, if checked, a topic of `gcn.notices.icecube`
+            will result in ACLs for both `gcn.notices.icecube` (literal) and
+            `gcn.notices.icecube.` (prefixed).
+          </small>
+        </div>
+        <Button type="submit" name="intent" value="create">
+          Submit
+        </Button>
+      </Form>
+    </>
+  )
+}
diff --git a/app/routes/admin.tsx b/app/routes/admin.tsx
index a385863072..0531f8c358 100644
--- a/app/routes/admin.tsx
+++ b/app/routes/admin.tsx
@@ -27,6 +27,9 @@ export default function () {
         <div className="desktop:grid-col-3">
           <SideNav
             items={[
+              <NavLink key="kafka" to="kafka" end>
+                Kafka
+              </NavLink>,
               <NavLink key="users" to="users" end>
                 Users
               </NavLink>,
diff --git a/playwright.config.ts b/playwright.config.ts
index 5aa5401b45..76bf15d536 100644
--- a/playwright.config.ts
+++ b/playwright.config.ts
@@ -4,7 +4,6 @@ import { defineConfig, devices } from '@playwright/test'
  * Read environment variables from file.
  * https://github.com/motdotla/dotenv
  */
-// require('dotenv').config();
 
 const deviceList = ['Desktop Firefox', 'Desktop Chrome', 'Desktop Safari']
 
@@ -69,7 +68,6 @@ export default defineConfig({
     command: 'npm run dev',
     url: 'http://localhost:3333',
     reuseExistingServer: !process.env.CI,
-    stdout: 'pipe',
     timeout: 120 * 1000, // 120 Seconds timeout on webServer
   },
 })
diff --git a/sandbox-seed.json b/sandbox-seed.json
index 35534487e4..448b71353e 100644
--- a/sandbox-seed.json
+++ b/sandbox-seed.json
@@ -5155,5 +5155,19 @@
       "requestorEmail": "example@example.com",
       "subject": "Optical Observations for GRB 971227"
     }
+  ],
+  "kafka_acls": [
+    {
+      "topicName": "test_topic_created_from_website",
+      "permissionType": "consumer",
+      "cognitoGroup": "gcn.nasa.gov/kafka-gcn-test-consumer",
+      "prefixed": false
+    },
+    {
+      "topicName": "test_topic_created_from_website",
+      "permissionType": "producer",
+      "cognitoGroup": "gcn.nasa.gov/kafka-gcn-test-producer",
+      "prefixed": false
+    }
   ]
 }