I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

Found the below, hopefully it helps?

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

Thanks for Anton raising this question and Adrians info. In addition, you could consider using strategies like distributing callbacks more evenly across queues or limiting priority overrides to prevent significant distortions in EWT. Another approach could be to implement separate queues for callbacks and regular calls, ensuring that priority interactions don't disproportionately affect regular call wait times.

Found the below, hopefully it helps?

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

Thanks Matt,

I've been trying to get the business to reconsider their priority assignment for a while now, unfortunately not about to happen any time soon. We have calls that get 300+ priority boosts. And we already throttle the amount of callbacks allowed.

With customer first callback, the callback is already there, this is when it auto dials and putting it back in queue. So you basically have to put them at the front of the queue with prioritization (assuming it is the same queue) or it is a not very good experience. And from the documentation link I shared, and Adrian copied from, it states that it expects new interactions in queue to arrive at the back of the queue not the front.

So just feels a little like by the very intent of this new feature is in conflict with the expectations of EWT.  

Thanks for Anton raising this question and Adrians info. In addition, you could consider using strategies like distributing callbacks more evenly across queues or limiting priority overrides to prevent significant distortions in EWT. Another approach could be to implement separate queues for callbacks and regular calls, ensuring that priority interactions don't disproportionately affect regular call wait times.

Found the below, hopefully it helps?

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

Hi @Anton Vroon

May I ask why you are not using the standard in-queue "Flow" callback action? 

That way you should keep your position in the queue without distorting EWT. Or is it not working with CFC ?

BR,

Georgy

Thanks Matt,

I've been trying to get the business to reconsider their priority assignment for a while now, unfortunately not about to happen any time soon. We have calls that get 300+ priority boosts. And we already throttle the amount of callbacks allowed.

With customer first callback, the callback is already there, this is when it auto dials and putting it back in queue. So you basically have to put them at the front of the queue with prioritization (assuming it is the same queue) or it is a not very good experience. And from the documentation link I shared, and Adrian copied from, it states that it expects new interactions in queue to arrive at the back of the queue not the front.

So just feels a little like by the very intent of this new feature is in conflict with the expectations of EWT.  

Thanks for Anton raising this question and Adrians info. In addition, you could consider using strategies like distributing callbacks more evenly across queues or limiting priority overrides to prevent significant distortions in EWT. Another approach could be to implement separate queues for callbacks and regular calls, ensuring that priority interactions don't disproportionately affect regular call wait times.

Found the below, hopefully it helps?

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.

I have a few questions with how people are using this and if they are seeing impacts to EWT presented to customers.

First are you using the same queue as the original call / original callback to send the customer first callback call to? Are you using a flow to update the priority first or direct to queue, if direct to queue how do you ensure it isn't sent to the back of that queue?

Assuming you are updating priority from flow or DataAction from InQueue Flow, are you finding EWT presented is impacted, as I could be wrong, but my understanding with how it is calculated (https://developer.genesys.cloud/routing/routing/estimatedwaittime-v2) is that if you have multiple interactions that push to the front, this will impact that lower quartile value, and make seem like the longer calls are the anomalies and tell the other customers a lower EWT than what they actually should expect.

This also assumes you have a high volume of callbacks, with enough 6+ calling out to customers in a short space of time.