Your Data, Your Rules: Managing Custom Datasets with the reference.do API

Every business runs on its own unique set of rules and classifications. Beyond universal standards like country codes and currencies, you have product categories, internal department IDs, sales territories, approved vendor lists, and countless other datasets that provide crucial context to your operations. This is your custom reference data.

Where does this data live? All too often, it's scattered across the organization—in spreadsheets emailed between teams, as hardcoded lists in application source code, or siloed in a legacy database that nobody wants to touch. This fragmentation isn't just messy; it's a direct bottleneck to agility and a breeding ground for inconsistency.

While reference.do provides seamless access to standard public datasets, its true power is unlocked when you use it to manage your own proprietary data. It's time to stop managing critical data in static files and establish a single source of truth, accessible through one simple, reliable API.

The Chaos of Scattered Reference Data

Managing custom reference data manually across multiple applications is an uphill battle. The challenges are likely familiar to any growing engineering or data team:

• Data Inconsistency: The marketing team's list of product categories doesn't match the one used by the inventory system. One microservice thinks a user role is called "Admin," while another expects "administrator." These small discrepancies lead to bugs, bad data, and broken user experiences.
• Update Paralysis: Need to add a new sales region or a product line? This simple business change can trigger a cascade of required code updates, testing, and coordinated deployments across multiple teams and services, slowing down innovation.
• No Versioning: When a dataset is just a file, there's no history. It's impossible to know what the list of "active subscription plans" looked like last quarter, making historical analysis and debugging a nightmare.
• Lack of a Single Source of Truth: Without a central, authoritative source, every team and application is left to fend for itself. This duplicates effort, increases maintenance overhead, and erodes trust in the data itself.

Beyond ISO Codes: A Unified API for All Your Data

Accessing standard ISO codes for countries and currencies via an API is a clear win over maintaining local copies. Now, imagine applying that same principle to your own data.

What if your custom list of store-locations or product-categories was just as easy to query as the standard iso-4217 currency list?

This is the core philosophy of reference.do. We provide a unified platform to manage all your reference data—both public and private—through the same interface and the same simple API. You get to define the structure, own the content, and control the versions. Your data, your rules.

How It Works: Custom Data, On Demand

Centralizing your proprietary data with reference.do is a straightforward process designed to get you up and running quickly.

1. Upload: Securely upload your custom datasets. Whether it's a simple list of key-value pairs or a more complex data structure, you can bring your existing data into the platform.
2. Manage & Version: Once uploaded, your dataset is no longer just a static file. You can manage its lifecycle, make updates through a clean interface, and crucially, version your changes. Versioning ensures that you can update data without breaking existing applications that depend on an older structure.
3. Query via API: Instantly access and integrate your custom data into any application using the same simple SDK or API endpoint you use for public data.

Let's see it in action. While our homepage shows fetching standard currencies, here’s how you would fetch your company's proprietary list of internal product lines:

import { Do } from '@do-inc/sdk';

const an = new Do(process.env.DO_API_KEY);

// Get your company's custom list of product lines
const productLines = await an.reference.get('acme-corp-product-lines');

console.log(productLines);
/*
=> [
     { "id": "pl-001", "name": "Enterprise Solutions", "division": "B2B" },
     { "id": "pl-002", "name": "Consumer Gadgets", "division": "B2C" },
     { "id": "pl-003", "name": "Data Services", "division": "B2B" },
     ...
   ]
*/

The call is identical. The only thing that changes is the name of the dataset. This elegant simplicity makes development faster and your systems more robust.

From Theory to Practice: Custom Data Use Cases

Centralizing your custom reference data unlocks efficiency across your entire business. Here are a few examples:

• E-commerce: Manage product-categories, brand-names, and shipping-zones. Ensure your website, mobile app, and internal fulfillment tools all present consistent, up-to-date information to customers and staff.
• Fintech: Maintain a master list of your internal chart-of-accounts, transaction-types, or risk-levels. Provide a single, auditable source of truth for all financial reporting and compliance applications.
• SaaS: Control subscription-plans, feature-flags, and user-permission-roles. Update pricing tiers or roll out new features to specific user groups without needing to redeploy every microservice.

Establish Your Single Source of Truth Today

Your custom reference data is the institutional knowledge of your business, codified. It deserves to be treated as a first-class asset, not an afterthought managed in spreadsheets and source code.

reference.do empowers you to treat your most critical business data with the same simplicity, reliability, and accessibility as universal standards. Stop wrestling with inconsistent lists and unlock development velocity.

Take control of your custom datasets today. Get started with reference.do and build your single source of truth.