Invented by Galante; Gregory, Hu; Dennis, Cheng; Yu Xin, Liang; Dennis Jing Jing, Hariri; Behnoosh, Chiu; Bikin, Izatt; Matthew, Henrichs; Miles, Leslie; Shawn Thomas
Modern work happens across many apps and platforms. Teams use online documents, project tools, calendars, and databases—often from different companies. Moving and updating data between all these places is hard. It usually means copying and pasting, which takes time and is easy to mess up. But what if there was a way for all these tools to talk to each other and keep everything in sync, automatically? That’s what this patent application aims to do. Let’s explore how this technology changes the way we work together online.
Background and Market Context
To understand this patent, let’s first look at how people and companies use digital tools today. Most teams work together using a mix of apps. You might write a report in Google Docs, track tasks in Asana, keep files in Dropbox, and manage your schedule in Outlook. Each of these tools is great at what it does, but they don’t always play nicely with each other.
When you want to get data from one tool into another, you often have to do it by hand. Maybe you copy a list of tasks from your project tool and paste them into a table in your report. Or you export a spreadsheet, then upload it somewhere else. This is slow, boring, and sometimes you make mistakes. If the task list changes, you have to do it all over again to keep things up to date.
Companies have tried to solve this problem in a few ways. Some offer built-in connections, called integrations, between their apps and a few others. For example, you might be able to pull your Google Calendar into your project tool. But these connections are often limited. They might only work for a small set of apps, or only move certain types of data. Sometimes, companies build custom “bridges” for their own needs, but these are expensive and hard to keep working as apps change.
The rise of Application Programming Interfaces, or APIs, has helped. APIs let different software talk to each other. But using APIs still takes effort. Each app has its own way of doing things. If you want your document to pull in data from five different tools, you might need five different pieces of code. And when one of those tools changes, your code might break.
Today, teams are looking for better ways to bring all their work together. They want their reports, plans, and dashboards to pull in live data from wherever it lives, and to update automatically. They want to be able to add or change data in one place, and have it show up everywhere it’s needed, right away. Most of all, they want this to “just work,” without needing a programmer every time.
This is where the patent comes in. It describes a new way to connect collaborative documents with data from many other platforms, using a flexible system that can work with all sorts of data. It promises to make syncing data between tools simple, automatic, and reliable. If successful, it could change how teams work together, making it easier to keep everyone on the same page—literally.
Scientific Rationale and Prior Art
Let’s look at what’s already out there, and why this new idea matters.
For a long time, moving data between tools has relied on manual effort. People copy and paste, or export and import files. This works, but it’s slow and causes errors. Each tool has its own way of showing data—what one app calls a “task” another might call an “item” or a “row.” Some apps use simple data, like plain text or numbers. Others use more complex data, like a “project” that includes a title, a list of tasks, dates, and team members.
APIs were introduced to help apps talk to each other. With an API, one app can ask another for data, or tell it to update something. But APIs are not all the same. Each one has its own rules and data formats. One might use “JSON” to send a list of items; another might use XML. Some APIs are well-documented and stable. Others are hard to use or change often. Even when APIs are available, connecting many apps together can be a big job. You might need to write special code for each pair of apps you want to connect.
Some companies offer “integration platforms” that try to help. These tools let you set up simple rules like, “when I add a new row in this spreadsheet, add a task in my project tool.” Zapier and IFTTT are examples. These are great for basic needs, but they have limits. They don’t usually let you sync complex data, like a table with many columns and special data types. Real-time updates can be hard. And if you want to connect more than two apps or keep large tables in sync, things get complicated fast.
Other apps offer “native integrations.” For example, you might be able to pull in a calendar or a list of tasks from another app, if both apps support it. But these only work for certain combinations of apps, and they’re often built for basic use cases. If you want to bring in custom data, or sync changes in both directions, you might be out of luck.
Some companies have built “middleware”—custom code that sits between two apps and translates data back and forth. This is powerful, but it’s expensive to build and hard to maintain. Every time one of the connected apps changes how it works, you have to update your middleware.
There are also tools that let you embed live data in documents, like Google Sheets or Microsoft Excel. But even here, syncing data from outside sources can be tricky. Excel can pull data from databases or the web, but it often needs special setup and works best with simple data. Google Sheets can connect to some APIs, but not all, and setting it up takes some technical skill.
The main problem is that every app, every API, and every data type is different. There’s no single, simple way to connect them all, especially for complex data like tables with custom columns, or “objects” that hold many pieces of information. Most solutions are built for one or two apps at a time, not for a world where people use dozens of tools.
This patent’s approach is different. It uses a “universal” way to describe tables and their data—something called a “configurable tabular data schema.” This schema can handle both simple data (like numbers or text) and complex data (like a task that includes a name, a due date, and an owner). By using this flexible system, the platform can connect to many different apps, and keep their data in sync, even as the data changes.
The patent also describes how users can work together in real-time. Two or more people can look at and change the same table at once, even if they’re on different devices. When someone adds or changes data, the update shows up for everyone, and can also be sent back to the original app where the data came from.
Unlike earlier tools, this system is designed to be easy to use. You can pick which data you want to sync, set up new tables with just a few clicks, and let the platform handle the rest. There’s no need to write custom code for each pair of apps. And because the system can work with any data schema, it can handle new types of data as they appear.
In short, while other tools can move simple data or connect a few apps, this patent describes a way to connect any app, any data, and any user—all through an easy-to-use, flexible framework.
Invention Description and Key Innovations
Now, let’s break down what this patent actually does, and why it is special.
At its core, the invention is a way for an online document—think word processor, wiki, or spreadsheet—to connect to outside data sources from other apps or platforms. It does this using a special type of table that knows how to talk to other apps using their APIs.
Here’s how it works in simple terms:
A user opens a document in a collaborative platform. The document can be shown to one person, or to a whole team at once, with everyone seeing the same thing in real-time.
Inside the document, the user can “insert” a table that is linked to a third-party app—maybe a project tracker, a database, or another source of live data. They can pick from a list of possible tables, each set up to match the way the outside app stores its data. This list is built using a “tabular data schema,” which says what kind of data each column should hold—like a task name, a date, or a person.
Once the table is added, the collaborative platform checks if the “table synchronization” option is turned on. If it is, the platform sends a request to the other app, using its API, asking for the latest data to fill in the table. The outside app responds with data, which the platform uses to update the table in the document.
Now, as users work in the document, they can add new rows, change data, or even delete things. Any changes made by any user (even from different devices) are shown to everyone else right away. If someone adds a new task, for example, it appears for everyone in real-time.
But here’s the magic: the collaborative platform can also send these changes back to the original app. If you add a new row in the table, the platform can use the API to update the third-party app, so both places always have the same data. This works for any kind of data the schema supports—even complex data types with many pieces.
The system can also handle multiple tables, even from different apps, in the same document. You can sync a table of tasks from one tool, and a table of contacts from another, all in the same place. The tables can each have their own schema, and each syncs with its own app as needed. The platform can use different APIs for each app, but manages all the details behind the scenes.
If a user wants to add another table, they just pick from the list of available options, or even build a custom table by choosing which data types they need. The platform handles setting up the schema and connecting to the right API.
The patent also covers how the system handles complex data. For example, a “task” might be made up of a title, a description, a due date, and an owner. The table can store this as a single “data object,” or break it into separate columns. The schema keeps track of how to map between these forms, so syncing works either way.
When syncing, the platform checks if there are any changes in the outside app. If there are, it updates the table in the document. If there are changes in the document, it updates the outside app. This can happen on a schedule, when a user asks for it, or in real-time as changes happen.
The system also supports sending only part of a table to another app, if needed. For example, maybe only certain rows should be synced with a given tool. The platform can use different APIs for different apps, managing all the connections cleanly.
Importantly, users can interact with these tables through a simple graphical interface. They can add, delete, copy, or move rows—just like in a normal spreadsheet. The platform takes care of turning these actions into the right API calls to update the connected apps.
What makes this invention stand out is how it combines all these features into one easy-to-use system:
– It works with many apps, not just one or two.
– It handles both simple and complex data.
– It lets users set up new tables and connections without needing to write code.
– It keeps data in sync automatically, both in and out.
– It lets many people work together on the same data, in real time.
– It manages all the tricky parts of mapping data between different schemas and APIs.
This approach means teams can finally bring all their important data into one place, without losing the ability to update it at the source. You can write a report that always shows the latest numbers, track projects with live updates, or build dashboards that reflect real-time changes—no more manual updates or broken links.
For businesses, this means less wasted time, fewer mistakes, and more reliable data. For users, it means less hassle and more focus on real work. And for software makers, it means their tools can become part of a wider ecosystem, with less effort.
Conclusion
This patent application describes a new way to keep data in sync across many different apps, using a flexible system of tables and smart connections. It solves real problems that teams face every day, making it easy to bring together data from anywhere, keep it up to date, and let people work together without barriers. By using a universal schema and handling the hard work behind the scenes, it promises to make collaboration smoother, faster, and less error-prone. If adopted widely, this technology could shape the future of online teamwork, helping everyone stay connected—no matter which tools they use.
Click here https://ppubs.uspto.gov/pubwebapp/ and search 20250217326.