Cyber attacks in November 2026: what they teach businesses about AI agents and secure software
Optimizely, Maileva, AI agents: what the cyber attacks of November 2026 teach about third-party scripts, suppliers and AI in production.
Published on 12 min read
Sébastien Nobour
Founder of DEVEDANOS
You are having an application built. For months, the development team works, you get progress updates, features are ticked off one by one. Then the users start using it, or try to, and the verdict comes back: “this is no use to me”. All those months you were paying, and your users went on working as before.
At a large telecoms group, a project spent two years in development and was then cancelled without a single user ever having been able to use it.
The development and product team followed the plan, sometimes very well. What was missing was a way of knowing, before the end, whether the application met a need. This is what’s known as the big bang approach. A team moves ahead for a long time without anyone outside the project seeing what it produces, and only discovers what users need once it has finished.
This article shows how to avoid it, whether the application is for your teams or your customers: ask your users what they are trying to do, put the application in their hands as early as possible, and measure what they do with it.
On this kind of project, everything goes into production at once, at the end, and users are not at the centre of the thinking. And by the end, there is almost no room left to change anything.
Some years ago, this large telecoms group wanted to automate the way it made network resources available to its customers, which until then had relied on manual configuration. The group applied SAFe (Scaled Agile Framework), a framework that coordinates many teams on one product, with several levels of decision-making above them.
The group had itself written down what the software was to do, based on its own assumptions. No user had taken part in writing the specifications. Nobody had used the software: if there was any feedback, it was about software nobody had used.
Several teams, spread across two countries, worked on this project. Each one worked on its own copy of the code. Nobody asked for the work to be integrated as it went along. Then it all had to be brought together. During that integration, every problem surfaced at once: bugs, conflicts between versions, decisions about which code to keep. The project team went through two weeks of overtime and stress.
Integration this late has another cost: you build features you cannot manage to integrate, and you deliver less than planned.
Integration had barely finished when a manager the project team never saw came to tell them that the project was cancelled: the market was not interested in what they were doing. Yet nothing had ever gone into production: the software had never met its users. Nobody explained to the team what this conclusion was based on. The project had lasted two years.
One team member then said, in all sincerity: “We’re getting better: it used to take us six years to reach this conclusion, now it only takes two.” He knew it was slow, and that nothing justified it. But it was all he had ever known. A developer on the team added: “I’ve been here five years, and nothing I’ve worked on has ever made it to production.” Our About page comes back to this project.
One entrepreneur described spending seven months building, alone, the application he had imagined, design included. When he showed it, users told him his application was “nice”, but of no use to them. He had put a substantial budget into it, the kind you don’t commit twice if it doesn’t work the first time. He had nothing left to launch another application, and no wish to put more money in.
At least this entrepreneur met his users, after seven months; at the telecoms group, that meeting never took place. And all that time, the problem the application was meant to solve remained untouched, while the company went on paying. Our article on budgeting for an application explains what it costs to wait six months for the first feedback.
Feedback from users, from the first days of work, tells you whether it is worth carrying on. You get it before spending months on development.
Before building, you have to know what your users are trying to do.
Whether the application is for your teams or your customers, it has to take its users from a point A to a point B. You are planning to build a vehicle. But what says they don’t want a bridge instead? It is up to them to say where they are starting from and where they want to go. So first check that what you plan to build is what they want.
To gather needs, start by choosing the right people: those who will use the application, not just the person commissioning it. The commission often describes how the work is supposed to be organised; the people doing that work every day know how it actually happens.
Next, you have to separate what they ask for from what they need. A request is a solution someone has already thought up: “add an export button”. The need is the situation behind that request: for example, someone copies figures into a spreadsheet every week to send them to someone else. Several solutions meet that need, and an export is not necessarily the best. To find it, ask these people to describe their current situation, what gets in their way and what they would like, rather than asking which features to add.
This method has a limit. Asked in advance, people cannot always say what they need; in front of a working application, they react. We take this observation from Dave Farley, a software engineer and continuous delivery specialist, in our article on budgeting for app development. Interviews are therefore for setting a goal and hypotheses, not for writing a final list.
As soon as an application has several users, information arrives in a continuous flow and in large quantities. At some point, someone has to filter it.
Scrum, a framework built on short cycles, provides for a product owner, the person responsible for deciding the order in which features will be developed. A product owner is above all useful as a facilitator: they filter this flow without stopping users and developers from talking to each other. They are not a mediator: a mediator steps in between two sides in conflict, which is not the case here.
Extreme Programming, another software development method, makes a different choice: the “on-site customer”, a user representative who works alongside the developers. In companies, this person is called a key user or super user. It is better to appoint several. If there is only one, their preference easily passes for everyone’s.
A product owner makes sense when the product raises marketing or growth questions. Otherwise, key users are often enough.
Even before building, an MVP can test the idea at the lowest cost. MVP stands for minimum viable product. With an MVP, you are not trying to fit everything into a short timescale: you keep what is essential.
The same judgement applies to each version of the application. That is how we understand lean, the way of producing that came out of the car industry and focuses effort on what brings value to the customer.
Suppose the bridge question is settled: the customer wants precisely a car, to get from a point A to a point B. The first version is the simplest car that drives: an engine, a steering wheel, brakes, wheels. You deliver it. The second adds seat belts and the horn, and you deliver again. The third brings more safety, such as ABS. Then comes air conditioning, and so on. With each version, the question stays the same: what is essential today, given what has been asked for? It always comes down to priorities.
A widely shared image presents lean differently: a skateboard that becomes a bike, then a motorbike, then a car. When the customer asks for a car, each version is already a car, more and more complete.
For an application, the engine and the brakes are the few features without which your users cannot do what they came to do.
Once development has begun, keep exploring your users’ needs. The sooner the application reaches the hands of those who will use it, the sooner their reactions correct what the interviews did not reveal.
For a social network devoted to high-mountain sports, we held the interviews directly with the users. When an application can’t find users, it is easy to conclude that it doesn’t have enough features yet. That was also the starting point of this project. That idea comes from a feeling: the needs gathered from users don’t confirm it.
We helped its founder see that what matters is not the features he has in his head, but going out to question his users, understanding what they are trying to do, looking for the right solution with them, and delivering new features as they are ready, in a continuous flow. The application had 600 users after three months of development.
Building more features is throwing more darts. It doesn’t bring the bullseye any closer: you have to learn to aim. For an application, aiming means starting from what its users are trying to accomplish.
A user who has worked with the feature tells you what is missing, what gets in the way and what they don’t use. That becomes the next hypothesis to test, following the adaptive approach, which we compare with the predictive approach.
In a project, “delivered” means the feature has reached you. After acceptance testing (you check that the feature does what was agreed), it goes into production: users can use it. In both cases, nothing yet proves the need is met.
In Continuous Delivery, their 2010 book, Jez Humble and Dave Farley consider a feature done only when it is in the hands of its users. We add two clarifications: what you expect from that use is written down before building, and “done” implies a deadline.
That requires defining it in advance: the time you allow yourself, and the conditions to be met (how many people have to use it, to do what, how often). A measurement in production shows whether these conditions are met.
Once the time is up, the feature is done, even if the conditions are not met: every goal remains a hypothesis. You look at the result and decide what comes next: evolve the feature, or remove it.
A KPI is a figure you track. Two kinds of figures are often confused.
The first measure delivery: how often the team puts changes into production, how long it takes, and how many cause problems. This is what Google Cloud’s DORA research programme tracks, which we present in our article on continuous delivery and continuous deployment. A team can put changes into production several times a day, with no incidents and every dashboard green, while users go on working in their spreadsheet. These figures say the delivery chain works. They don’t say whether what it delivers is useful and creates value for the company.
The second measure use. Dave Farley, in Continuous Delivery Pipelines, lists them among the measures to track in production, under the name “pirate metrics”, or AARRR, after their five initials:
For an internal application, these five measures read differently. The two that count first are activation and retention: are the people concerned using it, and do they come back?
Behind these two figures lies shadow IT: the tools teams use to work without the company having chosen them. According to the National Cyber Security Centre (NCSC), it generally appears when staff struggle to complete a task with approved tools. So an internal application that doesn’t meet needs does not just go unused. Teams may then open, alongside it, a shared spreadsheet or a personal online storage account, and put company data there that nobody monitors. Our article on shadow IT goes through the risks. If a spreadsheet reappears next to your application, ask the team what they do in it: it describes a need the application does not cover.
To read these figures, write down the expected effect before going into production, otherwise you will look for an explanation after the fact. Once the application is in production, you compare the measured figure with the expected effect. A gap seen among few people or over a short time proves nothing; if the gap keeps recurring, act.
We develop your bespoke software, usable within a month, for a fixed monthly budget, and adjust it continuously as your business evolves.
If your application has been in development for months and its users are not using it yet, we can look with you at what they say about it today. Shall we talk?
Optimizely, Maileva, AI agents: what the cyber attacks of November 2026 teach about third-party scripts, suppliers and AI in production.
Quality code is code that is easy to change. Why that matters for your application, and how to measure code quality without reading the code.
What is shadow IT? The definition from the UK's National Cyber Security Centre, examples (Excel, AI tools) and the risks to the business.