// software audit

Technical audit for software applications

An independent assessment of your application: architecture, code, security, data, scalability, integrations and operations. You get a clear picture of the risks and a prioritised remediation plan that management can use to decide and the technical team can use to deliver.

9 dimensions
assessed, each on a maturity scale from 1 to 5
Read-only
access to code and infrastructure, with no changes in production
17 specialists
software engineers, QA, DevOps and UI/UX in the DevTeam team
Since 2015
building and maintaining web applications, CRM, ERP and SaaS
// context

When an application needs a technical audit

The audit answers a business question with evidence: what state is the application in, and what needs to be done to take it further safely. Most often, the question comes up at one of these moments.

Technical due diligence

Before an investment, an acquisition or a partnership, the audit shows the real state of the product, the risks and the costs you take on.

Taking over from another vendor

When you change vendors or internal teams, find out exactly what you are getting: code, infrastructure, documentation, access and risks.

Preparing for growth

More users, new markets or new integrations: we check whether the architecture and the infrastructure can support the next stage.

Recurring incidents and regressions

Production errors, slowdowns or releases that break existing features. We identify the root causes, not just the symptoms.

Security and compliance

Security questionnaires from large clients, GDPR or NIS2: an independent assessment shows where the application stands and what needs to be done.

Modernise or rewrite

Before a costly decision, find out what can be kept, what needs modernising and whether a rewrite is really justified.

// what we assess

Nine dimensions of the application, one assessment scale

Each dimension receives a maturity level, with the reasoning behind it. We agree on the scope together: a full audit or only the dimensions relevant to the decision you need to make.

  1. 1
    CriticalRisks that require immediate action.
  2. 2
    FragileIt works, but every change is risky.
  3. 3
    AcceptableStable, with improvements needed.
  4. 4
    SolidGood practices applied consistently.
  5. 5
    MatureGood practices, automation and complete documentation.

Architecture and design

The structure of the application and its ability to evolve without becoming fragile.

  • Modularity and separation of concerns
  • Dependencies between components and single points of failure
  • Consistency of architectural decisions
  • The cost of adding new features

Code quality

How readable, testable and maintainable the code is, measured automatically and reviewed by hand.

  • Complexity, duplication and dead code
  • Conventions, consistency and code review
  • Automated test coverage
  • Technical debt, estimated per module

Application security

Vulnerabilities in the code and in the configuration, assessed against the OWASP Top 10 and OWASP ASVS.

  • Authentication, authorisation and sessions
  • Input validation and injection protection
  • Secrets management and data encryption
  • Dependencies with known vulnerabilities

Data and database

The data model, data integrity and the safety of business information.

  • Data model, constraints and integrity
  • Expensive queries and indexes
  • Migrations, backups and tested restores
  • Retention and protection of personal data

Performance and scalability

Today’s bottlenecks and tomorrow’s limits, estimated from the code and from measurements.

  • Response times on critical flows
  • Jobs, queues and background processing
  • Caching and resource usage
  • Limits as data volume and user numbers grow

Integrations and APIs

The connections to the ERP, payments, invoicing and other systems, where an error quickly reaches customers or the books.

  • API contracts, versioning and documentation
  • Error handling, retries and idempotency
  • Dependence on external services
  • Authentication and permissions of API keys

Infrastructure, DevOps and operations

How the application is built, released and monitored in production.

  • Separate development, test and production environments
  • CI/CD, the release process and rollback
  • Monitoring, logs and alerts
  • Recovery plan: RPO, RTO and restore tests

Dependencies, licences and vendors

The risks that come from outside your own code: unsupported versions, licences and vendors.

  • Language, framework and library versions against official support
  • Open-source licences compatible with the business model
  • Dependence on a single vendor (vendor lock-in)
  • Recurring costs of external services

Documentation and knowledge transfer

How much the application depends on the people who know it, and how quickly someone else could take it over.

  • Technical and architecture documentation
  • Onboarding a new developer
  • Knowledge concentrated in a single person
  • Access control for code, servers and accounts
// methodology

Automated analysis, expert review and validation with your team

Automated tools quickly find known issues. The risks that matter to the business, however, only surface when an engineer understands how the application works. That is why we combine four sources of information.

Automated static analysis

Code, dependencies, exposed secrets and licences, checked with specialised tools.

Manual review

Experienced engineers read the critical flows: authentication, payments, invoicing, integrations, reporting.

Interviews and documentation

Conversations with the technical team, the product owner and the people who operate the application.

Infrastructure and processes

Environments, releases, backups, monitoring and system access, checked against the real configuration.

Assessment references

  • OWASP Top 10
  • OWASP ASVS
  • ISO/IEC 25010 (software product quality)
  • GDPR
  • WCAG, for user interfaces

We use them as references for a consistent assessment that can be compared over time. The audit is not a certification.

// deliverables

What you receive at the end of the audit

A report structured on two levels: conclusions for decision-making and details for delivery.

  • Executive summaryThe overall state, the major risks and our recommendation, in terms management can act on.
  • Maturity scorecardThe level of each assessed dimension, with the reasoning behind it.
  • Risk registerEvery finding with its evidence, severity, impact, recommendation and estimated effort.
  • Current architecture mapThe components, data flows and integrations as they are today.
  • Remediation plan by horizonImmediate (0–30 days), short term (1–3 months) and medium term (3–12 months).
  • Presentation of the resultsFor management and for the technical team, together or separately.
Risk register sample, fictitious data
Sample risk register from a software audit, with fictitious data
ID Finding and recommendation Severity Horizon
R-01 API keys and the database password stored in the Git repositorySecurity · move to a secrets vault and rotate the keys critical 0–30 days
R-02 Restoring from backup has never been testedOperations · documented restore test, then on a schedule critical 0–30 days
R-03 Framework version no longer receives security updatesDependencies · staged upgrade, covered by tests high 1–3 months
R-04 Only one person knows the release processProcesses · documentation and CI/CD automation high 1–3 months
R-05 Invoicing logic duplicated across three modulesCode · extract into a shared service medium 3–12 months
Every finding in the register is backed by evidence in the technical appendix: the file, the configuration or the measurement.
// who it is for

One audit, three perspectives

// management

Well-founded decisions

Risks expressed in business terms, the costs the application will generate and a clear recommendation: continue, modernise or rewrite.

// technical team

A prioritised work list

Concrete findings with files, configurations and remediation steps, ordered by risk and effort. An outside view of the decisions made so far.

// investors and partners

An independent assessment

The real state of the product, its dependence on key people, licensing risks and the investment the next stage requires.

// process

How the audit is carried out

We start from the questions the audit has to answer, for example “can the application support five times as many users?” or “what are we taking on with this product?”. We agree on the scope, access and schedule together, before we start.

  1. 01

    Goals and scope

    We agree on the decision the audit has to support, the dimensions in scope and the people to talk to.

  2. 02

    Confidentiality and access

    On request, we sign a non-disclosure agreement (NDA). We receive read-only access to the code, the documentation and, where relevant, the infrastructure.

  3. 03

    Discovery

    Conversations with the team and a review of the documentation, to understand the context of the technical decisions.

  4. 04

    Analysis

    Automated analysis and manual review for every dimension in scope.

  5. 05

    Validation of findings

    We discuss the important findings with your team before the report, to rule out misinterpretations.

  6. 06

    Report and presentation

    We deliver the report and present it to management and to the technical team.

  7. 07

    Remediation support (optional)

    We can help implement the plan or reassess the dimensions after remediation.

// principles

Independence and confidentiality

Objectivity

We recommend a rewrite only when it costs less than modernisation or when the risks demand it.

The report is yours

Your internal team or any vendor can use it. There is no obligation to continue with us.

Confidentiality

Minimal, read-only access and an NDA on request. Personal data stays out of the report.

The system, not the people

We assess the code, the architecture and the processes. Findings are validated with the team before the report.

// what the audit is not

Not a penetration test, and not a certification

We assess security in the code, the dependencies and the configuration, without attacking the systems. If you need a certified penetration test or an ISO/IEC 27001 or SOC 2 certification, we tell you so in the first call.

// next step

Talk to a DevTeam engineer

In a first call, we agree on the goals of the audit, the scope and the access needed. We then send you a proposal with the scope, the timeline and the cost. The call comes with no obligation.

For the first call, it helps us to know:

  • what the application does, who uses it and which technologies it is built with;
  • which decision the audit needs to support;
  • what access is available: code, documentation, infrastructure.
Request a consultation
// questions

Frequently asked questions about software audits

It is an independent assessment of how an application is built and operated: architecture, code, security, data, performance, integrations, infrastructure, dependencies and documentation. The result is a report with the maturity level of each dimension, a risk register and a prioritised remediation plan.

A website audit focuses on what visitors and search engines see: speed, technical SEO, accessibility, forms. A software application audit goes deep into the system: architecture, business logic, data, integrations, operations and long-term risks. For brochure sites and online shops, see our technical website audit.

It is the audit carried out before an investment, an acquisition or a strategic partnership. It answers questions such as: how healthy is the product, what technical and legal risks does it hide (for example, incompatible open-source licences), how much does it depend on key people and what investment does the next stage require.

Read-only access to the source code (the Git repository), the documentation and, where relevant, the infrastructure and monitoring systems. Together, we agree on the minimum access needed for the dimensions in scope. Conversations with the technical team help us understand the context of past decisions.

On request, we sign a non-disclosure agreement (NDA) before receiving access. We use the access only for the audit, we do not copy personal data into the report, and at the end we recommend closing the accounts created for us.

No. We work with read-only access and do not run tests that could overload or block production systems. Measurements that need more are run in a test environment.

We assess in depth applications built with PHP and Laravel on MySQL, JavaScript front ends and REST APIs, the technologies we have built with every day since 2015. Mobile applications are assessed together with their backend and APIs. For other technologies, we tell you in the first call what we can and cannot assess.

It depends on the size of the application, the dimensions in scope and the decision the audit needs to support. After a first call, we send you a proposal with the scope, the timeline and the cost.

No. We assess security in the code, the dependencies and the configuration, without attacking the systems. The audit is not a certified penetration test, nor an ISO/IEC 27001 or SOC 2 certification. If you need one of these, we tell you in the first call.

Yes. We talk to the team at the start, for context, and we validate the important findings with them before the report, to avoid misinterpretations. The audit assesses the system and the processes, not the people.

The decision is yours. The report can be used by your internal team or by any vendor. If you wish, we can support remediation, modernisation or take over maintenance, as we do for Time Critical Line.

// technologies

What software technologies do we use?

Our main technology for web projects is Laravel, a PHP framework with elegant syntax that scales easily and offers excellent security.

Laravel doesn't stop us from working with .NET, Java, Swift or other technologies when a project calls for it. We prefer it for the web because it lets us deliver similar projects faster, at a lower development cost.

  • Artificial intelligence
  • Deep Learning
  • TensorFlow
  • .NET Framework
  • .NET Core
  • Java EE
  • Python
  • PHP
  • main Laravel
  • React
  • Vue.js
  • Bootstrap
  • REST API
  • Android
  • iOS
  • Swift
  • Jira
  • Git
  • GitHub
  • Bitbucket
  • SQL Server
  • MySQL
  • MariaDB
  • MongoDB
// next step

Do you have a project you want to develop?

Write to us or give us a call and we will set up a meeting. We reply with questions first, then with a free quote that covers cost and timeline.

Or email us at contact@devteam.ro.