Security & Zero Trust

A closed port cannot be attacked.

We design infrastructure that exposes nothing: inbound access arrives through outbound tunnels, every admin interface sits behind strong authentication, and secrets never live in a Git repository.

  • Zero inbound ports open
  • MFA on administrative access
  • Encryption end to end
  • CVE watch and tracked remediation
0 Inbound ports exposed to the internet with Cloudflare Tunnel
MFA Strong authentication in front of every sensitive interface
TLS Encryption throughout, certificates renewed automatically

Security is decided in the architecture, not afterwards

Most incidents don’t come from a sophisticated exploit but from needless exposure: a database reachable from the internet, an admin panel protected by a single password, a test service left running on an open port. These situations almost always come from an architectural choice made by default, not from a deliberate decision.

Our starting position is simple: nothing is exposed until it needs to be, and whatever must be exposed travels a controlled, authenticated and logged path.

Publishing an application without opening a port

The conventional approach opens ports 80 and 443, publishes an IP address, and then defends that door: firewall, rate limiting, intrusion detection. It works, but it demands constant vigilance — and one badly written rule reopens the gap.

The outbound-tunnel approach inverts the logic. With Cloudflare Tunnel, a cloudflared agent establishes an encrypted outbound connection to the Cloudflare network itself. Visitors reach Cloudflare, never your server directly. What follows from that:

  • no inbound port to open — a port scan finds nothing;
  • the origin IP address stays private — it cannot be targeted directly;
  • the WAF and DDoS protection apply upstream, before traffic reaches your infrastructure;
  • TLS certificates are handled automatically, with no renewal to keep an eye on.

We add Cloudflare Access in front of sensitive interfaces — back offices, administration tools, staging environments. The user authenticates against your identity provider with MFA, and the application never sees an unauthenticated request. Someone leaving the team means immediate revocation, with no shared password to rotate.

Hardening what runs

A container image built without care often ships a full operating system, a shell, build tooling and a process running as root. We apply the same rules every time: minimal base image, unprivileged user, read-only root filesystem where the application allows it, Linux capabilities reduced to what is strictly needed, and vulnerability scanning on every build in CI.

On Kubernetes this comes with admission policies, NetworkPolicies that forbid unplanned pod-to-pod traffic, and RBAC that is genuinely restrictive — not cluster-admin handed out for convenience.

Being able to go back

No protection is absolute. So the honest question isn’t only “how do we prevent an incident?” but “how long until we’re running again, and with which data?”.

That’s why we treat backups as a security function in their own right: encrypted, stored off-site, unreachable from the production server — the condition for surviving ransomware — and above all restored regularly to prove they work. The real restore time is measured and written down, not estimated at the moment you need it.

The four planes we cover

Network exposure

The easiest attack surface to remove is the one you never open. We replace direct entry points with controlled outbound connections.

  • Cloudflare Tunnel (cloudflared) to publish without NAT or open ports
  • Default-deny firewall, administration through a bastion or WireGuard
  • WAF and denial-of-service protection upstream
  • Network isolation between applications and databases

Identity and access

Knowing who reaches what, and being able to revoke it in one action. Admin interfaces should never be reachable with a password alone.

  • Cloudflare Access or SSO in front of back offices and internal tools
  • Mandatory MFA, named accounts, least privilege
  • Logging of logins and sensitive actions
  • Periodic access reviews, immediate revocation when someone leaves

Containers and the build chain

A container is not a virtual machine: its security is decided when the image is built as much as when it runs.

  • Minimal images, non-root user, read-only root filesystem
  • Image vulnerability scanning in CI
  • Secrets injected at runtime, never in the repository or the image
  • Dependencies tracked and updated automatically (Renovate)

Data and continuity

Security includes the ability to go back: after human error, corruption or ransomware.

  • Encrypted backups, stored off-site and out of reach of the production server
  • Restores tested, with the real duration measured and documented
  • A written recovery plan with explicit RPO and RTO
  • Encryption in transit and at rest, according to sensitivity
Frequently asked questions

Security: the questions that keep coming up

In practice, how does Cloudflare Tunnel work?
A lightweight agent (cloudflared) runs next to your application and opens an outbound connection to the Cloudflare network. Visitor traffic reaches Cloudflare, then travels back down that already-established tunnel. Your server therefore has no inbound port open and its IP address doesn’t need to be public: a port scan finds nothing to attack.
Does that make us dependent on Cloudflare?
It is a real dependency and it deserves to be named. It also stays reversible: the application itself doesn’t change, only the way it is published. We always document the switch back to a conventional reverse proxy (Traefik or nginx with Let’s Encrypt certificates), and we can build the architecture without Cloudflare if your policy requires it.
Do you run penetration tests?
We run configuration and hardening audits, and fix what they surface. For a formal penetration test we work with specialist firms: the auditor should not be the person who built the system.
How do you handle secrets and passwords?
They are never committed to Git. Depending on the context: Docker secrets, encrypted Kubernetes secrets (SOPS, Sealed Secrets), or HashiCorp Vault. CI automatically checks that no secret leaks into a commit.
Are we affected by GDPR or NIS2?
We are neither lawyers nor a certification body, and we won’t pretend otherwise. What we do provide are the technical measures those frameworks expect — logging, encryption, access control, backups, reversibility — along with the technical documentation your DPO or auditor will ask for.

Let's talk about your infrastructure

Migration, redesign, taking over an existing setup or starting from scratch: tell us your context and we'll come back with a first technical opinion — no strings attached.