Transparency Under the Hood: Self-service Integration Diagnostics

Transparency Under the Hood – the Next Generation of Self-service AIOps

As many recent studies show (like this one from Mckinsey), self-service in B2B products is a growing trend. Today’s enterprise users expect the same seamless and simple experience they’ve learned to love as consumers.

This works well for many simple tasks. But when it comes to more complex actions that require working with ‘under the hood’ technical features, things haven’t changed much since the early days of enterprise technology. In these cases, it’s more than likely that enterprise users will follow a time-consuming and frustrating path:

    1. Visit support pages and FAQs
    2. Read the user manuals or docs
    3. Ask the online community (if one exists)

And if all these fail to provide an answer – which commonly happens when the issue is not a standard error or problem – users exit the self-service path,  open a ticket and wait in the queue for a human technical support process to kick in.…

 

The better option

So what can be done differently? Simple: we can offer our enterprise customers a valuable asset for advanced self-service configuration, debugging and troubleshooting – the ability to put their own knowledge to work.

Our enterprise IT customers are highly technically skilled, and know their environment best. They also know best what they’ve done or tried thus far. When we give them tools to better understand our internal mechanics, they usually get their customization just right or debug and troubleshoot their problem faster than it would have taken our own support team, who would have needed to get up to speed on the request first. 

Many consumer product developers have already figured this out – providing developer modes on smartphones, task manager utilities in computer operating systems, and so on – allowing advanced users more flexibility to develop their own processes.

 

Deep visibility into integrations

One of the first areas where we are implementing this strategy is in our inbound integrations.

When implementing a custom integration with our APIs and aggregating large volumes of data from different sources, there are several considerations, such as:

    • A need to parse payload data in very specific ways.
    • The integration’s data ‘throughput’ rate.
    • The possibility users may require ongoing customization to improve how data is presented and parsed.
    • Integrations may not work as expected.
    • Potential connection issues at the onset.

That’s why we want to provide our users with deep visibility into these integrations, so they can quickly fine-tune and/or resolve any issues with them on their own. Today, once an integration is successfully set up, the data from the integrated source/tool appears in the BigPanda Operations Console in different locations. 

If the data does not appear, or appears differently than expected, users are encouraged to verify they did the integration correctly, and if that doesn’t work, they can always contact our support team.

Our upcoming integration enhancements will provide users with deep visibility into the inner workings of these integrations, so they can:

    • View an integration’s traffic and its data latency.
    • View the data flow messaging (notifications and errors).
    • View alert data correlation information.
    • Define error thresholds, escalation rules and push notifications.

Here’s a sneak peek at this feature’s screenshots:

The integration lobby: Each integration tile now displays its status summary, creating immediate visibility across the board. The detailed view displays the integration’s setup instructions and its consolidated historical operational metrics.

 

Troubleshooting

The troubleshooting screen where the user is able to review, investigate and verify detailed messages, errors and the payload itself.

 

That’s it. The integration deep-visibility feature is just one of many self-service features coming your way soon.

Watch this space for more news in the weeks to come!