Software we could run ourselves: architecture and development

We design and build software that is meant to go into production: SaaS applications, APIs and multi-tenant services, with microservices where they fit. It is for founders, business units and software teams. We plan the architecture for operations: tenant isolation, recovery, delivery by GitOps. Fortlauf is our product. We built it, and we run it on our own hardware.

Request an intro call

Typical first stepTypical entry point: an intro call about your goal, your users and your timeline. After that you get a written proposal with scope, result and assumptions.

Where teams usually start

  • A new product, but no engineering in-house. The idea is clear, customers are waiting, and nobody on staff can build and run the software.
  • Every new customer means manual work. Another instance, another copy of the database, another special case. The application does not scale with the business.
  • A rebuild is due. The code has grown for years, every change takes too long, and nobody wants to touch the data model.
  • Systems need to talk to each other. There is no API for customers and partners, or data moves between applications by export and import.

How we work

  1. Software architecture.

    Requirements, tenancy model, data storage, interfaces and operations. You get an architecture document with the decisions and the reasons for them.

  2. Development.

    In short increments, with a working build after each one and automated tests.

  3. Delivery.

    The pipeline exists from day one: build, test, version, roll out to a test environment first, then to production.

  4. Operations or handover.

    Runbooks, a measured restore rehearsal and a walkthrough. After that your team runs the software, or we run it within the scope agreed in the contract.

What we build and run ourselves

Our clearest example is our own product: a multi-tenant SaaS, in production since July 2026. Building it is where we made the decisions we now recommend to clients:

Where the software runs afterwards: Kubernetes platforms, built and run.

Stack

  • Tenant isolation in the database: PostgreSQL enforces the separation between customers through row-level security; the application connects with a role that cannot bypass those rules.
  • Immutable document storage: documents sit in S3-compatible object storage with Object Lock and cannot be overwritten there.
  • Its own sign-in: a dedicated identity instance based on authentik, kept apart from our internal services.
  • Delivery by GitOps: every component is versioned automatically and rolled out to a separate test cluster first, then to production.
  • Stack: TypeScript and SvelteKit, PostgreSQL with CloudNativePG, Kubernetes. In client projects also Kotlin and Spring Boot, Node.js, Argo Workflows and Crossplane.

Case studies

Small manufacturer of safety systems

Case study: one development process for a hardware maker

A manufacturer of safety systems introduced a Kanban development process covering code, designs and hardware tests. We advised on it and set up GitLab, GitLab CI, OpenProject and paperless-ngx on their own VMs with SMTP and LDAP/SAML2.

Passenger information at a large transport operator

Case study: release tests for passenger information, automated

Test tooling as dedicated services (Spring Boot, Kotlin, Node.js), release tests as Argo Workflows, release environments via Crossplane on Kubernetes.

Our own product

Case study: running a SaaS on our own infrastructure

In production since July 2026: tenant isolation in the database, immutable document storage, delivery by GitOps, measured recovery.

Who you will talk to

One fixed contact from the intro call to the handover.

Send a message

What we do not do

  • No staff placement at a day rate without an agreed outcome.
  • No handover without documentation: what we build, your team can run and develop further.
  • No projects around our own product. For questions about Fortlauf: fortlauf.de.

Frequently asked questions

Can you build alongside our existing team?

Yes. We work in your repositories, follow your review and release rules, and hand over knowledge as we go rather than at the end.

Monolith or microservices?

It depends on your team and your load. Microservices pay off when parts have to ship or scale independently and someone can run them. For a new product with a small team, a well-structured monolith is often the faster route; we cut it so that parts can be split out later.

Can you review an existing application first?

Yes. Before a rebuild we look at the code, the architecture, the data model and how it is run, and write down what can stay, what should be replaced and in which order, each with its effort.

Do you run the software afterwards?

If you want us to, within the scope agreed in the contract, on your platform or in your cloud. How we build and run platforms: Kubernetes platforms, built and run.

Do you also work on test and release tooling for existing platforms?

Yes. For an event-driven data platform (Kafka, Spring Boot) we took the test orchestration from plain GitLab CI jobs to automated end-to-end release testing: test runners in Node.js, REST APIs for the test tooling in Kotlin and Spring Boot, Argo Workflows for orchestration, and Kubernetes with Crossplane to provision release environments.

Insights

Want to talk about what you are building?

Tell us what needs building, for whom and by when.