Dromo's Support for Multiple File Types: Beyond CSV and Excel

In today's data-driven products, users may provide data in many different file formats. A finance app might receive transactions in Excel; an IoT platform might get JSON logs; an enterprise system could export XML; others may use tab-separated text or legacy spreadsheet files. Rigid import workflows that only accept CSV files force all these diverse inputs into one format. This format inflexibility creates extra work and risk: engineers or end-users must manually convert files, often leading to errors or dropped data. According to industry research, traditional import tools typically support only CSV, and requiring conversions from Excel, JSON, XML or other formats "introduces unnecessary complexity, increasing the risk of errors and data loss" during onboarding. In an era where customers expect software to "just work" with their data, telling a user "sorry, we only accept CSV" is a significant roadblock. It delays onboarding, frustrates users who have to fiddle with re-formatting, and can ultimately drive them away if the process is too cumbersome.

Multi-format support is no longer a luxury – it's a necessity for a pleasant data onboarding experience. By accommodating whatever file the customer already has, you reduce friction and show that your product meets users where they are. The payoff is quicker time-to-value: users can upload their information immediately and start using your product's features, instead of spending hours converting or cleaning files. It also means fewer support tickets and emails asking "How do I get my data into your app?" Modern data import solutions recognize this need and have evolved to handle a variety of file types seamlessly.

Dromo was built with versatility in file handling as a core design principle. It goes far beyond the basics of CSV. Right out of the box, Dromo's importer can natively parse CSV, TSV (tab-separated values), and Excel spreadsheets – covering both .XLS and .XLSX formats. In fact, Dromo supports virtually all Excel variants, including older legacy formats (Excel 97–2004 .xls and even Excel 2.0–5.0), as well as other spreadsheet file types like OpenDocument (.ods), Apple Numbers, and even legacy tools such as Lotus 1-2-3 or Quattro Pro. This means if your users have an oddball spreadsheet format from a decade ago, Dromo can likely handle it out-of-the-box or with minimal configuration.

Why is this valuable? Consider the common scenario of an enterprise client who only has their data in an old Excel 97 .xls file or a regional format. With many import solutions, that file might fail to upload or scramble the data. Dromo, by contrast, will parse it cleanly and guide the user through the import just like any modern CSV. The same goes for TSV files – which are common in scientific data and other systems – Dromo treats them just like CSV (recognizing the tabs as delimiters). This native flexibility saves engineering time as well: you don't have to write custom parsing logic for each file type or incorporate multiple libraries. Dromo's robust parsing engine has broad format compatibility baked in.

Not only does this multi-format support make life easier for end users, it also prevents data errors. Every time a file is manually converted (say from Excel to CSV), there's a chance of things going wrong – maybe an encoding issue that turns "José" into "José", or a conversion that strips leading zeros from ZIP codes. By accepting the original file format directly, Dromo avoids those intermediate pitfalls. The data goes through one rigorous import pipeline, preserving its integrity. In short, whether the source data is comma-separated, tab-separated, or in a binary Excel workbook, Dromo can ingest it and normalize it into a structured dataset for you.

Tip: If your application only wants to allow certain formats, Dromo lets you restrict allowed file types in the configuration or via simple checks. For example, you might choose to accept CSV and Excel but not JSON uploads (perhaps if you want to handle JSON via API instead). Dromo's default is to enable all common formats, but you remain in control – you can configure the uploader to reject unexpected file types or show a friendly error if a user tries to upload an unsupported format. This ensures security (no one uploading random executables) and keeps the user experience focused. But for most use cases, keeping all the format options open will make your import flow much more accommodating.

JSON is ubiquitous in modern web services and data interchange – from API responses to configuration exports. Can Dromo handle JSON files? The answer is yes – with a slightly different approach. While a user cannot drag-and-drop a .json file directly into the Dromo UI (JSON isn't a tabular format in the way CSV/Excel are), Dromo provides a straightforward way for developers to import JSON content: the initialData setting. Essentially, you can parse a JSON file (or any JSON data source) in your application code and provide the data directly to Dromo as an array of records, bypassing the file upload step.

Here's how it works in practice: Suppose your customer has exported data from another system as a JSON file. Instead of writing your own full JSON processing and validation pipeline, you can read that JSON (for example, in JavaScript or Python), and pass the resulting array of objects to Dromo's uploader via the initialData configuration. Dromo will then treat that data as if it was uploaded via a file, and the user gets the same mapping and validation interface for it. In other words, JSON support is achieved through Dromo's flexible API – you convert JSON into in-memory data, and Dromo takes it from there. The end result is the same clean, structured dataset.

This method has a couple of benefits. First, it means there's effectively no limit to the data sources you can feed into Dromo. If tomorrow a new format emerges (say, YAML or a custom JSON schema), as long as you can write a few lines of code to translate it into objects or rows, you can leverage Dromo's powerful importer on that data. Second, by using initialData you keep the user experience seamless. For the end-user, it might all happen behind the scenes – they click "Import JSON", you handle parsing invisibly, and then pop up the Dromo interface with their data ready for mapping. They don't need to manually copy-paste anything; it feels like Dromo "just understands" JSON.

It's worth noting that when Dromo completes an import (regardless of input format), the final output it provides is JSON. After the user reviews and submits, your application receives the cleaned data as a JSON object matching your predefined schema, typically via a callback or API response. That means even if the input was an Excel file, you get a nice JSON array or JSONL (JSON Lines) output that's ready to be inserted into your database or used in your code. This design is particularly convenient if your backend or database (like MongoDB, for instance) works with JSON documents – Dromo essentially bridges the gap between user-friendly file formats and your JSON-based pipelines. In fact, one of Dromo's guides highlights how traditionally one would have to convert CSV rows into JSON to load into a system like MongoDB, whereas Dromo handles that conversion and validation for you automatically.

What about more complex or less structured formats like XML, HTML tables, or even PDFs containing tables of data? Dromo's architecture is built to be extensible so that no matter what format your data comes in, you can teach Dromo to import it. Through the use of Custom File Parsers, developers can plug in their own parsing logic for any file type. Dromo will use your custom parser to transform the file into a rows-and-columns structure that its importer can understand.

In practice, using a custom parser with Dromo involves registering a function (in JavaScript, for example) that knows how to extract data from the custom file. You also specify which file extensions this parser should apply to. For example, you might write an xmlParser function that reads an XML file and outputs a 2D array of strings (essentially simulating a CSV grid). Then you tell Dromo's uploader: "Whenever a .xml file is uploaded, use xmlParser instead of the default." From that point on, if a user uploads an XML, your parser runs under the hood, converting the XML into a table, and then Dromo proceeds with its normal import flow (field mapping, validation, etc.) on that parsed data. The user sees a familiar spreadsheet-like preview, even though the source was an XML file. This pattern can be used for HTML files (maybe your users have an HTML table export), fixed-width text files, or any proprietary format you encounter. It's a powerful way to extend Dromo's versatility beyond the already broad built-in formats.

A dramatic example of this extensibility is PDF support. PDFs are not designed for data interchange, but sometimes that's what customers have – think of a PDF report with a table of records. Rather than saying "no, we don't support PDF," you can use a third-party tool (like an OCR or table extraction API) inside a custom parser. Dromo's documentation even provides a guide for importing a PDF table by hooking into the PDFTables API as a parser. The custom parser takes the PDF, extracts structured table data from it, and hands it to Dromo. The user can then validate and import as if they had provided a normal spreadsheet. This approach shows how Dromo can handle virtually any file type as long as you can define how to convert it into rows and columns.

In summary, for XML and other non-standard formats, Dromo has you covered via its plugin-like parser system. Many formats (like XML or JSON) are hierarchical or nested, so converting them to a flat table might require some design decisions (which fields become columns, etc.). But once you've written a parser for it, you get to reuse Dromo's entire import UI and validation engine on those formats – saving a massive amount of development time versus building a dedicated importer from scratch for each format. This ensures that "no customer's data is left behind due to format quirks," as every source can be accommodated one way or another. Importantly, the user experience remains consistent: whether they import an Excel file or an XML file, they go through the same smooth Dromo workflow.

Supporting multiple file types is only half the battle – once the data is parsed, the next challenge is making sense of it and ensuring it fits your application's schema. This is where Dromo's AI capabilities shine, turning what could be a confusing mapping exercise into a quick, even pleasant step. Dromo uses advanced machine learning (including GPT-4 from OpenAI under the hood) to intelligently map columns and fields on behalf of the user. For example, if your app expects a field called Customer Email and the uploaded file (be it CSV, JSON, etc.) has a column header Email Address or Email_Id, Dromo's AI can recognize that those likely mean the same thing and automatically suggest or apply the mapping. This OpenAI-powered matching spares the user from manually dragging fields around or wondering "What does this column correspond to?" – the system harnesses AI to assist in the mapping process, accelerating it dramatically.

The AI isn't just for header matching. Dromo also performs content-aware validations and transformations in real time. As soon as the data is uploaded and parsed, Dromo's engine (augmented with AI rules and heuristics) checks every cell against the expected type and constraints. Is that date in a valid format? Are those product codes alphanumeric? Are any required fields missing? Traditional import workflows might only surface such errors after you try to import (and then throw a cryptic "error on row 42" message). In contrast, Dromo flags issues immediately on the review screen, highlighting problematic cells and even offering suggestions to fix them. Users get clear explanations – e.g. "ZIP code must be 5 digits" – right in context. This real-time, AI-enhanced validation allows users to see and correct data errors within the import interface, ensuring high-quality data from the start.

One of the most impressive aspects is how the AI can sometimes auto-correct or normalize data. For instance, if a column is supposed to be a date and one row says "32/13/2025", Dromo might flag it and even suggest the nearest plausible date or explain the format issue. Or if the header names are slightly off, Dromo's AI mapping will have already taken care of aligning those columns to your schema's fields. All this leads to far fewer errors needing manual intervention. The importer becomes more forgiving of user mistakes or variations in the data. For the end user, it feels like the system "understands" their data intent.

From a developer or product manager's perspective, these AI capabilities translate into lower support burden and happier customers. Your team doesn't have to pre-define every possible synonymous column name or every validation edge case – Dromo's learning-driven approach covers many of them. And when users upload data, they rarely get stuck. As an UpKeep engineer described their pre-Dromo experience, people would often "upload all their data and get a generic error message with no idea why it failed". With Dromo, that scenario disappears; errors are specific and usually solvable by the user on the spot, thanks to the guided AI feedback. The overall import success rate shoots up, meaning more customers fully onboard their data without frustration. Dromo's own metrics and case studies show significant improvements in self-serve import completion when AI-driven mapping and validation are in play – essentially, users can do it themselves instead of opening support tickets.

It's also worth noting that Dromo's AI features aren't static. The platform continuously improves its suggestions and coverage. And for specialized needs, you can always enforce custom rules or transformations (Dromo even has an AI-powered "Transform Data" feature for bulk edits via natural language). But even without going into those advanced features, the out-of-the-box AI for schema mapping and data quality is a game changer for imports. It brings a level of automation and intelligence to what used to be a very manual, tedious part of data onboarding. By combining this with multi-format support, Dromo ensures that no matter what file a user has or how it's structured, the system can both read it and make sense of it almost automatically.

All these capabilities – multi-format parsing, AI mapping, instant validation – are not just theoretical improvements. They produce measurable results in the real world, as several Dromo customers have discovered. Let's highlight one example: UpKeep, a maintenance management software company, was struggling with their previous CSV import process. Users frequently encountered errors and format issues, and only about half of imports succeeded on the first try. After integrating Dromo, UpKeep saw their import success rate soar from roughly 50% to over 99%. This dramatic increase meant that nearly every customer could get their data in on the first attempt, without back-and-forth with support. In fact, UpKeep reported saving around $40,000 annually thanks to the reduction in support requests and manual error correction workload – a direct financial impact from smoother imports.

Multi-format support was a key factor in this success. UpKeep's users weren't all coming with perfectly formatted CSVs; some had Excel files with slight differences, others might have had regional number formats or different delimiters. By using Dromo, UpKeep was able to accommodate these variations effortlessly. What previously might have caused a failed import (and a frustrated customer) now became a non-issue – Dromo would handle it or guide the user to fix it. The expanded format support also future-proofed their onboarding: if a big client came with, say, an XML export from an older system, UpKeep could ingest it by adding a custom parser or using Dromo's headless API to preprocess it, rather than turning that client away or spending weeks building a one-off importer.

UpKeep isn't alone. Many other teams have benefited from Dromo's flexibility. Ingenious Build, for instance, managed to shrink a planned several-month development of a custom data importer down to just a few hours by leveraging Dromo's solution. Part of that speed-up is because Dromo handled all the tricky parts – reading various file formats, ensuring data cleanliness, etc. – so the Ingenious Build engineers didn't have to reinvent those wheels. Another company, Waycool Software, was able to reduce onboarding-related support tickets by 90% and cut their customers' onboarding time in half after switching to Dromo. That kind of improvement is a testament to how a flexible, intelligent import tool can transform the customer experience. When users aren't getting stuck on importing data, they can start using the product sooner and more effectively, which makes them (and your team) much happier.

These real-world outcomes underscore an important point: a versatile import process isn't just a nice-to-have – it directly impacts your bottom line and customer satisfaction. By supporting multiple file types and automating the heavy lifting, Dromo removes friction from the very first interaction a customer has with your product (uploading their data). The result is more successful onboarding, less hand-holding, and faster time-to-value. As one CEO put it after rolling out Dromo across their onboarding, "our customers love the new experience". When was the last time customers raved about a file import? With Dromo, it's possible!

Data import might not be the flashiest feature of a software product, but it is often the make-or-break moment for turning a trialing user into a happy, active customer. Dromo's support for multiple file types – going well beyond the old CSV-only paradigm – removes a huge source of friction from this process. It means your product can meet users where their data is, whether that's an Excel spreadsheet, a JSON export, an XML feed, or anything in between. This format flexibility, combined with Dromo's AI-driven mapping and validation, delivers an importer that feels almost magical to end users: "I uploaded my file and it just worked."

From an engineering standpoint, adopting Dromo's versatile importer saves invaluable time. Your team doesn't need to maintain a patchwork of import scripts or assist every customer who has trouble with file formatting. Dromo acts as a smart front-end to your data pipeline, reliably converting messy inputs into clean, structured outputs with minimal oversight. And it does so securely – processing data in-browser or in your environment (with options like bring-your-own-storage for sensitive data), and with compliance certifications to back it. In short, you get a turnkey solution that covers everything from file parsing to field mapping to error resolution.

The benefits are clear in both quantitative and qualitative terms: higher successful import rates, lower support costs, faster onboarding cycles, and happier users. Businesses that have embraced this modern approach are seeing onboarding times drop from weeks to minutes and customer churn due to onboarding issues virtually disappear. In today's competitive landscape, providing a smooth, flexible data onboarding experience can be a real differentiator – it shows customers you value their time and are equipped to handle their needs (no matter how their data is formatted).

Dromo's multi-file support is a key pillar of that superior experience. It signals that your product is ready for anything and that getting data into the system will be painless. When you pair that versatility with AI-assisted usability, you end up with an import workflow that delights users (and makes your developers' lives easier too). If your team is looking to eliminate the headaches of data imports and deliver a truly shockingly pleasant onboarding, Dromo's solution is worth a look. The road your data travels from source to destination can be long and winding, but with Dromo handling the import, it's a much smoother ride.