Skip to content

Security & data

Application and data security audits.

We review your code and configuration, implement fixes and cover the technical side of GDPR, so your application runs reliably and stays compliant.

Closed metal padlock on a white computer keyboard on a wooden desk

We secure your application so your data stays protected and your system is available 7 days a week. You also know exactly who can access your data, how long we keep backups and what happens in the first 24 hours after a breach is reported.

Overview

We check the details that decide how secure your data is.

It usually comes down to small things: a publicly accessible code directory, an active admin account belonging to someone who left the team, a plugin its vendor no longer supports, or a staging environment with real data that shows up in search results. We check each of these points and close it before it becomes a problem, so your data stays protected.

We read the code and test how the application responds to data sent straight to the server, bypassing the user interface—that’s where the flaws you can’t spot at first glance usually hide. You get a list of issues, each with a file name, a description and a priority, so you know what to fix first and how long it will take.

Empty server room corridor with glass doors and dark steel frames

Code review

XSS, SQL injection, IDOR and endpoints without permission checks.

Access & secrets

Named accounts with MFA, secrets in a password manager, key rotation after every team change.

Server & TLS

nginx, TLS 1.2/1.3, HSTS and auto-renewing Let's Encrypt certificates.

Data & retention

Logs kept for 90 days, backups for 30 days, a restore test every quarter.

What our security work covers.

Everything from a one-time audit and post-infection cleanup to ongoing maintenance of your environment.

Ongoing support after the audit
  • Application & store audit

    The application, the admin panel and the integrations. The report ranks findings by priority and estimated hours.

  • Code review

    We review the code by hand, because the most serious flaws sit in the application’s business logic—an automated scanner misses them, since on paper everything works.

  • Secrets, keys & accounts

    We move passwords and access keys out of the code into a secure password manager, review permissions and rotate keys, so only the right people can access the system.

  • Server hardening

    We configure the server (nginx, TLS 1.2/1.3, HSTS and CSP) and take the admin panel and internal services off the public internet, so connections are encrypted and access is limited to trusted people.

  • Backups & restore

    We store backups off the production server and encrypt them before upload. Once a quarter, we restore them on a clean machine, so you can be sure you’ll recover quickly after a failure.

  • Malware cleanup

    We remove hidden backdoors from WordPress and close the exploited vulnerability, so the system stays clean and the infection doesn’t return.

Methodology

What our audit checks.

A checklist we work through every time, plus items that follow from how your specific application is built.

  • Input and output encoding—in templates, in the admin panel and in customer-facing fields
  • Database queries built in a safe, parameterized way, so user input can’t change what they do
  • Permission checks on every request to the server, so only authorized people can access the data
  • Places where passwords and keys can end up by accident—in the code, in the commit history and in the site configuration
  • Server-side validation of amounts, discounts and permissions
  • Verification of notifications from other systems (webhooks) and safe handling of repeat deliveries, so that, for example, one payment isn’t recorded twice
  • Server: dependency versions, headers, certificates and access to the hosting console
  • WordPress
  • WooCommerce
  • MedusaJS
  • Next.js
  • Node.js
  • PHP
  • PostgreSQL
  • MySQL
  • nginx
  • Docker
  • Let's Encrypt

Findings

What we regularly find in audits.

These are the issues that come up most often in our audits, so we check them first in your system.

  • Active admin accounts belonging to people who left several months earlier
  • Dependencies and plugins in versions that no longer get security updates from the vendor
  • No two-factor authentication and no limit on failed login attempts
  • Backups on the same server as production, so a server failure takes the backup down with it
  • A copy of the production database in the test environment, without anonymization
  • Staging sites with no indexing block and no block on outgoing email
  • Email addresses and full request bodies written to logs without filtering
  • Passwords hashed with MD5 or SHA1, sometimes without a salt
  • API endpoints without authentication, guarded only by the user interface
  • Notifications from other systems (webhooks) accepted without verifying that they come from a trusted source
  • A .git directory, database dumps and ZIP archives at a public URL
  • No enforced encrypted connections (HSTS, CSP) and a certificate renewed by hand, which is easy to overlook

Our principles

Eight questions to ask before you sign.

We ask our own vendors the same questions before they get access to our infrastructure.

24h Notice of a suspected breach, counted from detection
72h Patch for vulnerabilities rated CVSS 9.0 or higher, weekends included
4h Response to a critical incident, during business hours
30days Backup retention, with a full backup every 24 hours
Who has access to your code and data?

Only named accounts with SSH keys and MFA. Production access is limited to two named people, and everyone else works in the test environment. Accounts expire on the day the engagement ends. We keep secrets and .env files only in a password manager, with per-project access, outside the repository and messaging apps. We rotate keys after every change in the team.

Where is your data physically stored?

In data centers within the EEA—Warsaw or Frankfurt. Server disks are encrypted, and traffic runs over TLS 1.2/1.3 with HSTS enforced. We encrypt backups before sending them to remote storage and keep their keys off the server they belong to. On request, we send you the list of subprocessors by name.

How long are backups and logs kept?

A full backup once a day, an incremental backup every hour, 30-day retention. Once a quarter, we restore a backup on a clean server and measure the restore time, because only a backup that has actually been restored proves it will work after a failure. We keep logs for 90 days, free of passwords, tokens and national ID numbers: we filter by field name before anything is written to disk.

Does production data end up in the test environment?

Only in anonymized form. Before taking a dump, we run a script that anonymizes email addresses, phone numbers, ID document numbers and payment data, and the script stays in your repository. Production, staging and local environments each have their own databases, keys and email accounts. Staging sends no email to external addresses.

How does code reach production, and how fast are vulnerabilities patched?

Every pull request is reviewed by a second person—nobody ships their own code to production unreviewed. CI runs tests, a static analyzer and a dependency scan (composer audit, npm audit). We update dependencies every month and patch vulnerabilities rated CVSS 9.0 or higher within 72 hours, weekends included.

What happens if the system goes down at night?

Before each deployment, we take a database dump and tag the release. Rolling back takes a single command and less than a minute of downtime. Production deployments stop at 3 p.m. CET on Fridays. We connect monitoring to your Slack channel, so you see a 500 error alert in the same minute we do. We respond to critical incidents within 4 business hours.

What happens in the event of a data breach?

We notify you of a suspected breach within 24 hours of detection, so you have time to report it to the data protection authority within the 72 hours required by GDPR. You receive the scope and categories of data affected, the time window, the list of systems and a description of what we have already contained. If there has been an intrusion, we secure the logs first, because they show how the attacker got in and let us close that route for good.

Do AI tools see your code?

We use business tiers of AI tools, where the provider contractually excludes training models on the data we submit. We never paste secrets, .env files or production data into them. If your policy prohibits AI tools entirely, we work without them and confirm this before the project starts.

Retention

What we store, where and for how long.

This table covers our infrastructure. Data in your systems stays with you.

Data retention in LifeDigital’s infrastructure
WhatWhere it’s storedHow it’s protectedHow long
Code and change historyYour GitHub repositoryNamed accounts, MFA, mandatory code reviewWorking copy deleted 30 days after the engagement ends
Production database backupsRemote storage in the EEAEncrypted before upload, key kept off the server30 days
Pre-deployment database dumpDeployment serverEncrypted disk, two named accounts14 days
Application logsApplication serverFields with passwords, tokens and national ID numbers filtered out90 days
Secrets and configurationPassword manager, per-project accessRotated after every team changeUntil the engagement ends

End of engagement

What we keep when the engagement ends.

Within 30 days, we delete repository copies, database dumps and working files, and send you a dated written confirmation. You get a list of accounts to deactivate and keys to rotate. We sign a data processing agreement under Article 28 GDPR before we receive the first password, so the rules are clear from the very start of the engagement.

Transparency

Limits of responsibility and proof.

Three limits we state in our first reply.

We don’t hold ISO 27001 certification or a SOC 2 report, and we say so up front. If your procurement team requires either document, mention it in your first email, so you know right away whether working with us meets its requirements.

We don’t run penetration tests, because pentesting is a separate specialty with its own toolkit and its own liability. We refer you to a specialist firm, implement the fixes from its report and ask for a retest of the same points.

We don’t claim full GDPR compliance on your behalf, because compliance covers your organization as a whole—records of processing, legal bases, contracts. We’re responsible for the mechanisms on our side and for making sure the application respects them. A lawyer writes your privacy policy, and we supply the technical facts it rests on.

Check it yourself in one minute.

Run curl -I https://yourdomain.com and look for the Strict-Transport-Security header. We check every system we deploy this way—and you can check us the same way. On request, we send the following within the same business day:

  • A template data processing agreement—to pass to your lawyer before we discuss scope
  • The list of subprocessors by name: hosting, email, monitoring, backups
  • A sample code review report from an anonymized project
  • The checklist for handing a project over to another company—the same one we’ll use if you decide to move on
  • The result of our latest backup restore test: the date, the restore time and what didn’t go to plan

Process

Security audit, step by step.

  1. 01

    Scope & rules of engagement

    We document versions, dependencies, integrations and who has access to what. Together, we agree on what must stay untouched.

  2. 02

    Code review & abuse testing

    A code review and controlled abuse attempts on a copy of the environment. Each finding gets a priority and an hour estimate.

  3. 03

    Fixes

    We deploy fixes outside production first, with regression tests, and agree on the order with you.

  4. 04

    Retest & maintenance

    We recheck the same points and close the report. After that: monitoring, updates, backups.

Incident

When an incident is underway, order matters.

First, we secure a snapshot of the system state and the logs, then revoke access and look for the entry point. We close the vulnerability before removing the malicious file, so the problem doesn’t come back. Restoring the service comes last: we change passwords and keys, and check for hidden accounts and injected redirects.

FAQ

Questions we hear most often.

Do we get more than a scanner report?

We treat the scanner as the starting point for a proper review. The most serious flaws sit in the application’s business logic: a server request with no permission check, an ID that can be swapped, browser data accepted at face value. An automated tool misses them because on paper everything works, so we review the code by hand and show you what actually needs fixing.

Why does this page describe vulnerability classes?

Because an audit finding is, in practice, a manual for exploiting the vulnerability. Once published, it harms the system owner even after the fix, since the same bug usually sits in several places in the same codebase. That’s why we talk about vulnerability classes, our audit checklist and our own access rules—the same ones we apply to your project.

Can we give the report to another company to implement the fixes?

Yes. The report is yours, and it contains no clauses that would prevent this. Each item includes its location in the code and a description of the fix, so your own team or any contractor can handle it.

We suspect our site is infected. Where do we start?

Email us before you clean anything up. Untouched files and logs let us determine how the attacker got in and close that route. We secure the current state, find the entry point, remove hidden backdoors and close the vulnerability, so the system returns to stable operation.

This page was last updated in August 2026. We mark substantive changes. If the retention period, the hosting provider or the breach reporting procedure changes, we say so explicitly here.

Make sure your application and data are protected.

Email us what your application runs on and what concerns you. We reply within one business day with questions, then send an audit scope and a start date. If you suspect a breach, we get back to you the same day.