Fibery is a tool that connects different processes together. Think about Strategic Goals and Product Management, or Customers Feedback and Ideation. It can replace many work management tools, but not all. Quite often you do want to use another tool like HubSpot, Intercom, or GitHub for a specific or complex process. How to provide natural and seamless connections between all these tools?
Here is the article that describes various approaches to data models and explains why we selected the flexible one.
Data Model is an abstract model that organizes elements of data and defines how they relate to one another. Check the picture below that shows a simple data model:
The main elements of the data model are:
- Type represents data with fields. Like Type Goal has Name, Description, Deadline, and Priority
- Relation connects Types together. Like Goal has many Features.
- App is just a logical group of Types for convenience.
In most work management tools, data model is fixed. Let’s say, if you check the picture above, you can’t introduce User Stories or Epics, you just have Features and Tasks in Product Dev. App.
A traditional approach to integration
If you take almost any existing work management software like Trello or Asana, you will see that all integrations are hardcoded. Let’s say, you can link GitLab Merge Requests to Cards in Trello, but that is not automatic and you can’t link build status to a Card. Indeed, Trello has its own data model and it’s hard to extend it with an external tool domain. Every integration is hardcoded and provides fixed extension points.
The main problem with this approach is that the integration creator should foresee all important cases. Sometimes it’s easy to do, but in general, it’s a very hard problem.
- What if you want to see a list of recent builds with statuses?
- What if you want to attach Merge Requests to Features instead of Tasks?
- What if you want to visualize the latest Merge Request status for a Bug?
What if we’ll not hardcode integrations, but just extend the data model? What if we’ll fetch data from an external system and allow you to do whatever you want with the data: connect entities together, visualize entities, and enhance entities with more data?
External App → Fibery: Extend Data Model
Fibery has an unfair advantage, it has a flexible data model 😜. It means Fibery can replicate the data model of any external tool. For example, it can fetch Companies, Contacts, Conversations, and Tags from Intercom and connect them together. Or it can fetch Projects, Branches, and Merge Requests from GitLab and connect them.
Usually, you can’t freely manipulate data from an external system, but in Fibery you can do interesting things. Here are some examples:
- Automatically connect GitHub Pull Requests to User Stories.
- Highlight text in Intercom Chats and create new Features/Bugs/Insights from them.
- Automatically connect Chats from Intercom to Accounts from HubSpot CRM.
- Create a field on a Feature that shows the status of the last GitLab Merge Request.
- Create a chart that shows new HubSpot Accounts registration per month.
- Create a Table that shows all GitLab Merge Requests attached to User Stories.
Automatically connect GitHub Pull Requests to User Stories.
In this video, I show the flow of connecting Pull Requests to User Stories using auto-linking in Fibery.
Highlight text in Intercom Chats and create new Features/Bugs/Insights from them.
Here we already exported conversations from Intercom and I attach feedback to an Idea.
Native and Integration Types: The Great Unification
It all means that Fibery native data and external systems data is unified, there is no difference between them!
Type represents data: Task, Feature, Project, Vacation, Meeting, Asset, etc. Integration Types are created from an external system, Native Types are created manually in Fibery.
Here is the snapshot of a Fibery workspace. As you see, there is not much difference between Integration and Native Types.
Data unification unfolds the whole power of Fibery visualizations, connections, and enhancements for the external data. On an abstract level, you can create Views from it (Table, Board, Timeline), you can create Charts, you can add your own custom fields, thus augmenting imported data.
From the end-user perspective, internal/external data distinction does not exist, all data is here and readily available.
Here I create a chart that shows new Intercom Companies registration per month.
You can add Integration Types into existing Apps, or you can create new Apps that consist of Integration Types only.
The potential is huge. Eventually, it will be possible to bring all important data from external systems into a single place (Fibery) and connect the data. Let’s explore just one example.
Imagine, you are a software development company and use tools like GitLab, Intercom, HubSpot & Google Analytics. You decided to use Fibery for work management. What benefits you can have by syncing the data between these external systems in Fibery?
Let’s focus on Accounts. Accounts are tracked in HubSpot and now you have all of them in Fibery. You can connect all Intercom conversations into Accounts and find the most active customers or leads. You can also connect Google Analytics data and track Accounts activity right there. You can mix all important data about Accounts in a single system.
Now let’s focus on Features. You can connect Merge Requests to Features and see Feature status. Then you can link feedback on Features from Intercom. Finally, you can track what Accounts requested what Features to make customer discovery calls or notify customers about feature completion.
When you have everything in sync in a single place, it opens up unexpected ways to handle feedback and customers interactions.
Fibery → External App: Actions
NOTE: This part of the integration strategy is not implemented yet.
Everything above was about one-way-sync. But how to initiate actions in external systems? For example, create a new Merge Request from a Feature? Send a message to a Slack channel? We are going to solve this via Action concept.
Action will be a first-class citizen in Fibery ecosystem. Here are some Action properties:
- Operate on native and integration Types.
- Compose new Actions from existing Actions.
- Invoke Action from different places: Button, console, Batch action, context menu, API call.
To add Actions for any external system it will be required to implement a basic unified protocol.
This is just a hint into Actions future. Later Actions will become a part of Automation Rules module, where we will finally glue together Types, Events, and Actions.
We believe Data and Actions unification will empower Fibery to:
- Fetch all important data from any external system.
- Connect data from various systems together, augment the data, and give people more insights into their work processes.
- Do many actions from a single place and reduce tools distractions.
And for us it will mean that we can implement integrations to the new systems extremely fast 💪.
We just released Data Sync for several external Apps: Intercom, GitHub, GitLab and Trello. Next steps are to add more external systems, implement Actions and make everything public to boost third-party integrations.