Today at VSLive! Orlando we opened the VELO self-serve preview. The announcement covers what the preview is and how to get in. This post is for the people who will actually upload code: what VELO measures, what it hands back, and which parts still need a person.
To keep it concrete, we ran one application from start to finish. sks-inventory-sample is a small VB6 inventory and ordering system: 18 forms, three .bas modules, one .vbp, and the ActiveX controls you would expect from an app of that era (MSFlexGrid, ListView, the ADO data control, Common Dialog, a masked edit box and a chart control). We picked something small on purpose, so every number below can be checked against the reports. All of them come straight from the two reports VELO produced.
In this preview, VB6, PowerBuilder and Microsoft Access applications move to Blazor on .NET for Azure.
The assessment reads everything you upload and sorts it before it estimates anything. That sorting is where most legacy estimates go wrong.
The headline figure for the sample is 8,493 lines. The breakdown tells a different story:
|
Category |
Lines |
Share |
|---|---|---|
|
Executable code |
2,913 |
34.3% |
|
UI layout |
4,890 |
57.6% |
|
Empty / blank |
517 |
6.1% |
|
Commented-out |
173 |
2.0% |
|
Total |
8,493 |
100% |
More than half the file content is form layout: the property blocks at the top of every .frm that describe where each control sits. That layout does not get translated line by line. It gets regenerated as Razor components. The real logic in this app is about 2,900 lines, which is why the report treats the total as a ceiling, not as the size of the job. If you have ever priced a VB6 migration off a raw line count, this table shows how far off it can be.
Coverage tells you how much of the estimate rests on code VELO could actually read. For the sample it was 22 of 22 files readable as text, with zero binaries and zero unknown file types. In a real codebase, compiled files such as DLLs, OCXs and PowerBuilder PBLs show up as "identified binary". VELO knows they exist but cannot count their lines, so a lower coverage score means the estimate carries more uncertainty. Upload the full project folder, not a curated subset, and that number stays honest.
Figure 1. The assessment header. 8,493 lines across 22 files and 18 screens, with every file readable, so the estimate rests on measured code.
Every form and module gets a conversion-risk rating based on object type, size and specific content signals: Win32 API calls, late-bound COM, Shell calls, data-access patterns and suppressed error handling (yes, On Error Resume Next). For the sample, 11 forms rated Medium and the remaining forms and all three modules rated Low. The highest-risk item was frmOrderRequest.frm at 376 lines.
The rating measures how much effort it takes to move a component to the web stack. It says nothing about how buggy the component is today. That distinction matters when you read the list: a Medium form is one that will need design decisions, such as business logic embedded in event handlers, not one that is broken.
The sample references 13 non-native components: nine OCX controls and four DLL or type-library references. Each one is listed by name and flagged for review, because each needs a decision about what replaces it.
|
Component |
Type |
Typical role in a VB6 app |
|---|---|---|
|
MSFLXGRD.OCX |
ActiveX control |
Editable data grids |
|
MSCOMCTL.OCX |
ActiveX control |
ListView, StatusBar, ImageList |
|
MSCOMCT2.OCX |
ActiveX control |
Date pickers, up-down controls |
|
MSDATGRD.OCX, MSDATLST.OCX |
ActiveX controls |
Bound data grid and lists |
|
MSADODC.OCX |
ActiveX control |
ADO data control |
|
MSMASK32.OCX |
ActiveX control |
Masked input |
|
COMDLG32.OCX |
ActiveX control |
Open/save/print dialogs |
|
MSCHRT20.OCX |
ActiveX control |
Charts |
|
msado25.tlb, msbind.dll, msstdfmt.dll, stdole2.tlb |
Type libraries / DLLs |
ADO, data binding, formatting, OLE automation |
The assessment comes in two views. The Executive view is written for whoever owns the budget: a summary, what inaction could mean across customer trust, service continuity and cost of change, a risk table, and a recommended approach. For the sample, it recommended an incremental, module-by-module move to Blazor Server, so each module can be verified before the next one moves. The Engineer view has the detail above, plus file explorer, project composition and an API summary. Both views export as standalone HTML files you can send to the people who need them. The estimate behind the fixed-price quote is in the report too; we have left it out here.
Figure 2. Conversion risk per component. 11 of 18 forms rate Medium, led by frmOrderRequest.frm at 376 lines; all three modules rate Low.
After the modernization run, VELO evaluates its own output and produces a second report. Here is the header for the sample:
|
Area |
Original |
Modernized |
|---|---|---|
|
Language and platform |
Visual Basic 6 |
Blazor Server, .NET 10 |
|
User interface |
VB6 forms |
MudBlazor pages and dialogs |
|
Data access |
ODBC |
Entity Framework Core, SQLite in this run |
|
Code units |
22 objects |
459 generated files |
|
Packaging |
.vbp project |
.sln solution |
|
Build state |
Compiles |
|
|
Modernized objects |
90.5% (19 of 21) |
|
|
Review items |
12 |
VELO does not produce a C# copy of each form with the old event handlers pasted into code-behind. It separates what the screens show from what the business does, and generates a layered .NET solution:
SKS.sln src/ Presentation/SKS.Presentation Razor pages, dialogs, layouts (MudBlazor) Application/SKS.Application commands, queries, handlers, DTOs, validators Common/SKS.Common base entities, domain events, Result type Domain/SKS.Domain entities, value objects, domain services Infrastructure/SKS.Infrastructure EF Core DbContext, entity mappings, repositories CrossCutting/SKS.CrossCutting identity, authorization, dialogs, security headers tests/ SKS.Application.Tests SKS.Domain.Tests SKS.Infrastructure.Tests
|
Responsibility |
Files |
|
|---|---|---|
|
Presentation |
Screens and components users see and interact with |
62 |
|
Application |
Use cases and workflows triggered by user requests |
192 |
|
Business domain |
Business entities and rules, independent of screens |
50 |
|
Infrastructure |
Database, file and external-system access |
24 |
|
Shared services |
Logging, security and configuration |
11 |
|
Automated tests |
Unit and integration tests for the generated code |
117 |
|
Other |
Solution file, .editorconfig, .gitignore |
3 |
The application layer uses a command/query split: every write is a command with its own handler and interface, every read is a query with its own handler. Domain services hold the rules that used to live in event handlers, and domain events connect them.
frmOrderRequest.frm, the highest-risk form in the assessment, shows how this works. In VB6 it was one form with its logic in event handlers and calls into a shared helper module. In the generated solution it becomes:
The shared helper module, modFunctions.bas, is the other interesting case. A 169-line grab-bag of functions shows up as a source for more than 20 generated files, from stock-adjustment commands to totals services. Its functions moved to wherever they were used, rather than becoming a new Helpers class.
Every generated file records which original object or objects it came from. In the Presentation layer, 37 of 62 files trace back to a VB6 form; in Application, 90 of 192; in Domain, 22 of 50. The rest, including all of Infrastructure, the shared services and the tests, are new scaffolding with no VB6 counterpart, and the report says so. When a reviewer asks where a handler came from, the answer is in the file explorer, not in someone’s memory.
Figure 3. From one VB6 project to a 459-file layered .NET solution. Application logic is the largest layer; tests are the second largest.
The solution ships with 117 test files: unit tests for the command and query handlers, unit tests for domain entities, value objects and services, integration tests for each EF Core repository, and builders for test data. VELO also identified 69 business rules in the original app, such as "Last remaining user cannot be deleted" and "New username must be unique". Those numbers lead straight into the next section.
"Compiles" means the build succeeds. Whether every screen behaves like the original is a separate question, and the review list is where VELO answers it. The sample came back with 12 items, each marked Needs attention, To review or By design:
|
Status |
Item |
What it means |
|---|---|---|
|
Needs attention |
37 of 69 business rules have no covering test |
The rule was carried over; nothing proves it yet. Includes the login credential check and a hardcoded administrator session in modMain.bas. |
|
Needs attention |
33 automated tests not written yet |
Planned tests still to be filled in. |
|
Needs attention |
Read-only MSFlexGrid has no direct MudBlazor equivalent (4 forms) |
MudTable has no current-column concept, so only row selection is reproduced. |
|
Needs attention |
Editable MSFlexGrid has no direct MudBlazor equivalent (2 forms) |
Only row selection and the single editable column are reproduced. |
|
Needs attention |
One security setting depends on the hosting environment |
A decision for whoever deploys it. |
|
Needs attention |
No reporting library chosen |
Report output needs a library decision. |
|
To review |
StatusBar has only a partial equivalent (10 forms) |
Confirm single-row status text is fine, or ask for a three-panel layout. |
|
To review |
ListView has only a partial equivalent (6 forms) |
Confirm column order and labels match the original. |
|
To review |
MSFlexGrid floating editor replaced with in-place numeric input (2 forms) |
Confirm the new input pattern is acceptable. |
|
To review |
7 files still to be completed |
Unfinished generated files, including the EF Core repositories. |
|
To review |
No recorded outcome for modConnection.bas and modMain.bas |
Nothing in the new solution names them, so whether they came across is unknown until someone checks. |
|
By design |
OfrmAccountProfile.frm left out |
Excluded on purpose. |
We publish this list in full because it is the useful part. A modernization tool that reports only successes hands the hard 10% to your team without warning. VELO tells you which grid behaviors changed, which rules are untested, which files are unfinished, and which two modules it could not account for. That is the work list for the last mile, and it is the same list whether your own team finishes the job or GAPVelocity AI’s AI Squad does.
Figure 4. All 12 review items, as VELO reports them. Each one names the affected forms, modules or files.
Uploading production source to a cloud service is a fair thing to be cautious about. The short version, from the VELO Trust Center:
One practical tip: strip credentials and connection strings before you upload. The malware scan protects the service; it is not a security review of your application.
The team behind VELO has been building migration tools for more than 35 years, starting with the technology behind the Visual Basic Upgrade Wizard that shipped in Visual Studio. Across billions of lines of code and thousands of projects, one lesson keeps repeating: the assessment that matters is the one that tells you what is left. VELO’s reports are built around that lesson. They count what can be measured, flag what cannot, trace every generated file to its source, and put the remaining work in a list you can assign.
General availability is planned for early 2027. Bring the app nobody wants to touch.
What does the VELO assessment measure?
File and line counts split into executable code, UI layout, comments and blanks; how much of the codebase was readable; a conversion-risk rating per form and module; every third-party component; and a recommended migration approach. It also produces the estimate behind your fixed-price quote.
What does VELO generate from a VB6 application?
A layered .NET 10 solution with Blazor Server and MudBlazor for the UI, Entity Framework Core for data access, separate application, domain, infrastructure and shared-services projects, and unit and integration test projects. Every generated file is traced to the original objects it came from.
Does "Compiles" mean the application is ready for production?
No. It means the solution builds. The review items list what still needs a decision, a test or a finished file before the app goes live, and the VELO terms require your team to review and test modernized code before deployment.
Is my code used to train AI models?
No. Under the VELO terms your code is siloed, never used to train any AI model, and deleted within 60 days of termination or a written request.