See Pwas at work: 30 guided minutes on an application that already runs. Book the demo →
Compare products Pwas in your industry Book a demo
Pwas-One
ERPShopCRMDoc ManagerAI Agent
Pwas.FrameworkPwas.ClientPwas.OrchestratorPwas.Microservice
Pwas CLIAssessmefyDynamic Registry Builder
Solutions Industries Documentation Partners Request a demo Get Started
Italiano English
pwas.it — powered by pooel.it
documentation · deployment and architectures

The infrastructure choices in a Pwas project.

Reference architectures, environment separation, integration with existing systems and the checks that precede production — the decisions made at the start that shape everything else.

the principle

Few initial decisions, many consequences.

A Pwas project consists of a few containerised components and a standard relational database: the architecture is simple by construction. What has to be decided at the start therefore isn't how to assemble the system, but where it runs, how it connects to what you already have, and how environments are separated. Three decisions taken in a few hours that are expensive to revisit later.

reference architectures

Three configurations covering almost every case.

They aren't product options but ways of deploying the same system. The choice depends on your constraints, not on the features you need.

Managed cloud — the default configuration

All components run on European cloud, with a managed database and backups under agreed policies. It's the configuration that costs least to run and doesn't tie up your infrastructure team.

It suits most projects, including many applications handling ordinary personal data. It becomes unsuitable where contractual data residency constraints exist, where integrations concern systems that never leave the corporate network, or where your organisation has an explicit policy against it.

What to verify first: who operates it and under which service levels, how you access logs and metrics, and how restore works.

On-premise — when the perimeter is a requirement

The same components run in your infrastructure: a virtual machine with container execution is enough to start, an orchestrator becomes the natural choice when high availability and zero-downtime updates are needed.

It's the frequent configuration in healthcare, public sector, finance and utilities, for three recurring reasons: regulatory or contractual constraints on data, integrations with systems that live only inside the corporate network, and infrastructure teams that prefer to keep everything in-house.

What to verify first: who operates the environment and with what skills, how monitoring and backups integrate with the tools you already use, and how component updates get applied.

Hybrid — the most frequent compromise when there's a portal

The outward-facing part — customer portal, citizen area, public interfaces — sits on cloud; the application core and sensitive data stay on site, with a controlled channel between them.

It's often the right configuration when you must expose something to external users but can't or won't move everything. It carries a cost in operational complexity — two environments instead of one, a channel to watch — that should be weighed deliberately.

What to verify first: which data crosses the channel and how often, what happens when the channel is unavailable, and who is responsible for which half.

Environment separation: the thing not to economise on

A serious project has at least a production environment and one where changes are verified before being applied. Because every project is an isolated environment with its own network, volumes and ports, creating a second environment is an ordinary operation rather than a parallel infrastructure to design.

The configuration describing the domain is versioned like any document, so promoting a change from the verification environment to production is a controlled, reconstructable step rather than a manual intervention.

Where data separation is a requirement, the verification environment works on anonymised or synthetic data. That's a choice to make at the start: building a realistic test dataset afterwards is far harder than it sounds, and in practice it's why so many projects end up verifying changes in production.

frequently asked

Deployment: the questions.

What resources are needed, roughly?
Sizing depends on volumes, concurrent users and automation load, and is established for your case during the project. The runtime is compact by construction — few containers, no mandatory ecosystem of ancillary services — so the starting point is smaller than you'd expect from an application platform.
Do we need a container orchestrator?
Not to start: an environment that can run containers is enough and many projects stay on that setup. An orchestrator becomes useful when you need high availability, zero-downtime updates or horizontal scaling under variable load.
How are updates applied?
They're container image releases, applied with your environment's standard procedures. Because the configuration describing the domain is separate from the images, a runtime update doesn't overwrite your rules or require redoing customisations.
What should be verified before go-live?
At least three things: load testing against peak volumes rather than averages; an independent security test, the good practice no architectural property replaces; and a full restore rehearsal, because an unverified backup isn't a backup.
Who operates the environment?
Us, you or an infrastructure partner of yours: all three are workable. Because there's no exotic technology in the stack, a competent infrastructure team works with what it already knows. The choice is made on where you prefer operational responsibility to sit.

Already have specific infrastructure questions?

Write to us — we'll answer directly, even before this page is complete.