Deploying Access Databases with the Runtime
The Access Runtime lets you distribute your database to users who do not own Access. Here is how it works, what it limits, and when it makes sense — and when it does not.
One of the most common questions from Access developers who have built something useful: how do I give this to people who do not have Access installed?
The answer is the Access Runtime — a free, redistributable version of Access that runs your database without requiring a full Office license. It has been available since Access 2007, and it is still the standard way to distribute Access applications to end users.
Here is what you need to know.
What the Access Runtime Is
The Access Runtime is a stripped-down version of Access that Microsoft makes available for free download and redistribution. It can open and run Access databases — forms, reports, VBA code — but it removes the developer-facing features.
Users with the Runtime can:
- Open and use your database
- Enter and edit data through your forms
- Run reports
- Execute VBA code you have written
- Use any navigation or switchboard you have built
Users with the Runtime cannot:
- Open tables directly in Datasheet View
- Open queries in Design View
- Modify forms or reports
- Access the VBA editor
- See the Navigation Pane (it is hidden by default)
This is actually a feature, not a limitation. Your users should be interacting with your application through the forms and navigation you designed — not poking around in the raw tables.
Downloading the Runtime
The Access Runtime is available as a free download from Microsoft. Search for "Microsoft Access Runtime" and your version year (2016, 2019, 2021, or Microsoft 365). Download the version that matches the Access version you used to build the database.
Important: the Runtime version must match the Access version. A database built in Access 2021 will not run correctly on the Access 2016 Runtime.
The Runtime installer is a standard Windows executable. You can distribute it to users directly or include it in a packaged installer.
Preparing Your Database for Runtime Deployment
Before distributing your database, make sure it is ready for users who cannot access developer features.
Build a complete navigation system. Users cannot use the Navigation Pane in the Runtime. Every form, report, and function they need must be accessible through your application's UI — a switchboard, navigation form, or ribbon customization.
Set startup options. In File > Options > Current Database, configure:
- Display Form: set to your main menu or switchboard
- Application Title: your application name (appears in the title bar)
- Application Icon: your application icon
- Uncheck "Display Navigation Pane" — users should not see it
- Uncheck "Allow Full Menus" and "Allow Default Shortcut Menus" if you want to restrict right-click menus
Handle errors gracefully. In the Runtime, unhandled VBA errors show a generic error dialog and then close the database. Every procedure that touches data needs proper error handling. Test your error handlers before distributing.
Compile your VBA. In the VBA editor, go to Debug > Compile. Fix any compilation errors. A database with uncompiled VBA will fail at runtime in ways that are hard to diagnose.
Test in the Runtime. Before distributing, install the Runtime on a test machine and run your database there. Things that work fine in the full Access version sometimes behave differently in the Runtime — better to find out before your users do.
The Package Solution Wizard
Access includes a Package Solution Wizard (available in some versions under Database Tools) that creates a distributable installer package containing your database and optionally the Runtime installer.
For most deployments, a simpler approach works fine:
- Copy the compiled
.accdbfile to a shared network location or distribute it directly - Ensure the Runtime is installed on each user's machine separately
- Create a desktop shortcut that opens the database
For a more polished deployment — especially to non-technical users — consider a third-party installer tool like Inno Setup (free) or InstallShield. These let you create a proper Windows installer that installs the Runtime, copies your database, and creates shortcuts automatically.
Splitting the Database for Runtime Deployment
If multiple users will share the database, split it before distributing:
- Backend (.accdb with tables only) on a shared network location
- Frontend (.accdb with forms, reports, queries, VBA) distributed to each user's machine
Each user runs their own copy of the frontend, which links to the shared backend. This is the same split-database architecture covered in the multi-user post — it is even more important for Runtime deployments because you cannot easily update a database that is open on multiple machines simultaneously.
When you update the application, you distribute only the new frontend. The backend (and its data) stays in place.
Updating Runtime Deployments
Updating a Runtime-deployed application is the most operationally challenging part. Unlike a web application where you deploy once and everyone gets the update, each user has a local copy of the frontend that needs to be replaced.
Common approaches:
Manual replacement. Tell users to copy the new frontend file over the old one. Simple but error-prone — users forget, or copy it to the wrong location.
Auto-update on startup. Add VBA code to the startup form that checks a version number against a file on the network share. If the network version is newer, copy it to the local machine and relaunch:
Function CheckForUpdate() As Boolean
Dim strNetworkVersion As String
Dim strLocalVersion As String
Dim strNetworkPath As String
Dim strLocalPath As String
strNetworkPath = "\\server\share\MyApp_v" & GetNetworkVersion() & ".accdb"
strLocalPath = CurrentProject.FullName
' Compare version numbers stored in a config table
strNetworkVersion = GetNetworkVersion()
strLocalVersion = GetLocalVersion()
If strNetworkVersion > strLocalVersion Then
If MsgBox("A new version is available. Update now?", vbYesNo) = vbYes Then
FileCopy strNetworkPath, strLocalPath
Shell "cmd /c start """" """ & strLocalPath & """"
Application.Quit
End If
End If
End Function
This pattern works but requires careful version management and testing.
When the Runtime Makes Sense
The Runtime is a good fit when:
- You have a well-built Access application that works reliably
- Users need read/write access to data but should not modify the application
- Your user base is small (under 20 users)
- You want to distribute to users without Office licenses
- You are maintaining an existing application and not ready to migrate
When to Consider Moving On
The Runtime is not a long-term strategy for growing applications. Consider migration when:
- Your user base is growing beyond 10–15 concurrent users
- You are spending significant time on deployment and update logistics
- Users need mobile access or remote access beyond VPN
- The application needs features that Access cannot provide
- You are building new functionality and the Runtime deployment complexity is slowing you down
The Runtime extends the useful life of an Access application — it is not a replacement for a proper migration when the time comes.
Work With Access Evolved
If you found this article useful, Access Evolved specializes in exactly this kind of work — from hands-on Microsoft Access support to full database modernization projects.
Packaging and deploying an Access runtime application? Schedule a free call and get expert help with your deployment strategy.
Thinking about migrating?
Ready to move beyond Microsoft Access?
Access is a great starting point, but growing businesses often hit its limits. Anthony Passeri specializes in migrating Access databases to modern platforms — Power Platform, Power Apps, SQL Server, Azure, and more — so you keep your data and workflows without the headaches.
Written by
Anthony Passeri, MBA
Access Expert and Editor
Bridging the gap between Access and the Future
Explore Topics
Keep reading
More on Access Basics
Managing Multi-User Conflicts in Access Databases
Record locking, split databases, and refresh strategies — here is what every Access developer needs to know about keeping shared databases stable under concurrent use.
7 Access Table Design Mistakes That Cause Big Problems
Bad table design is the root cause of most Access performance, data quality, and migration problems. Here are the seven most common mistakes — and how to fix them.
Access Split Database: When It Helps and When It Doesn\'t
Splitting your Access database into a front end and back end is the standard advice for multi-user deployments. But it is not a cure-all. Here is when it actually helps — and when you need something more.