The Developer’s Guide to Contextual Analytics

Achieving a contextual analytics experience that supercharges the value and usability of your software application is much easier than you may think.

As a specialized and mature form of embedded analytics, contextual analytics is a game-changer if you're a software vendor looking to further augment your customers’ user experience, without requiring developers to completely reengineer your offering.

Contextual analytics blends the data your users need for decision-making right at the point of their daily work, directly inside the interface and transaction flow of your software. It embeds analytical components like dashboards, reports, charts, tables, and alerts into core workflows, meaning these helpful tools are no longer a separate solution.

Most importantly, critical data is now provided in-context as your users work, supporting better decision-making. Instead of having to view analytics in a different app or stand-alone module, your customers can now get the insights they need on the same screen.

The best part is contextual analytics and its benefits can be achieved with relatively low effort, using your developers' existing skills. Here, we detail how devs can get started.

Contextual analytics augments, not replaces your embedded BI

First things first: Contextual analytics elevates your product’s analytical capabilities.

Its purpose is not to be a replacement for any analytics features you may already have in your software, but rather a solution that enhances the analytics experience by bringing the data and the tools closer to your end-users in ways previously not accomplished.

Crucially, this means it does not necessitate developers to re-architect your product. 

Contextual analytics also encompasses various levels of implementation to accommodate varying requirements. It can be embedded into your software with a light touch, like bringing in-line charts to users as they explore, right up to fully integrated automated insights and embedded dashboards that alert users to changes in real-time as they work.

The extent of the integration is up to your team to decide, but the inclusion of advanced APIs ensures there’s zero rebuilding from the ground up and that implementation is fast. In short, it will not take you years to leverage the benefits of contextual analytics.

It’s understandable some of the advanced capabilities contextual analytics introduces may sound and look complex, which is why we advise you to first read our explainer on what contextual analytics is. It will provide clarity and example use cases to get your team understanding just how beneficial it can be for your software today.

So, where do you start when planning to build contextual analytics into a product? 

3 simple steps to create a contextual analytics experience

There are several elements to consider during the build process for product developers, but we’ve broken down the most important considerations into 3 critical steps that must be defined before building any contextual analytics solution into your software. 

#1 - Identify your content

Take the time to identify the exact content that is going to be embedded into your application’s workflows. Typically, this will be in-line dashboards and charts, but your specific use case could also encompass other content like automated alerting and data storytelling features. Your UX designers will need to understand what information will best support your users at each particular stage in the application workflow, and then identify existing content that can be embedded to support that, or build new content for that specific purpose. In Yellowfin, content built for contextual analytics is built in the same way as content consumed within Yellowfin - using drag and drop. All content - in Yellowfin’s case, Signals, Assisted Insights, Stories & Presentations - can be customized and styled using a simplified visual interface, without the need for coding.  

#2 -  Start embedding

This is the actual integration or embedding process of implementing contextual analytics into your application. In Yellowfin, this can be accomplished simply by cutting and pasting an embed link for the relevant content into your application or webpage, or with a few lines of code to dynamically load the content using the Yellowfin JavaScript API. At this point, you now have content embedded within your application and the content will be fully functional and have all of the usual interactivity and usability customers need for analysis; including drilling, filtering, assisted insights and exporting.

#3 - Create contextual linkages

Finally, it’s time to create contextual linkages. Depending on the type of integration required, this can be a very simple process. For example, in your application, when the user initiates a specific event - such as clicking on a row in a table, filtering a page or clicking a button – that may generate some context that can then be passed to the Yellowfin content embedded on that page. A user may click on a table of employee leave balances, and in doing so automatically filter an embedded chart for the selected employee. The employee ID can be passed as a filter to the embedded chart, with a couple of lines of code and the chart refreshed.

What about custom contextual analytics experiences?

For developers wanting to construct more customized experiences with contextual analytics, modern solutions like Yellowfin supports this by providing extensive advanced APIs, comprehensive documentation, code samples and how-to-guides to get started.

Customized experiences with contextual analytics generally demand more complex forms of integration, so keep in mind that additional coding may be required.

For example, the Signals icon that appears in the table of Yellowfin’s ISV demo obtains Signal data from a simple call to a Yellowfin REST API; then with a few lines of code matches that to the data in the application table to display an appropriate icon.

Other techniques should be used in order to make the contextual experience seamless include rebranding; this is done to blend the analytical and native application components together visually. It’s easy to align the look and feel of your software with Yellowfin contextual components, using Yellowfin’s white labelling toolset; you can build each component to be intuitive and aesthetically pleasing using shapes, text, and images alongside charts and reports to deliver a highly unique and optimized design.

There’s also Single Sign-On (SSO) which Yellowfin and most modern solutions include to ensure your app users are not prompted to or required to log in again to access your embedded BI solution – and that your core app and components work securely alongside each other. 

Contextual analytics: Getting started with Yellowfin

Contextual analytics is set to re-shape how software vendors embed analytics into their software and transform how their users engage with and extract value from data while doing their work. Solutions like Yellowfin make it easy for your developers to get started.

When implemented with all business and technical considerations taken into account, it will deliver highly differentiated and unique analytical experiences for your users, dramatically improving their efficiency and effectiveness when using your software.

You may also like: