# Home Information: a floor plan that doubles as a home knowledge base

> Home Information is a Django and Bootstrap application that stores manuals, maintenance records and device state for a house, then places every item on a floor plan you draw yourself. It runs as a Docker container on your own network with SQLite storage, and it earns its keep only if you already run Home Assistant, Frigate or a similar stack.

**cassandra/home-information** — Home Information - Your home, your data, organized.

- Repository: https://github.com/cassandra/home-information
- Stars: 962 · Forks: 73
- Language: Python
- License: NOASSERTION
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/cassandra-home-information

## The organizing idea is a location, not a device category

Home Information is a Django and JavaScript application for households that want a single place to hold the information about a property. The README names the gap it fills: home automation and security systems give you control over devices, but they do not answer where the HVAC manual is filed, when the water heater was last serviced, or which camera covers the back door. The answer the project proposes is spatial. Items are positioned on a floor plan or property map that you customize to match the house, so the record for the boiler is looked up by walking to the boiler.

That is a different information model from a typical device dashboard, which groups things by vendor, protocol or integration. A dashboard tells you the state of a device. A spatial index tells you everything about the place a device lives in, including paperwork, warranty documents, service history and notes, and the README is explicit that this is a deliberate departure from organizing by device type or vendor.

The audience is narrow and the project says so. The stated users are homeowners who want to keep property organised, households moving away from scattered notes and files, and people with integrated homes running security systems, home automation or smart devices. Someone with a single smart plug and a folder of PDFs will find the floor plan editor more work than the payoff.

## Records are anchored to a drawn floor plan, and views slice it

The mechanism behind the spatial idea is a layout editor and the set of views built on top of it. Items are placed exactly where they belong on floor plans or property maps, the layout is customizable to match the home and property, and multiple views can be created over the same underlying data, such as a whole house view, a kitchen only view, or a view scoped to security zones. The README lists a floor plan editor under working features, and a separate Layout Editor document covers how to use it.

Alongside the spatial layer sits conventional record keeping. Manuals, warranties and documents are uploaded and organized by location, notes and specifications are stored for each item, and maintenance histories and repair records are tracked. The point is that all of these are attached to the same positional object rather than living in a separate document repository.

Security views add a layer of state on top of the same map. The README describes visual security zone monitoring with color coded status, email alerts, customizable alarm sounds, and browsable video event histories. The mapping is thus not decorative: the same coordinate that places a manual also places a camera and a zone status, which is what makes a per kitchen or per security zone view possible without duplicating data.

## One shell command, then a browser on port 9411

The stated requirement is Docker, installed and running. The quick start is a single command that pipes the install script into a shell, and the README states that the script handles Docker setup verification, secure credential generation and application startup on its own.

```shell
curl -fsSL https://raw.githubusercontent.com/cassandra/home-information/master/install.sh | bash
```

After it completes you open the application in a browser, and the documented address is a local port.

```
http://localhost:9411
```

Two practical notes. The script URL points at the master branch, while the repository's default branch is staging, so a user following the default branch setting will be looking at a different line of the project than the one the quick start fetches. Second, piping a remote script straight into a shell gives the script your privileges with no review step, which is worth doing by hand the first time: the repository also ships an install.sh at its top level, so you can read it before running it.

The README points to an Installation Guide and a Deployment Options document for anything beyond the quick start, including network access, custom compose stacks and production configuration, and the repository root contains a docker-compose.example.yml, a local.env.example, an update.sh and an unraid directory, so a manual deployment is a supported path rather than a fallback.

## The value lives in the integrations, not in the records alone

Manual storage on a nice map is a modest feature. What the project actually adds is a bridge to the tools a technical household already runs. The README names Home Assistant for controlling lights, switches and devices, and for monitoring device states and histories, and it names Frigate or ZoneMinder for camera management, with email alerts and event histories layered on top. It also links to information held in other applications: Paperless-ngx, HomeBox and Immich.

The direction of the link matters. Home Information is not claiming to replace any of those systems. Home Assistant remains the control plane for devices, Frigate and ZoneMinder remain the camera engines, and Home Information points at information stored in Paperless-ngx, HomeBox and Immich. What Home Information adds is a spatial index that can point at records living in those other tools, so the manual for a device in a specific room can be found from the room rather than from a document list.

That framing also explains the architecture choices. A Django backend with SQLite storage and a Bootstrap front end is a modest stack, which is the point: the value of a hub is its ability to point at other systems, and a small deployment surface is easier to keep running on a home network than a heavier one. The README describes the project as local first, stating that your data stays on your network and that no cloud services are required, and the integrations are described as the way it fits with existing automation and security systems rather than replacing them.

## One container, four processes, a pinned Python image

The Dockerfile in the repository root shows more than a single web process. The build stage pins a specific interpreter for consistency across platforms, and the runtime stage installs nginx, redis-server and poppler-utils alongside supervisor, which is then used to run several processes from one configuration file.

```
FROM python:3.11.16-slim-trixie
ENV PYTHONPATH=/src
ENV VIRTUAL_ENV=/opt/hienv
```

The application source is copied to /src, a virtual environment is created at /opt/hienv in the build stage and copied into the runtime image, and the nginx and supervisor configuration files come from the package directory. The data directories for the database and for media are created in the image, which tells you that persistent state is expected to live in mounted volumes rather than in the container layer. Poppler being present is consistent with a document oriented application that needs to work with PDF manuals.

The Makefile shows the development loop, and it is worth reading because it names the expectations the project has for a working checkout.

```
cd src && ./manage.py test --keepdb
cd src && flake8 --config=.flake8 hi/ 2>/dev/null
```

Those are the Django test and lint entry points, run from the src directory, and the test target reuses the existing test database. Other targets build the image with a version tag read from a HI_VERSION file, generate environment files with a Python script under deploy, and check for environment drift with a shell script in the same directory, which suggests the project treats configuration drift between environments as something it wants a tool for.

## A licence label that does not match the documentation

Here is a detail that deserves a careful look before anyone builds on this. The repository licence is labelled as a custom licence that GitHub cannot classify, and the README points at a LICENSE.md file described as MIT License terms. Those two statements sit awkwardly together, and a reader cannot tell from the repository listing alone which one governs. The safe move is to open LICENSE.md and read it before copying code, modifying it, or redistributing a derived image, because the difference between an MIT grant and a custom, possibly restrictive, licence is the difference between permissive use and a redistribution obligation.

That is a paperwork point, not a code quality point, and it is one of several reasons to treat this as an early stage project. The README describes the status as ready for early adopters, with all core features implemented and functional, and the project is explicitly looking for users who want to help refine the experience. Under the heading of what is evolving, it lists user interface polish in some areas, additional integrations based on user demand, and mobile experience optimisation. It also names the floor plan editor, the security modes, the monitoring and alerts, the multi location and multi view support, and the Home Assistant, Frigate, Paperless-ngx, HomeBox, Immich and ZoneMinder integrations as the parts that already work.

The maintenance record is consistent with that picture. Version 1.2.1 was published on 2026-06-04, 1.2.2 on 2026-06-08 and 1.2.3 on 2026-06-11, and the last push to the repository was on 2026-09-08. The repository is not archived. The gap between the last release and the last push suggests work continued after the newest tagged version.

## Where this stops being the right tool

The limits are concrete. First, the spatial model is a manual effort. The floor plan has to be drawn and the items placed, and while the editor is a working feature, the README is candid that user interface polish in some areas is unfinished. For a household with a large number of devices, the initial placement work is the cost that never fully goes away, and re-placing items after a renovation is a chore the product does not solve.

Second, this is not a monitoring or control system. Home Assistant handles device control, and Frigate and ZoneMinder handle camera management. Home Information reads from those systems, displays what they report, and sends alerts, but it is not the place where a light is actually switched or a camera is actually configured. Treating it as a security console will disappoint, because the underlying engines still need their own attention.

Third, the deployment story assumes a home lab. Docker, a container that runs nginx, redis and supervisor together, and an install script that generates credentials, all assume a machine that is on and reachable. The local first claim is a real advantage over a hosted service, since nothing leaves the network, but it also means updates, backups of the SQLite database and the mounted media directory become the operator's job, and the repository's own documentation is where the details live.

Finally, the project is candid about audience. An early adopter profile means a rough edge or two in the interface and a feature set that will move. For a household that wants a finished dashboard, reading the stated status before installing is more useful than reading it after.

## Conclusion

Adopt Home Information if you already run a local home automation or camera stack, you want the manual and the maintenance history next to the physical object, and you are willing to maintain a Docker deployment that hosts a web app on your own network. Do not adopt it if the problem is only device control, since Home Assistant already does that, or if you need multi user accounts and cloud delivery. Verify first that the licence file matches what you intend to do with the code, since the repository is labelled with a custom licence that GitHub cannot classify while the README points at MIT terms, then confirm the install script resolves the branch you expect before piping it into a shell.

## FAQ

### What is Home Information and who is it for?

Home Information is a Django and Bootstrap application that stores manuals, warranties, notes and maintenance history for a home, positioned on a floor plan you draw. The README points it at homeowners, households moving away from scattered notes, and people with integrated homes running automation, security systems or smart devices.

### How do I install Home Information?

Docker must be installed and running, then the quick start runs the install script, which the README says handles Docker verification, secure credential generation and application startup. After that you open http://localhost:9411 in a browser.

### Does Home Information need an internet connection or a cloud account?

The README describes the project as local first, stating that your data stays on your network and that no cloud services are required. It is deployed as a Docker container with SQLite storage, so the application and its data live on your own machine.

### Which home automation and camera systems does Home Information connect to?

The README names Home Assistant for controlling lights, switches and devices and for watching device states, and Frigate or ZoneMinder for camera management. It can also link to information held in Paperless-ngx, HomeBox and Immich.

### What licence does Home Information use?

The repository is labelled with a custom licence that GitHub cannot classify, while the README points at a LICENSE.md file described as MIT License terms. Read the LICENSE.md file in the repository root before reusing the code, since those two descriptions do not line up.

### How often is Home Information updated?

Version 1.2.1 was published on 2026-06-04, 1.2.2 on 2026-06-08 and 1.2.3 on 2026-06-11, and the last push to the repository was on 2026-09-08. The repository is not archived, and the README describes the project as ready for early adopters with some interface work still to come.

## Sources

- [cassandra/home-information on GitHub](https://github.com/cassandra/home-information)
- [Issues](https://github.com/cassandra/home-information/issues)
- [README](https://github.com/cassandra/home-information/blob/staging/README.md)
- [Releases](https://github.com/cassandra/home-information/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/cassandra-home-information