ACE the Call Scripting Process

By Wayne Waldner

The need for accuracy, correctness, and efficiency (ACE) is driving call scripting in the call center environment. The days of entering simple text-based messages are slipping away. Today’s call center clients have increasingly complex needs and expectations.

Call centers and their equipment vendors have adapted to new customer demands for ACE in call processing. These days, scripting software expertly guides agents through calls, providing concise information and gathering the data needed accurately, correctly, and efficiently, and it can even include scripting of the dispatch and message delivery process.

Graphical user interfaces greatly enhance the ease of script usage for agents processing calls. Graphics, colors, and prompts can steer agents to make prompt and accurate decisions during calls. Databases on the backend of scripts store the collected data in a safe and secure manner. Scripts can also connect to clients’ external databases to access and update the customer data directly.

However, even with all these advances, some necessary steps need to be taken to ensure that agents ACE the call scripting process. The call process begins long before an agent receives a call and begins collecting data. Data is collected from the client that dictates how calls need to be processed. Most clients have unique data that needs to be collected by the agent. Additionally, how information is delivered to the client can vary greatly. The clients’ needs determine how the script will be built.

Obviously, depending on which vendor’s scripting platform you use, the method you use to build a script will vary. Most modern scripting platforms sport a GUI and time-saving features so scripts can be cranked out with minimal effort. However, before building the script, there are a few points to keep in mind during the process. These steps will ensure that you ACE the call scripting process both in the beginning and as the needs of the client change.

Don’t Repeat Yourself: Duplication is perhaps the biggest problem when it comes to building and maintaining scripts. It is very tempting to duplicate client data in various places in a script instead of having it in a single location. The issue is not with displaying data but with having data entered into a script multiple times.

Consider the maintenance necessary to update a piece of information for each item that is duplicated in a script. Each time information is duplicated, it makes it difficult to find all the instances when a change is needed in the script. Missing one instance causes the agent to be presented with invalid information.

You may have updated all ninety-nine instances but forgot that last one; does it matter that you went through all the work to update the ninety-nine when the one you missed may cause the call scripting process to fail? If so, you are no longer the ACE.

Duplication can be avoided in several ways. When building scripts and setting up client information, always try to have the least amount of duplicated data. This may not be possible in every instance, but avoiding duplication should become a high priority.

Depending on your system, the exact methods will vary; however, in general, it is easy to avoid duplication by saving client information in a database, a directory, or in script variables. This will allow various components to readily retrieve the data, and –best of all – one update will affect every use of the data.

Don’t Be Too Rigid: When building scripts, don’t hard-code client information such as phone numbers and contact names directly into a script. These should be saved into a separate database so they can be updated and the changes will be reflected when the script is run.

Generally, it is better to update a database than to modify a script. It’s a lot less error-prone to update a database instead of changing the script. Sometimes it becomes more difficult to create the script initially, but avoiding hard-coding values in a script pays off when updates are made.

As a more advanced point on this subject, also avoid having logic in a script that depends on variable data. When a script contains conditionals based on variables such as a contact name, you will be forced to update the script when you need to add more contacts or a contact changes.

When you find the need to put phone numbers, emails, and other contact information into a script, this is usually a sign that a database or other storage system should be used. Having conditional branches in the script that are based on information not gathered during the call is often a symptom of being too rigid. This leads to a final point.

Don’t Homogenize Logic and Data: Scripts generally are a collection of various bits of data and logic or processes. For instance, the script may prompt the agent to collect some order information, and then, during some later process, the order may be sent to a fulfillment house and a confirmation email may be sent.

As much as possible, try and keep a strong separation of the various processes that need to happen in a script. This will allow each process to be modified without radically affecting some other process.

For instance, in the previous example, the process that sends the confirmation email only cares about the content and the email address. As long as this information is provided to the confirmation portion of the script, the email confirmation portion will work even if the rest of script is modified radically.

Scripts are easier to maintain and modify if you preserve a clear distinction between the data and the process that operates on the data. It is best when the process that works on the data is clearly separated so that either the script that collects the data or the process that dispatches the data can change independently.

As a rule, coupling data and processes too tightly will make the script difficult to maintain and modify. If this is not kept in mind, making a simple change to a script may cause a cascade effect, forcing many other changes to keep things working.

Always remember, the success of the result of call scripting is always a product of careful planning up front. What happens behind the scenes in building call scripts is vital in garnering results that will please customers and create satisfied callers.

This all depends on ACE – accuracy, correctness, and efficiency – in the scripting process. This principle starts when the client is assigned and continues through the beginning of call processing.

Wayne Waldner, a senior software engineer at Amtelco, developed the original architecture for Amtelco’s Infinity Intelligent Series scripting tools.

[From Connection Magazine Jul/Aug 2010]

Leave a Reply