Home

The Platform Velocity Index: A 7-Dimension Scoring System for Your Tech Stack

Every CTO I talk to knows their platform has hidden costs. They feel it in the slow feature cycles, the painful upgrades, the 3-month onboarding for new hires. But they can't put a number on it.

That's why I built the Platform Velocity Index.

What Is the PVI?

The Platform Velocity Index is a 10-point scoring system that measures how much your technology platform helps or hurts your ability to ship product. It scores 7 dimensions, each weighted by business impact, and produces a single composite score that tells you whether your tech stack is an asset or a liability.

It's not a code quality tool. It's not a performance benchmark. It's a business impact assessment that happens to look at code.

The 7 Dimensions

Each dimension answers a question a CEO should care about. No jargon.

1. Dependency Gravity (Weight: 20%)

Question: How many external packages can break your app?

Every dependency is a liability. It needs updating, it has CVE exposure, and it can introduce breaking changes. We count every direct dependency across all package managers and repositories. A Rails app with 32 gems scores very differently than a React Native monorepo with 252 npm packages.

2. Architectural Complexity (Weight: 20%)

Question: How many moving parts must work together for your product to function?

We count repositories, services, databases, message queues, cloud services, and infrastructure-as-code files. The ratio of infrastructure code to application code is one of the most telling metrics. If you have more lines of CloudFormation than application code, your platform is serving itself more than it's serving your customers.

3. Feature Delivery Velocity (Weight: 20%)

Question: How fast can you ship a feature to all users?

We trace the path a feature takes from code to production. How many repos does it touch? How many deployment pipelines? How many build systems? A platform where you build once and deploy everywhere scores a 9. A platform where every feature requires coordinated changes across 4 repos and 3 build systems scores a 2.

4. Operational Overhead (Weight: 15%)

Question: What does it cost just to keep the lights on?

Monthly hosting, number of managed services, environment variables to configure, deployment complexity. We're looking for the ratio of operational effort to product value. A single-server Kamal deploy at $50/month is fundamentally different from 15+ AWS managed services at $2,250/month.

5. Talent Accessibility (Weight: 10%)

Question: How hard is it to hire and onboard a developer?

We count the languages, frameworks, package managers, and cloud services a developer needs to know. Then we estimate onboarding time. "Know Rails" in 2-4 weeks is a very different hiring proposition than "know React Native + Expo + NX + AWS Amplify + AppSync + DynamoDB + CloudFormation" in 3-4 months.

6. Upgrade & Migration Safety (Weight: 10%)

Question: How expensive is it to stay current?

We check every major dependency against its latest stable version. Frameworks that are 3-4 major versions behind represent real dollar costs to upgrade. We estimate the upgrade debt in hours and dollars, and we calculate the monthly accrual rate—because the longer you wait, the more expensive it gets.

7. Platform Unification (Weight: 5%)

Question: Are you building 1 product or 3?

For apps that serve multiple platforms (web, iOS, Android), we measure actual code reuse. Not aspirational code reuse—actual. A shared UI library with 1 component in it is not code reuse. It's a broken promise. We calculate the ratio of shared code to platform-specific code and assess how many times a feature must be implemented to reach all users.

The Scoring

Each dimension gets a score from 1-10:

  • 9-10: Best-in-class. This dimension is an asset.
  • 7-8: Strong. Minor improvements possible.
  • 5-6: Adequate. Noticeable drag on the business.
  • 3-4: Poor. Significant hidden costs.
  • 1-2: Critical. This dimension is actively hurting the business.

The composite PVI is a weighted average producing a single score and letter grade:

  • 8.0-10.0 (A): Your platform is a competitive advantage.
  • 6.0-7.9 (B): Solid platform with room for improvement.
  • 4.0-5.9 (C): Platform is creating noticeable drag.
  • 2.0-3.9 (D/F): Platform is a significant business liability.
  • 0.0-1.9 (F-): Critical. Immediate action required.

A Real Case Study: From 2.2 to 8.7

I recently ran the PVI on both the old and new platforms for one of my apps, PrayAI. The old platform was a React Native + AWS Amplify ecosystem. The new platform is Rails 8 + Turbo Native.

Here's what the numbers looked like:

DimensionOld PlatformNew PlatformDelta Dependency Gravity2/108/10+6 Architectural Complexity2/109/10+7 Feature Delivery Velocity2/109/10+7 Operational Overhead3/109/10+6 Talent Accessibility3/108/10+5 Upgrade & Migration Safety1/109/10+8 Platform Unification3/109/10+6 Composite PVI2.2 (F-)8.7 (A)+6.5

The single most striking data point: the old platform required 35,934 lines of CloudFormation infrastructure code to support 12,900 lines of application code. That's a 2.8:1 ratio of plumbing to product. For every line of code that served a user, nearly three lines existed just to keep the platform running.

The new platform delivers the same product with 184 lines of infrastructure (a 72-line Dockerfile and a 112-line Kamal config) supporting 11,547 lines of shared application code. That's a 175x reduction in infrastructure overhead.

Translating Scores to Dollars

The PVI isn't just a scorecard. Each dimension maps to a cost bucket.

For PrayAI, the old platform carried approximately $500,000/year in hidden platform costs (dependency maintenance, multi-service overhead, multi-platform builds, specialist hiring, upgrade debt). The new platform runs at approximately $67,000/year.

That's $433,000/year in savings. With the same 2-person team. Shipping twice as many features.

The migration cost approximately $87,000 and paid for itself in 4 months.

Why This Matters

Most technical assessments focus on code quality, test coverage, or performance benchmarks. Those matter, but they miss the bigger picture. A codebase can have 100% test coverage and still cost you $400,000/year in unnecessary architectural complexity.

The PVI measures what actually impacts your business: how much of your engineering budget goes to shipping features vs. maintaining infrastructure. It puts a dollar amount on the gap between where you are and where you could be.

Run It On Your Codebase

If you're curious what your platform's PVI score looks like, I run these assessments for companies considering a platform transformation. The assessment reads actual files, counts actual dependencies, and traces actual deployment paths. No guessing. No hypotheticals.

Every month you operate on a low-PVI platform, money walks out the door. The first step is knowing the number.

Get in touch at Ruby Growth Labs to schedule your free PVI assessment.

]]>