Finally: A proper, consistent Integration overview instead of the endless tile hunting

mannebk · August 13, 2026, 12:20am

I love Home Assistant. I really do.

But there is one thing that has been driving me absolutely

*insert here your preferred choice of profanity

nuts for a long time:

the UI.

Especially the constant use of tiles/cards where everything seems to be somewhere else depending on what you’re looking at.

One integration has its devices here, entities there, configuration somewhere else, and then you have to remember which menu/card/page you need to open to actually get to the thing you want.

For example: I open Settings → Devices & Services, and I land on the Integrations tab in Tile mode. There’s no way to change that view or make it remember my preferred layout.

And every damn time I open it, the tile I’m looking for is somewhere else. Maybe I added a new integration, deleted something, or simply opened Home Assistant from a different device with different screen dimensions and capabilities.

The result is that the UI feels completely unpredictable. I’m constantly having to visually hunt for the thing I need instead of knowing where it will be.

It drives me absolutely NUTS.

Yes, it might look nice.

Indeed, it might even be “modern”.

But intuitive?

Not really.

And when you’re managing a Home Assistant installation with a lot of integrations, devices and entities, this becomes increasingly annoying.

I don’t want to hunt through tiles.

I don’t want to remember where Home Assistant decided to put something today.

I want a simple overview:

Integration → devices → entities → open integration

All in one place.

And preferably something that looks and behaves like an actual table.

What I want is simple: a stable, user-controlled way to organize this view, with a layout that stays predictable regardless of what I add, remove, or which device I’m using.

So I built my own.

The goal was pretty simple:

one integration per row
integration icon
readable integration name
domain / folder ID
number of devices
number of entities
everything clickable
no separate navigation needed
alphabetically sorted
usable on a 10" landscape display
and, importantly, still perfectly usable in the Home Assistant Companion App on a phone
and also convenient on a desktop with a row of 4k displays.
and most importantly, adjustable and customizable as the user sees fit!

The result looks much more like an administration interface than, jet another, useless collection of colourful tiles.

And that’s exactly what I wanted.

How it works

The data comes from a small shell script which generates the integration information.

The result is stored in a Home Assistant sensor:

- sensor:
    name: "Integration_Info"
    command: "/config/integration_info.sh"
    value_template: "OK"
    json_attributes:
      - integrations

The sensor exposes an integrations attribute containing objects like:

{
  "domain": "adaptive_lighting",
  "devices": 1,
  "entities": 4,
  "device_url": "/config/devices/dashboard?historyBack=1&domain=adaptive_lighting",
  "entity_url": "/config/entities?historyBack=1&domain=adaptive_lighting"
}

I then use flex-table-card to turn that data into an actual table.

The nice part is that the table isn’t just visual.

Everything that should be clickable actually is.

The device count links directly to the device list, the entity count directly to the entities, and the folder icon opens the integration page.

For the integration icons I’m using the Home Assistant Brands repository:

http://brands.home-assistant.io/<domain>/[email protected]

That also turned out to be important: the http URL works reliably in my setup, while the https version didn’t, since its in a fully isolated network and i therefore don’t need ssl and never bothered to set it up.

I also opted to choose the dark theme icon as my HA is all dark theme.

The final Lovelace card

This is the version I’m currently using:

title: Integrations
path: integrations
icon: mdi:server
panel: true

cards:
  - type: custom:flex-table-card
    title: 🖥️ Server Explorer

    entities:
      include: sensor.integration_info

    sort_by: integration

    columns:

      # Integration + icon
      - name: Integration
        id: integration
        data: integrations
        modify: >
          '<div style="display:flex;align-items:center;gap:30px;">' +
          '<img
          src="http://brands.home-assistant.io/' + x.domain +
          '/[email protected]"
          style="width:60px;height:60px;object-fit:contain;">' +
          '<strong style="font-size:30px;">' +
          x.domain.replaceAll('_', ' ').replace(/\b\w/g, c => c.toUpperCase()) +
          '</strong>' +
          '</div>'

      # Integration domain
      - name: Ordner-ID
        id: domain
        data: integrations
        modify: |
          '<code>' + x.domain + '</code>'

      # Devices
      - name: Devices
        id: devices
        data: integrations
        align: center
        modify: |
          x.devices > 0
            ? '<a href="' + x.device_url + '">' + x.devices + '</a>'
            : '—'

      # Entities
      - name: Entities
        id: entities
        data: integrations
        align: center
        modify: |
          x.entities > 0
            ? '<a href="' + x.entity_url + '">' + x.entities +
          '</a>'
            : '—'

      # Open integration
      - name: ''
        id: open
        data: integrations
        align: center
        modify: >
          '<a href="/config/integrations/integration/' + x.domain +
          '" title="Integration öffnen">' +
          '<span style="font-size:60px;line-height:1;">📁</span>' +
          '</a>'

    css:
      table+: 'width: 100%;'
      th+: 'padding: 8px 10px;'
      td+: 'padding: 7px 10px; font-size: 30px;'
      tbody tr+: 'border-bottom: 1px solid var(--divider-color);'

Result

The end result is intentionally boring.

And that’s a compliment.

Something like:

┌──────────────────────────────────────────────────────────────────────────────┐
│ 🖥️ Server Explorer                                                          │
├───────────────────┬────────────────────┬─────────┬───────────┬──────────────┤
│ Integration       │ Domain             │ Devices │ Entities  │              │
├───────────────────┼────────────────────┼─────────┼───────────┼──────────────┤
│ [icon] Adaptive   │ adaptive_lighting  │    1    │     4     │      📁      │
│ [icon] Browser    │ browser_mod        │    3    │    39     │      📁      │
│ [icon] Dreame     │ dreame_vacuum      │    2    │   313     │      📁      │
│ [icon] MQTT       │ mqtt               │    8    │    98     │      📁      │
│ [icon] ZHA        │ zha                │   57    │   563     │      📁      │
└───────────────────┴────────────────────┴─────────┴───────────┴──────────────┘

Except, obviously, the actual HA version is much nicer.

The important thing for me is that the UI now behaves predictably.

I can see what’s installed.

I can see how many devices and entities each integration has.

I can click directly where I want to go.

No tile hunting.

No “where the
*insert here your preferred choice of profanity
did Home Assistant put that again?”

Just a table.

And honestly, this is probably one of the most useful dashboards I’ve built for administering my HA installation.

Ah, I almost forgot:
my integration_info.sh script that sits inside the home assistant docker, that’s where the action actually is happening:

#!/bin/sh

domains="$(
  for d in /config/.cache/brands/integrations/*/; do
    [ "$(ls -1 "$d" | wc -l)" -gt 1 ] &&
    [ "$(basename "$d")" != "_placeholder" ] &&
    basename "$d"
  done | sort
)"

jq -n \
  --arg domains "$domains" \
  --slurpfile config_entries /config/.storage/core.config_entries \
  --slurpfile devices /config/.storage/core.device_registry \
  --slurpfile entities /config/.storage/core.entity_registry '
  ($config_entries[0].data.entries) as $entries |
  ($devices[0].data.devices) as $devices |
  ($entities[0].data.entities) as $entities |

  {
    integrations: (
      $domains
      | split("\n")
      | map(select(length > 0))
      | map(
          . as $domain |
          ($entries
            | map(select(.domain == $domain) | .entry_id)
          ) as $entry_ids |

          {
            domain: $domain,

            devices: (
              $devices
              | map(
                  . as $device |
                  select(
                    ($device.config_entry_id != null) and
                    (($entry_ids | index($device.config_entry_id)) != null)
                  )
                )
              | length
            ),

            entities: (
              $entities
              | map(
                  . as $entity |
                  select(
                    ($entity.config_entry_id != null) and
                    (($entry_ids | index($entity.config_entry_id)) != null)
                  )
                )
              | length
            ),

            device_url:
              ("/config/devices/dashboard?historyBack=1&domain=" + $domain),

            entity_url:
              ("/config/entities?historyBack=1&domain=" + $domain)
          }
        )
    )
  }
'

this integration_info.sh file must be inside the docker container, so in the terminal integration run: docker exec -it homeassistant bash and create the script with touch /config/integration_info.sh
don’t forget to chmod it to be executable
** hint: chmod +x /config/integration_info.sh

Requirements

Home Assistant
custom:flex-table-card
the sensor providing the integrations attribute
your integration_info.sh script generating the data

Tested on:

Installation method: Home Assistant OS
Core: 2026.8.1
Supervisor: 2026.07.5
Operating System: 18.2
Frontend: 20260729.6

mannebk · August 13, 2026, 12:29am

And that’s how it looks:

Desktop:

Tablet 10" landscape:

(sorry for the background, night lighting due to sleeping kids)

Companion App on a Motorola Edge 30 Pro:

Landscape:

Portrait:

Its not jet perfect, but its a significant start. and I’m sure to add stuff to that table. e.g. “Add new Device” and making the integrations name and Icon clickable as well

mannebk · August 13, 2026, 12:53am

mannebk:

The result is stored in a Home Assistant sensor:

- sensor:
    name: "Integration_Info"
    command: "/config/integration_info.sh"
    value_template: "OK"
    json_attributes:
      - integrations

On an afterthought, I used the hass config_packages system to add a yaml file that contains just this one commandline_sensor

For this to work, you need

homeassistant:
  packages: !include_dir_named config_packages

in your configuration.yaml.

and then have a folder layout like this:

/CONFIG/config_packages/your-package-name/your-packages-config-files

I use this for better maintainability, as this way all the stuff for one thing to work is in one place. Again a “where the profanity is that hidden again?” thing.

my: /CONFIG/config_packages/integrations/integrations.yaml

# This package generates a list from all integrations that contain 
# more than just the "I am a not used integration icon.png" file 
# and then moves on to query their devices and entities. hopefully at least.

# I added the script into the docker container of HASS cause I just
# was not sure if my queries would work from outside. 
#
# This is not update proof, and I'm open to suggestions how to fix this.




command_line:
  - sensor:
      name: "Integration_Info"
      command: "/config/integration_info.sh"
      value_template: "OK"
      json_attributes:
        - integrations

Deedee · August 13, 2026, 1:01am

Looks great! Bookmarked your post so I can check it out later when I have time. Thanks for sharing this.