You probably know what omnichannel means, but a quick definition is always helpful. It refers to the various touch points by which a business/organization can reach a customer. The idea — and the ideal — is to get the offer in front of them at the time they’re most likely to be interested. Typically in the modern business ecosystem, omnichannel refers to:

• Website
• Brick and mortar locations
• Social media
• Other digital efforts
• How you come across on mobile
• Face-to-face interactions between customers and employees

There is more you could group under omnichannel, but that’s a good start. Unfortunately, in a few years from now, we may need a different approach entirely.

Why?

OMNICHANNEL AND THE RAPID SCALE OF BIG DATA 

Consider this: in 2020, it’s possible 1.7 megabytes of new data will be created for every person on the planet every second. If you do the full math on that, the total volume of data globally in 2020 might be around 44 zettabytes. A zettabyte is a trillion gigabytes. This is somewhat because of “The Internet of Things” — connected devices and sensors — which should have an economic value of $3 trillion by 2025. Internet of Things tech alone will be 3-6 zettabytes of that total.

Now we know the rapid scale of Big Data. It’s actually arriving in daily life maybe faster than even mobile did. What are the repercussions?

THE REPERCUSSIONS FOR OMNICHANNEL

As noted in this post on Information Age:

Companies hoped “omnichannel experiences” would enable them to anticipate customers’ needs to provide them with a personalised response, which meets or even exceeds their expectations. And this effort is based on the company’s ability to mobilise the necessary data to deliver.

But what happened?

Today, these same companies struggle to draw together all the information required to give them a unified view and appreciation of their customers’ needs. The result is a mixed bag of omnichannel initiatives, many of which result in failures. In the retail sector, for example, only 18% of retailers claim to have an engagement strategy, which covers all channels.

The sheer math looks like this: 44 zettabytes of generated data in 2020 is 10 times — yes, ten times — what we are generating now, three years earlier. Companies are already struggling to manage data properly towards better customer experience. What will happen when 10 times the data is available in 33 months or so?

WHAT’S THE FUTURE LOOK LIKE FOR OMNICHANNEL AND CX?

This is obviously hard to predict. In times of great complexity, though, sometimes sticking to the basics — i.e. The Five Customer Experience Competencies — isn’t a bad idea. A strong base almost always beats an all-over-the-place strategy.

In my mind, this is what needs to happen:

• Companies need a good handle on what really drives their business now and what could drive it in the future.
• This involves products/services but also types of customer and platform they use.
• Once that picture is mostly clear, senior leaders need to be on the same page about the importance of customer-driven growth.
• “Being on the same page” also involves, ideally, vocabulary and incentive structures.
• If the customer-driven plan/platforms and senior leadership alignment are there, now you need to make sure the work is prioritized.
• No one should be running around on low-value tasks when great opportunity is right there.
• Kill a stupid rule, etc. Basically move as many people as possible to higher-value work, especially if lower-value work can be more easily automated.
• It’s all been important so far, but let’s bold this: You don’t need to collect all the data. You need data that relates to your priorities and growth. 
• That data should be analyzed and condensed for executives. You may need “data translators,” yes.
• Decision-making should come from relevant information and customer interactions.

This flow is hard to arrive at for some companies, but essential.

Phrased another way: trying to be “omnichannel” in five years and looking at an Excel with trillions of touch points/data on it? That will just burn out employees and managers alike. You need a prioritized, aligned plan focused on customer-driven growth and well-articulated goals. That will get you there post-omnichannel.

Reprinted from LinkedIn with permission from the author. View original post here.

Author’s Bio: Jeanne Bliss, Founder & CEO, CustomerBliss

Jeanne Bliss pioneered the role of the Chief Customer Officer, holding the first-ever CCO role at Lands’ End, Microsoft, Coldwell Banker and Allstate Corporations. Reporting to each company’s CEO, she moved the customer to the strategic agenda, redirecting priorities to create transformational changes to each brands’ customer experience. Her latest book, “Chief Customer Officer 2.0” (Wiley) was published on June 15, 2015.

There has always been one eternal question in marketing: what is the shortest path between you and your next paying customer?

We already know the right answer to this question: “It depends.” But a better answer is that effective marketing is very context-dependent. So let’s look at the pros and cons of three of today’s key marketing approaches – phone, mail and email marketing.

Telemarketing has practically been with us ever since Alexander Graham Bell first solicited his assistant Watson from the next room in 1876. Its key advantage is that it is the only one of these three approaches that builds an interactive personal connection with a prospect – one that allows you to qualify him or her, ask questions, and respond to their needs. Big-ticket products and services, particularly in a business-to-business environment, are often sold as the result of a sales process that begins with a phone contact. Conversely, large scale telemarketing often is a key ingredient of selling consumer products and services in large volumes.

Telemarketing also has numerous drawbacks. It is labor-intensive, time-bound, and requires a good telecommunications infrastructure when used on more than a small scale. Perhaps most importantly, it requires the right business context. If you are selling an airliner or high-end financial services, those prospects may expect an initial phone call, while carpet-bombing consumers with telephone sales pitches at dinnertime may provoke mostly negative responses. Moreover, unsolicited calls to consumer wireless phones can lead to large fines under the Telephone Consumer Protection Act (TCPA).

Direct mail marketing gives businesses an opportunity they do not have with phone or email: the chance to deliver content-rich information in print or even multimedia form. (For example, anyone who belongs to Generation X or older remembers those ubiquitous AOL CDs that were a fixture of the 1990s.) Anyone with a valid mailing address is a potential prospect, it is a medium that lends itself well to A-B testing as well as demographic targeting, and there are few if any regulatory roadblocks to targeting consumers with a direct mail campaign.

Drawbacks of direct mail include its expense per prospect, in terms of time, content costs, and mailing costs. This is particularly a disadvantage for smaller businesses, given the economies of scale that reduce per-unit printing and mailing costs for those who can afford very large campaigns. Response rates are generally low and can vary widely, and the accuracy of your contact data is a critical factor in your costs and profitability.

Email marketing is, relatively speaking, the new kid on the block – even though it now has its own decades-long track record. It has one towering advantage over the other two approaches: a much lower cost per contact that only minimally scales with the size of your prospect base, once you have a list that opts in. Email also gives you the opportunity to include rich media content, or make “warm call” introductions to individual prospects as a precursor to telephone contact.

Disadvantages of email include being the easiest mode of contact for people to ignore – particularly as the inbox sizes of busy people continue to expand – as well as the need to have accurate contact information from people who have opted in to hear from you, to avoid consequences for spamming from your internet services provider.

A common thread through each of these marketing approaches is data quality. Inaccurate, incomplete or outdated contact information will cost you in time and marketing expenditure at the very least, and in the worst cases could subject your business to substantial penalties. And in a world where up to 25% of your contact data is bad, and up to 70% goes out of date each year, a data quality strategy is absolutely necessary for effective marketing.

The best marketing strategy? As we said earlier, it depends. But with the right approach to data quality, you can get the maximum ROI from any approach that fits your business.

In this demonstration I am going to show you how to implement our DOTS Address Validation 3 web service with JavaScript and no Asp.Net markup tags using Visual Studio.  We are going to create a form for address inputs, similar to what you would see on a checkout page, which will call our API to validate the address.  Although, we could call the web service directly from JavaScript, we would then be forced to expose our license key.  So we will use an aspx.cs page to handle our call to the service API, keeping our license key safe from prying eyes.  In this demonstration, I will also show you how to add the NuGet version of DOTS Address Validation 3 to the project so that you are always using our best practices and speeding up your integration.

First, create a new empty web site, which I am going to call, cSharpJavascriptAjax.  Then I am going to add a new html page called, Addressvalidation.html.

   

Next, we are going to add the markup for the form.  Add the following code in between the body tag.

    <div>
        <table cellSpacing="4" cellPadding="4" border="0">
            <tr>
                <td>
                    <b>Enter An Address</b><br />
                    <i>(US addresses only)</i>
                    <p></p>
                </td>
            </tr>
            <tr>
                <td>Business Name:</td>
                <td><input type="text" id="inputBusinessName" /></td>
            </tr>
            <tr>
                <td>Address 1:</td>
                <td><input type="text" id="inputAddress" /></td>
            </tr>
            <tr>
                <td>Address 2:</td>
                <td><input type="text" id="inputAddress2" /></td>
            </tr>
            <tr>
                <td>City:</td>
                <td><input type="text" id="inputCity" /></td>
            </tr>
            <tr>
                <td>State:</td>
                <td><input type="text" id="inputState" /></td>
            </tr>
            <tr>
                <td>PostalCode:</td>
                <td><input type="text" id="inputZip" /></td>
            </tr>
            <tr>
                <td>
                    <input id="submitButton" type="button" onclick="submit()" value="Continue" />
                </td>
            </tr>
        </table>
    </div>

This form was designed using the table structure for the layout.  You will likely want to create the layout using divs, which is more appropriate.   Here is what the page looks like in the browser.

To speed things up a bit, I am going to include jQuery in the header so we can utilize some of the short cut functions.  Of course, all of this can be done in pure JavaScript.

<head>
    <script src="http://code.jquery.com/jquery-latest.min.js" type="text/javascript"></script>
    <title>Address Validation 3</title>
	<meta charset="utf-8" />
</head>

For the action we will take when the Complete button is clicked, we will create the submit function.  This will take in all the values from the form, call the web service and then display the response to the screen.  I added an alert and left the URL blank, this will allow for a quick test to make sure what we have is working.  Later we will update the failure and success sections as well.  For now, they will simply display an alert for testing.

<script>
        function submit() {
            var DataValue = "{BusinessName:'" + $('#inputBusinessName').val() + 
"',Address1:'" + $('#inputAddress').val() + 
"',Address2:'" + $('#inputAddress2').val() + 
"',City:'" + $('#inputCity').val() + 
"',State:'" + $('#inputState').val() + 
"',ZipCode:'" + $('#inputZip').val() + "'}";

            alert(DataValue);
            $.ajax({
                type: "POST",
                url: "",
                data: DataValue,
                contentType: 'application/json; charset=utf-8',
                dataType: 'json',
                failure: function (response) {
                    alert(response.d);
                },
                success: function (response) {
                    alert(response.d);
                }
            });
        }
    </script>

First, let’s start by making sure we are getting all the inputs into the submit function and are getting all the inputs back.  I am going to display an alert with DataValue variable so we can see what we have.

Good, now that we know that is working, we will need to make the call to the web service.  Like I mentioned before, we could call the service directly but using JavaScript would make the license key visible.  So we are going to leverage asp.net for security by creating and empty aspx page and add a method to the aspx.cs page to handle the call.  Let’s go ahead and add the aspx/aspx.cs page to the project and call it, ServiceObjectsAPIHandler.

Here is our empty aspx.cs page, where we will be adding our function. It will go below the Page_Load method.

Let’s call the method, CallDOTSAddressValidation3_GBM.  There are two things to notice with the signature for this method.  We decorate the method with the WebMethod attribute so that our new method can be exposed as a web service method. And, we declare it as static because of the stateless nature of the static methods.  An instance of a class does not need to be declared.

        [WebMethod]
        public static string CallDOTSAddressValidation3_GBM(string InputText)
        {
            return InputText;
        }

To test things out, for now we will just take one string input and return it to the Ajax call where we will display it.  In order to do this, we will need to adjust our DataValue call in the script on the html page.

var DataValue = "{InputText:'Hello World!'}";

We will also need to add the URL and method to the Ajax call.

url: "ServiceObjectsAPIHandler.aspx/CallDOTSAddressValidation3_GBM",

I also adjusted the alerts so we can see the success or fail.

failure: function (response) {
                    alert(response.d + " :(");
                },
                success: function (response) {
                    alert(response.d + " :)");
                }

Great! That worked! Now, let’s write up the code in the aspx.cs page to make the call to the service.  We could grab some sample code from the web site and walk through it, but we have documentation and tutorials already on how to do that.  Instead, I am going to take a short cut and grab what I need from NuGet.  We offer NuGet packages for most of our services, which include best practices such as failover configurations and speeding up the integration time.

To do this, we will need to open up the NuGet Package Manager in Visual Studio under the Tools menu option.  When browsing  for our services, you can type “Serviceobjects”.  You should see a list of available Service Objects NuGet packages to choose from.

Select DOTSAddressValidation3US, you will be prompted to select the project you want to install it under.  Select the project and then click install.

Once the installation is complete, a ReadMe file will automatically open that will contain a lot of information about the service.  You will also notice a few things were added to your project.  First, a DLL for DOTSAddressValidation3US was added to the bin folder and was referenced in your project.

Next, an AV3LicenseKey app setting was added to your web.config file with the value “WSXX-XXXX-XXXX”.  You will need to substitute this value for the key you received from Service Objects.

    <appSettings>
      <add key="AV3LicenseKey" value="WSXX-XXXX-XXXX" />
    </appSettings>

Also in the web.config you will see several endpoints were added.  These will be used in the pre-packaged code to determine how to call the service based on your key.

<system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="DOTSAddressValidation3" />
                <binding name="DOTSAddressValidation31" />
            </basicHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://wsbackup.serviceobjects.com/AV3/api.svc/soap"
                      binding="basicHttpBinding" 
                      bindingConfiguration="DOTSAddressValidation3" 
                      contract="AV3Service.IAddressValidation3" 
                      name="DOTSAddressValidation3Backup" />
            <endpoint address="http://trial.serviceobjects.com/AV3/api.svc/soap" 
                      binding="basicHttpBinding" 
                      bindingConfiguration="DOTSAddressValidation3" 
                      contract="AV3Service.IAddressValidation3" 
                      name="DOTSAddressValidation3Trial" />
            <endpoint address="http://ws.serviceobjects.com/AV3/api.svc/soap" 
                      binding="basicHttpBinding" 
                      bindingConfiguration="DOTSAddressValidation31" 
                      contract="AV3Service.IAddressValidation3" 
                      name="DOTSAddressValidation3" />
        </client>
    </system.serviceModel>

Now that we have the NuGet package added to the project, we can use it.  Next is the code that will use the DOTSAddressValidation3US DLL by loading it up with the input parameters, making the call to the service, then working with the response and finally sending the data back out to our JavaScript.

First we get the license key from the web configs file.

string LicenseKey = System.Configuration.ConfigurationManager.AppSettings["AV3LicenseKey"];

Then we make the call to the service.  You will notice that we throw in a Boolean parameter at the end of the call to GetBestMatches for live or trial.  This is an indicator that will tell the underlying process which endpoints to use.  A mismatch between your license key and this Boolean flag will cause the call to the service to fail.

DOTSAddressValidation3US.AV3Service.BestMatchesResponse DOTSAddressResponse = DOTSAddressValidation3US.DOTSAV3.GetBestMatches(BusinessName, Address, Address2, City, State, ZipCode, LicenseKey, false);

After we make the call to the service, we will process the response and send the data back to the JavaScript. If there is an error,  we will return the error details. Otherwise, we will return a serialized version of the response object.  Note that you can also just deal with the response completely here or completely in JavaScript.  I mixed it up so you can see a bit of both.

if(DOTSAddressResponse.Error != null)
{
string ErrorDesc = DOTSAddressResponse.Error.Desc;
string ErrorType = DOTSAddressResponse.Error.Type;
      return "Address Error: " + ErrorType + ". " + ErrorDesc;
}
else
{
      return new JavaScriptSerializer().Serialize(DOTSAddressResponse);
     } 

Here is the whole method all together.

[WebMethod]
public static string CallDOTSAddressValidation3_GBM(string BusinessName, string Address, string Address2, string City, string State, string ZipCode)
{
string LicenseKey = System.Configuration.ConfigurationManager.AppSettings["AV3LicenseKey"];
DOTSAddressValidation3US.AV3Service.BestMatchesResponse DOTSAddressResponse = DOTSAddressValidation3US.DOTSAV3.GetBestMatches(BusinessName, Address, Address2, City, State, ZipCode, LicenseKey, false);
            if(DOTSAddressResponse.Error != null)
            {
                string ErrorDesc = DOTSAddressResponse.Error.Desc;
                string ErrorType = DOTSAddressResponse.Error.Type;
                return "Address Error: " + ErrorType + ". " + ErrorDesc;
            }
            else
            {
                return new JavaScriptSerializer().Serialize(DOTSAddressResponse);
            }
}

Now we will turn our attention back to the JavaScript and update our submit function.  All we really have to deal with now is the response from the aspx method call.  Here is the portion of the Ajax call implementing that.

failure: function (response) {
    alert('Something went wrong!');},
success: function (response) {
    if ((response.d + "").startsWith("Address Error")) {
         alert(response.d);
    }else {
         var AddressResponse = JSON.parse(response.d);
         if (AddressResponse.Addresses[0].DPV === "1") {
              alert("Good Address!");
         }else {
              alert("Not Good Address: " + AddressResponse.Addresses[0].DPVNotes);
         }
    }}

Success or failure here does not mean that the address is good or not.  It is really just a success or failure of the call to the aspx web method.  On failure, we simply make an alert stating something went wrong.  On success, we examine the response value, determine if the address was good or not and display the appropriate response.  Here is the whole submit function.

function submit() {
var DataValue = "{BusinessName:'" + $('#inputBusinessName').val() + 
"',Address1:'" + $('#inputAddress').val() + 
"',Address2:'" + $('#inputAddress2').val() + 
"',City:'" + $('#inputCity').val() + 
"',State:'" + $('#inputState').val() + 
"',ZipCode:'" + $('#inputZip').val() + "'}";
            $.ajax({
                type: "POST",
                url: "ServiceObjectsAPIHandler.aspx/CallDOTSAddressValidation3_GBM",
                data: DataValue,
                contentType: 'application/json; charset=utf-8',
                dataType: 'json',
                failure: function (response) {
                    alert('Something went wrong!');
                },
                success: function (response) {
                    if ((response.d + "").startsWith("Address Error")) {
                        alert(response.d);
                    }
                    else {
                        var AddressResponse = JSON.parse(response.d);
                        if (AddressResponse.Addresses[0].DPV === "1") {
                            alert("Good Address!");
                        }else {
                            alert("Not Good Address: " + AddressResponse.Addresses[0].DPVNotes);
                        }
                    }
                }
            });
        }

 

Here is a good address.

 

And here is a bad address.

 

In the submit function, we did the most basic check to see if an address was good or not.

if (AddressResponse.Addresses[0].DPV === "1")

But many more data points from the response can be used to make any number of conclusions about an address.  One thing you will notice is that AddressResponse.Addresses is an array.  A check to see if multiple addresses are returned can be valuable because in certain situations more than one address may be returned.  One example is when an East and a West street address are equally valid responses to an input address.  In this case you may want to display both addresses and let the user determine which to use.  You may want to evaluate the individual address fragments or the corrections that were made to the address.

The data points associated to the DOTS Address Validation US 3 service can be found on our development guide page for the service.

The following is commented out code that I added to the submit method for easy access to the various output data points.

//AddressResponse.Addresses[0].Address1
//AddressResponse.Addresses[0].Address2
//AddressResponse.Addresses[0].City
//AddressResponse.Addresses[0].State
//AddressResponse.Addresses[0].Zip
//AddressResponse.Addresses[0].IsResidential
//AddressResponse.Addresses[0].DPV
//AddressResponse.Addresses[0].DPVDesc
//AddressResponse.Addresses[0].DPVNotes
//AddressResponse.Addresses[0].DPVNotesDesc
//AddressResponse.Addresses[0].Corrections
//AddressResponse.Addresses[0].CorrectionsDesc
//AddressResponse.Addresses[0].BarcodeDigits
//AddressResponse.Addresses[0].CarrierRoute
//AddressResponse.Addresses[0].CongressCode
//AddressResponse.Addresses[0].CountyCode
//AddressResponse.Addresses[0].CountyName
//AddressResponse.Addresses[0].FragmentHouse
//AddressResponse.Addresses[0].FragmentPreDir
//AddressResponse.Addresses[0].FragmentStreet
//AddressResponse.Addresses[0].FragmentSuffix
//AddressResponse.Addresses[0].FragmentPostDir
//AddressResponse.Addresses[0].FragmentUnit
//AddressResponse.Addresses[0].Fragment
//AddressResponse.Addresses[0].FragmentPMBPrefix
//AddressResponse.Addresses[0].FragmentPMBNumber

And here is the same thing but for the Error object in the aspx page.

//string ErrorDesc = DOTSAddressResponse.Error.Desc;
//string ErrorDescCode = DOTSAddressResponse.Error.DescCode;
//string ErrorType = DOTSAddressResponse.Error.Type;
//string ErrorTypeCode = DOTSAddressResponse.Error.TypeCode;

I hope this walk-thru was helpful in demonstrating how to implement our DOTS Address Validation 3 web service with JavaScript and no Asp.Net markup tags using Visual Studio.  If you have any question, please feel free to contact Service Objects for support.

This is where the US government comes in. The federal universal service high-cost program – also known as the Alternative-Connect America Cost Model (A-CAM) – is designed to ensure that consumers in rural, insular, and high-cost areas have access to voice and broadband service at rates that are reasonably comparable to those in urban areas. And Service Objects is excited to help carriers find and deliver broadband internet to these hard-working rural Americans by introducing an indicator in our Address Geocode US that will let carriers know if the location is eligible for A-CAM funding.

The Connect America Fund is a win-win for everyone involved. It incentivizes the growth of rural internet access by reimbursing carriers for a portion of their costs of development, from the federal Universal Service Fund. Currently the Fund offers over 1 billion dollars annually to help defray the high cost of running fiber optic cables and equipment to sparsely populated areas, for carriers of all sizes. This can

Internet access is about much more than posting selfies to your Instagram feed. Today, it has become the engine of both commerce and human connection. The United Nations and the US both recognize that the internet has become so fundamental to freedom of expression and opinion that it is a basic human right needed for all people. But for many people living in rural areas of the United States, affordable internet access is still out of reach. According to US News and World Report, only 55 percent of rural Americans have access to broadband internet, versus 94 percent of urban dwellers.

quickly add up to a big source of income for the carriers and a great incentive to expand their coverage.

But there is a catch. To compete for these grants, carriers must submit the addresses, GPS coordinates and several other key pieces of information to the FCC. The deadline for 2016 funds is barely a month away – on July 1st, 2017 –so finding all the businesses and households located in these remote areas is not easy. Some of these addresses do not have mail service, others are just work sites such as barns or grain silos, and many are not the main address of the business. But all of these locations would still benefit from high speed internet, AND contribute to the per-address size of the carrier’s grant.

This is where Service Objects can help. Our Address Validation product can verify, correct and append address information, as fast as 150 milliseconds per record, using our CASS-certified USPS database engine. And our Address Geocode product can translate these addresses into exact latitude-longitude coordinates, with property-level match rate accuracy up to 99.8% and indicate if the location is within the funding boundaries. Both of these products can be put to work right away, as either an API for your application or through convenient batch list processing.

According to the Hudson Institute, rural broadband companies contributed nearly $25 billion US dollars to the economies of their states, were responsible for nearly 70,000 jobs, and supported over $100 billion dollars in e-commerce in 2015. And the impact of this broadband access ranges from the ability to locate manufacturing plants in rural areas, all the way to telehealth capabilities that bring top medical expertise to patients in remote areas. It is truly an enabling technology for closing the digital divide that still impedes economic growth in these areas.

Many people don’t realize that rural America was actually the birthplace of much of our modern telecommunications – long before most of us had phones, farmers would talk with each other on networks connected through barbed-wire fencing. Today, it makes perfect sense to have the online era come full circle to a population that needs and deserves the right kind of access.

Service Objects is proud to help with this initiative. We can now import the footprint of service from a rural carrier and match all eligible addresses within that area and provide the information needed to submit to the FCC. This allows the carriers to maximize funding of A-CAM and get their portion of the 1 billion dollars at stake.

If you would like more information on how we can help with Connect America Fund, send an email to communications@serviceobjects.com.

The reality about any set of residential customer data is that given enough time, addresses and the people living there are bound to change. Occasionally, businesses and organizations can rely on the customer to notify them of changing addresses but when people move, this often times falls to the wayside on the list of priorities.

For cases like these, accessing the USPS National Change of Address database can provide a helpful solution to ensure that mail gets delivered to the correct person. The USPS maintains a large data set of address forwarding notifications, and with the DOTS NCOA Live service, this information is right at your finger tips.

Our DOTS NCOA Live service is a bit different than the rest of our products. Most of our other products process validation requests in a one at a time manner. NCOA is a little different in that in order to start a request, a minimum list of 100 addresses must be sent to the service, and from there anywhere from 1 to 500 records can be processed at a time. To show you how it works, we’ve put together a quick step by step tutorial.

What You Will Need

• C# experience
• Visual Studio ( VS 2015 is used for this example)
• A DOTS NCOA Live license Key. A free Trial Key can be obtained here.

Project Creation and Setup

To get started, go ahead and launch Visual Studio and select File->New->Project.  From here you can choose whatever project will meet your needs. For this example, we’ll be creating a very basic console application.  So if you want to follow along step by step, you can choose the same project details as shown below.

Select OK and wait for Visual Studio to finish creating the project. Once that is done, right click the project, select Add and then select Service Reference. Here, we’ll enter the URL to the WSDL so that Visual Studio will create all the necessary classes, objects and methods that we’ll use when interacting with the DOTS NCOA Live service. To successfully do this, add the necessary information into the pop up screen as shown in the screenshot below.

Select OK. Now that the service reference is successfully set, open up the App.Config. Below is a screenshot of the App.Config that has been modified.

We’ve added the appSettings section and within that we’ve added two key value pairs. The first is the license key field where you will enter your key. Storing the license key in the app or web config files can be helpful and easy when transitioning from a trial to a live environment in your application. When you are ready to use a production key, changing it in the app config is an easier option than having to change a hard coded license key.

We’ve also put the path to a csv that will contain the address and name information that we will be sending to the NCOA service. You may not want to read in a CSV for your application but the process of building the input elements for the service will be relatively similar. For this example, we’re just going to put the file in the BIN folder of our project, but you can add any path you want to the file.

We’ve also increased the maximum buffer size in the http Binding. Since we’ll be sending a list of 100 addresses to the DOTS NCOA Live service, we’ll indeed need to increase the buffer size.

Lastly, we’ve changed the name of the original endpoint to “PrimaryClient,” made a copy of the endpoint and changed that name to “BackupPoint.” Currently, both of these endpoints point to the trial Service Objects environment, but when a production key is purchased, the PrimaryClient url should point to http://ws.serviceobjects.com/nl/ncoalive.asmx and the BackupClient should point to http://wsbackup.serviceobjects.com/nl/ncoalive.asmx.

Calling the DOTS NCOA Live web service

The first thing we’ll do is instantiate two static strings outside of the Main method. One will be for the input file, and the other will be for the license key that we’ve placed in the app.config. Inside the scope of the Main method, we’ll instantiate a NCOAAddressResponse object called response and set it equal to null. We’ll also create a string called jobID and set that equal to null as well.  This jobID will be passed as a parameter to our NCOA service call. A JobID can be seen as a unique identifier for all the records that are run against the service.

Now we’ll create the following method that will read our input file.

This method will return a List of the NCOAAddress object that will have all the inputs we need to send to the service. In my particular file the fields are as follows: Name, Address, Address2, City, State, Zip.  Your code will need to be modified to read the specific structure of your input file. This code reads in the file and then loops through each of the lines and adds the appropriate values to the fields of the NCOA address object. After the line is successfully read, we add the individual NCOAAddress objet to the list called inputAddresses and then return that object once the code has finished looping through the file.

Now we’ll insert a try catch block into the main method. Within this try catch block we’ll create a List of the NCOAAddress object and call the readInputFile method to fill it. We’ll also make a JobID with today’s date appended to the end of it. You will likely want to customize your job id to fit into your business application. Jobs close on Sunday at 11:55 PM so that is also something to take into consideration when designing your code.

Failover Configuration

Now that we have all our inputs successfully set up, we are able to call the NCOA web service. The first step we’ll take is create another try catch block to make the web service calls in. We will also create an instance of the DOTSNCOALibraryClient and pass in the trip “PrimaryClient” as a parameter. This will ensure that our first call to the NCOA service will point to our primary URL that we have defined in the web config. Next we’ll make the call to the webservice using the library client and set it equal to our response object.

After we get a response back from the service we’ll perform our failover check. We check if the response is null or if an error TypeCode of 3 was returned from the service. An error type code of 3 would indicate that a fatal error occurred with the service. If either of these criteria are met, then we’ll throw an exception that will be caught by the catch block we have created. Within this catch block we’ll set the library client object to a new instance with the “BackupClient” string passed to it to ensure that we call the backup client. The code should look like the following.

This failover logic will ensure that your application stays up and running in the event that a Service Objects web service is unresponsive or in the event that it is not behaving as expected.

Processing the Response

Now that we have successfully called the service, we’ll need to do something with the response. In this tutorial, we’ll take the results from the service and download them as a CSV into our bin folder.

To do this, we will call and create a method called processResponse that will take a NCOAAddressResponse as an input. This method will take the outputs from the service and build a DataTable that we will use to eventually turn into a CSV. This can be done as shown in the following screen shot.

 

 

Now that our output data table has been created, we’ll call and create two methods will loop through our DataTable and convert it to a CSV string, and then write that CSV to the bin folder.  The code to perform this is shown below.

More information on all the elements in the response object can be found on our developer guide for the NCOA service.

Now that our output data table has been created, we’ll call and create two methods will loop through our Data Table and convert it to a CSV string, and then write that CSV to the bin folder. The code to perform this is shown below.

Now our code is ready to run and the service is ready to test.

We’re always available for assistance, so be sure to contact us with any questions about integration for NCOA or any of our other services.

While Mother’s Day is all about the Moms in our lives, it’s an even bigger day for retailers. This year the National Retail Federation estimates Mother’s Day spending to reach an all-time high of $23.6 billion; roughly $10 billion higher than 2010. The traditional gifts of jewelry and flowers, along with personal services are predicted to contribute the most to this increase. Needless to say, with Mother’s Day only a few days away, businesses are experiencing a busy week, especially in ecommerce.

According to the National Retail Federation’s annual survey, conducted by Prosper Insights & Analytics, 30% of Mother’s Day shopping is to be done online this year. Most ecommerce sites have already experienced an influx of orders over the last few weeks. With an even bigger rush coming in now from typical procrastinators (like myself) who will take advantage of two-day delivery from retailers like Amazon. Online shopping has become even more convenient with the addition of mobile shopping. With thousands of easy to use mobile apps offering gift cards for anything from dinner to spa treatments, redeemable right on the recipient’s mobile device, digital sellers have definitely made Mother’s Day purchases easier than ever…even for the most ardent procrastinators.

Unknown to most, data quality solutions are quietly working behind the scenes contributing to a smooth and happy Mother’s Day for businesses and celebrants alike. Data quality solutions have made processing increased online holiday orders, restaurant reservations, and mobile app purchases more efficient and safer than ever. By leveraging tools like our Address, Phone and Email Validation services, our clients ensure that their customer contact information is complete and accurate while also identifying malicious fraud before transactions are completed. Our data quality tools give businesses more time to focus on providing memorable experiences for their customers and achieving their revenue goals on the busiest of holidays, including Mother’s Day.

Whether our clients are experiencing or still preparing for a busy Mother’s Day, our data quality solutions will be running smoothly in the background for them the entire time. If your business needs any assistance now or before the next major holiday contact us.

Before moving to my current home, making sure I completed a change of address form with the Post Office was on the top of my “to do” list.  Although most mail received these days is typically coupons and business advertisements, I looked forward to receiving the first piece of mail with my name and new address on the envelope. What can I say… I appreciate the little things in life.

Well, the first time I checked the mail I found a letter addressed to the prior resident. As I had recently filled out my own change of address form at the post office I understood it would take some time for each other’s information to be updated and anticipated this would continue happening for a bit. As expected, I began receiving mail addressed with my name soon after. However, years later I’m still getting the same letter from one particular storage company for the prior resident.

At first, I tried writing “Not at This Address,” “Moved, Left No Forwarding Address” and “Return to Sender” on the letters. After a couple months I realized this did not work. The next thing I tried was calling the storage company. I thought the human element of speaking to someone over the phone and explaining the situation would resolve the case of this never ending letter. This also did not work and actually seemed to make it worse.

As I mentioned previously, the bulk of my mail (like many other people) consists of coupons and advertisements addressed to “current resident” which are seemingly impossible to stop. Along with these, the never ending letter from this storage center started taking the excitement out of checking my mail. For a few years, checking the mail monthly instead of every few days became the routine. Every month, my mailbox was filled to max capacity with mainly junk and of course a letter (or two or three) from the storage center. Unfortunately there are some draw backs to checking your mail so infrequently. I eventually learned that if the mail does not fit in your box it is sent back to the post office which is how I missed a wedding invitation and a few birthday cards. Needless to say I went back to checking my mail more frequently and simply continued sending back the storage company letter hoping they’d eventually run their customer database through a National Change of Address (NCOA) service.

While this situation was obviously annoying, I also wondered how much this letter alone must be costing the storage center. At this point, I estimate receiving about 100 copies of the same letter equating to:

• $46 in just postage, each has a $0.46 First-Class stamp
• 100 wasted envelopes
• 100 wasted pieces of paper
• Ink for each letter
• Wasted time/salary of the person(s) at the storage center responsible for mailing
• Wasted time for the mail sorter(s)
• Wasted gas and time of the mail carrier(s)
• A big Headache for me over the last few years
• Possible frustration for the last tenant who still hasn’t received this letter (I’m assuming it’s a bill which is even worse if they are incurring additional costs all this time)

Ultimately, this also damaged the reputation of the storage company. This mail discrepancy gave me a glimpse into their lack of customer service, organization and concern for our environment. By simply implementing an address validation check in their processes this entire scenario could be avoided. What’s worse is imagining how many other letters they are sending to the wrong address.

After further research, I found out anyone can submit a change of address form at the post office for prior tenants by making a note that they did not provide a forwarding address (the online form requires a forwarding address to submit). I’ll be heading to the post office today to fill one out. If that doesn’t resolve this, I also learned storage centers eventually auction off your items if you don’t pay your bills. Although I don’t want the prior tenant to lose their personal items, I’ll be glad to stop receiving these notices.

Until then…

If your business needs help avoiding unnecessary costs, resources and headaches associated with outdated customer information including name, address, phone, email and more contact us!

Java is easily one of the most popular programming languages in the world. It is a general purpose language that users have managed to implement in a variety of applications. It is popular with web applications; which is why it is one of our most requested sample code languages for our DOTS validation products. This is no surprise either, since Java is able to run on a wide range of architecture, applications and environments.  Since it is so popular, we’re here to show you the ropes and get a Service Objects web service up and running.

For this example we’ll be using a fairly new operation in our DOTS Address Detective service. Our Address Detective service is a power house address validation service that can leverage multiple different data sources to validate an address.  The DOTS Address Detective service has input fields for a person’s name, a business name, and a phone number along with the traditional address fields. These additional data points help the service leverage other data sources to get your address validated.  This service even has an operation that will take your data in any order it’s given and return a standardized address. It’s called FindAddressLines and has 10 inputs ranging from “Line1” to “Line10” and can work wonders on standardizing messy data sources.  We’ll be integrating with this operation in our tutorial today, so let’s get started!

What You’ll Need

• A Java IDE (We’re using Eclipse for this example)
• Basic Java Knowledge
• A Service Objects DOTS Validation product License Key (We’re using DOTS Address Detective for this case)

Setting Up the Project

Launch Eclipse and select a workspace if it asks you do so. Once everything has finished loading,  select File->New->Other. In the search field type “Dynamic Web Project” and click next.

On the next screen, type in an appropriate project name and configure the settings to our specific needs. Congratulations, you’ve built a project! We’ll need to add several files to take in our inputs, send them to the DOTS Address Detective service, serialize the XML response and display the results back to the user. To start, add two jsp files by right clicking the project and selectingNew->JSP File as shown below:

In this tutorial we’ll name them “inputForm.jsp” and “webServiceCall.jsp.”  These will function as the input form and the display page for the results from the service.

These new JSP files will obviously need something more than they currently have. We’ll place all the necessary HTML elements in the inputForm.jsp file. Make your page look like it does below:

These 10 input lines will send all the necessary information to the FindAddressLines operation.  Now that we have the necessary fields to take our input parameters, we’ll need to put the code in place to actually call the DOTS Address Validation web service. We’ll create a package with the necessary class files for the response from the Address Detective service and within that package we’ll create a method that will actually perform the call to the web service.

To add a package, right click the project and select New->Package.  For this project we’ll name the package “serviceObjects” as shown below.

Be sure to select the “Create package-info.java” checkbox as we’ll need to add some necessary import statements into the package.info file.  After the package as been added, right click it and select New->Class and add all the following classes to the project.

We’ll talk briefly about the necessary code to add to each of the different objects and classes so that the XML response from the web service will be successfully deserialized into the objects that we are defining here. One thing that needs to be added to the package-info.java file is as follows.

This will let the code know that it should expect the http://www.serviceobjects.com namespace in the XML response from the service.

Like most classes, all the values in each of the code files will need the “getters and setters” for each of the objects that the service returns in order to properly work with the returned object. The highest level object that is returned from the service (meaning all the other objects and values will be contained within that one) will be the FixedAddressResponse. This object will contain a possible array of FixedAddress objects that is called “Addresses” and it will contain an Error object that the Address Detective service can potentially return. See below for an example of how to format the declarations and, XML annotations and the “getters and setters.”

As mentioned this is a general example of how to do this and we’ll include all the class files with this tutorial so that they can be easily added to your own project.

Now we’ll point out some things to be aware of in our “ADClient” file.

Inside the class declaration, we’ll define a few things that we’ll need to make the actual call to the service.

In the above code, we’ve defined both the trial and the backup URLs. Currently, they both point to the trial environment Service Objects servers. In the event that a license key is purchased the primary call should be to ws.serviceobjects.com and the backup URL should be to wsbackup.serviceobjects.com. We’ve also defined our LicenseKey in the class which will allow us to keep it hidden from outside view and we’ve defined a method called “FindAddressLines” that will eventually call the same operation. Notice that it returns the FixedAddressResponse object.

Within the actual method we have some cleanup logic that is performed on the input strings, and then the URLs are assembled for the HTTP call. See below:

In the above snippet of code URL strings are assembled and sent to the DoHTTPRequest method. After the web service is called, it is necessary to do a check to ensure that the call was completed correctly. The code will check for a null response from the service or a ‘TypeCode” of 3 is returned which would indicate a fatal error from the Service Objects web service.  If either of those conditions is true, then the code will throw an exception and use the backup URL.  The above functionality and logic will ensure that your application will be uninterrupted in the unlikely event that the Service Object servers are non responsive or returning a TypeCode of 3.

Displaying The Results from the Web Service

Since our failover logic and call to the DOTS Address Detective web service are set up, we can now create the objects that will call the web service with the inputs from the input form, and display the results to the user.

Navigate to the webServiceCall.jsp file and implement the following code:

In this bit of code we’ll grab the inputs from the inputForm.jsp page and place them in strings of the same name.  We’ve also instantiated an instance of the “FixedAddressResponse” object which will hold the results from the service and the “ADClient” object which will make the actual call to the web service.  Since our FindAddressLines method in the ADClient object returns a FixedAddressResponse object we can set it equal to it.

Our call to the web service is all set up and now we can implement some logic that will either display the results from the service.  Implement the following logic in your JSP page.

adResponse = adCall.FindAddressLines(line1, line2, line3, line4, line5, line6, line7, line8, line9, line10);
        
if (adResponse.getError() != null){
    %> 
    <br/><h3>Address Detective - FindOutlyingAddress Error!</h3>
    <table border='1' width="450" cellspacing="4" cellpadding="4" >
    <tr><td>Desc:</td><td><%out.println(adResponse.getError().getDesc());%></td></tr>
    <tr><td>DescCode:</td><td><%out.println(adResponse.getError().getDescCode());%></td></tr>
    <tr><td>Type:</td><td><%out.println(adResponse.getError().getType());%></td></tr>
    <tr><td>TypeCode:</td><td><%out.println(adResponse.getError().getTypeCode());%></td></tr>
    <tr><td colspan="2" ><input type ="button" value="Start Over" onClick="document.location='inputForm.jsp';"></td></tr>
    </table>
    <%
}
else{
    %>
    <br/><h3>FindAddressLines Results</h3>
    <table border='1' width="450" cellspacing="4" cellpadding="4" >
    <tr><td>Address:</td><td><%out.println(adResponse.getAddresses()[0].getAddress());%></td></tr>
    <tr><td>City:</td><td><%out.println(adResponse.getAddresses()[0].getCity());%></td></tr>
    <tr><td>State:</td><td><%out.println(adResponse.getAddresses()[0].getState());%></td></tr>
    <tr><td>Zip:</td><td><%out.println(adResponse.getAddresses()[0].getZip());%></td></tr>
    <tr><td>DPV:</td><td><%out.println(adResponse.getAddresses()[0].getDPV());%></td></tr>
    <tr><td>DPVDesc:</td><td><%out.println(adResponse.getAddresses()[0].getDPVDesc());%></td></tr>
    <tr><td>DPVNotes:</td><td><%out.println(adResponse.getAddresses()[0].getDPVNotes());%></td></tr>
    <tr><td>DPVNotesDesc:</td><td><%out.println(adResponse.getAddresses()[0].getDPVNotesDesc());%></td></tr>
    <tr><td>Corrections:</td><td><%out.println(adResponse.getAddresses()[0].getCorrections());%></td></tr>
    <tr><td>CorrectionsDesc:</td><td><%out.println(adResponse.getAddresses()[0].getCorrectionsDesc());%></td></tr>
    <tr><td>BarcodeDigits:</td><td><%out.println(adResponse.getAddresses()[0].getBarcodeDigits());%></td></tr>
    <tr><td>CarrierRoute:</td><td><%out.println(adResponse.getAddresses()[0].getCarrierRoute());%></td></tr>
    <tr><td>CongressCode:</td><td><%out.println(adResponse.getAddresses()[0].getCongressCode());%></td></tr>
    <tr><td>CountyCode:</td><td><%out.println(adResponse.getAddresses()[0].getCountyCode());%></td></tr>
    <tr><td>CountyName:</td><td><%out.println(adResponse.getAddresses()[0].getCountyName());%></td></tr>
    <tr><td>FragmentHouse:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentHouse());%></td></tr>
    <tr><td>FragmentPreDir:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentPreDir());%></td></tr>
    <tr><td>FragmentStreet:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentStreet());%></td></tr>
    <tr><td>FragmentSuffix:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentSuffix());%></td></tr>
    <tr><td>FragmentPostDir:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentPostDir());%></td></tr>
    <tr><td>FragmentUnit:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentUnit());%></td></tr>
    <tr><td>Fragment:</td><td><%out.println(adResponse.getAddresses()[0].getFragment());%></td></tr>
    <tr><td>FragmentPMBPrefix:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentPMBPrefix());%></td></tr>
    <tr><td>FragmentPMBNumber:</td><td><%out.println(adResponse.getAddresses()[0].getFragmentPMBNumber());%></td></tr>
    <tr><td colspan="2" ><input type ="button" value="Start Over" onClick="document.location='inputForm.jsp';"></td></tr>
    </table>
    <%
}

}
catch (Exception ex){
    System.out.println(ex);        
}

%>

This code will first check if an error is present in the response; if it is present it will display that error to the screen. If the error response is null, it will display the validated response from the service.  Notice that we call the “getters” that we have previously defined in our response class to display the results to the user.

We now have everything we need to use the service, let’s see it in action!

As mentioned previously, the FindAddressLines operation can take the inputs for an address in any order and return the validated output address.  See below for an example.

After we send that input to the service, we will receive this response:

You are now all set to test the FindAddressLines operation in the DOTS Address Detective web service. Sample code downloads are also available for all of our other services. As always if you have any questions about integrations, service behavior or best practices, feel free to contact us and we will gladly assist in any way that we can!

Some things are – sadly – a fact of life. Less than a third of people floss their teeth every day. The average US household has over $16,000 in credit card debt.  And according to the United States Postal Service, undeliverable mail costs businesses roughly $20 billion every year.

Ironically, the quality of your contact data is far and away the most easily fixed of these three things. We can’t stop people from using credits cards, and we can’t make flossing your teeth more fun. But we can easily and inexpensively automate the quality of your mailings – and in the process, save you from some very real and tangible costs.

Let’s look at some of the real costs of poor data quality for direct mail:

Time. Direct mailing remains a labor-intensive process, where sorted physical pieces of mail are prepared for delivery. And when some of these are addressed to an out-of-date lead who has moved – or someone gave you a fake name and address, like Bugs Bunny in Rabbitville, Wisconsin – you are wasting human effort at each step of the life cycle of the process, from mail preparation to updating undeliverable addresses in your database.

Money. If bad contact data isn’t enough of a problem, according to Biznology over 70% of it changes every year as people move, change jobs, or get new contact information. Multiply this across the sunk costs of a direct mail campaign, from printing to postage to manpower, and you are looking at a substantial drain on your marketing budget.

Conservation. Is your company “green”? Not if you aren’t strategically addressing your data quality. The USPS alone estimates that it handles over 6 billion pieces of undeliverable mail annually. Multiply this by the impact on trees, energy use, water and landfill space, and you have a huge and largely preventable impact on our environmental waste stream.

Customer Satisfaction. The impact of data quality gets even worse when you don’t deliver what you promised, and your customer reputation takes a hit. Add in the costs of inventory loss, re-shipping, and bad publicity on channels such as social media, and you risk a loss of customer good will, repeat business and market share.

Missed Market Opportunities. They call them leads for a reason – and if your lead is sitting in a landfill somewhere because of bad contact data, they become the customer that never happened. And then the actual costs of this bad data get compounded by the loss of potential future business.

The worst thing about each of these costs is that they are all completely preventable. Real-time contact data validation is an easy, inexpensive capability that can be built right into your applications, or used directly on your lists via the Web. Once in place, they leverage the power of continually updated contact databases from the USPS and others, and you reap the financial benefits of good data quality forever after. It is truly a situation where an ounce of prevention is worth much more than a pound of cure.

Our professions don’t exempt us from real life. Doctors get sick, contractors have leaky roofs – and people who work at Service Objects receive misaddressed mail, just like the rest of us. But one piece of junk mail that recently arrived at my house wasn’t just a mistake: it was a full-fledged tutorial on everything that can go wrong in a direct mail campaign.

For starters, it was a big orange envelope with a bold message on the front – in Swedish. Which I don’t speak. A quick visit to Google Translate revealed that by opening the envelope, I could discover how to see my entire Swedish pension online.

Alas, I don’t have a rich Swedish uncle who has left me a pension. However, the person who used to live in my house did speak Swedish. So this mailing might have been useful to her when she lived here. Unfortunately, that was over 12 years ago.

So now, let’s suppose that this was meant for her, and that she in fact would like to learn about her Swedish pension. The next problem was that her last name was incorrect. Or more accurately, it would have been correct had she not gotten married 18 years ago and taken her husband’s last name.

But that’s not all. The street address was incorrect as well. Actually, they kinda sorta got it right, which is why it probably ended up at my house. But the street name was translated into the same kind of pidgin Swedish that I haven’t seen since the prank subtitles in Monty Python and the Holy Grail. For example, “Saint” = Sankt and “Anne” should be “Ann”.

Mercifully, they did get my city of Santa Barbara, California correct. But it was written in European format, with the ZIP code first (e.g. 93109 Santa Barbara CA). And apparently they don’t do commas in Sweden.

Finally, they did at least make sure that this went to the United States. Because they put this no less than three times in the address, in three different styles (US, USA, and U.S.A.)

Of course, spending a little quality time with Service Objects could have fixed all of these problems, easily and automatically:

• Our Address Validation 3 product would have turned this address into a correctly formatted, CASS-certified USPS address.
• More important, our National Change of Address (NCOA) Live would have produced a current, up-to-the-minute address for the intended recipient.
• Finally, our Lead Validation product could have validated their contact record and assessed the overall accuracy and viability before sending.

This incident was pretty funny. But at another level, it is also sad. Think of all the resources that were expended sending this piece of junk mail across the Atlantic. Now multiply this by all the other misaddressed pieces of mail that were probably sent out in this campaign. Then multiply it again by the amount of direct mail that crosses the globe every day. That sum could pay for a lot of Swedish pensions.

If there is one silver lining to this story – aside from hopefully entertaining our blog readers – it is that at least this piece of mail will not end up in a landfill somewhere. It now hangs proudly on our Wall of Shame here at Service Objects, as a reminder for why we do what we do. And how we can help YOU save money and resources.