Key takeaways
- Digital frugality means writing only the code that serves your users and your business, from features to dependencies and data.
- Frugal code is faster, easier to maintain and harder to attack, because it has fewer moving parts.
- It is a discipline applied at every stage: scoping, development, release and maintenance.
What digital frugality means in our code
Digital frugality is often mistaken for austerity, as if a frugal application had to be plain or limited. That is not what we mean by it. For us, frugality means that every element of a website or business application has a reason to exist: each feature answers a real need, each line of code serves that feature, and each dependency, file or database query justifies its cost in energy, maintenance and risk.
This principle is now formalized in the Web Sustainability Guidelines published by the W3C Sustainable Web Interest Group. Its web development section asks teams to minify and remove unused code, avoid redundancy, use dependencies sparingly, reduce the number and complexity of database queries and use the latest stable language version. None of these recommendations is new to experienced developers. What changes is that they are treated as a coherent method rather than as occasional good intentions.
At Codyweb, eco-design is the value we deliver, and digital frugality is how we deliver it in the code. The sections below describe how this plays out at each stage of a project.
Fewer features, better chosen
The most efficient code is the code that never needs to be written. Many applications carry features that were requested once, used by a handful of people and then forgotten, yet still loaded, maintained and secured for years. Frugality therefore starts during scoping, when the team decides what the product must do and, just as importantly, what it will not do.
During this phase, we work directly with the people who will use the tool. We map their actual tasks, identify the information they need and question each requested feature against its use. This conversation often simplifies the project, and it shortens the delivery. Our page describing our approach to web projects explains how this scoping stage frames the rest of the work.
Custom code instead of generic layers
Generic platforms are designed to serve thousands of different businesses, so they ship with features, settings and scripts that most of their users never touch. Each plugin added to cover a specific need brings its own code, its own updates and its own potential vulnerabilities. Over time, the site carries far more than it uses.
We take the opposite route. We develop websites and business applications from scratch, with no third-party plugins, so that the code reaching the server and the browser corresponds exactly to the project. When a client needs to manage content, we install our own custom CMS, designed for their team, with only the functions they use. This is the core of our custom web development expertise, and it is also why the client owns the full source code at delivery.
Architecture follows the same logic. A frugal architecture is the simplest one that meets the real load and the real organization of the teams, not the most fashionable one. For most mid-market platforms, a well-structured application is easier to run and maintain than a distributed system, while very large products with independent teams may need a different split. We discuss this trade-off in our guide to choosing between a monolith and microservices.
Efficient on the server
On the server side, frugality is measured in work avoided. Database queries are the first place to look: a page that triggers dozens of queries where two would suffice consumes processing time on every view. We design schemas and indexes around the questions the application actually asks, and we group or cache results that do not change between requests.
Background tasks deserve the same attention. Synchronizations, exports and notification jobs are often scheduled far more frequently than the data requires. Aligning their frequency with the rhythm of the business removes a constant, invisible load. Finally, we keep the server language up to date. Each PHP branch receives four years of support, two of them for critical security issues only, after which its users may be exposed to unpatched vulnerabilities. The guidelines also recommend using the latest stable version of a language, so both concerns lead to the same practice.
Light in the browser
What happens on the visitor's device matters as much as what happens on the server, since devices account for a large share of the environmental footprint of digital technology. We write semantic HTML, keep JavaScript to what the interface needs and load non-critical resources only when they are required. Styles come from a shared component framework, so the site does not accumulate slightly different versions of the same element.
Media and fonts are handled with the same care. Images are compressed and served in modern formats at the right size, icons are drawn in SVG, and fonts are limited to the variants the design uses. On the sites we build, audience measurement relies on a cookieless tool and the consent banner is integrated, which avoids loading a chain of external scripts on every page.
Maintainable code stays frugal over time
A frugal application at launch can become heavy within two years if nobody watches it. New features are added, temporary fixes become permanent and unused code is never removed. Maintainability is therefore part of frugality: code that is readable, structured and documented is code that can be cleaned up instead of piled on.
We apply a few simple rules before each release, so that the application does not drift from its initial discipline.
- Develop in a separate environment. Every change is built and tested outside production, and nothing goes live without verification.
- Remove what is no longer used. Retired features, obsolete styles and dead scripts are deleted rather than left in place.
- Review every new dependency. A library is added only when writing the function ourselves would be less reliable, and its purpose is recorded.
- Check performance before going live. Load times and page weight are compared with the previous version, so that a regression is caught before visitors see it.
When an application has already accumulated years of shortcuts, these rules are not enough on their own, and a structured cleanup becomes necessary. Our article on managing technical debt in a legacy application explains how to decide when refactoring is worth it.
Security as a consequence of frugality
Every component is a potential entry point. A platform built on dozens of third-party extensions inherits the vulnerabilities of each of them, and its owner depends on their authors to publish fixes. With fewer components, the attack surface shrinks and each remaining part can be reviewed properly.
Frugality does not replace security measures, it makes them easier to apply. We validate and filter every user input on the server, protect databases against injection, encrypt communications and keep regular off-site backups. Our web security expertise page details these production standards.
Work with a team that writes only the code you need
Digital frugality is not a feature that can be added at the end of a project. It is a way of making decisions, from the first scoping meeting to the last maintenance release, and it produces applications that are faster for their users, cheaper to maintain and easier to secure. It is also the most concrete form of our commitment to a more responsible web.
If your website or business application has become slow, fragile or expensive to evolve, we can review it with you and tell you whether a targeted cleanup or a custom rebuild makes more sense.
- vote(s)