diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b0b40a8233..86825ab7ed 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -424,6 +424,27 @@ jobs:
 
     steps: *build-package-steps
 
+  build-ipk:
+    needs: [validation]
+    if: github.event_name == 'push'
+    runs-on: ubuntu-24.04
+    name: "Build photon-sc-app IPK"
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Make build script executable
+        run: chmod +x photon-sc-app/build.sh
+      - name: Build IPK
+        working-directory: photon-sc-app
+        run: ./build.sh
+      - name: Upload IPK artifact
+        uses: actions/upload-artifact@v7
+        with:
+          archive: false
+          name: photon-sc-ipk
+          path: '*.ipk'
+
   run-smoketest-native:
     needs: [build-package-linux, build-package-macos, build-package-windows]
 
@@ -629,7 +650,7 @@ jobs:
 
   release:
     # Require smoketest-native so that if those fail, we don't release broken artifacts
-    needs: [build-photonlib-vendorjson, build-image, combine, build-package-linux, build-package-macos, build-package-windows, run-smoketest-native]
+    needs: [build-photonlib-vendorjson, build-image, combine, build-package-linux, build-package-macos, build-package-windows, run-smoketest-native, build-ipk]
     if: (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v')) && github.repository == 'PhotonVision/photonvision'
     runs-on: ubuntu-24.04
     steps:
@@ -652,6 +673,11 @@ jobs:
         with:
           merge-multiple: true
           pattern: photonvision-*.xz
+      # Download IPK package
+      - uses: actions/download-artifact@v8
+        with:
+          name: photon-sc-ipk
+          path: .
 
       - run: find
       # Push to dev release
@@ -667,6 +693,7 @@ jobs:
             **/*win*.jar
             **/photonlib*.json
             **/photonlib*.zip
+            **/*.ipk
         if: github.event_name == 'push'
       - name: Create Vendor JSON Repo PR
         uses: wpilibsuite/vendor-json-repo/.github/actions/add_vendordep@HEAD
diff --git a/.gitignore b/.gitignore
index 032a1d7e11..5406f830d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -150,6 +150,13 @@ dist-ssr
 components.d.ts
 photon-server/src/main/resources/web/index.html
 
+# photon-sc-app IPK build artifacts
+photon-sc-app/build/
+photon-sc-app/*.ipk
+
+# NT4 persist files
+photon-sc-app/*.json
+
 # Playwright
 photon-client/test-results/
 photon-client/playwright-report/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..1660f315e6
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,75 @@
+# AGENTS.md
+
+## Repo overview
+
+Monorepo with three package systems:
+- **Gradle** multi-project (Java 25, C++) -- root `./gradlew`
+- **pnpm** workspaces -- `photon-client/` (Vue 3 + Vuetify 3 SPA) and `website/` (Vite SSG marketing site)
+- **Python** -- `photon-lib/py/` (photonlibpy wheel, pytest + mypy)
+
+Key Gradle subprojects (defined in `settings.gradle`):
+- `photon-server` -- fat JAR entrypoint (`org.photonvision.Main.main()`, port **5800**)
+- `photon-core` -- vision pipelines, hardware manager, config
+- `photon-targeting` -- native C++ AprilTag + JNI
+- `photon-lib` -- robot-side vendor library (Java, C++, Python)
+- `photon-docs` -- JavaDoc + Doxygen
+
+## Commands (run from repo root)
+
+| What | Command |
+|------|---------|
+| Full app (backend + frontend) | `./gradlew run` |
+| Build all Java/C++ | `./gradlew build` |
+| Run Java tests | `./gradlew test` |
+| Java format | `./gradlew spotlessApply` |
+| Cross-compile toolchain | `./gradlew installArm64Toolchain` |
+| Deploy to coprocessor | `./gradlew deploy -PArchOverride=linuxarm64` |
+| Frontend dev (hot reload) | `pnpm dev` (in `photon-client/`) |
+| Frontend type-check | `pnpm type-check` (in `photon-client/`) |
+| Frontend lint/format | `pnpm lint` / `pnpm format` (in `photon-client/`) |
+| E2E tests (Playwright) | `pnpm test` (auto-starts `./gradlew run`) |
+| Python tests | `pytest` (in `photon-lib/py/`) |
+
+Use `pnpm` not `npm` for JS packages.
+
+## Frontend conventions
+
+- **Formatter**: Prettier — `semi: true`, `singleQuote: false`, `tabWidth: 2`, `printWidth: 120`, `trailingComma: "none"`
+- **Linter**: ESLint 9 flat config — enforces same style as Prettier
+- **Router**: hash-based (`/#/dashboard`, `/#/cameras`, `/#/settings`, `/#/cameraConfigs`, `/#/docs`)
+- **API base**: `http://{host}:5800/api` (Axios baseURL set automatically in `src/main.ts`)
+- **Path alias**: `@` → `src/`
+- **State**: Pinia stores in `src/stores/`, key store is `StateStore`
+- **WebSocket**: `ws://{host}:5800/websocket_data` for real-time data
+
+## Ports
+
+- App UI + API: **5800**
+- Vite dev server (photon-client): default Vite port (usually 5173)
+
+## Build artifacts
+
+- `photon-server/build/libs/photonvision.jar` (fat JAR via Shadow plugin)
+- `photon-client/dist/` (built SPA, served by Gradle during `./gradlew run`)
+- `photon-lib/py/dist/` (Python wheel)
+
+## Testing quirks
+
+- Playwright tests expect `./gradlew run` on port 5800 (auto-configured in `playwright.config.ts`)
+- Java tests use JUnit 5 (Jupiter) with JaCoCo coverage
+- Python tests use pytest + mypy type checking
+- CI runs typecheck-client (`vue-tsc --noEmit`) before Playwright
+
+## CI workflows
+
+- `build.yml` — main CI: typecheck, Playwright, Gradle build/test, cross-compile, IPK, disk images, smoketests
+- `lint-format.yml` — wpiformat, Spotless, ESLint + Prettier
+- `python.yml` — Python wheel build, pytest, mypy, PyPI publish
+- `website.yml` — marketing site build + deploy
+- `photon-api-docs.yml` — JavaDoc + Doxygen publish
+
+## Repository quick reference
+
+- Non-obvious dirs: `photon-serde/` (YAML→Java/C++/Python codegen), `photon-sc-app/` (IPK packaging), `test-resources/` (test images/configs)
+- Version: WPILib 2027.0.0-alpha-6, JDK 25, Node 24, Python 3.14, Gradle 9.4.0
+- License: GPL-3.0
diff --git a/photon-sc-app/README.md b/photon-sc-app/README.md
new file mode 100644
index 0000000000..1fea03ea47
--- /dev/null
+++ b/photon-sc-app/README.md
@@ -0,0 +1,128 @@
+# photon-sc-app
+
+IPK-packaged dashboard aggregator for PhotonVision. Runs on a coprocessor (SystemCore / Orange Pi 5) and provides a tabbed web UI that auto-discovers all PhotonVision camera coprocessors on the FRC team network, loading each into its own iframe.
+
+## How to build
+
+```sh
+bash build.sh
+```
+
+Produces `photon-sc-app_1.0.0.ipk` in the current directory.
+
+## How to develop
+
+```sh
+bash run_local.sh
+```
+
+Opens a dev server at `http://127.0.0.1:8080`. The web UI is served from the `www/` directory — refresh the browser to see changes. Pass `--team 5123` to enable FRC network scanning, or `--help` to see all options.
+
+## File layout
+
+| Path | Purpose |
+|------|---------|
+| `build.sh` | Assembles the IPK: copies overlay/ into a directory, merges control/ files, tars both, wraps with `ar` |
+| `run_local.sh` / `run_local.bat` | Launches `photon_sc_app.py --local` for development without systemd |
+| `control/` | OPKG metadata (`control`) and lifecycle scripts (`postinst`, `prerm`, `postrm`) |
+| `overlay/` | Filesystem tree installed verbatim to the target coprocessor root |
+| `overlay/usr/local/bin/photon-sc-app/photon_sc_app.py` | Python HTTP server entrypoint |
+| `overlay/usr/local/bin/photon-sc-app/discovery/` | Network discovery strategies (one module per strategy) |
+| `overlay/usr/local/bin/photon-sc-app/www/` | Web frontend (HTML, CSS, JS) |
+| `overlay/etc/systemd/system/` | Systemd socket + service units for production |
+| `overlay/usr/share/photon-sc-app.png` | App icon for SystemCore launcher |
+
+## Requirements
+
+### Web UI
+
+A dark-themed single-page app served from a built-in Python HTTP `ThreadingHTTPServer`. No build step, no framework — just static HTML/CSS/JS served from `www/`. The UI must:
+
+- Display a horizontal tab bar. Each tab is a `<button>` labeled with the discovered coprocessor's IP address.
+- Show a full-height `<iframe>` that loads the selected coprocessor's PhotonVision dashboard (port 5800). The iframe sandbox attribute is `allow-scripts allow-same-origin allow-forms` — the iframe lives on a separate origin (the coprocessor IP), so same-origin restrictions do not block cross-origin content.
+- Include a "Update Clients" button that re-fetches the tab list from the backend. The page load also triggers the initial fetch.
+- Display an empty state message ("No clients found") when no coprocessors are discovered, so the user knows the discovery is running but hasn't found anything yet.
+
+A dark palette (`#101820` background, `#1a67d0` accent blue, tabs with active bottom-border highlight) keeps visual consistency with the PhotonVision brand. The tab bar sits above the iframe, separated from the content area by a thin border, so the user always knows which coprocessor they're viewing.
+
+### Front-end / back-end communication
+
+The web UI communicates with *this* Python server (not with the remote PhotonVision coprocessor directly) via two HTTP endpoints served on the same host:port:
+
+| Endpoint | Method | Response | Purpose |
+|----------|--------|----------|---------|
+| `/tabs` | GET | `{"tabs": [{"title": "10.51.23.42", "url": "http://10.51.23.42:5800"}, ...]}` | Returns the cached list of discovered coprocessors. The frontend calls this on page load and when the user clicks "Update Clients". |
+| `/status` or `/health` | GET | `{"service": "...", "status": "running", "socket_activated": true/false, "pid": ..., "timestamp": "..."}` | Health check for system monitoring / orchestration. |
+
+All other paths serve static files from `www/`. The `/` and `/index.html` paths are both mapped to serve `index.html`.
+
+This design means the frontend never needs to know about network discovery, caching intervals, or the remote coprocessor's availability. The backend handles all of that and serves a single, simple JSON contract.
+
+### Backend discovery strategies
+
+The backend finds PhotonVision coprocessors by running four parallel strategies in a background thread (driven by `DiscoveryCache`). Results are cached and served instantly via `/tabs` without blocking.
+
+**Why four strategies:** The FRC pit environment is unpredictable. A coprocessor may be reachable via mDNS, or only by its static IP on the team subnet, or only via NetworkTables if it's publishing robot data. Each strategy covers a different failure mode:
+
+1. **mDNS** — resolves `photonvision.local` via `socket.gethostbyname()`. Requires avahi-daemon or similar running on the coprocessor. Fast and zero-config, but not all networks have working mDNS.
+
+2. **Network scan** — pings every host on the FRC team subnet (`10.TE.AM.0/24`). Derives the subnet from the `--team` argument (e.g., team 5123 → `10.51.23.1-254`). Slow (254 pings) but finds any coprocessor on the wired team network regardless of hostname resolution.
+
+3. **Port 5800 check** — TCP-connects to port 5800 on candidate IPs (from mDNS and network scan results). Filters out non-PhotonVision hosts. The 2-second timeout per connection avoids hanging on dead IPs.
+
+4. **NetworkTables** — queries the `/photonvision` table via ntcore for IP addresses published by PhotonVision instances. Requires ntcore installed. Useful as a supplement when other strategies miss a coprocessor that is publishing NT data.
+
+**Fast vs. slow intervals:** mDNS and port checks run every 10 seconds (fast). Network scan and NetworkTables run every 60 seconds (slow). This avoids flooding the team network with pings while still providing near-real-time tab updates for strategies that are cheap.
+
+**Caching:** `DiscoveryCache` stores results and serves them synchronously to `/tabs` requests. The background thread never blocks the HTTP server. If discovery fails, the last known good tab list remains visible rather than disappearing — the empty state only shows when no coprocessors have ever been found since the service started.
+
+### Production deployment
+
+Production uses systemd socket activation (port 9002). Only the `.socket` unit is enabled — the service starts on-demand when a connection arrives, then stays running. The `postinst` script in the IPK handles enabling and starting the socket unit automatically.
+
+## NetworkTables structure (reference)
+
+Confirmed by inspecting the actual PV source code (`NetworkTablesManager.java`, `NTTopicSet.java`, `NTDataPublisher.java`, `PhotonCamera.java`).
+
+Each PV coprocessor publishes camera data under `/photonvision/{CAMERA_NAME}/`. A subtable is a valid PV camera **if and only if** it has a `rawBytes` entry. This is the same detection logic `PhotonCamera.java` uses on the robot side.
+
+**Key topics per camera:**
+
+| Topic | Type | Purpose |
+|-------|------|---------|
+| `rawBytes` | raw | Primary pipeline result packet (type `"photonstruct:PhotonPipelineResult:{UUID}"`) |
+| `heartbeat` | int64 | Increments each frame — used to detect connectivity |
+| `pipelineIndexState` / `pipelineIndexRequest` | int64 | Active pipeline index (bidirectional) |
+| `driverMode` / `driverModeRequest` | bool | Driver mode toggle (bidirectional) |
+| `latencyMillis` | double | Pipeline latency |
+| `fps` | double | Frames per second |
+| `hasTarget` | bool | Whether the current frame has a target |
+| `targetPitch`, `targetYaw`, `targetArea`, `targetSkew` | double | Best target scalar values |
+| `cameraIntrinsics` | double[] (9) | Camera calibration matrix |
+| `cameraDistortion` | double[] (up to 8) | Camera distortion coefficients |
+
+**Coprocessor metadata** (published once at startup):
+
+| Topic | Type |
+|-------|------|
+| `/photonvision/coprocessors/{MAC}/hostname` | string |
+| `/photonvision/coprocessors/{MAC}/cameraNames` | string[] |
+| `/photonvision/version` | string |
+| `/photonvision/buildDate` | string |
+
+**System metrics** (published each cycle):
+
+| Topic | Type |
+|-------|------|
+| `/photonvision//metrics/{HOSTNAME}` | protobuf `DeviceMetrics` (includes `ipAddress`) |
+
+NT discovery connects to the roboRIO's NT server (port 1735, identified by team number), enumerates subtables under `/photonvision/`, confirms each by checking for `rawBytes`, reads coprocessor hostnames from the metadata, and resolves them to IPs via mDNS.
+
+## Roadmap / TODO
+
+- [x] **Implement proper NetworkTables table layout.** Rewrote `networktables_discovery.py` to connect to the roboRIO NT server, enumerate subtables under `/photonvision/`, validate cameras by checking for `rawBytes` (same logic as `PhotonCamera.java`), read coprocessor hostnames from `/photonvision/coprocessors/{MAC}/hostname`, and resolve via mDNS.
+- [ ] **Test on a real SystemCore.** Validate the IPK installs, socket activates, discovery finds coprocessors, and the web UI renders correctly.
+- [ ] **Prefer mDNS hostnames over raw IPs.** When mDNS resolves a coprocessor, use its hostname (e.g., `http://photonvision.local:5800`) in the tab URL instead of its IP. Fall back to IP when mDNS is unavailable. This keeps tabs working if the coprocessor's DHCP lease changes.
+- [ ] **Expose rich coprocessor info in the UI.** Show metadata alongside each tab — hostname, camera count, pipeline name, version, connection quality — without cluttering the tab bar. Options: tooltip on tab hover, a subtitle row below the tab bar, or a collapsible sidebar.
+- [ ] **Test error conditions.** Validate behavior when: ping sweep succeeds but port 5800 is unreachable; NT is unavailable; a previously discovered coprocessor goes offline; mDNS resolves intermittently; the team network has non-PV hosts on port 5800. Ensure the UI degrades gracefully (shows empty state, re-attempts discovery, doesn't cache stale entries that fail to load).
+- [ ] **Check "likely a PV coprocessor" NT client IPs.** Cross-reference IPs from NT `/photonvision` entries with mDNS and port-scan results. Build a confidence score so the UI can prefer verified PV instances over speculative ones.
diff --git a/photon-sc-app/build.sh b/photon-sc-app/build.sh
new file mode 100644
index 0000000000..dfbaa2d2ef
--- /dev/null
+++ b/photon-sc-app/build.sh
@@ -0,0 +1,94 @@
+#!/bin/bash
+
+set -e
+
+# Extract package info from control/control file
+if [ ! -f "control/control" ]; then
+    echo "Error: control/control not found!"
+    echo "Create a control/control file with package metadata"
+    exit 1
+fi
+
+# Parse package name and version from control file
+PACKAGE_NAME=$(grep "^Package:" control/control | cut -d' ' -f2- | tr -d ' ')
+PACKAGE_VERSION=$(grep "^Version:" control/control | cut -d' ' -f2- | tr -d ' ')
+
+# Validate required fields
+if [ -z "$PACKAGE_NAME" ] || [ -z "$PACKAGE_VERSION" ]; then
+    echo "Err: Package and Version must be set in control/control"
+    echo "Package: my-package"
+    echo "Version: 1.0.0"
+    exit 1
+fi
+
+PACKAGE_DIR="${PACKAGE_NAME}_${PACKAGE_VERSION}"
+BUILD_DIR="build"
+
+echo "Building IPK package from overlay structure..."
+echo "Package: ${PACKAGE_NAME}_${PACKAGE_VERSION}.ipk"
+
+if [ ! -d "overlay" ]; then
+    echo "overlay/ directory not found"
+    exit 1
+fi
+
+if [ ! -d "control" ]; then
+    echo "Error: control/ directory not found!"
+    echo "Create control/ with control, postinst, prerm, postrm files"
+    exit 1
+fi
+
+echo "Cleaning previous build..."
+rm -rf "$BUILD_DIR"
+mkdir -p "$BUILD_DIR/$PACKAGE_DIR"
+
+echo "Copying overlay structure..."
+cp -r overlay/* "$BUILD_DIR/$PACKAGE_DIR/"
+
+echo "Copying CONTROL files..."
+mkdir -p "$BUILD_DIR/$PACKAGE_DIR/CONTROL"
+cp control/* "$BUILD_DIR/$PACKAGE_DIR/CONTROL/"
+
+echo "Setting file permissions..."
+
+# Make scripts executable
+find "$BUILD_DIR/$PACKAGE_DIR" -name "*.py" -exec chmod +x {} \;
+
+if [ -d "$BUILD_DIR/$PACKAGE_DIR/CONTROL" ]; then
+    chmod +x "$BUILD_DIR/$PACKAGE_DIR/CONTROL"/* 2>/dev/null || true
+fi
+
+find "$BUILD_DIR/$PACKAGE_DIR" -name "*.sh" -exec chmod +x {} \;
+
+echo "Building IPK dir structure"
+cd "$BUILD_DIR"
+
+echo "Creating data.tar.gz"
+tar --exclude='CONTROL' -czf data.tar.gz -C "$PACKAGE_DIR" .
+
+echo "Creating control.tar.gz"
+tar -czf control.tar.gz -C "$PACKAGE_DIR/CONTROL" .
+
+echo "Creating IPK..."
+ar r "../${PACKAGE_NAME}_${PACKAGE_VERSION}.ipk" control.tar.gz data.tar.gz
+
+cd ..
+
+echo ""
+echo "IPK package created."
+echo "Package: ${PACKAGE_NAME}_${PACKAGE_VERSION}.ipk"
+echo ""
+echo "Package structure:"
+echo "  CONTROL files:"
+find control -type f | sort | sed 's/^/    /'
+echo "  Overlay files (will be installed):"
+find overlay -type f | sort | sed 's/^overlay/    /' | head -15
+
+if [ $(find overlay -type f | wc -l) -gt 15 ]; then
+    echo "    ... and $(($(find overlay -type f | wc -l) - 15)) more files"
+fi
+
+rm -rf "$BUILD_DIR"
+
+echo ""
+echo "Build complete"
\ No newline at end of file
diff --git a/photon-sc-app/control/control b/photon-sc-app/control/control
new file mode 100644
index 0000000000..9da746e655
--- /dev/null
+++ b/photon-sc-app/control/control
@@ -0,0 +1,12 @@
+Package: photon-sc-app
+Version: 1.0.0
+Description: PhotonVision SystemCore App
+Section: development
+Priority: optional
+Maintainer: PhotonVision
+Architecture: all
+Source: local
+X-Port: 9042
+X-Has-UI: true
+X-Auto-Start: false
+X-Icon-Path: /usr/share/photon-sc-app.png
\ No newline at end of file
diff --git a/photon-sc-app/control/postinst b/photon-sc-app/control/postinst
new file mode 100644
index 0000000000..9879873262
--- /dev/null
+++ b/photon-sc-app/control/postinst
@@ -0,0 +1,42 @@
+#!/bin/sh
+PACKAGE_NAME="photon-sc-app"
+
+echo "Setting up socket activation for $PACKAGE_NAME"
+
+# Stop any existing instances (cleanup from previous versions)
+systemctl stop $PACKAGE_NAME.service 2>/dev/null || true
+systemctl stop $PACKAGE_NAME.socket 2>/dev/null || true
+systemctl disable $PACKAGE_NAME.service 2>/dev/null || true
+systemctl daemon-reload
+
+# Enable ONLY the socket unit
+if systemctl enable $PACKAGE_NAME.socket; then
+    echo "Socket unit enabled successfully"
+else
+    echo "Failed to enable socket unit"
+    exit 1
+fi
+
+# Start listening
+if systemctl start $PACKAGE_NAME.socket; then
+    echo "Socket started successfully"
+else
+    echo "Failed to start socket"
+    systemctl status $PACKAGE_NAME.socket --no-pager
+    exit 1
+fi
+
+# Verify
+sleep 1
+
+if systemctl is-active --quiet $PACKAGE_NAME.socket; then
+    echo "Socket activation configured successfully."
+else
+    echo "Socket failed to activate"
+    echo "Debug info:"
+    systemctl status $PACKAGE_NAME.socket --no-pager || true
+    journalctl -u $PACKAGE_NAME.socket --no-pager -n 10 || true
+    exit 1
+fi
+
+exit 0
\ No newline at end of file
diff --git a/photon-sc-app/control/postrm b/photon-sc-app/control/postrm
new file mode 100644
index 0000000000..26cea64f40
--- /dev/null
+++ b/photon-sc-app/control/postrm
@@ -0,0 +1,17 @@
+#!/bin/sh
+PACKAGE_NAME="photon-sc-app"
+
+echo "Cleaning up socket activation for $PACKAGE_NAME"
+
+systemctl daemon-reload
+systemctl reset-failed $PACKAGE_NAME.socket 2>/dev/null || true
+systemctl reset-failed $PACKAGE_NAME.service 2>/dev/null || true
+
+if systemctl list-units --all | grep -q "$PACKAGE_NAME"; then
+    echo "Some $PACKAGE_NAME units may still be present (this is normal until reboot)"
+else
+    echo "All $PACKAGE_NAME units cleaned up"
+fi
+
+echo "Socket activation cleanup completed"
+exit 0
\ No newline at end of file
diff --git a/photon-sc-app/control/prerm b/photon-sc-app/control/prerm
new file mode 100644
index 0000000000..dcaafb37b9
--- /dev/null
+++ b/photon-sc-app/control/prerm
@@ -0,0 +1,25 @@
+#!/bin/sh
+PACKAGE_NAME="photon-sc-app"
+
+echo "Stopping socket activation for $PACKAGE_NAME"
+
+if systemctl stop $PACKAGE_NAME.socket 2>/dev/null; then
+    echo "Socket stopped"
+else
+    echo "Socket was not running"
+fi
+
+if systemctl stop $PACKAGE_NAME.service 2>/dev/null; then
+    echo "Service stopped"
+else
+    echo "Service was not running"
+fi
+
+if systemctl disable $PACKAGE_NAME.socket 2>/dev/null; then
+    echo "Socket disabled"
+else
+    echo " Socket was not enabled"
+fi
+
+echo "Socket activation stopped and disabled"
+exit 0
\ No newline at end of file
diff --git a/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.service b/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.service
new file mode 100644
index 0000000000..e24baff1d5
--- /dev/null
+++ b/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.service
@@ -0,0 +1,27 @@
+[Unit]
+Description=PhotonVision SystemCore App service
+Requires=photon-sc-app.socket
+After=photon-sc-app.socket
+DefaultDependencies=no
+
+[Service]
+Type=simple
+User=root
+Group=root
+ExecStart=/usr/local/bin/photon-sc-app/photon_sc_app.py
+
+Restart=no
+
+KillMode=mixed
+TimeoutStopSec=3
+
+
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/log
+
+#don't enable this service unit
+[Install]
+#########
\ No newline at end of file
diff --git a/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.socket b/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.socket
new file mode 100644
index 0000000000..772495ec46
--- /dev/null
+++ b/photon-sc-app/overlay/etc/systemd/system/photon-sc-app.socket
@@ -0,0 +1,18 @@
+[Unit]
+Description=photon-sc-app Socket
+
+[Socket]
+ListenStream=9002
+Accept=no
+
+SocketUser=root
+SocketGroup=root
+SocketMode=0660
+
+NoDelay=true
+KeepAlive=true
+
+DefaultDependencies=no
+
+[Install]
+WantedBy=sockets.target
\ No newline at end of file
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/__init__.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/__init__.py
new file mode 100644
index 0000000000..8b694e71a7
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/__init__.py
@@ -0,0 +1,8 @@
+"""Discovery suite for finding PhotonVision dashboards on the network.
+
+Provides multiple strategies to locate PhotonVision instances:
+- mDNS discovery via photonvision.local
+- Network scanning on FRC team networks (10.TE.AM.XX)
+- Port 5800 verification
+- NetworkTables client discovery
+"""
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/aggregator.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/aggregator.py
new file mode 100644
index 0000000000..f7e04a7284
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/aggregator.py
@@ -0,0 +1,113 @@
+"""Discovery aggregator - combines multiple strategies into a single list.
+
+This module orchestrates all discovery strategies:
+1. mDNS (photonvision.local)
+2. Network scanning (10.TE.AM.XX)
+3. Port 5800 verification
+4. NetworkTables discovery (validates cameras on the roboRIO's NT server)
+
+Results are merged, deduplicated, and returned as a list of tabs
+for the dashboard UI.
+"""
+
+import logging
+from typing import Dict, List, Optional, Set
+
+from .mdns_discovery import discover_mdns
+from .network_scan_discovery import discover_network_scan
+from .networktables_discovery import discover_networktables
+from .port_check_discovery import verify_port_5800
+
+logger = logging.getLogger(__name__)
+
+
+def discover_all(
+    team_number: Optional[int] = None,
+    enable_mdns: bool = True,
+    enable_network_scan: bool = True,
+    enable_port_check: bool = True,
+    enable_networktables: bool = True,
+) -> List[Dict[str, str]]:
+    """Discover all PhotonVision dashboards using multiple strategies.
+
+    Runs all enabled discovery strategies and combines results:
+    - mDNS resolution of photonvision.local
+    - Network scanning of 10.TE.AM.0/24
+    - Verification of port 5800 accessibility
+    - NetworkTables discovery (connects to roboRIO NT server to find
+      coprocessors publishing camera data)
+
+    NT-discovered hostnames are cross-referenced with IPs from other
+    strategies. Duplicates are removed and results are sorted.
+
+    Args:
+        team_number: FRC team number for network scanning and NT server
+                     discovery (e.g., 5123).
+        enable_mdns: Whether to attempt mDNS discovery.
+        enable_network_scan: Whether to scan the team network.
+        enable_port_check: Whether to verify port 5800 accessibility.
+        enable_networktables: Whether to use NetworkTables discovery.
+
+    Returns:
+        List of dicts with "title" and "url" keys, one per discovered dashboard.
+        Empty list if no dashboards found.
+    """
+    all_candidates: Set[str] = set()
+
+    # Strategy 0: mDNS discovery
+    if enable_mdns:
+        try:
+            mdns_results = discover_mdns()
+            if mdns_results:
+                logger.info("mDNS discovery found %d candidates", len(mdns_results))
+            all_candidates.update(mdns_results)
+        except Exception as e:
+            logger.error("mDNS discovery error: %s", e)
+
+    # Strategy 1: Network scanning (10.TE.AM.XX)
+    if enable_network_scan:
+        try:
+            network_results = discover_network_scan(team_number)
+            if network_results:
+                logger.info("Network scan found %d candidates", len(network_results))
+            all_candidates.update(network_results)
+        except Exception as e:
+            logger.error("Network scan error: %s", e)
+
+    # Strategy 2: Port verification
+    # Only check port 5800 on candidates found by mDNS and network scan
+    if enable_port_check and all_candidates:
+        try:
+            verified = verify_port_5800(all_candidates)
+            if verified:
+                logger.info("Port verification found %d active dashboards", len(verified))
+            all_candidates = verified
+        except Exception as e:
+            logger.error("Port verification error: %s", e)
+
+    # Strategy 3: NetworkTables discovery
+    # Connects to the roboRIO NT server, enumerates PV cameras, and
+    # resolves coprocessor hostnames to IPs via mDNS
+    if enable_networktables:
+        try:
+            nt_results = discover_networktables(team_number=team_number)
+            if nt_results:
+                logger.info("NT discovery found %d dashboards", len(nt_results))
+            all_candidates.update(nt_results)
+        except Exception as e:
+            logger.error("NT discovery error: %s", e)
+
+    # Convert IPs to tab entries and sort for consistency
+    if not all_candidates:
+        logger.debug("No PhotonVision dashboards discovered")
+        return []
+
+    sorted_ips = sorted(all_candidates, key=lambda x: tuple(map(int, x.split("."))))
+
+    tabs: List[Dict[str, str]] = [
+        {"title": f"{ip}", "url": f"http://{ip}:5800"}
+        for ip in sorted_ips
+    ]
+
+    logger.info("Discovery complete: %d dashboards found", len(tabs))
+    return tabs
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/cache.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/cache.py
new file mode 100644
index 0000000000..b06a3692bb
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/cache.py
@@ -0,0 +1,152 @@
+"""Background discovery cache and refresh manager.
+
+Manages periodic discovery of PhotonVision dashboards in a background thread
+with low CPU overhead. Supports different refresh intervals for expensive
+operations (network scanning) vs. quick checks (mDNS, port verification).
+"""
+
+import logging
+import threading
+import time
+from typing import Dict, List, Optional
+
+from .aggregator import discover_all
+
+logger = logging.getLogger(__name__)
+
+
+class DiscoveryCache:
+    """Background discovery cache with configurable refresh intervals.
+
+    Runs discovery strategies periodically in a background thread and caches
+    results for fast serving to the /tabs endpoint.
+
+    Supports tuning different discovery strategies independently:
+    - Fast strategies (mDNS, port checks): ~10 seconds default
+    - Slow strategies (network scan, NetworkTables): ~60 seconds default
+    """
+
+    def __init__(
+        self,
+        team_number: Optional[int] = None,
+        fast_interval: float = 10.0,
+        slow_interval: float = 60.0,
+        enable_fast: bool = True,
+        enable_slow: bool = True,
+    ):
+        """Initialize the discovery cache.
+
+        Args:
+            team_number: FRC team number for network scanning.
+            fast_interval: Seconds between fast discovery cycles (mDNS, port checks).
+            slow_interval: Seconds between slow discovery cycles (network scan).
+            enable_fast: Whether to run fast discovery strategies.
+            enable_slow: Whether to run expensive discovery strategies.
+        """
+        self.team_number = team_number
+        self.fast_interval = fast_interval
+        self.slow_interval = slow_interval
+        self.enable_fast = enable_fast
+        self.enable_slow = enable_slow
+
+        # Cache storage and synchronization
+        self._tabs_cache: List[Dict[str, str]] = []
+        self._cache_lock = threading.RLock()
+
+        # Background thread management
+        self._discovery_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+    def start(self) -> None:
+        """Start the background discovery thread.
+
+        The thread will periodically call discover_all() and update the cache.
+        Uses daemon threads so the service can shut down cleanly.
+        """
+        if self._discovery_thread is not None:
+            logger.warning("Discovery cache already started")
+            return
+
+        self._stop_event.clear()
+        self._discovery_thread = threading.Thread(
+            target=self._discovery_loop,
+            daemon=True,
+            name="DiscoveryCache",
+        )
+        self._discovery_thread.start()
+        logger.info("Background discovery cache started")
+
+    def stop(self) -> None:
+        """Stop the background discovery thread.
+
+        Signals the thread to stop and waits for it to finish.
+        """
+        if self._discovery_thread is None:
+            return
+
+        logger.info("Stopping background discovery cache")
+        self._stop_event.set()
+        if self._discovery_thread.is_alive():
+            self._discovery_thread.join(timeout=5.0)
+
+    def get_tabs(self) -> List[Dict[str, str]]:
+        """Get the currently cached list of tabs.
+
+        Returns immediately without blocking for new discovery.
+
+        Returns:
+            List of discovered tabs, or empty list if none found.
+        """
+        with self._cache_lock:
+            return self._tabs_cache.copy()
+
+    def _discovery_loop(self) -> None:
+        """Background discovery loop.
+
+        Periodically runs discovery strategies with different intervals:
+        - Fast strategies every fast_interval seconds
+        - Slow strategies every slow_interval seconds
+
+        The loop is designed to be low-CPU: it sleeps most of the time and
+        wakes periodically to check if discovery is needed.
+        """
+        next_fast_discovery = time.time()
+        next_slow_discovery = time.time()
+
+        while not self._stop_event.is_set():
+            now = time.time()
+            run_fast = now >= next_fast_discovery
+            run_slow = now >= next_slow_discovery
+
+            if run_fast or run_slow:
+                try:
+                    # Run discovery with appropriate strategies enabled
+                    tabs = discover_all(
+                        team_number=self.team_number,
+                        enable_mdns=self.enable_fast and run_fast,
+                        enable_network_scan=self.enable_slow and run_slow,
+                        enable_port_check=self.enable_fast and run_fast,
+                        enable_networktables=self.enable_slow and run_slow,
+                    )
+
+                    # Update cache atomically
+                    with self._cache_lock:
+                        self._tabs_cache = tabs
+
+                    # Log results periodically (not on every cycle)
+                    if run_fast or run_slow:
+                        logger.debug(f"Discovery updated: {len(tabs)} dashboards found")
+
+                except Exception as e:
+                    logger.error(f"Discovery error: {e}")
+
+            # Schedule next runs
+            if run_fast:
+                next_fast_discovery = now + self.fast_interval
+            if run_slow:
+                next_slow_discovery = now + self.slow_interval
+
+            # Sleep briefly to be responsive to stop signal
+            # Use a small sleep so we check stop_event frequently
+            sleep_time = min(0.5, self.fast_interval / 2)  # At most 0.5s, smart default
+            self._stop_event.wait(sleep_time)
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/mdns_discovery.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/mdns_discovery.py
new file mode 100644
index 0000000000..331ad62716
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/mdns_discovery.py
@@ -0,0 +1,38 @@
+"""mDNS discovery strategy.
+
+Attempts to resolve 'photonvision.local' via multicast DNS (mDNS).
+This is typically set up on a PhotonVision host running avahi-daemon
+or similar mDNS responder.
+
+Returns:
+    Set of IP addresses (as strings) that resolve photonvision.local.
+    Empty set if resolution fails or mDNS is unavailable.
+"""
+
+import logging
+import socket
+from typing import Set
+
+logger = logging.getLogger(__name__)
+
+
+def discover_mdns() -> Set[str]:
+    """Discover PhotonVision via mDNS hostname resolution.
+
+    Attempts to resolve 'photonvision.local' to an IP address.
+    On success, returns the resolved IPv4 address.
+
+    Returns:
+        Set containing the resolved IP, or empty set if resolution fails.
+    """
+    try:
+        # Try to resolve photonvision.local
+        result = socket.gethostbyname("photonvision.local")
+        logger.info(f"mDNS discovery found: {result}")
+        return {result}
+    except socket.gaierror as e:
+        logger.debug(f"mDNS resolution failed: {e}")
+        return set()
+    except Exception as e:
+        logger.error(f"Unexpected error during mDNS discovery: {e}")
+        return set()
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/network_scan_discovery.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/network_scan_discovery.py
new file mode 100644
index 0000000000..a5aa28e8af
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/network_scan_discovery.py
@@ -0,0 +1,92 @@
+"""Network scanning discovery strategy.
+
+Scans the FRC team network (10.TE.AM.0/24) by pinging each host.
+
+FRC team networks follow the pattern 10.TE.AM.XX where:
+- 10 = FRC standard first octet
+- TE = team number first two digits (zero-padded)
+- AM = team number last two digits (zero-padded)
+- XX = host ID (1-254, 255 is broadcast)
+
+Example: Team 5123 -> 10.51.23.1-254
+Example: Team 254 -> 10.02.54.1-254
+
+Returns:
+    Set of IP addresses that respond to ping.
+"""
+
+import logging
+import subprocess
+from typing import Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+def discover_network_scan(team_number: Optional[int] = None) -> Set[str]:
+    """Scan the FRC team network for responding hosts.
+
+    Constructs the team network address from the team number and pings
+    each host (XX from 1 to 254). Returns IPs that respond to ICMP ping.
+
+    Args:
+        team_number: FRC team number (e.g., 5123, 254, 1).
+                     If None, uses environment variable PHOTONVISION_TEAM
+                     or skips network scanning.
+
+    Returns:
+        Set of IP addresses that respond to ping on the team network.
+    """
+    if team_number is None:
+        import os
+
+        team_str = os.environ.get("PHOTONVISION_TEAM")
+        if not team_str:
+            logger.debug("No team number provided for network scanning")
+            return set()
+        try:
+            team_number = int(team_str)
+        except ValueError:
+            logger.error(f"Invalid team number: {team_str}")
+            return set()
+
+    # Format team number to IP: 10.TE.AM.XX
+    # Team 5123 -> 10.51.23.XX
+    # Team 254 -> 10.02.54.XX
+    tens = team_number // 100
+    ones = team_number % 100
+    base_ip = f"10.{tens:02d}.{ones:02d}"
+
+    responding: Set[str] = set()
+
+    # Scan hosts 1-254 (0 is network, 255 is broadcast)
+    for host_id in range(1, 255):
+        ip = f"{base_ip}.{host_id}"
+        if _ping_host(ip):
+            logger.info(f"Network scan found: {ip}")
+            responding.add(ip)
+
+    return responding
+
+
+def _ping_host(ip: str, timeout: int = 1) -> bool:
+    """Check if a host responds to ping.
+
+    Args:
+        ip: IP address to ping.
+        timeout: Timeout in seconds for the ping.
+
+    Returns:
+        True if host responds to ping, False otherwise.
+    """
+    try:
+        # Use ping with count=1 and timeout
+        # Platform-specific timeout flag
+        result = subprocess.run(
+            ["ping", "-c", "1", "-W", str(timeout * 1000), ip],
+            capture_output=True,
+            timeout=timeout + 1,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception) as e:
+        logger.debug(f"Ping failed for {ip}: {e}")
+        return False
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/networktables_discovery.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/networktables_discovery.py
new file mode 100644
index 0000000000..0211c27f17
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/networktables_discovery.py
@@ -0,0 +1,220 @@
+"""NetworkTables discovery strategy.
+
+Connects to a NetworkTables server (typically on the roboRIO) and enumerates
+PhotonVision coprocessors by looking for cameras publishing under /photonvision/.
+
+Uses the same camera-detection logic as PhotonCamera.java / photonCamera.py:
+a subtable under /photonvision/ is a valid PV camera if it has a "rawBytes" entry.
+
+Discovered hostnames are returned for mDNS resolution. The aggregator
+cross-references them with port-scan and network-scan results to build
+the final IP list.
+"""
+
+import logging
+import socket
+import time
+from typing import Any, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+try:
+    from ntcore import NetworkTableInstance
+    NTCORE_AVAILABLE = True
+except ImportError:
+    NTCORE_AVAILABLE = False
+    logger.debug("ntcore not available, NetworkTables discovery disabled")
+
+NT_SERVER_PORT = 1735
+NT_CLIENT_IDENTITY = "photon-sc-app"
+NT_CONNECT_TIMEOUT = 2.0
+NT_SCAN_TIMEOUT = 3.0
+
+
+def discover_networktables(team_number: Optional[int] = None, timeout: float = NT_CONNECT_TIMEOUT + NT_SCAN_TIMEOUT) -> Set[str]:
+    """Discover PhotonVision coprocessors via NetworkTables.
+
+    Connects to the NT server (roboRIO, identified by team number) and
+    enumerates cameras under /photonvision/. A camera is valid if its
+    subtable contains a "rawBytes" entry. Returns hostnames for each
+    unique coprocessor found.
+
+    Args:
+        team_number: FRC team number. Used to auto-discover the NT server
+                     address (10.TE.AM.2). If None, discovery is skipped
+                     since there is no server to connect to.
+        timeout: Maximum total time in seconds for the NT discovery attempt.
+
+    Returns:
+        Set of hostnames (e.g. "photonvision", "photonvision-2") that
+        were confirmed to be publishing PV camera data.
+        Empty set if ntcore is unavailable, no team is given, or no
+        coprocessors are found.
+    """
+    if not NTCORE_AVAILABLE:
+        return set()
+
+    if team_number is None:
+        return set()
+
+    instance = NetworkTableInstance.create()
+    instance.setServerTeam(team_number, NT_SERVER_PORT)
+    instance.startClient(NT_CLIENT_IDENTITY)
+
+    deadline = time.monotonic() + timeout
+
+    try:
+        connect_timeout = min(NT_CONNECT_TIMEOUT, timeout)
+        if not _wait_for_connection(instance, connect_timeout):
+            logger.debug("NT server not reachable for team %d", team_number)
+            return set()
+
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return set()
+
+        return _discover_from_nt(instance, timeout=remaining)
+
+    finally:
+        try:
+            instance.stopClient()
+        except Exception:
+            pass
+
+
+def _wait_for_connection(instance: "NetworkTableInstance", timeout: float = NT_CONNECT_TIMEOUT) -> bool:
+    """Wait up to `timeout` seconds for the NT client to connect to a server.
+
+    Returns True if connected, False if timeout elapsed.
+    """
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if instance.isConnected():
+            return True
+        time.sleep(0.1)
+    return False
+
+
+def _discover_from_nt(instance: "NetworkTableInstance", timeout: float = NT_SCAN_TIMEOUT) -> Set[str]:
+    """Enumerate PV coprocessors from a connected NT instance.
+
+    Strategy:
+    1. Wait briefly for topic data to arrive
+    2. List subtables under /photonvision/
+    3. Each subtable with a "rawBytes" entry is a valid PV camera
+    4. Group cameras by coprocessor
+    5. Resolve coprocessor hostnames from /photonvision/coprocessors/ subtables
+    6. Try mDNS to convert hostnames to IPs
+
+    Args:
+        instance: Connected NT instance.
+        timeout: Maximum time to wait for topic data.
+
+    Returns a set of IP addresses (as strings).
+    """
+    wait = min(NT_SCAN_TIMEOUT, timeout)
+    if wait > 0:
+        time.sleep(wait)
+
+    root_table = instance.getTable("/photonvision")
+    if root_table is None:
+        return set()
+
+    subtable_names = root_table.getSubTables()
+    if not subtable_names:
+        logger.debug("No subtables under /photonvision/")
+        return set()
+
+    # Filter subtables: a PV camera subtable has a "rawBytes" entry
+    camera_names: Set[str] = set()
+    for name in subtable_names:
+        if _is_camera_table(root_table, name):
+            camera_names.add(name)
+
+    if not camera_names:
+        logger.debug("No PV camera subtables found under /photonvision/")
+        return set()
+
+    logger.info("Found %d PV camera(s): %s", len(camera_names), ", ".join(sorted(camera_names)))
+
+    # Try to read coprocessor metadata to get hostnames
+    coprocessor_hostnames = _get_coprocessor_hostnames(root_table)
+
+    found: Set[str] = set()
+
+    # For each hostname from coprocessor metadata, try mDNS resolution
+    for hostname in coprocessor_hostnames:
+        ip = _resolve_mdns(hostname)
+        if ip:
+            found.add(ip)
+            logger.info("NT+mDNS resolved %s -> %s", hostname, ip)
+        else:
+            logger.debug("Could not resolve coprocessor hostname: %s", hostname)
+
+    return found
+
+
+def _is_camera_table(root_table: Any, name: str) -> bool:
+    """Check if a subtable looks like a PV camera (has a rawBytes entry)."""
+    try:
+        sub = root_table.getSubTable(name)
+        if sub is None:
+            return False
+        return sub.getEntry("rawBytes").exists()
+    except Exception:
+        return False
+
+
+def _get_coprocessor_hostnames(root_table: Any) -> Set[str]:
+    """Read hostnames from /photonvision/coprocessors/{MAC}/hostname.
+
+    Returns a set of hostname strings (e.g. {"photonvision", "photonvision-2"}).
+    """
+    hostnames: Set[str] = set()
+
+    try:
+        coprocessors_table = root_table.getSubTable("coprocessors")
+        if coprocessors_table is None:
+            return hostnames
+
+        macs = coprocessors_table.getSubTables()
+        for mac in macs:
+            try:
+                coprocessor_table = coprocessors_table.getSubTable(mac)
+                if coprocessor_table is None:
+                    continue
+                hostname = coprocessor_table.getString("hostname", "")
+                if hostname:
+                    hostnames.add(hostname)
+                    logger.debug("Coprocessor %s hostname: %s", mac, hostname)
+            except Exception as e:
+                logger.debug("Error reading coprocessor %s: %s", mac, e)
+
+        if hostnames:
+            logger.info("Found %d coprocessor(s) via NT metadata: %s", len(hostnames), ", ".join(hostnames))
+
+    except Exception as e:
+        logger.debug("Error reading coprocessors table: %s", e)
+
+    return hostnames
+
+
+def _resolve_mdns(hostname: str) -> Optional[str]:
+    """Try to resolve a hostname to an IPv4 address via mDNS.
+
+    Tries both the bare hostname and with .local suffix.
+    Returns the IP string or None.
+    """
+    candidates = [hostname]
+    if not hostname.endswith(".local"):
+        candidates.append(f"{hostname}.local")
+
+    for name in candidates:
+        try:
+            result = socket.gethostbyname(name)
+            logger.debug("mDNS resolved %s -> %s", name, result)
+            return result
+        except socket.gaierror:
+            continue
+
+    return None
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/port_check_discovery.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/port_check_discovery.py
new file mode 100644
index 0000000000..d87dac0bcf
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/discovery/port_check_discovery.py
@@ -0,0 +1,65 @@
+"""Port 5800 verification strategy.
+
+Given a set of candidate IP addresses, checks which ones are serving
+a web server on port 5800 (PhotonVision default).
+
+Returns:
+    Set of IP addresses with accessible web servers on port 5800.
+"""
+
+import logging
+import socket
+from typing import Set
+
+logger = logging.getLogger(__name__)
+
+# Timeout for TCP connection attempts (seconds)
+PORT_CHECK_TIMEOUT = 2
+
+
+def verify_port_5800(candidates: Set[str]) -> Set[str]:
+    """Check which candidates have web servers on port 5800.
+
+    Attempts a TCP connection to port 5800 on each candidate IP.
+    Includes IPs where the port is accessible.
+
+    Args:
+        candidates: Set of IP addresses to check.
+
+    Returns:
+        Set of IP addresses with accessible port 5800.
+    """
+    verified: Set[str] = set()
+
+    for ip in candidates:
+        if _has_port_5800(ip):
+            logger.info(f"Port verification found: {ip}:5800")
+            verified.add(ip)
+
+    return verified
+
+
+def _has_port_5800(ip: str) -> bool:
+    """Check if port 5800 is open on the given IP.
+
+    Attempts a TCP connection to port 5800. Success indicates
+    a web server is likely running there.
+
+    Args:
+        ip: IP address to check.
+
+    Returns:
+        True if port 5800 is open, False otherwise.
+    """
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(PORT_CHECK_TIMEOUT)
+        result = sock.connect_ex((ip, 5800))
+        sock.close()
+
+        if result == 0:
+            return True
+        return False
+    except Exception as e:
+        logger.debug(f"Port check failed for {ip}:5800: {e}")
+        return False
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/photon_sc_app.py b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/photon_sc_app.py
new file mode 100644
index 0000000000..42d8f50b2e
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/photon_sc_app.py
@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+"""
+Photon SC App - Tab Dashboard HTTP Server
+
+This service serves a dynamic tab-based dashboard UI that can display multiple
+external web content in iframes. It supports two deployment modes:
+
+1. Systemd socket activation (production): The service is managed by systemd
+   and receives a pre-bound socket via FD 3.
+
+2. Local development mode (--local flag): Direct HTTP server on localhost.
+
+Key Features:
+- Dynamic tab list via /tabs API endpoint
+- Service status endpoint at /status for health checks
+- Graceful shutdown via SIGINT/SIGTERM
+"""
+
+import argparse
+import http.server
+import json
+import logging
+import os
+import signal
+import socket
+import socketserver
+import sys
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from discovery.cache import DiscoveryCache
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# Global flag to track deployment mode (True for systemd, False for local)
+SOCKET_ACTIVATED: bool = False
+
+# Global team number for network discovery (set by main())
+TEAM_NUMBER: Optional[int] = None
+
+# Global discovery cache (initialized in main(), shared between request handlers)
+DISCOVERY_CACHE: Optional[DiscoveryCache] = None
+
+
+class ServiceHandler(http.server.SimpleHTTPRequestHandler):
+    """HTTP request handler for the Photon SC App.
+
+    Extends SimpleHTTPRequestHandler to add custom endpoints while maintaining
+    the ability to serve static files from the 'www' directory.
+    """
+
+    def __init__(
+        self, *args: Any, directory: Optional[str] = None, **kwargs: Any
+    ) -> None:
+        """Initialize handler with www directory for static file serving.
+
+        Args:
+            directory: Optional directory path. Defaults to 'www' subdirectory.
+        """
+        www_dir = directory or os.path.join(os.path.dirname(__file__), "www")
+        super().__init__(*args, directory=www_dir, **kwargs)
+
+    def do_GET(self) -> None:
+        """Route incoming GET requests to appropriate handlers."""
+        # Serve index.html for root requests
+        if self.path in ("/", "/index.html", ""):
+            self.path = "/index.html"
+            return super().do_GET()
+
+        # Service status endpoint for health checks
+        if self.path in ("/status", "/health"):
+            return self.send_status()
+
+        # Dynamic tab configuration endpoint
+        if self.path == "/tabs":
+            return self.send_tabs()
+
+        # Default: serve static files from www directory
+        return super().do_GET()
+
+    def send_status(self) -> None:
+        """Return service status as JSON for health monitoring."""
+        self.send_response(200)
+        self.send_header("Content-type", "application/json")
+        self.end_headers()
+
+        response: Dict[str, Any] = {
+            "service": os.path.basename(os.path.dirname(__file__)),
+            "status": "running",
+            "socket_activated": SOCKET_ACTIVATED,
+            "pid": os.getpid(),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        self.wfile.write(json.dumps(response, indent=2).encode())
+
+    def send_tabs(self) -> None:
+        """Return list of available tabs as JSON.
+
+        The frontend fetches this on startup and refresh to populate the tab bar.
+        Discovered tabs are served from the background discovery cache, which
+        periodically updates the list of available PhotonVision dashboards using:
+        1. mDNS (photonvision.local hostname)
+        2. Network scanning (10.TE.AM.0/24 for team network)
+        3. Port 5800 verification
+        4. NetworkTables client discovery
+
+        Tab format: {"title": "Display Name", "url": "http://..."}
+
+        Returns an empty list if no dashboards are discovered, allowing the
+        frontend to display a "No dashboards available" message gracefully.
+        """
+        # Return cached results from background discovery thread
+        if DISCOVERY_CACHE is not None:
+            tabs: List[Dict[str, str]] = DISCOVERY_CACHE.get_tabs()
+        else:
+            # Fallback if cache not initialized (should not happen in normal operation)
+            tabs = []
+
+        self.send_response(200)
+        self.send_header("Content-type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps({"tabs": tabs}, indent=2).encode())
+
+
+class SocketActivatedService:
+    """Service wrapper for systemd socket activation mode (production).
+
+    In this mode, systemd creates a listening socket and passes it to the
+    service via file descriptor 3. This separation of concerns allows:
+
+    - Privileged socket binding (e.g., port 80/443) without service privileges
+    - Socket reuse across service restarts without TIME_WAIT delays
+    - Systemd to manage service lifecycle and auto-restart on failure
+    - Better integration with systemd security features and resource limits
+    """
+
+    def __init__(self, discovery_cache: Optional[DiscoveryCache] = None) -> None:
+        """Initialize the socket-activated service.
+
+        Args:
+            discovery_cache: Optional DiscoveryCache for background discovery.
+        """
+        self.httpd: Optional[socketserver.ThreadingTCPServer] = None
+        self.discovery_cache = discovery_cache
+
+    def get_systemd_socket(self) -> socket.socket:
+        """Retrieve and validate the socket passed by systemd.
+
+        Systemd sets LISTEN_PID and LISTEN_FDS environment variables:
+        - LISTEN_PID: Our process ID (to ensure the socket is for us)
+        - LISTEN_FDS: Number of file descriptors (should be >= 1)
+
+        The first socket is always FD 3 (by convention):
+        - FD 0 = stdin
+        - FD 1 = stdout
+        - FD 2 = stderr
+        - FD 3+ = sockets/files from systemd
+
+        We validate all three conditions before returning the socket.
+
+        Returns:
+            A socket object for the systemd-provided listening socket.
+
+        Raises:
+            RuntimeError: If not started by systemd or validation fails.
+        """
+        listen_pid = os.environ.get("LISTEN_PID")
+        listen_fds = os.environ.get("LISTEN_FDS")
+
+        if not listen_pid or not listen_fds:
+            raise RuntimeError("Not started by systemd socket activation")
+
+        if int(listen_pid) != os.getpid():
+            raise RuntimeError(
+                f"PID mismatch: expected {listen_pid}, got {os.getpid()}"
+            )
+
+        if int(listen_fds) < 1:
+            raise RuntimeError(f"No sockets provided: LISTEN_FDS={listen_fds}")
+
+        # Convert file descriptor to a Python socket object
+        sock = socket.fromfd(3, socket.AF_INET, socket.SOCK_STREAM)
+        return sock
+
+    def start(self) -> None:
+        """Start the HTTP server using the systemd-provided socket.
+
+        Key details:
+        - bind_and_activate=False: Socket from systemd is already bound/listening
+        - daemon_threads=True: Allows quick shutdown (threads don't block exit)
+        - poll_interval=0.5: Checks signals frequently for responsive Ctrl-C
+        """
+        # Start background discovery if available
+        if self.discovery_cache:
+            self.discovery_cache.start()
+
+        server_socket = self.get_systemd_socket()
+
+        # Create threaded server WITHOUT calling bind() or listen()
+        # The socket from systemd is already bound and listening
+        self.httpd = socketserver.ThreadingTCPServer(
+            ("", 0), ServiceHandler, bind_and_activate=False
+        )
+        self.httpd.daemon_threads = True  # Allow quick shutdown
+        self.httpd.socket = server_socket  # Replace with systemd socket
+
+        print(f"Service started (PID: {os.getpid()})")
+        # Poll interval allows signal handler to interrupt serve_forever()
+        self.httpd.serve_forever(poll_interval=0.5)
+
+    def stop(self) -> None:
+        """Cleanly shut down the server and release resources."""
+        # Stop background discovery
+        if self.discovery_cache:
+            self.discovery_cache.stop()
+
+        if self.httpd:
+            self.httpd.shutdown()
+            self.httpd.server_close()
+
+
+def signal_handler(signum: int, frame: Any) -> None:
+    """Handle SIGINT (Ctrl-C) and SIGTERM signals for graceful shutdown.
+
+    Prints a message and exits, allowing the main exception handler to run
+    cleanup. We don't directly call service.stop() here because:
+    - If called from a signal handler during blocking I/O, it may not work cleanly
+    - Using sys.exit() allows the exception handler to call stop() properly
+
+    Args:
+        signum: Signal number received.
+        frame: Current stack frame.
+    """
+    print("\nShutdown signal received, exiting.")
+    sys.exit(0)
+
+
+class LocalService:
+    """Service wrapper for local development mode (--local flag).
+
+    Runs a standard threaded HTTP server on localhost without systemd.
+    This is convenient for development without requiring:
+    - Systemd service file setup
+    - Privileged socket binding
+    - Special environment variables
+
+    Default: localhost:8080 (customizable via --host and --port arguments)
+    """
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 8080,
+        discovery_cache: Optional[DiscoveryCache] = None,
+    ) -> None:
+        """Initialize the local service.
+
+        Args:
+            host: Hostname to bind to. Defaults to '127.0.0.1'.
+            port: Port to bind to. Defaults to 8080.
+            discovery_cache: Optional DiscoveryCache for background discovery.
+        """
+        self.httpd: Optional[http.server.ThreadingHTTPServer] = None
+        self.host = host
+        self.port = port
+        self.discovery_cache = discovery_cache
+
+    def start(self) -> None:
+        """Start the HTTP server on the specified host:port.
+
+        Key details:
+        - ThreadingHTTPServer: Handles each request in a separate thread
+        - daemon_threads=True: Threads don't block shutdown
+        - allow_reuse_address=True: Allows quick restart without TIME_WAIT
+        - poll_interval=0.5: Responsive to Ctrl-C and other signals
+        """
+        # Start background discovery if available
+        if self.discovery_cache:
+            self.discovery_cache.start()
+
+        self.httpd = http.server.ThreadingHTTPServer(
+            (self.host, self.port), ServiceHandler
+        )
+        self.httpd.daemon_threads = True  # Allow quick shutdown
+        self.httpd.allow_reuse_address = True  # Reuse port after restart
+        print(f"Local service started at http://{self.host}:{self.port}")
+        # Poll interval allows signal handler to interrupt serve_forever()
+        self.httpd.serve_forever(poll_interval=0.5)
+
+    def stop(self) -> None:
+        """Cleanly shut down the server and release resources."""
+        # Stop background discovery
+        if self.discovery_cache:
+            self.discovery_cache.stop()
+
+        if self.httpd:
+            self.httpd.shutdown()
+            self.httpd.server_close()
+
+
+def main() -> None:
+    """Entry point: parse arguments, select deployment mode, and start service.
+
+    Deployment modes:
+
+    1. Systemd socket activation (default):
+       - Requires LISTEN_PID and LISTEN_FDS environment variables
+       - Best for production with systemd
+
+    2. Local development (--local flag):
+       - Direct TCP server on localhost
+       - Customizable host/port via --host and --port
+
+    Discovery Strategy:
+    The service automatically discovers PhotonVision dashboards via a background
+    thread running multiple strategies on different intervals:
+    - Fast strategies (mDNS, port checks): Default 10 seconds
+    - Slow strategies (network scan, NetworkTables): Default 60 seconds
+
+    Use --team to enable network scanning for your FRC team number.
+    Use --discovery-fast-interval and --discovery-slow-interval to tune timing.
+    """
+    global TEAM_NUMBER, DISCOVERY_CACHE
+
+    parser = argparse.ArgumentParser(description="Photon SC App service")
+    parser.add_argument(
+        "--local",
+        action="store_true",
+        help="Run in local development mode without systemd socket activation",
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Local host address when running in local mode",
+    )
+    parser.add_argument(
+        "--port", type=int, default=8080, help="Local port when running in local mode"
+    )
+    parser.add_argument(
+        "--team",
+        type=int,
+        default=None,
+        help="FRC team number for network discovery (e.g., 5123)",
+    )
+    parser.add_argument(
+        "--discovery-fast-interval",
+        type=float,
+        default=10.0,
+        help="Seconds between fast discovery cycles (mDNS, port checks). Default: 10s",
+    )
+    parser.add_argument(
+        "--discovery-slow-interval",
+        type=float,
+        default=60.0,
+        help="Seconds between slow discovery cycles (network scan, NetworkTables). Default: 60s",
+    )
+    parser.add_argument(
+        "--discovery-disable-fast",
+        action="store_true",
+        help="Disable fast discovery strategies (mDNS, port checks)",
+    )
+    parser.add_argument(
+        "--discovery-disable-slow",
+        action="store_true",
+        help="Disable slow discovery strategies (network scan, NetworkTables)",
+    )
+    args = parser.parse_args()
+
+    # Set team number for discovery
+    TEAM_NUMBER = args.team
+    if TEAM_NUMBER:
+        logger.info(f"Network discovery enabled for team {TEAM_NUMBER}")
+
+    # Create and start discovery cache
+    DISCOVERY_CACHE = DiscoveryCache(
+        team_number=TEAM_NUMBER,
+        fast_interval=args.discovery_fast_interval,
+        slow_interval=args.discovery_slow_interval,
+        enable_fast=not args.discovery_disable_fast,
+        enable_slow=not args.discovery_disable_slow,
+    )
+
+    # Select deployment mode based on --local flag
+    if not args.local:
+        # Production: systemd socket activation
+        if not os.environ.get("LISTEN_PID") or not os.environ.get("LISTEN_FDS"):
+            logger.error(
+                "Must be started by systemd socket activation or use --local "
+                "for development mode"
+            )
+            sys.exit(1)
+        service: SocketActivatedService | LocalService = SocketActivatedService(
+            discovery_cache=DISCOVERY_CACHE
+        )
+    else:
+        # Development: local server
+        service = LocalService(
+            host=args.host,
+            port=args.port,
+            discovery_cache=DISCOVERY_CACHE,
+        )
+
+    # Register signal handlers for clean shutdown
+    signal.signal(signal.SIGINT, signal_handler)  # Ctrl-C
+    signal.signal(signal.SIGTERM, signal_handler)  # Termination request
+
+    try:
+        service.start()
+    except (KeyboardInterrupt, SystemExit):
+        # Ensure cleanup happens on any exit (Ctrl-C, signal, etc.)
+        service.stop()
+        logger.info("Server stopped.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/index.html b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/index.html
new file mode 100644
index 0000000000..12fc2eb27a
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/index.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Photon SC App</title>
+  <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+  <main>
+    <section class="tabs-row">
+      <div class="tab-bar" id="tabList"></div>
+      <button class="refresh-button" id="refreshButton">Update Clients</button>
+    </section>
+
+    <section class="panel-section">
+      <div class="iframe-wrapper">
+        <iframe id="tabFrame" src="about:blank" sandbox="allow-scripts allow-same-origin allow-forms"></iframe>
+      </div>
+    </section>
+  </main>
+
+  <script src="script.js"></script>
+</body>
+</html>
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/script.js b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/script.js
new file mode 100644
index 0000000000..21774a6f6a
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/script.js
@@ -0,0 +1,113 @@
+/**
+ * Photon SC App - Frontend Tab Dashboard
+ * 
+ * This script manages the dynamic tab interface for loading external web content
+ * in iframes. It handles:
+ * - Fetching the tab list from the backend
+ * - Rendering tab buttons
+ * - Loading content in the iframe
+ */
+
+const tabList = document.getElementById('tabList');
+const tabFrame = document.getElementById('tabFrame');
+const refreshButton = document.getElementById('refreshButton');
+let tabs = [];
+let activeTabIndex = 0;
+
+/**
+ * Fetch the list of tabs from the backend.
+ * 
+ * Called on page load and when user clicks the "Update Clients" button.
+ * The /tabs endpoint returns a JSON array of tab objects:
+ * [
+ *   {"title": "Example", "url": "https://example.com"},
+ *   ...
+ * ]
+ */
+async function fetchTabs() {
+  try {
+    const response = await fetch('/tabs');
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const payload = await response.json();
+    tabs = Array.isArray(payload.tabs) ? payload.tabs : [];
+    renderTabs();
+
+    // Automatically load the first tab if available
+    if (tabs.length > 0) {
+      setActiveTab(0);
+    } else {
+      tabList.innerHTML = '<div class="empty-state">No clients found</div>';
+      tabFrame.src = 'about:blank';
+    }
+  } catch (error) {
+    console.error('Failed to load tabs:', error);
+    tabList.innerHTML = '<div class="empty-state">Unable to load tabs</div>';
+    tabFrame.src = 'about:blank';
+  }
+}
+
+/**
+ * Render tab buttons based on the current tabs list.
+ * 
+ * Creates a button for each tab in the tabs array and adds click handlers.
+ * The buttons are styled with CSS and the active one is highlighted.
+ */
+function renderTabs() {
+  tabList.innerHTML = '';
+
+  tabs.forEach((tab, index) => {
+    const button = document.createElement('button');
+    button.className = 'tab-button';
+    button.textContent = tab.title || `Tab ${index + 1}`;
+    // Click handler to switch to this tab
+    button.addEventListener('click', () => setActiveTab(index));
+    tabList.appendChild(button);
+  });
+
+  // Update visual highlighting of the active tab
+  updateActiveTabStyles();
+}
+
+/**
+ * Set the active tab and load its content.
+ * 
+ * This is the main function that handles tab switching:
+ * 1. Validates the index is in range
+ * 2. Gets the URL from the selected tab
+ * 3. Loads the URL in the iframe
+ * 4. Updates visual styling
+ * 
+ * @param {number} index - Index of tab to activate
+ */
+function setActiveTab(index) {
+  if (index < 0 || index >= tabs.length) {
+    return;
+  }
+
+  activeTabIndex = index;
+  const tab = tabs[index];
+  tabFrame.src = tab.url || 'about:blank';
+  
+  updateActiveTabStyles();
+
+
+/**
+ * Update visual styling to highlight the active tab.
+ * 
+ * Adds the 'active' CSS class to the selected tab button and removes it
+ * from others. The CSS provides visual highlighting (different background
+ * color, border color, etc.).
+ */
+function updateActiveTabStyles() {
+  const buttons = tabList.querySelectorAll('.tab-button');
+  buttons.forEach((button, index) => {
+    button.classList.toggle('active', index === activeTabIndex);
+  });
+}
+
+// Event listeners
+refreshButton.addEventListener('click', fetchTabs);  // "Update Clients" button
+window.addEventListener('load', fetchTabs);          // Load tabs on page load
diff --git a/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/styles.css b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/styles.css
new file mode 100644
index 0000000000..7e104314cc
--- /dev/null
+++ b/photon-sc-app/overlay/usr/local/bin/photon-sc-app/www/styles.css
@@ -0,0 +1,195 @@
+body {
+  margin: 0;
+  min-height: 100vh;
+  font-family: "Prompt", "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
+  background: #101820;
+  color: #e8eef8;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem 1.5rem;
+  background: #0f1f38;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.brand-mark {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 48px;
+  height: 48px;
+  background: #1a67d0;
+  border-radius: 14px;
+  font-weight: 700;
+  font-size: 1rem;
+  color: white;
+}
+
+header h1 {
+  margin: 0;
+  font-size: 1.2rem;
+}
+
+header p {
+  margin: 0.15rem 0 0;
+  color: #b8c8ea;
+  font-size: 0.95rem;
+}
+
+header button {
+  padding: 0.75rem 1rem;
+  background: #1a67d0;
+  color: white;
+  border: none;
+  border-radius: 12px;
+  cursor: pointer;
+  transition: background 0.2s ease;
+}
+
+header button:hover {
+  background: #0f56c2;
+}
+
+main {
+  display: grid;
+  grid-template-rows: auto 1fr;
+  gap: 0.85rem;
+  padding: 1rem 1.25rem 1.25rem;
+  height: calc(100vh - 92px);
+}
+
+.tabs-row {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  width: 100%;
+}
+
+.tab-bar {
+  display: flex;
+  gap: 0.25rem;
+  width: 100%;
+  padding: 0 0.25rem;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.12);
+}
+
+.tab-button {
+  position: relative;
+  flex: 0 0 auto;
+  padding: 0.75rem 1rem;
+  background: #0f1f38;
+  color: #e8eef8;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  border-bottom: 1px solid transparent;
+  border-radius: 12px 12px 0 0;
+  cursor: pointer;
+  transition: background 0.2s ease, border-color 0.2s ease;
+}
+
+.tab-button.active {
+  background: #101820;
+  border-color: #1a67d0;
+  border-bottom-color: #101820;
+}
+
+.tab-button:not(.active):hover {
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.refresh-button {
+  flex: 0 0 auto;
+  padding: 0.75rem 1rem;
+  background: #1a67d0;
+  color: white;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  border-radius: 12px;
+  cursor: pointer;
+  transition: background 0.2s ease;
+}
+
+.refresh-button:hover {
+  background: #0f56c2;
+}
+
+.panel-section {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 1rem;
+  min-height: 0;
+}
+
+.iframe-wrapper {
+  background: #0c1421;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 18px;
+  overflow: hidden;
+  min-height: 0;
+}
+
+iframe {
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  border: none;
+}
+
+.status-panel {
+  display: flex;
+  flex-direction: column;
+  padding: 1rem;
+  background: #0f1f38;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 18px;
+}
+
+.panel-title {
+  font-weight: 700;
+  margin-bottom: 0.75rem;
+}
+
+pre {
+  flex: 1;
+  margin: 0;
+  padding: 1rem;
+  overflow: auto;
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.04);
+  color: #d6e1ff;
+}
+
+.empty-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 240px;
+  padding: 2rem;
+  text-align: center;
+  color: #8899bb;
+  font-size: 1rem;
+  background: linear-gradient(135deg, rgba(26, 103, 208, 0.05) 0%, rgba(15, 31, 56, 0.1) 100%);
+  border: 1px solid rgba(26, 103, 208, 0.15);
+  border-radius: 18px;
+}
+
+@media (max-width: 900px) {
+  .panel-section {
+    grid-template-columns: 1fr;
+  }
+
+  .status-panel {
+    max-height: 240px;
+  }
+}
diff --git a/photon-sc-app/overlay/usr/share/photon-sc-app.png b/photon-sc-app/overlay/usr/share/photon-sc-app.png
new file mode 100644
index 0000000000..1eebb28d3b
Binary files /dev/null and b/photon-sc-app/overlay/usr/share/photon-sc-app.png differ
diff --git a/photon-sc-app/run_local.bat b/photon-sc-app/run_local.bat
new file mode 100644
index 0000000000..7080590524
--- /dev/null
+++ b/photon-sc-app/run_local.bat
@@ -0,0 +1,5 @@
+@echo off
+rem Run the Photon SC App in local development mode
+set SCRIPT_DIR=%~dp0
+cd /d "%SCRIPT_DIR%"
+python "%SCRIPT_DIR%overlay\usr\local\bin\photon-sc-app\photon_sc_app.py" --local %*
diff --git a/photon-sc-app/run_local.sh b/photon-sc-app/run_local.sh
new file mode 100755
index 0000000000..c092045b7a
--- /dev/null
+++ b/photon-sc-app/run_local.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "Starting Photon SC App in local development mode..."
+python3 "${SCRIPT_DIR}/overlay/usr/local/bin/photon-sc-app/photon_sc_app.py" --local "$@"