Building an app that integrates with legacy systems doesn’t require replacing your existing infrastructure. Instead, you can modernize by connecting legacy data (from Oracle, SQL Server, or even mainframes) to mobile and web apps using tools like DreamFactory and Adalo. Here's how:
- DreamFactory: Quickly generates REST APIs from legacy systems without coding. It supports over 20 database types, converts outdated formats (e.g., SOAP to REST), and ensures secure API connections.
- Adalo: Lets you build a single app and deploy it to the web, iOS, and Android without rebuilding for each platform. Using DreamFactory APIs, you can connect legacy data directly to app components.
This approach saves time and money, avoids risky migrations, and improves efficiency. For example, Mazda used similar methods to modernize 500 systems, boosting productivity by 4Ă—. By combining DreamFactory and Adalo, you can create modern apps that work seamlessly with decades-old systems while maintaining data integrity and security.
4-Step Process to Connect Legacy Systems to Modern Apps Using DreamFactory and Adalo
How to integrate legacy enterprise applications into your data pipelines
sbb-itb-d4116c7
What Are Legacy Systems and How Do They Connect to Apps?
Legacy systems are older software applications that still power essential business operations. These systems often include SQL databases like Oracle, SQL Server, and IBM DB2, as well as enterprise resource planning (ERP) platforms such as SAP HANA and Deltek Costpoint. Despite their age, legacy systems remain widely used, accounting for about 31% of the technology in organizations today. However, they often create challenges for modern app development due to their outdated design and lack of compatibility with newer platforms.
The main issue is that legacy systems weren’t built to interact with today’s web and mobile apps. Most of them lack RESTful APIs - the standard communication method modern apps rely on - and instead use older protocols and data formats. This results in data silos, making it tough for businesses to create apps or tools that require real-time access to critical information.
The upside? You don’t need to be an expert in legacy systems to connect them to modern apps. Tools like DreamFactory can bridge the gap by generating REST APIs from legacy data sources. This means even a 1970s mainframe or an outdated ERP system can provide data through the same interface used by contemporary cloud services.
Finding Your Legacy Data Sources
The first step in tackling legacy system challenges is identifying your data sources. This involves determining what type of system you’re working with and gathering the necessary technical details. For SQL databases like MySQL, Oracle, or IBM DB2, you’ll need information such as the host address (IP or domain), port number (e.g., 3306 for MySQL), database name, and valid credentials. Similarly, NoSQL databases like MongoDB or Cassandra require comparable connection details.
If your system uses file-based transfers through SFTP or FTP, figure out whether it uses SSH key or password authentication. For older web services built with SOAP, you’ll need access to their WSDL (Web Services Description Language) files, which outline the available operations. When working with mainframes like IBM DB2 for z/OS, check if the data format needs converting from EBCDIC to ASCII - a common requirement for compatibility.
To minimize risk, start with a read-only user account during testing to avoid accidental changes to production data. Also, ensure your firewall settings allow traffic between the legacy system’s port and your integration platform’s IP address. Many modern platforms can automatically detect tables, stored procedures, and other metadata using schema introspection, saving you from manual documentation.
Common Problems When Connecting Legacy Systems
One of the biggest hurdles is the lack of APIs in many legacy systems. Some rely on SOAP, a complex XML-based protocol that modern apps find difficult to use efficiently.
Security is another major concern. Older systems often don’t support modern security features like TLS encryption, OAuth, or multi-factor authentication, making them vulnerable when exposed online. To put this into perspective, the U.S. federal government spends roughly $337 million annually to maintain legacy systems that are between 8 and 51 years old.
Data format mismatches add to the complexity. For instance, a mainframe might store data in EBCDIC format, while a mobile app expects JSON. Similarly, a legacy ERP system might use proprietary data structures that don’t align with modern database schemas. Platforms like DreamFactory tackle these issues by converting data formats, generating secure REST APIs with built-in TLS encryption and role-based access control, and transforming SOAP services into REST endpoints. In fact, automated API generation can reduce common security risks by up to 99%.
| Legacy Issue | DreamFactory Solution |
|---|---|
| Missing REST APIs | Automated REST API generation for 20+ databases |
| Old Protocols (SOAP) | SOAP to REST conversion with automatic WSDL parsing |
| Inconsistent Data Formats | Automatic handling of EBCDIC and XML conversion |
| Security Risks | Built-in TLS encryption, role-based access control, and rate limiting |
| Complex Business Logic | Custom scripting in Python, PHP, or NodeJS |
Creating APIs from Legacy Systems with DreamFactory
DreamFactory acts as a bridge between outdated systems and modern applications. It connects directly to your existing databases - whether that's MS SQL Server 2016, Oracle 12c, or an IBM DB2 mainframe - and automatically generates REST APIs. The platform supports over 20 connectors, including SQL, NoSQL, SOAP, and file storage systems, making integration straightforward.
Setup is quick, averaging just 5 minutes. On G2, DreamFactory has earned a 4.7/5 rating, with users frequently highlighting its ease of use. Edo Williams, Lead Software Engineer at Intel, shared:
"DreamFactory streamlines everything and makes it easy to concentrate on building your front end application. I had found something that just click, click, click... connect, and you are good to go."
Once connected, the platform automatically generates endpoints for Create, Retrieve, Update, and Delete (CRUD) operations. It also provides OpenAPI (Swagger) documentation, enabling users to test endpoints directly within the interface. For platforms like Adalo, DreamFactory structures record collections under a resource JSON key, ensuring compatibility with Adalo's external collections.
How to Set Up DreamFactory for API Creation
Setting up DreamFactory involves four key steps. First, create a Service by selecting your database type (e.g., MS SQL Server or PostgreSQL) and entering the connection details. DreamFactory uses schema introspection to automatically detect tables, views, and stored procedures, saving you from manual documentation.
Next, define a Role to enforce security controls. Instead of granting broad database access, you can restrict an API key to specific tables (e.g., _table/employees/*) or limit it to read-only operations using the GET HTTP method. This role-based access control is especially critical for meeting U.S. compliance standards when handling sensitive data. DreamFactory also supports Windows Authentication for SQL Server, encrypted system databases, and multi-protocol authentication methods like Okta, SAML, and Active Directory.
Third, generate an API key by assigning the defined Role to an App. This key is then used in the X-DreamFactory-API-Key header for Adalo's External Collections.
Finally, for databases behind strict firewalls, you can establish an SSH tunnel from the DreamFactory server to the database host. This ensures secure data transmission without exposing the database port to the public internet. Additionally, enabling data retrieval caching in the service configuration can significantly improve performance when working with large datasets.
| Step | Action | Details |
|---|---|---|
| 1. | Connection | Create a Service by selecting the database type and entering details |
| 2. | Security | Define a Role to control access to specific services, tables, and HTTP methods |
| 3. | Access | Create an App and generate an API key linked to the Role |
| 4. | Integration | Use the Base URL and X-DreamFactory-API-Key header in External Collections |
DreamFactory has proven effective in real-world scenarios. For example, the Vermont Department of Transportation used it to connect legacy systems from the 1970s with modern databases through secure REST APIs. The National Institutes of Health (NIH) avoided a costly system overhaul by linking various SQL databases via APIs to support grant application processes and analytics. Deloitte also leveraged DreamFactory to integrate Deltek Costpoint ERP data, enabling executive dashboards with real-time access through REST APIs.
With your API established, the next step is to adapt legacy data formats for modern app consumption.
Converting Legacy Data Structures for Modern Apps
Legacy systems often store data in formats that modern applications can't readily process. For instance, a mainframe might use EBCDIC encoding while a mobile app expects JSON. Similarly, an old ERP system might have rigid table structures with obscure field names or rely on SOAP web services with complex XML schemas. DreamFactory simplifies these challenges by automatically transforming data to ensure compatibility with modern app builders like Adalo.
The platform allows you to select specific fields, optimizing payload size and improving performance. For example, if your legacy database has 50 columns but your app only needs a name, email, and department, you can configure the API to return just those fields. This reduces data transfer and speeds up load times.
For more complex data structures, DreamFactory offers server-side scripting in JavaScript, PHP, or Python. This enables you to reformat and clean up data before it reaches your app. And if your system still relies on SOAP web services, DreamFactory can convert them into REST APIs. By parsing WSDL files, it exposes SOAP operations as REST endpoints with JSON responses - making integration much simpler.
DreamFactory also handles stored procedures, exposing them as REST resources. This means you can retain and access years of tested business logic - like calculations, validations, or workflows - directly through the API.
Organizations using DreamFactory have reported substantial cost savings. On average, it reduces common security risks by 99% and saves $45,719 per API compared to manual development. Adam Dunn, Sr. Director at McKesson, shared:
"DreamFactory is far easier to use than our previous API management provider, and significantly less expensive."
Connecting Adalo to Your Legacy Data
Once DreamFactory generates your REST API, you can link it to Adalo using External Collections. This setup allows you to perform full CRUD operations through DreamFactory's endpoints. By adopting this method, organizations have reported 90% faster development cycles compared to traditional coding approaches. Additionally, it's estimated that 70% of new enterprise applications will rely on no-code/low-code platforms by 2025.
After establishing the connection, Adalo's Magic Text feature enables you to map legacy fields (like first_name or hire_date) to app components such as text boxes, lists, or profile screens.
Adding DreamFactory as a Data Source in Adalo
Setting up DreamFactory as a data source in Adalo is straightforward. Start by retrieving your API Base URL and API key from DreamFactory. Navigate to Adalo's Database menu, click "Add Collection", and name it according to the data you're accessing - examples include "Customer Records" or "Inventory Items."
Enter the Base URL exactly as provided in DreamFactory, ensuring it points to the specific table you want to access. For example, if you’re connecting to a SQL Server database with an employees table, your URL might look like this:
https://api.yourcompany.com/api/v2/sqlsrv/_table/employees.
Next, add the authentication header by selecting "Header", using X-DreamFactory-API-Key as the header name, and pasting your API key as the value. This ensures a secure connection. DreamFactory's role-based access control allows you to limit the API key to specific tables or assign read-only permissions if needed.
To configure the "Get All" endpoint, set the Results Key to resource. This step ensures Adalo can correctly parse the returned JSON data. After testing the connection and confirming the data preview, your legacy data will function as a native collection in Adalo, ready for use just like an internal database table.
With the data source in place, the next step is to adjust legacy data formats to ensure they display correctly in Adalo.
Making Legacy Data Work in Your App
Now that Adalo is connected to your legacy data, you’ll need to make sure the data formats align with modern app standards. Legacy systems often store data in outdated formats that may not work seamlessly in newer platforms. For instance, a mainframe might record dates as 19850415 (YYYYMMDD), while Adalo requires 1985-04-15 (YYYY-MM-DD). Similarly, numeric or measurement data from legacy systems may include currency symbols, European decimal formats, or metric units that need to be adjusted for U.S.-based applications.
To ensure compatibility, reformat date fields to YYYY-MM-DD for standard dates or use ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ) for date and time values. If your legacy system uses an alternate format like MM/DD/YYYY, DreamFactory's scripting engine can automatically convert the data during processing.
For numeric data, strip out any currency symbols or extra characters, ensuring Adalo receives clean numbers (whole numbers, decimals, or negative signs only). When working with measurements, convert weights from kilograms to pounds by multiplying by 2.20462, and for temperatures, apply the formula (Celsius Ă— 9/5) + 32. Additionally, make sure boolean fields are represented as true or false (with blank values treated as false). If your app uses image URLs, check that they are correctly formatted and include a domain prefix if necessary to make them accessible.
Building and Publishing Your App with Adalo
Once your legacy data is integrated into Adalo, you’re all set to design screens and launch your app. Adalo’s visual builder makes it easy to transform legacy data into modern interfaces and publish your app to the web, iOS, and Android - all from a single build. Start by designing your app’s screens, then move on to publishing.
Designing Your App Interface
Adalo’s drag-and-drop editor simplifies screen creation using your legacy data. Start by creating a new screen, then drag components like Lists, Forms, or Cards onto the canvas. These components can be directly linked to your DreamFactory External Collection by selecting the component and choosing your legacy data source from the dropdown menu.
For example, you can add a List component to display inventory items, map key fields with Magic Text, and format prices in USD. Want to visualize stock levels? Add a Chart component. Need users to update inventory details? Include a Form that sends changes back to your legacy system through DreamFactory.
When designing detail screens - such as an employee profile or product page - use a Click Action on list items to navigate to a new screen and pass along the relevant data automatically.
Adalo’s Responsive Builder, introduced in April 2023, ensures that your layout adjusts seamlessly across mobile, tablet, and desktop devices. This unified design approach not only keeps your app consistent across platforms but also makes updates faster, as changes are applied everywhere at once. Once your interface is polished and synced with your legacy data, you’re ready to publish.
Publishing to Web, iOS, and Android
When your app design is complete, head over to the Publish tab in Adalo to deploy it. For web apps, you can generate a shareable URL or embed code to launch instantly. For iOS and Android, upload your app icons and splash screens, then use Adalo’s one-click build feature to create native app wrappers.
Make sure to configure localization settings: set the app language to en-US, format currency as USD, and display dates in MM/DD/YYYY. If your legacy data includes measurements, ensure that DreamFactory converts them from metric to imperial (e.g., miles, pounds, and °F) during the data transformation process. Web publishing happens instantly, while app store reviews typically take between one and seven days.
Adalo’s single-build system compiles your app into native code for iOS and Android, while also creating a Progressive Web App for the web. Platform-specific features like touch gestures and keyboard navigation are handled automatically. Use preview mode to test for issues like slow API responses or formatting errors. Start by launching your app on the web for initial user testing, gather feedback, and make improvements before submitting it to the app stores.
Improving Performance and Scaling Your App
Once your legacy data starts flowing into your app, ensuring smooth performance as usage grows becomes crucial. Legacy systems were never built for real-time mobile access, which makes prioritizing performance a top priority. With the right strategies, you can significantly boost speed and prepare your app to handle thousands of users - without needing a complete rebuild. These optimizations set the stage for scaling your app effectively as demand increases.
Making Legacy Data Load Faster
Streamline screen logic. Complex calculations and deeply nested data structures can drag down screen load times. Adalo's internal performance tests showed an 86% reduction in initial screen loading times for large databases after making targeted optimizations. Simplifying overly complex screens with dozens of components into multiple, smaller screens reduces the number of database queries sent to your legacy system through DreamFactory.
Filter data at the source. If you're using an intermediary data source, create views that only show the data you actually need. This saves both time and API calls. For direct connections to legacy systems via DreamFactory, implement pagination by leveraging Adalo's "Load items as user scrolls" feature. This approach avoids overwhelming your app with massive datasets all at once.
Switch to PATCH instead of PUT for updates. PUT replaces the entire record, which can lead to data loss if you're only sending partial updates. PATCH, on the other hand, updates only the fields you specify, reducing payload size and preventing accidental overwrites.
If your app serves users outside the United States, you may encounter higher latency since Adalo's servers are US-based. To address this, consider using a short-lived cache (60–120 seconds) within DreamFactory. This can improve response times while maintaining data accuracy.
By incorporating these performance tweaks, you’ll not only speed up your app but also set the stage for scaling and securing it for enterprise-level demands.
Using Adalo Blue for Enterprise Needs
When your app must support hundreds of employees or manage sensitive legacy data, Adalo Blue provides the enterprise-grade tools you need. It includes SAML-based Single Sign-On (SSO), allowing users to log in with their existing corporate credentials - no need to juggle extra passwords. Advanced permission controls let you limit access to specific legacy data, ensuring only authorized departments can view or edit sensitive information like payroll or customer records. To meet compliance requirements in regulated industries, Adalo Blue also offers audit logs that track every instance of data access or modification.
For apps handling over 10,000 records or catering to more than 1,000 daily active users, pairing Adalo Blue with a scalable backend solution is a smart move. This combination not only ensures your app can grow with demand but also provides the robust security enterprises require. With API security incidents costing businesses an average of $591,404 globally, having built-in protections is critical when connecting modern apps to decades-old systems.
Conclusion
Creating an app that works seamlessly with legacy data doesn’t require tearing down your existing systems or diving into lengthy custom development projects. By using DreamFactory to connect to your current databases - whether it’s Oracle, SQL Server, or even older mainframe systems - you can quickly generate a REST API without writing a single line of backend code. From there, Adalo’s External Collections feature allows you to link those API endpoints directly into your app’s interface through an intuitive visual builder, eliminating the need for programming expertise.
Here’s how it works: first, use DreamFactory to generate your API and configure role-based access and authentication keys. Then, in Adalo, set up the external collection by mapping the correct endpoints and setting the Results Key to “resource.” (If you're using other data sources, you might first need to build an Airtable database to organize your information.) From there, it’s as simple as dragging and dropping components to display your legacy data. Once your app’s screens are designed, you can publish it simultaneously for web, iOS, and Android - all from a single build. This streamlined process enables fast and efficient deployment, saving both time and resources.
Organizations adopting this method report development cycles that are up to 90% faster than traditional coding approaches. What used to take months can now be achieved in weeks - or even days for simpler projects. Starting at just $65/month for Adalo’s Professional plan, this approach provides a budget-friendly alternative to costly legacy system overhauls, all while retaining your existing data infrastructure.
One major advantage is that your legacy data stays exactly where it is - no risky migrations, no downtime, and no need to re-train your team on unfamiliar systems. Updates made in your app sync back to the original database via API calls, and changes in your legacy system are automatically reflected in your app. This two-way connection modernizes the user experience while preserving the business logic and reliability of your current systems. It’s a practical way to bridge decades-old data with sleek, modern interfaces.
Whether you’re enabling mobile payroll access for employees, connecting field technicians to inventory systems, or providing order history access from an older ERP, Adalo’s app builder offers a fast, affordable solution to get your app up and running in no time.
FAQs
How can DreamFactory help integrate data from legacy systems?
DreamFactory makes it easier to integrate legacy systems by transforming existing data sources into secure REST APIs that follow modern standards - no coding required. It seamlessly connects to a variety of on-premise databases, such as SQL Server, Oracle, MySQL, and even SOAP services. This means you can take decades-old data and expose it as modern, user-friendly HTTP endpoints for applications, including no-code platforms.
Security is a top priority with DreamFactory. It includes enterprise-level protections like role-based access control (RBAC), API key management, OAuth, and TLS encryption to safeguard sensitive legacy data. Plus, it supports server-side scripting, allowing you to apply complex business logic or data transformations while keeping your original systems stable and intact.
DreamFactory also lets you modernize workflows gradually. You can start with read-only access to legacy data, then move on to enabling write capabilities and custom logic over time. This phased approach minimizes disruptions, making it easier and more cost-effective to bring legacy systems into the fold of new applications.
What are the steps to set up DreamFactory for creating APIs?
Setting up DreamFactory to create APIs is a simple process that can be broken down into a few key steps. Start by installing DreamFactory using the deployment method that best suits your environment - whether that's Docker, Kubernetes, or a system-specific installer. After installation, log in using the default admin credentials, update to a secure password, and configure essential settings like the server URL and email notifications.
Once that's done, you’ll need to connect your legacy system. Add it as a data source through the DreamFactory console by entering the required connection details, such as the host, port, and credentials. Test the connection to make sure everything is functioning properly. DreamFactory will then generate RESTful endpoints for the connected system automatically. You can refine these endpoints by enabling or disabling specific tables, views, or procedures as needed.
To wrap things up, secure your API by implementing Role-Based Access Control (RBAC), API keys, or OAuth to manage access. Use tools like Postman to test the endpoints and ensure they’re functioning correctly. Additionally, DreamFactory provides auto-generated API documentation, which you can share with your team for easier collaboration.
How does Adalo make it easy to build apps using data from legacy systems?
Adalo’s no-code platform takes the hassle out of app development by letting you directly connect to legacy databases, APIs, and external data sources - all without writing a single line of code. This approach allows you to build fully functional apps up to 90% faster compared to traditional development methods.
The platform makes it simple to integrate legacy data while maintaining both compatibility and performance. Thanks to its intuitive visual builder, even those without a technical background can modernize outdated systems and transform complex data into a user-friendly app experience.
Related Blog Posts
