Software engineering
Backend services, APIs and domain logic written to be read, tested and maintained by other engineers long after the first release.
IT engineering company · English
House 55 GmbH designs, builds and operates custom software, cloud platforms and secure digital products. We work as an engineering partner: architecture you can review, code you can maintain and systems you can keep running.

House 55 GmbH provides information technology services to organisations that depend on software to operate. Our work covers the full life of a system: understanding the problem, designing an architecture, building and testing it, releasing it safely and keeping it healthy afterwards.
We deliberately keep the distance between decision and implementation short. The engineers who design a system are the ones who discuss it with you, which means trade-offs are explained in plain terms and documented as part of the work rather than summarised afterwards.
Backend services, APIs and domain logic written to be read, tested and maintained by other engineers long after the first release.
Environments designed around clear boundaries, reproducible infrastructure and predictable deployment paths across staging and production.
Web and mobile front ends built on accessible components, measurable performance budgets and consistent design systems.
Pipelines, storage models and reporting layers that keep data traceable from its source through to the decisions it supports.
Threat modelling, secure defaults, dependency hygiene and access control reviewed as part of delivery rather than after it.
Observability, alerting and operational runbooks so that incidents are detected, understood and resolved with a clear process.
Each service is described in detail on the services page.
Systems shaped around a specific operating model.
Responsive, accessible applications for browsers.
Native and cross-platform product work.
Architecture, migration and cost-aware operation.
Pipelines, environments and infrastructure as code.
Research, interaction design and design systems.
Test strategy across unit, integration and end-to-end.
Reviews, hardening and secure delivery practices.
Pipelines, analytics and applied machine learning.
Architecture guidance and ongoing product care.
We favour mature, well-documented technology with active maintenance and a hiring pool deep enough that your system remains supportable. New tools are introduced when they solve a real constraint and can be justified in writing.
Six repeatable stages. Nothing is hidden behind a phase gate you cannot inspect.
We map the problem, the users, the existing systems and the constraints before proposing an approach.
Interfaces, data models and integration points are agreed and documented so the plan can be reviewed.
Work is delivered in short cycles with running software at the end of each one.
Automated tests, code review and manual verification run continuously, not only before release.
Deployment is automated and repeatable, with rollback paths defined before anything ships.
Monitoring, maintenance and roadmap work continue after launch for as long as the engagement runs.
The vocabulary changes between industries; the requirements for correctness, traceability and uptime do not. We begin every engagement by learning the domain language of the people who will use the system.


Infrastructure is defined in version-controlled code so environments can be rebuilt rather than repaired by hand.
Accounts, services and pipelines receive only the permissions required for the task they perform.
Credentials are managed outside the codebase, and dependency updates are monitored for known vulnerabilities.
Logging, metrics and tracing are part of the initial build so that failures can be diagnosed rather than guessed.
Backup and restore procedures are written down and exercised, not assumed.
A test suite describes intended behaviour, so future changes fail loudly when the intent is broken.
Static analysis, type checks and linting run locally and in CI before review begins.
Every change is read by another engineer, with an emphasis on clarity and risk rather than style.
Staging environments mirror production closely enough for verification to be meaningful.
The people who design and build the system take part in the discussions about it.
Working software, issue trackers and code repositories are open to you throughout the engagement.
We optimise for the cost of the next change, not just the speed of the current one.
Infrastructure, documentation and source code are handed over in a form your own team can operate.

Correspondence in English is handled by email. Details published here are limited to information we can verify.
