Skip to main content
ProtoComet
ProtoComet

  • Know what you’re running before you decide what to change.

    Find out what your .NET applications depend on, how healthy each one is and what modernizing them will really cost. It’s two fixed-scope steps that end with a phased roadmap your leadership can approve.

Where this actually breaks

Most teams come to an assessment after one of these. Each raises the same question: how many of our applications have this problem, and what will it take to fix?

Support has ended underneath your applications

Several applications run on .NET Framework and Windows Server versions that no longer get security patches. An auditor or a customer has flagged it. Nobody can yet say how many applications are affected or what upgrading each one involves.

The .NET upgrade stalled at the first dependency

The team tried moving one application. It stopped at a WCF service other systems call, a reporting component with no modern version and a shared library tied to .NET Framework. Nobody knows how many other applications have the same blockers.

Every release puts the business at risk

Deployments are manual and done out of hours, and something breaks often enough that releases have slowed to once a month. A change to one application breaks another, because they share a database and stored procedures nobody has mapped.

AI can't reach the data it needs

The AI use case is approved, but the data sits in SQL Server behind stored procedures called from WebForms code-behind. There's no API to call and no clean data model. Every AI pilot starts with rebuilding part of the application, and nobody has costed that yet.

Six steps from inventory to roadmap

Steps 1 to 3 are the Legacy Health Check (Tier 0), where every application gets a ModernityScore™. Steps 4 to 6 are the Modernization Roadmap (Tier 1). Each step ends with a written output, and the next step builds on it

1. Inventory

We list every application, integration, scheduled job and shared database, and who relies on each one. It's built by scanning your code, servers and pipelines, so it picks up what your current list has missed.

Tier 0 · dependency map

2. Score

Each application is scored on five dimensions, using evidence from its code, configuration and deployment pipeline. AI-assisted code analysis speeds this up, and a senior consultant checks every finding.

Tier 0 · ModernityScore™ per application

3. Report findings

A short report on the risks that matter most: what's out of support, what's blocking an upgrade, and what would fail first under load. You can stop here and still have a clear picture of what you own.

Tier 0 · findings report

4. Decide

Each application gets a verdict: Rehost, Replatform, Refactor, Rebuild, Retire or Retain. The reasoning is written down along with the option we rejected, and Retire and Retain get the same scrutiny as a rebuild.

Tier 1 · 6R verdict register

5.Sequence

Applications are grouped into delivery waves by dependency and risk, so nothing moves before the systems it relies on. Retirements usually come early, because every application switched off is one less to migrate.

Tier 1 · wave plan

6. Cost and plan

Each wave gets a cost range, with its assumptions listed so you can challenge them. You get a one-page summary for leadership and the full plan for your engineers, including what to leave alone this year and when to look again.

Tier 1 · costed roadmap

The five dimensions

Security. Whether the framework and operating system still get patches, how users and services sign in, where secrets are kept, and what an audit would flag first.

Scalability. Whether the application can run on more than one server, and what stops it: session state in memory, files on a local disk, or a scheduled job that assumes a single machine.

Observability. Whether you'd know it had failed before a user told you. Logging, metrics and tracing, and whether anyone actually looks at them.

DevOps maturity. How a change gets from a developer's machine to production, how long that takes, and how much depends on someone following a document by hand.

Data portability. How much business logic lives in the database, how tied the schema is to other systems, and whether the data could move without the application.


AI readiness is calculated from these five. It's reported as a signal inside the score, because an application that isn't healthy can't support AI features reliably.

How the work actually runs

Both tiers are fixed price, agreed up front from the number of applications and integrations in scope. You’ll know the price and the timeline before any work starts, and you can stop after Tier 0.

Tier 0 takes one to two weeks


For most projects, the health check takes one to two weeks. We need read-only access to source control, configuration and deployment pipelines, and short interviews with your team fill in what the code can’t tell us. Larger estates take longer, and that timeline is agreed before we start.

Tier 1 follows straight on


The roadmap typically takes two to three more weeks. It’s walked through with everyone who has to act on it. Your technical leads get to challenge the verdicts and the sequence. Decision-makers get the costs, risks and trade-offs in plain language, whatever their background.

One senior consultant throughout


The consultant who reads your code and stored procedures is the one who presents the roadmap to your leadership. Nothing gets lost between the person who did the analysis and the person who wrote the summary, and you have one person to hold accountable for the numbers.


What you walk away with

Everything is yours to keep and use with any delivery partner, including one that isn’t us. The roadmap is written so that anyone can carry it out.

➖ Dependency map. Every application, integration, scheduled job and shared database, and what breaks downstream if any one of them stops.


➖ Findings report. The risks that matter most across your applications: what’s out of support, what blocks an upgrade and what fails first.


➖ Costed wave plan. Applications grouped into delivery waves by dependency and risk, each wave with a cost range and the assumptions behind it.

➖ Modernity Score. One per application, with a score on each of the five dimensions, the evidence behind each score and what would raise it.


➖ 6R verdict register. A verdict for each application with its reasoning, the option we rejected and a date to revisit anything left as it is.


➖ Leadership summary. What you have, what’s at risk, what moving costs and the order to do it in, written in plain language for every stakeholder.

Our Way

Modernity Score starts with evidence from your applications. The DevOps score comes from your deployment pipeline, or the lack of one. The data portability score comes from reading your stored procedures. Interviews with your team add the context, and where what people describe differs from what the code shows, we record the gap as a finding.

Each verdict is then weighed against the whole portfolio. An application can score poorly and still be the right one to leave alone, because nothing depends on it and nothing about it needs to change. Another can score well and still need to move first, because three others are waiting on it.

We’re comfortable with a quiet result. If most of your applications should stay as they are, the assessment has done its job, and you’ve learned that in a few weeks for a fixed price. The roadmap is written so your own team or any partner can deliver it.

The most useful thing an assessment can give you is confidence in your next decision. I’d rather tell you that most of your applications are fine for another two years than recommend work you don’t need.


Yogesh, founder and principal consultant

Questions clients typically ask

Short, direct answers about the assessment itself. Questions about the wider engagement are answered on the .NET Modernization overview.
Read-only access to source control, build and deployment configuration, and the database schema, plus a conversation with whoever runs production. We don’t need production data. If source access can’t be arranged, we can work from configuration and interviews, and every scorecard affected will say its score is less certain.
Usually a kickoff, a few one-hour conversations with the people who know each application best, and a review of the findings at the end. Most of the work is reading code and configuration, which your team doesn’t need to sit through.
Access is granted under an NDA signed before work starts, and your code stays in your environment or in tools you approve. AI-assisted analysis is used only with your agreement, in tools that don’t train on your data, and a senior consultant checks every finding it produces.

The scope is fixed and stands on its own, and the roadmap is written so anyone can deliver it. Some clients take it to another partner. Some stop after Tier 1 because the roadmap told them to wait. Either way, the assessment has done its job.

Modernity Score measures the health of your .NET applications, with AI readiness as one signal inside it. The AI Readiness Index is a broader assessment across seven dimensions, for organizations planning AI adoption. If your main question is how to modernize, start here. If it’s whether you can adopt AI, start with the Index.

Ready to move?

Let's talk about where you are and where you want to go.  and whether modernization is even the right answer this year. If it is not, you will hear that.

Let’s Talk