At MongoDB.Local London 2025, one of the sessions that truly stood out was “Designing Environmentally Sustainable Software”, presented by Snehal Bhatia, Senior Solutions Architect at MongoDB. Though short, the talk offered a powerful reminder that sustainability in software isn’t just an environmental goal – it’s a measure of technical excellence.

The hidden cost of code

Snehal began by highlighting a sobering statistic: software is responsible for around 2-4% of global carbon emissions, putting it on par with the airline industry. As AI workloads continue to grow, the carbon footprint of our digital systems is coming under sharper scrutiny.

Her core message was simple but striking – “The greenest energy is the energy we never use”. Every inefficient query, un-optimised process, or overprovisioned database contributes to unnecessary energy consumption. Sustainable code, therefore, is about doing more with less –designing smarter, faster, and leaner systems that achieve the same outcome with fewer resources.

Building for Efficiency

Snehal explored several practical strategies for making software greener without compromising performance:

• Plan data storage and hosting locations wisely
  • Hosting closer to target users minimises the distance data travels, reducing network load and energy use. MongoDB Atlas already supports deploying clusters in low-carbon regions – something worth considering for environmentally conscious teams.
• Leverage sustainability of scale
  
  • Cloud providers can achieve higher efficiency through large-scale optimisation, but 40% of cloud infrastructure is still overprovisioned by businesses. MongoDB Atlas, for example, helps right-size deployments to avoid wasted capacity.
• Optimise non-production environments
  
  • Snehal noted that non-production environments spend roughly 76% of their lifecycle idle, consuming resources unnecessarily. Simple automation to pause or scale down dev/test clusters can have a major impact.
    

Greener code in practice

The session also touched on how legacy code and AI models contribute to unseen energy waste.

Unused or unmonitored legacy systems often continue running background processes that consume compute power long after their usefulness has passed. Similarly, LLMs (Large Language Models) can be highly resource-intensive – One API call to a GPT model can use as much CO₂as ten phone charges.

To mitigate this, Snehal suggested:

• Caching frequently accessed data to reduce redundant model calls.
• Selecting efficient AI models that balance capability with cost and sustainability.
• Asking the right questions before training your own models – do you really need to, or can an existing one suffice?

As she put it, “Cleaner code is greener code.” Efficiency and sustainability are inherently aligned – when you optimise for performance, you often optimise for the planet too.

Measuring what matters

A key takeaway was that sustainability should become a measurable metric in software development – not an afterthought.

Snehal encouraged teams to:

• Set sustainability targets alongside performance KPIs.
• Include environmental SLAs (Service-level agreements) where possible.
• Use carbon-aware tools that provide visibility into energy consumption and resource usage.

By quantifying sustainability, teams can make data-driven decisions to reduce their footprint while improving system reliability and cost-efficiency.

Demand shaping and Carbon-aware applications

Another concept discussed was demand shaping – adapting application behaviour based on energy availability and carbon intensity.

For example:

• Reducing video quality or bandwidth usage during peak times.
• Scheduling compute-heavy tasks when renewable energy supply is highest.
• Dynamically routing workloads to low-carbon data centres.

This type of “carbon-aware” software not only reduces emissions but also extends hardware lifespan by avoiding energy spikes that stress infrastructure.

Final Thoughts

Snehal closed with a powerful statement:

“Sustainability is enough, by itself, to justify the work”

The message resonated strongly with the audience. Building sustainable systems isn’t just good ethics – it’s good engineering. Companies that find the intersection between digital innovation and sustainability are better positioned for long-term resilience, efficiency, and trust.

For developers, architects, and product teams alike, sustainable software design is no longer optional – it’s an integral part of responsible technology.

Read more about MongoDB.Local London 2025 here‍

Read more about the MongoDB.Local London 2025 Keynote here