Component-Aware VB6 Migration Services

Know every component before you move a single form.

Your VB6 application probably still works. Staff use it every day, and Microsoft still supports the runtime it depends on, even on Windows 11. The trouble sits around it: the development environment has been unsupported since 2008, the ActiveX controls it loads may belong to vendors that no longer exist, and the few people who can change it are close to leaving. Every request for a web screen, an API or a security control costs more than it should.

Most projects that move off Visual Basic 6 go wrong in one of two ways. A converter turns Visual Basic into .NET code that compiles but still reads like the original, or a rewrite begins without a list of what the old system loads and calls, and a control, a DLL or a device link surfaces during cutover week. Both fail for the same reason: nobody found every component first.

Cabot starts with an inventory of every form, class, component and dependency, and an assessment that can end in a plain recommendation to keep the system running for now, with the controls to protect it. When a move to C# and .NET is the right answer, we pin current behavior with tests, move the data, rebuild logic and screens, and run old and new side by side until the outputs match.

Tell us about your VB6 application

Share the VB6 version, the database it uses and the components it depends on. An engineer replies with the first scoping questions.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

No obligation. Your details stay private.

What VB6 migration actually involves

VB6 migration is the move of a Visual Basic 6 application, its forms, classes, ActiveX components and database to a platform your team can staff and extend, usually C# and .NET with SQL Server or PostgreSQL, without changing the behavior the business depends on.

That separates it from four things it is often confused with. Keeping the system running leaves the VB6 code as it is and adds controls around it, which is a good answer when the application is stable and the team is in place. Wrapping adds an API or a web front end around code that still has to be maintained in Visual Basic 6. Automated conversion translates the code line by line and often produces .NET code that reads like VB6. A full rewrite starts from a blank page and has to rediscover every behavior the old system quietly enforced. A sound migration keeps what the system does and changes what it is built on.

In practice some parts move and some are rebuilt. Data moves from DAO, ADO, Jet, Access files and ODBC sources to SQL Server or PostgreSQL, cleaned and reconciled on the way. Business logic moves to C# once tests have pinned what it does. Forms are rebuilt, because a Visual Basic form usually mixes screen layout, validation and database calls in one file. Reports are rebuilt and compared against the old output. ActiveX and OCX controls, COM objects and DLL calls are replaced or isolated one by one. Whether the target is a web application, a desktop client or an API, a VB6 to .NET move follows the same order: behavior first, then data, then logic, then screens, then a parallel run.

If your application already runs on .NET in VB.NET, the move to C# is a language conversion on a platform that stays the same, which carries far less risk than leaving VB6. Our answer to the VB.NET to C# question is in the FAQ below.

Migrating is not always the right call today. Microsoft still supports the VB6 runtime for existing applications on current Windows, including Windows 11 and Windows Server 2025, for serious regressions and critical security issues. That makes keeping a stable application running a real option for a time. The case for moving builds when the application depends on controls nobody supports, when you cannot hire for the skill, when the source no longer matches what runs, when security and audit needs go beyond what the old design can meet, or when the business needs web access or integration the application cannot give. The assessment is built to tell you which case you are in, in writing.

Why VB6 systems stall before they move

These are the six reasons technology and operations leaders give when the work slowed down or never started. Most are decided in the first weeks, before anyone writes code.

Two colleagues reviewing application code on desktop monitors in a bright office

The VB6 migration services we deliver

Our VB6 migration services come in six parts, and most engagements use all of them in a sequence set by the assessment. Some organizations need the full path from inventory to retiring the old runtime. Others need only the database moved first, or only the reports rebuilt. We give you our recommendation and our reasoning before you commit to anything.

Every part produces something you can open and check: an inventory, a reconciliation report, a test suite that pins current behavior, a working screen, a staged release. Testing and security run inside every part instead of sitting as separate lines.

What does VB6 migration cost, and what moves the number?

Five things set the cost of VB6 migration services: the size of the codebase and how many forms and reports it carries, how many ActiveX and third party components it depends on, the data layer and the volume and quality of the data, the number of integrations and device links, and how much of the logic has no tests. Two applications that look alike on paper can differ many times over, so any figure quoted before an assessment is a guess. Model a range in a few minutes, then tell us what you run and we will scope it properly. We would rather give you a narrow range you can plan around than a wide one that protects us.

What does a VB6 assessment tell you before you commit?

A short assessment answers the questions that sink most migrations of this kind before any code changes. It runs in four parts, in this order, and it can end in a recommendation to keep the system running for now.

Scope your own application: send us a short description of what you run and we will tell you what the assessment would cover.

What does AI actually change in a VB6 migration?

It changes how fast the slow parts go and leaves the judgment where it was. Reading forms, modules and classes that nobody documented, drafting a plain language list of the rules they enforce, mapping which forms touch which tables and controls, and finding dead code are all work a model can draft quickly. Deciding which behavior the business still needs, which was a workaround for limits that no longer exist and whether a screen should survive at all is not.

The saving concentrates in three places. Discovery goes faster, because a model can summarize an unfamiliar codebase into rules and dependencies for an engineer to check. Test writing goes faster, because characterization tests that record current behavior can be drafted from the code and then run against real data. Translation of repetitive routines goes faster, because a model can propose the same pattern in C# across hundreds of files for review, which is where a VB6 to C# move spends much of its time.

Automated converters are part of the picture, and we treat them as one tool among several. A conversion tool translates syntax quickly and leaves the design questions open: how the data layer is structured, which controls have a replacement and what the new code should look like. The output is a draft that needs the same tests, review and parallel run as any other, and we would not hand it to you as finished work.

The risk runs the other way. A model can describe a rule with confidence that the code does not implement, and it can miss behavior hidden in a global module, an event handler or a report expression. So every recovered rule is confirmed against real outputs and against the people who use the system before it counts.

AI shortens the slow parts of a migration. It does not decide which behavior survives, approve a merge or sign off a cutover. Those stay with senior engineers and with you, and where you need help choosing a model your policy allows, our AI development team is part of the conversation.

Three commitments hold on every engagement. Our process is model neutral, so we use the model your policy allows. A senior engineer reviews every change before it merges. And we never train any model on your code or data. Test data is synthetic or masked, so protected health information stays out of model prompts.

What we move your VB6 system onto, and the tools we use to move it

Three layers of tooling, chosen against your environment and your team's ability to run the result rather than against our preferences. The target follows what your security team will accept and what your staff can maintain, and we recommend on evidence from the assessment. Our QA and testing practice builds the test suites that compare the new system with the old before anyone relies on it.

What we work in:

Target platforms

C#
.NET
ASP.NET Core
WPF
Blazor
Entity Framework

Data and hosting

SQL Server
PostgreSQL
Azure SQL
Azure
AWS
Docker

Delivery and AI tooling

GitHub Copilot
SQL Server Integration Services
xUnit
Playwright
GitHub Actions
SonarQube

Where AI sits at each stage of the move, and where it does not

Each stage below has an output you can inspect and a person who approves it. Nothing an AI drafts reaches your data, your code or your production system without a named engineer accepting it first.

Migration stage What AI does What stays human Tools used
Assessment Reads VB6 forms, modules and classes and drafts a plain language list of the rules, data access, controls and dependencies they contain Confirming which behavior the business still needs and which was a workaround GitHub Copilot, SonarQube
Safety net Drafts characterization tests that record what the application does today, using real outputs as the reference Choosing which behaviors must never change and approving the tests GitHub Copilot, xUnit, Playwright
Translation Proposes C# versions of repetitive routines and drafts data migration scripts for review Approving every merge and every data move GitHub Copilot, SQL Server Integration Services
Cutover Compares outputs from the old and new systems and summarizes the differences Accepting or rejecting each difference and approving each cutover Playwright, GitHub Actions

The last column names the tools, so a security reviewer can see exactly what touched the work. Where your policy limits which tools can be used, the same stages run with the tools you allow and the same human review.

How a Cabot VB6 migration differs from a typical vendor's

VB6 migration services succeed or fail on components, data and cutover, not on the choice of target platform. Those are the places projects go wrong, so each row below is a moment where the approach changes the outcome.

Dimension Typical vendor Cabot
Starting point A quote after a short call A written inventory and assessment before you commit
Advice on whether to move Migration is always the answer A written recommendation that can say keep the system running for now
Business logic Translated line by line, or rediscovered in testing Recovered, written down and confirmed by the people who use the system
Components and controls Converted automatically or dropped Listed first, then each one replaced, isolated or retired on purpose
Data layer Tables copied as they are Profiled, cleaned and reconciled, with keys and constraints designed
Testing Tests written after the build Characterization tests that pin current behavior first
Cutover method One weekend switch One workflow at a time, with old and new running side by side
Knowledge transfer A handover document at the end Your engineers in standups and reviews from week one

Ask any vendor when they would advise against migrating. A credible answer comes quickly and names the conditions. Ours is written into each assessment.

The healthcare organizations we migrate VB6 systems for

We deliver VB6 migration services for three kinds of healthcare organization. Each card says what we understand about that environment, rather than claiming coverage of it.

Across all three the pattern is the same: the application is important enough that a failed cutover is not an option, and old enough that few people hold the whole picture. Where the new platform needs a rebuilt application around it, our healthcare application development practice carries the same discipline into the build.

Industries we already understand

volunteer_activism

Healthcare

shopping_cart

Ecommerce

paid

Fintech

apartment

Travel and Tourism

Client Success Stories

See all Cabot case studies

What a migrated VB6 system has to prove before it goes live

Security leads every migration, because the move is your chance to close what the old system never covered. We apply authentication and role based access, encrypt data in transit and at rest, log every change to an audit trail, hold secrets outside the code and scan dependencies and fix known vulnerable ones first. Protected health information stays out of test data and model prompts.

Where the system handles patient data, we map who can see what, scope the work to the safeguards your compliance team requires through our HIPAA compliance consulting practice, and document each control the migration touches. For each stage you receive evidence, not assurance: the test results, the reconciliation report, the list of changes with the engineer who approved each one and the plan for returning to the old system.

Role based access
Authentication and session control
Encryption in transit and at rest
Audit logging of every change
Secrets management
Dependency and vulnerability scanning
Synthetic and masked test data
HIPAA aligned controls
SOC 2 aligned controls

How does a VB6 application move without the business stopping?

Six steps, each ending in a decision you make rather than a document you receive. Most engagements begin with the first two steps alone, so you can judge the plan and the working relationship before committing to the migration.

Start with step 01: tell us what the application does and we will scope the inventory.

Who owns each part of a VB6 migration at Cabot

Accountability is explicit from the first day. A solution architect owns the target design and the order of migration, and answers for choices that are expensive to reverse. A business analyst owns the recovered rules and confirms them with the people who use the system. A data engineer owns the data layer move and the reconciliation that proves it. Senior engineers own the C# and .NET work and the merge reviews. A QA automation engineer owns the characterization tests and the comparison between old and new. A delivery lead owns the schedule and tells you plainly when something slips.

Our depth is greatest in four places: reading code nobody documented and finding every component it loads, writing tests that pin down behavior before anything changes, moving DAO, ADO, Jet and Access data to SQL Server or PostgreSQL without losing integrity, and running old and new side by side until the numbers match.

If you are searching for a VB6 developer, you are probably trying to keep the system alive or to find someone who understands it. A single contractor leaves the same key person risk in place. Our answer is a team that recovers what the code knows, moves it to a platform with a deep talent pool, and joins your standups and reviews from week one, so the knowledge stays with you. Where a larger group fits, we staff an embedded engineering pod inside your delivery cadence.

Why healthcare technology leaders choose Cabot for component-aware VB6 migration services

A move off VB6 is easy to start and hard to finish well. These are the six reasons buyers give when they explain why the work sits with us.

Where to go next, depending on what you run

This move is one of several specific moves. Which page helps next depends on where your system sits today, and it is usually one of three.

Our Clients

Questions technology and operations leaders ask before starting

  1. How do you migrate VB6 to .NET?
    We inventory the application and every component it loads, recover its behavior, pin it with tests, move the data to SQL Server or PostgreSQL and rebuild the logic and screens in C# on .NET. Old and new run side by side until the outputs match, then each workflow is cut over with a rehearsed rollback. This is a VB6 to .NET migration in stages, not a one weekend switch.
  2. Is VB6 still supported, and does it run on Windows 11?
    The VB6 runtime is still supported on Windows 11, but the VB6 development environment is not. Microsoft supports the runtime for the life of current Windows versions, including Windows 11 and Windows Server 2025, for serious regressions and critical security issues only. It has not supported the development environment since April 8, 2008, the runtime is 32 bit and runs under emulation on 64 bit Windows, and third party ActiveX and OCX controls are not supported at all. So an existing application can keep running, but changing it is the hard part.
  3. Should we migrate VB6 or keep running it?
    It depends on what is actually holding the application back, and the assessment tells you in writing. Keeping a stable application running is sound when the source matches production, the controls still work and you can find people to maintain it. A move to C# and .NET makes sense when a control has no vendor, you cannot staff VB6, security or audit needs have outgrown the old design, or the business needs web access or integration.
  4. Is there a tool that converts VB6 to .NET automatically?
    Yes, several tools translate VB6 code into .NET, but none moves the behavior, the data or the design for you. A converter gives you a draft that still needs tests, review and a parallel run, and the output often reads like Visual Basic written in .NET. We use tools where they save time and treat their output as a starting point, never as finished work.
  5. Should we migrate VB6 to C# or VB.NET?
    We recommend and deliver C#, not VB.NET. A VB6 to VB.NET move is the closer syntax match, but C# is the language most .NET teams write new code in, so it is easier to hire for and maintain over the long run. Choosing the language is part of the assessment, and your team's skills matter more than the syntax.
  6. What happens to my ActiveX controls, COM components and third party OCX files?
    Each one gets a decision in the inventory: replace it, isolate it or retire it. Microsoft does not support third party ActiveX and OCX controls, so we first confirm what each does and whether the vendor still exists. We then replace it with a supported .NET control or library, isolate it behind a small service while the rest moves, or retire it when the feature is no longer needed. COM and DLL calls are handled the same way.
  7. Can you convert VB.NET to C#?
    Yes, we handle it as an assessed project with tests first. Converting VB.NET to C# is a language change on a platform that stays the same, so the risk is lower than staying where you are. Automatic converters handle most syntax, but VB specific features such as XML literals and the My namespace have no direct C# equivalent, and those need a person. We pin current behavior with tests, convert in stages and compare outputs before each release.
  8. How long does a VB6 migration take, and how much does it cost?
    Both follow the same drivers: codebase size and the number of forms and reports, ActiveX and third party components, the data layer and its volume, the number of integrations and device links and how much logic has no tests. We give a timeline and a cost range after the assessment, so you see numbers before you commit. The migration itself runs in staged releases, usually over months, with the old system working throughout. For a first view, use the cost calculator.