AccessLeap FAQ — Everything You Need to Know

AccessLeap is a Windows desktop application that reads your Microsoft Access database (.accdb) and generates a deployable modern web application from it. It converts tables, forms, relationships, queries, and VBA business logic into a working web app — React + Node.js or HTML + SQLite depending on database complexity.

The result is code you own. Not a hosted service, not a SaaS subscription — a folder of source code you can deploy, modify, and extend like any other web application.

When you open AccessLeap and point it at your .accdb file:

• Schema extraction (local): AccessLeap reads your database structure — tables, columns, relationships, form definitions, queries, VBA code. This happens entirely on your machine.
• Review screen: Before anything is sent anywhere, you see exactly what the AI will receive. You can review, redact, or cancel.
• Generation: The AI receives the structural summary and generates the web application scaffold. This takes 2–10 minutes depending on complexity.
• Output: You receive a folder of working code with a README, setup instructions, and a test scaffold. You run the setup script and have a working app in your browser.

Clean, structured, and readable. The output follows standard conventions for the chosen stack:

• /db — schema definition and migration files
• /api — route handlers for every table and form operation
• /ui — page components and form components generated from your Access form definitions
• /tests — integration test scaffold for every API route
• README.md — setup instructions and a description of every generated component

It's scaffolded code, not production-ready code. A developer who understands that context will find it easy to work with.

Yes. The AI never sees your data — only structural metadata. What AccessLeap sends for processing: table names and column definitions, form layouts and field properties, query definitions (SQL text), VBA code, and relationship definitions.

What it never sends: your actual row data, file paths, connection strings, passwords, or any configuration values stored in the database.

Before any processing begins, the review screen shows you a complete list of what will be sent. You approve it explicitly before generation starts. If anything looks sensitive, you can redact it or cancel entirely.

Only for the generation step. Schema extraction — the part where AccessLeap reads your database and prepares the structural summary — works fully offline. The internet connection is only used when you choose to submit the reviewed schema to the AI for code generation.

If you need to review what the tool would send before committing to anything, you can run the extraction step offline and inspect the output before connecting.

The structural metadata (column names like "salary," "diagnosis," "account_balance") will appear in the extracted schema because AccessLeap needs to understand the structure to generate the forms. The actual values in those columns are never sent.

If even the column names are sensitive in your context, the review screen lets you rename or redact them before submission. The generated application will use the redacted names, which you can then adjust in the source code.

For highly regulated environments (HIPAA, FINRA, government classified), contact us to discuss the on-premises option where generation happens without any external API call.

AccessLeap works with .accdb files (Access 2007 format and later). It does not directly support .mdb files (Access 97–2003 format).

If you have .mdb files, the path is: use LegacyLeaps to convert .mdb → .accdb first, then use AccessLeap to generate the web application. LegacyLeaps preserves VBA macros, forms, and data during the format conversion.

AccessLeap performs best on departmental databases with data entry and reporting workflows:

• Data entry forms with standard field types and validation
• Lookup tables and dropdown-based navigation
• Reports and list views
• Simple workflow forms (fill, submit, review)
• Basic calculated fields and aggregate queries

These represent the majority of real-world departmental Access databases — inventory, CRM, project tracking, HR records, scheduling.

AccessLeap has real limitations worth knowing before you buy:

• Deeply nested multi-form workflows: Databases where a single operation spans 5+ forms with shared state and complex conditional navigation require significant manual work after generation.
• Heavy ActiveX dependency: ActiveX controls (custom calendars, grids, pickers) don't exist in browsers and need to be rebuilt as web equivalents.
• Windows API calls in VBA: Shell commands, file system operations, registry reads, and COM interop calls need to be redesigned for a web context — they can't be converted automatically.
• Complex concurrency logic: Databases with elaborate file-locking schemes or multi-step transactions built around Access's concurrency model need developer redesign for the web.

The free schema preview will flag these issues before you pay, so you can assess the complexity of your specific database first.

AccessLeap reads and analyzes all VBA code in your database. What happens to it depends on what it does:

• Simple event handlers (field validation, calculated totals, conditional visibility) — often generated directly as working JavaScript or server-side logic.
• Business logic routines — translated into stub functions with detailed comments explaining exactly what the original VBA did. You implement the web equivalent.
• Windows-specific calls (Shell, FileSystem, registry) — flagged in the review screen and in the generated code with clear notes that these need redesign.

The goal is that a developer who has never seen your Access database can understand what the generated code is trying to do without needing to reverse-engineer the original VBA.

It depends on your database.

For simple databases (primarily data entry and reporting with minimal VBA), a developer with basic web skills can work with the output directly. Setup, testing, and deployment are straightforward.

For databases with significant VBA, ActiveX controls, or complex multi-form workflows, plan for developer involvement to complete and test the generated code. AccessLeap gets you to a working scaffold — the customization and edge-case handling still require technical skill.

If you don't have a developer available, our done-for-you service includes developer review and delivery of a tested, deployable application.

The schema preview — which shows you exactly what the AI will see before any processing — is free. This is the step that lets you assess whether AccessLeap is the right tool for your specific database.

Web app generation pricing is per-database based on complexity tier. Visit legacyleaps.com/accessleap for current pricing. Done-for-you service pricing (generation + developer review + delivery) is available on request.

Yes. If AccessLeap doesn't generate a working application scaffold from your database, we'll refund your purchase — no questions asked.

The free schema preview step is specifically designed so you can evaluate whether the tool is right for your database before you pay anything. If the preview shows significant limitations for your database, don't pay — contact us and we'll discuss the right path forward.

AccessLeap runs on Windows 10 or Windows 11. Microsoft Access or the Access Database Engine Redistributable must be installed to read .accdb files.

The generated web application can be deployed on any server (Linux, Windows, or cloud). The output itself has no Windows dependency.

No. AccessLeap works as a standalone tool with any .accdb file.

However, if you have older .mdb files, use LegacyLeaps first to convert them to .accdb. LegacyLeaps preserves VBA macros, ActiveX controls, and data during the format migration. Once you have a clean .accdb, AccessLeap can generate the web application.

The two products are designed to work together as a complete legacy modernization path: .mdb → .accdb (LegacyLeaps) → modern web app (AccessLeap).