Sustainability

Efficient software is the cheapest carbon you will ever cut.

Every kilowatt-hour your systems consume is a cloud line item first and an emissions line item second. That ordering is the whole opportunity.

Sustainability in software is usually discussed as procurement — which region, which provider, which renewable tariff. Those choices matter, but they are someone else's decisions made on your behalf. The decisions you actually own are algorithmic: how much work a request does, how many instances sit warm behind it, how many bytes cross the wire, how many times a model is called to answer one question.

We build on Elixir and the BEAM for exactly this reason. It is not a green technology in the marketing sense — it is a runtime that does a great deal of concurrent work on very little hardware. Fewer instances, less idle, lower cost, lower draw. The efficiency argument and the sustainability argument are the same argument, and that is why we are comfortable making it.

Where the savings actually are

Four levers, ordered by how quickly they pay back. None of them requires buying anything.

  1. 01 · Runtime

    Do more work per core

    Elixir on the BEAM holds hundreds of thousands of lightweight processes per node. The same workload that needs a fleet in a thread-per-request stack often fits on a handful of instances — and instances are the thing you pay for, in dollars and in kilowatt-hours.

  2. 02 · Right-sizing

    Stop paying for idle

    Autoscaling, scale-to-zero and honest capacity planning. An idle instance draws close to full power and serves nothing. Most of the carbon in a typical web stack is not the traffic, it is the headroom nobody dared to remove.

  3. 03 · Transport

    Send fewer bytes

    Edge caching, image formats, sensible payload budgets. Network transfer costs energy at the origin and again on the device in someone's hand, which is a part of your footprint you do not meter and cannot see.

  4. 04 · Models

    Spend inference deliberately

    A smaller model with a good retrieval layer and a real evaluation set beats a large model prompted hopefully — on quality, on latency, and on energy per successful outcome. We build the eval set before the feature so this is measurable rather than rhetorical.

What we measure

Eight signals, all of them available from tooling you already run. We instrument them before we optimise anything, because a reduction you cannot see is a reduction you cannot defend.

  • EFF-1

    Requests per vCPU-hour

    requests / vCPU-h

    Runtime counters + a repeatable load test

    The single highest-leverage number in a web system. Efficiency here multiplies through every other line item.

  • EFF-2

    Idle capacity

    % of provisioned hours above baseline

    Autoscaler and scheduler metrics

    Provisioned-but-unused time is the most common source of avoidable emissions, and the easiest to cut.

  • EFF-3

    Bytes per page view

    KB transferred

    Real-user monitoring + CDN logs

    Transfer is energy at the origin and on the client device. Most teams only measure the first half.

  • EFF-4

    Cold starts

    count per 1k requests

    Platform logs

    A cold runtime redoes work a warm one already did: same output, more energy.

  • EFF-5

    Model calls per task

    calls / task

    Application traces

    Inference is the most energy-dense line item in any AI feature. Call count is the number you can actually budget.

  • EFF-6

    Tokens per successful outcome

    tokens / accepted result

    Traces joined to an evaluation set

    Separates a model doing work from a model filling space. Needs an eval set — that is the catch.

  • EFF-7

    Data retained

    GB-months, by storage tier

    Storage metrics + lifecycle policy audit

    Replicated storage is an always-on draw for data nobody reads, and it grows quietly.

  • EFF-8

    Embodied share

    % of provider footprint from hardware

    Provider product carbon footprint + amortisation

    Cloud moves hardware emissions into Scope 3. The provider's own footprint is the only honest input.

Where it lands in your disclosure

Under the GHG Protocol, software efficiency is spread across four places. It is worth knowing which one your team is on the hook for before anyone promises a reduction.

Scope 2 Purchased compute and electricity
The instance-hours you buy. For teams running their own racks or colocation this is already on your radar; for cloud-native teams it is largely the provider's grid problem, which is why the next line matters more.
Scope 3 · Cat. 1 Purchased goods and services
Where most reporting teams put cloud and SaaS subscriptions. This is the category our efficiency work actually moves, because activity data — instance-hours, requests, model calls — is what turns a spend-based estimate into a measured one.
Scope 3 · Cat. 3 Fuel- and energy-related activities
Upstream generation and transmission losses behind the electricity you purchased. Moves with Scope 2, so the same reduction shows up twice; do not double-count it in your narrative.
Scope 3 · Cat. 11 Use of sold products
If you ship software rather than consume it, the customer's compute is your category 11. An efficient runtime is the rare engineering decision that improves a downstream number you do not control.

Category numbering follows the GHG Protocol Corporate Standard. Sector-specific disclosure — SASB, ISSB IFRS S1/S2, or your exchange's rules — sits on top of this and differs by industry; the sector pages carry the metrics that tend to matter in each one.

Start with a measurement, not a pledge.

We will instrument the eight signals above against your current stack and tell you which two or three are worth attacking first. If the answer is "you are already fine", that is also a result.