Sustainable Code Insights

A static analysis tool that assesses code sustainability, structural performance risk, and green coding practices across software repositories.

This tool is intended for developers and platform teams reviewing code sustainability and structural performance risk. This tool analyses source code and configuration files. It does not measure live runtime energy usage or system performance.

Select Project

Last generated: Generated: —

—

Best practices detected

—

Files analysed

Live sustainability dashboard

View sustainability metrics, performance indicators, and optimisation opportunities for the selected repository.

View dashboard

What each section shows

Dashboard – Overall sustainability score, radar view, and key structural risks.
Performance metrics – Structural performance indicators and trends over time.
Code analysis and recommendations – File‑level green coding assessment, issues, and optimisation guidance.

Green coding principles

These principles describe how the tool evaluates long‑term sustainability and structural performance risk, rather than measuring live system energy usage.

Energy‑efficient algorithms

Prefer efficient algorithms and data structures to reduce unnecessary computation.

Memory optimisation

Reduce memory overhead through careful use of data structures and explicit resource management.

Resource cleanup

Ensure files, connections, and other resources are released promptly when no longer required.

Asynchronous processing

Use asynchronous and non‑blocking patterns to improve efficiency and scalability.

Avoid unnecessary computation

Eliminate redundant processing, repeated calculations, and unnecessary background tasks.

Modular and reusable code

Design small, reusable components to reduce duplication and simplify maintenance.

Configuration efficiency

Keep configuration files small, modular, and reusable to reduce parsing and maintenance cost.

Data transfer reduction

Minimise the amount of data transferred between systems and avoid unnecessary network calls.

Scalable design

Design systems that scale efficiently under increased load without requiring excessive resources.

Maintainability and longevity

Write clear, maintainable code to reduce rework and extend the usable life of software systems.

By improving code structure and applying green coding practices, teams can reduce long‑term performance risk and support more sustainable software delivery.

Sustainability metrics overview

● Excellent (85‑100) ● Good (70‑84) ● Fair (50‑69) ● Needs work (<50)

Scores range from 0 to 100. Higher values indicate stronger sustainability characteristics. Dashed and dotted rings represent benchmark and target reference values, not measured runtime performance.

Summary for this repository

Why is the overall score lower?

The overall score includes repository‑level risk factors in addition to individual directory scores.

Critical areas

Areas with low sustainability scores should be reviewed and monitored.

Directory scores show structural sustainability for individual areas. The overall score reflects additional repository‑level risk factors such as concentration and growth trends.

Structural performance metrics

Complexity pressure: —
Configuration footprint: —
API surface area: —
Performance risk trend: —

Performance trends

What do these metrics mean?

These indicators describe code‑level performance risk, not live system telemetry. They are derived from the structure, size, and organisation of the repository.

Complexity pressure – how difficult the codebase is to understand and change, based on size and concentration.
Configuration footprint – how much configuration, policy, and supporting logic exists in a single area.
API surface area – a proxy for the number of APIs, endpoints, and policies that must be processed and maintained.
Performance risk trend – whether these indicators are improving, stable, or worsening over time.

How can this be improved?

Suggested actions derived from the current structural performance indicators.

Code analysis and recommendations

File‑level green coding assessment (top 10)

Files with the lowest green coding scores based on static, rule‑based analysis.

File path	Green score	Issues	Practices	Energy impact	Status

Energy impact is marked as “N/A (Static)” because this analysis does not measure live runtime energy usage.

High‑priority issues

Structural or file‑level issues that have a significant impact on sustainability.

Optimisation opportunities

Recommended actions to improve sustainability and reduce structural performance risk.

Green coding practices found

Areas that demonstrate good structural sustainability or positive green coding practices.

This analysis is based on static inspection of source code and configuration files. It does not measure live runtime performance or energy consumption.

How sustainability rules are applied

This service analyses source code and configuration files using a fixed set of rules. These rules identify structural characteristics that can increase or reduce long‑term sustainability and performance risk.

This analysis is static. It does not measure live system performance, energy consumption, or carbon emissions.

Types of rules used

The rules fall into two main categories: issues and good practices.

Issues: Structural patterns that increase complexity, cost, or long‑term maintainability risk.
Good practices: Patterns that simplify code, reduce duplication, or support efficient operation over time.

Examples of rules

Below are examples of the types of rules currently applied.

Large configuration files: Very large configuration files can increase parsing time and maintenance effort. Keeping configuration modular supports reuse and reduces risk.
Directory concentration: When most files are located in one directory, changes become harder to review and test. This increases sustainability and performance risk.
Excessive imports or dependencies: Files with many dependencies can increase memory usage and make behaviour harder to understand. Keeping dependencies focused improves maintainability.
Use of dynamic execution: Dynamic execution patterns can increase security, performance, and sustainability risk. Static logic is preferred where possible.

How rules affect scores

Each file starts with a baseline score. Rules then adjust the score based on what is found.

Issues reduce the score by a fixed number of points.
Good practices increase or protect the score.
Repository‑level rules can apply penalties even if individual files are well structured.

Scores are intended to show relative sustainability risk, not precise energy or performance measurements.

How to use these results

The results are intended to support discussion and prioritisation, not to judge individual files or teams.

Focus on repeated issues affecting many files.
Use optimisation recommendations to guide refactoring work.
Track trends over time rather than single scores.

This service provides indicators of sustainability and performance risk based on code structure. It does not replace performance testing, monitoring, or energy measurement tools.