GUIDE · SOFTWARE AND INTEGRATION

Security in software development: a secure-by-design process for small teams

This guide explains how to build security into the software development lifecycle without a dedicated security team. You will see how to set minimum requirements, how to check dependencies and secrets, which automated checks to switch on, and how to manage vulnerabilities after release.

Updated october 2026
7 min read
Altovar Technical Editorial Team

1. Why security belongs in the process, not at the end

A security test run only at the end of a project finds problems that are expensive to fix: a wrong architectural choice, an access system built badly, or data stored in plain text. Secure SDLC, meaning the development lifecycle with security built in, moves the checks to the phases where fixing costs less. The cost of a defect rises as the project advances.

A small team does not need a complex structure. It needs a few clear rules, applied consistently, and automated tools that verify them during daily work. The goal is for security to be a normal part of a release, not an exception to be negotiated each time. The starting point is the practices the team already applies, even informally. Then the missing rules are added.

2. Defining security requirements

Before writing code, establish what data the software handles, who may access it, which operations are sensitive and which obligations apply, such as those of the GDPR for personal data. These elements become non-functional requirements, written like the other specifications and verified during acceptance testing. A requirement such as 'only the administrative role may export the complete master record' is more useful than a generic statement about security. The risk of forgetting a security requirement is high precisely here.

A simple threat-modelling exercise helps identify weak points: who might misuse a function, what happens if a user enters unexpected data, where an attack could come from. It does not need a complex method. A short meeting with developers and the owner already produces a useful list to start from. It is worth doing for every function that handles access or data changes.

3. Coding rules and review

Secure coding rules address recurring errors: always validate inputs, use parameterised queries for the database, handle errors without exposing internal details, and never build your own authentication or encryption mechanisms. Write them in a short document that the team reads at the start of the project, not in a hundred-page manual nobody opens. These are the ones to check first.

Code review is where these rules are applied. Every significant change should be read by a second person using a simple checklist: input is validated, permissions are checked on the server, secrets are not in the code, and logs do not contain unnecessary personal data. Review should happen even when the team is small, because it is the only check that sees decisions before they become habits.

4. Dependencies, secrets and automated checks

A large share of a modern project's code consists of third-party libraries. Each may contain known vulnerabilities, and vulnerabilities are discovered even after release. You need an inventory of dependencies, a process for updating them and an automated check that flags those with known problems. Credentials and secrets must never go into source code, but into a dedicated secrets management system. A manually kept inventory quickly becomes outdated, so generate it automatically.

Static analysis tools examine code without running it; dynamic tools test the running application. Switch them on in the release pipeline, configured to block serious problems and report the rest. An occasional false positive is normal, but a check everyone ignores is useless. It is worth configuring them carefully once, and then letting them work.

  1. Maintain an inventory of the libraries used, with version and source.
  2. Enable an automated check on dependencies with every change.
  3. Move credentials into a secrets manager and replace any that have been exposed.
  4. Run static analysis of the code before every release.
  5. Run tests on the application in a test environment with fictitious data.

5. Targeted tests and the release procedure

Before release, a targeted test of sensitive functions is worth more than a generic test. Verify that authorisations really work: a user in one role must not be able to see or change another role's data. Also check unauthenticated access to restricted pages and how the software behaves when errors occur. Permission checks matter most for money and personal data.

The release should follow a written procedure stating who approves it, what is verified and how to roll back. Ask the provider whether they maintain a separate test environment and whether releases are tracked. A change in production without traceability is one of the most common causes of incidents that are hard to reconstruct. Restoring a previous version must be tested, not just planned.

6. Vulnerabilities after release

Software remains exposed after release. You need a channel for receiving vulnerability reports, a procedure for assessing them and a schedule for fixing them according to severity. The Cyber Resilience Act, for products with digital elements, requires vulnerabilities to be handled throughout the life of the product: if your software falls into this category, check with an adviser which obligations apply. Whoever receives the report must have the time and authority to assess it. The channel must not exist only on paper.

Bespoke software also needs this discipline in practice: someone must receive the alerts, decide and release the fixes. When the provider is no longer operational, the risk falls on you. Ask how security updates are handled in the support contract. Even a well-written support contract should set a maximum time for fixing critical issues.

  • A reporting channel with a named contact person.
  • A severity assessment with written criteria.
  • A remediation plan with priorities and tracking.
  • Communication to users when a fix requires action on their part.

7. How to start this week

Choose a project in progress and ask the technical lead what data it handles, where the credentials are stored and which libraries it uses, with their versions. The answers immediately show where the risk concentrates. If they cannot answer, that is already useful information about the level of control over the project. The technical lead can do this in a short meeting. No new documents are needed.

Then enable a single automated dependency check and set a review rule for changes to sensitive functions. Starting small and consistent beats an ambitious programme nobody follows. If the provider cannot answer these questions, treat it as a factor in your choice. The same applies to periodic checks of these items, which should be scheduled in the team's calendar.

Frequently Asked Questions

Is a secure SDLC useful for a team of two people?

Yes, but in simple form. You do not need dedicated roles: you need written rules, a code review and automated checks. Two people can review each other's work, provided they use a common checklist. Security is more a matter of repeated habits than of complex organisation.

Is an automated security test enough?

No. Automated tools find known classes of error but do not understand the logic of your process. A user who can approve their own expense will not be flagged by any tool. Automation should be backed by human review and targeted tests of sensitive functions.

How do I manage third-party libraries?

Keep an inventory, update dependencies regularly and enable a check that flags those with known vulnerabilities. Avoid poorly maintained libraries for critical functions. When you update an important library, re-read the release notes for changes that may alter existing behaviour.

Who is liable if a vulnerability is exploited?

It depends on the contract and on each party's role. The provider that developed the software has technical responsibilities, while the company using it has obligations concerning its own data and processing. Clauses on security, incident notification and liability should be defined in advance and verified with a lawyer.

When must an incident be notified?

For personal data, the GDPR requires notification to the authority within 72 hours of becoming aware of the breach, unless a risk to individuals is unlikely. If the company falls under NIS2, D.Lgs. 138/2024 requires an initial report within 24 hours. Decide now who assesses the incident and under what procedure.

About this content

General informational guide. Regulations and technical requirements change over time: always check the official sources and assess your specific case with a qualified technical or legal advisor.

GET IN TOUCH

Talk to our team.

We'll show how Altovar integrates into your infrastructure. No commitment, no sales pitch. Just a technical conversation.

BOOK A DEMO →