Over the years, we have kept developing our stack. It is built entirely on open source and adds our own framework of components, services, libraries and modules. It is the foundation of every project.
The illustration shows the stack as a pyramid of five layers with 33 building blocks, with the broad, highlighted foundation at the bottom. Above it float five new candidates whose paths converge at a checkpoint. Only one building block gets through and is added to the top layer.
Every component in the stack meets three criteria: proven production readiness, long-term support and clean integration with the rest of the stack.
The stack is built entirely on open source that we master and bring together in the best possible way. On top sits our own framework of components, services, libraries and modules: a great many in-house features that are a fixed part of the stack.
We decide which features and modules are added. Every improvement from a project goes into the stack and is used in all projects. Your project benefits from continuous development.
What is standard in the stack has been running in production platforms for years. Anything new goes through an internal evaluation and real-world use before it is added.
From the framework to the firewall: every layer with the tools that have proven themselves in production with us, and with the reason they are in the stack.
PHP framework as the foundation, in use at cloudtec since 2013. Modular bundle architecture, active community, long-term support releases.
The language behind Symfony and Sylius. PHP 8.3+ with typed properties, enums and fibers: type safety and speed on a par with modern languages.
E-commerce framework based on Symfony. Headless architecture, flexible product models, connections to payment providers, automated tests.
Object-relational mapper for type-safe database abstraction. Schema changes are versioned and run through migrations.
REST APIs from a configuration. OpenAPI specification, pagination and serialisation are generated automatically: the standard for all interfaces in the stack.
Our own UI framework: templates, styles and scripts for every component, built in-house instead of with Bootstrap or Tailwind. Prototypes are created with AI directly in code, from the same components that later go live.
Semantic, valid markup as the foundation of every page: the basis for accessibility, SEO and AI discoverability.
Modern features directly on the platform: container queries, light-dark() and custom properties as the theming layer.
ES modules without framework lock-in. What the browser can do on its own, the browser does.
Preprocessor for Stack UI: tokens, mixins and components, compiled into lean CSS.
Relational database for structured data, compatible with MySQL. The standard persistence layer in the stack.
Full-text and faceted search, multilingual, with stemming and synonym support. The standard for search and filters in the stack.
Search and analytics engine in existing platforms. Full-text search with fuzzy matching and aggregations across large volumes of data.
Message broker for asynchronous processing. Decouples long-running jobs (imports, exports, notifications) from the page request.
Web analytics on our own servers. Visits and user journeys stay in Switzerland, with no data flowing to advertising platforms.
Containers for reproducible deployments. Every platform runs in isolation, in an identical environment from development to production.
Container management with a web interface. Administration, monitoring and scaling of the Docker environment, centrally across all platforms.
Reverse proxy and load balancer for containers. Routes, TLS certificates and redirects are taken over automatically from the container configuration.
Reverse proxy and web server on the front line: SSL termination, load balancing and caching in front of the application containers.
Open-source firewall and web application firewall. Network segmentation, intrusion detection and VPN access to the infrastructure.
Minimal Linux as the base of all containers. Small attack surface, fast builds, regular security updates.
Unit and integration tests run in the pipeline with every commit. Plus static analysis with PHPStan and a consistent code style via PHP-CS-Fixer.
Behaviour-driven testing: business logic is described in readable scenarios and played through in headless Chrome, automatically in the pipeline.
Visual regression tests: versions are compared pixel by pixel so that broken layouts are spotted before go-live.
End-to-end tests with a low-code approach: flows are recorded in the browser and then run automatically. This way, tests can be extended without writing code.
Profiling of the PHP runtime. Finds bottlenecks, monitors regressions and delivers concrete optimisation suggestions.
Error monitoring across all platforms. Exceptions from production land in the backlog as a ticket with a stack trace instead of getting lost in a log file.
Version control with branches and code reviews: every change traceable, every line attributable.
Code hosting and CI/CD pipelines: builds, tests and deployments run automatically with every merge.
Planning and tracking: every feature and every bug has a ticket, traceable from concept to release.
The team’s IDE. Code inspections, debugger and test runner work directly on the code, with shared rules for code style.
Stack 3.0 comes with its own UI framework. The templates, styles and scripts of every component come from our own development, not from Bootstrap or Tailwind. The admin area and the public website use the same building blocks.
From button and form to data table and dialogue to file upload. Every building block is a Twig component in Symfony. Its behaviour lives in a lean script that only loads when the page needs it.
Colours, fonts and logo come from a single theme file. Every base colour automatically produces a scale of eleven shades, light and dark mode included.
The interface is divided into regions that you jump between with F6. Dialogues keep the focus until they are closed, and animations step back when the operating system asks for reduced motion.
Container queries, @scope and light-dark() directly in the browser, without utility classes or unused framework parts. External libraries are only added where they solve a task better, such as Tiptap for the text editor.
Most say ‘we host in the cloud’. We run it ourselves: our own virtual servers in hosttech’s Virtual Data Center in Switzerland, set up and operated by the same team that builds your platform.
Open-source components with long-term stability, hosting and data in Switzerland, and a foundation that grows stronger with every project.
New projects no longer start from zero but on a shared base. The approach works, but each project evolves on its own copy. Improvements do not flow back into the base.
We rebuild the stack as a monorepo, today with 23 packages. Every project uses them in a defined version, and one update brings an improvement to all platforms. Docker and automated deployments make operations consistent end to end.
The third generation brings together what we have learned from two generations: our own UX library with standardised components, MCP as the basis for AI agents, more clearly decoupled layers and more security. On top of that, the stack is tuned for performance.
How we build, test and operate. Posts from the development team.
Data centre move completed. Three things we would do exactly the same way next time, and one we will approach differently.
What makes open-source solutions special, why they form the core of our stack and what that means for maintainability and for our clients’ independence.
Unit, integration and end-to-end tests working together: how we combine the types of testing so that platforms run reliably in production.
We show you architecture, tools and operations on a real project and answer the questions your development team asks.