October 31, 2014

Marketing-TechnologyAs a marketer, proving the impact of your campaigns through conversions and ROI is how you demonstrate your value to the company. It has always been important to measure the results of your marketing efforts, and professional marketers now rely more heavily on the technology that supplies this statistical evidence. There are many technologies that provide this data, and knowing which to use can make a big impact on where you choose to spend your marketing dollars. The following six technologies are those rated highest in our annual State of Marketing Measurement Survey:

  • Web Analytics: Web analytic technologies, like Google’s Universal Analytics, are currently being used by 73% of marketers. Track visitors’ activity on your websites, as well as the referring source, and when they left. Web analytics tools are helping marketers to create a formidable online presence by optimizing the way consumers interact with their websites.
  • SEO and PPC Tools: 63% of marketers are using SEO and PPC measurement tools in order to get the most out of their search engine presence. Technologies from companies like Kenshoo, Marin Software, and Acquisio help marketers to select the best keywords and optimize conversion and click-through rates for various search engines. If keyword-level advertising is part of your marketing mix, you don’t want to miss out on the benefits that come from this technology.
  • Customer Relationship Management (CRM): Just over half (52%) of marketers are using CRM solutions such as Salesforce.com, to deliver insights on sales conversions. Being able to track a prospect all the way through the sales cycle can provide valuable insight. The more data you have on each lead as it progresses through the pipeline, the more impact the marketing team will be able to have on future leads. CRM technology provides both marketing and sales managers the tools to close more business.
  • Call Tracking Solutions: Phone calls have surges in conjunction with the rise of mobile advertising. As a result, 38% of marketers are using call tracking technology from Ifbyphone to measure and optimize inbound phone leads. With phone leads being reported as your most valuable lead, you don’t want to miss out on the data that proves where your calls are coming from. Being able to determine where your inbound phone leads originate can make a huge difference in your marketing efforts.
  • Mobile or Responsive Website: With the rise of mobile phones, 46% of marketers are turning to mobile web measurement tools to optimize their mobile efforts. Mobile is thriving right now due to the influx of smartphones. By 2017 it is estimated that 92% of all mobile phones will be smartphones. Marketers are beginning to realize this and have started to heavily incorporate mobile into their marketing mix. Measurement of this channel, using services such as Optimizely, is on the rise and is necessary to demonstrate the impact mobile has on your conversions and ROI.
  • Marketing Automation: Only 33% of marketers are using this powerful technology, yet it provides some excellent data. When all marketing activities are flowing through a marketing automation platform, such as Act-On or HubSpot, this provides an abundance of data on the success of each marketing activity. Knowing where a lead originates and how they are interacting with your company can generate drastic improvements in your marketing efforts.

Proper use of all of these technologies can provide marketers with an abundance of data to demonstrate the effect your marketing campaigns have on conversions and ROI. When you have strong, data-driven marketing, it becomes difficult to argue against the value you provide. Learn more about the technologies marketers are using and the channels that are most successful for them in our 2014 State of Marketing Measurement Survey Report.

The post Top 6 Marketing Measurement Technologies appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 30, 2014

Each and everyday, we look for opportunities to add value to our platform and make it easier for you to deploy apps using Twilio. Sometimes that added value comes through in product innovation – with recent releases like MMS for long codes, Media Stream Control, and the Feedback API. Today, we’re excited to announce lower prices.

Beginning November 1st, customers will save up to 25% for US and select international call routes. These new prices will automatically be reflected in your bill – no further action is required.

Compared to on-premise alternatives, some of our largest customers have been able to deploy voice applications in half the time and at up to 50% lower cost. This price drop further reduces the total cost of ownership using Twilio.

Over the past year, our worldwide developer base has doubled to 400,000. Customers are now executing over two billion communication API interactions a month. That’s 25 billion API interactions a year. This growth allows us to achieve greater cost economies of scale, and continue our tradition of passing cost savings to customers in the form of lower prices.

We also recently deployed new Data-Driven Routing, which allows us to dynamically choose the highest quality and best value routes with over 3,200 carriers around the world.

Lastly, Record, which was bundled into Twilio Voice, is now a pay-per-use feature. This is driven by our “pay as you go” philosophy and helps customers optimize the cost of running their communication applications. Combined with new lower pricing, customers who use Record will save an average of 16% on their US voice bill. Customers who don’t use Record will save an average of 25% on their US usage. Customers do not have to change any code for this to take effect, new pricing will be automatically be applied.

US Price Reductions

Old New
Inbound Voice $0.01 $0.0075
Outbound Voice $0.02 $0.015
Toll Free Inbound $0.03 $0.0275

This table reflects starting prices for inbound and outbound minutes. As always, volume pricing will automatically kick in as you scale.

Sampling of International Price Reductions

Geography Savings As of November 1st
All International Inbound 25%
Mexico 25%
Brazil 16%
Australia 12%
United Kingdom 9%
Germany 9%

Cost benefits from higher scale and data-driven routing helped reduce prices for 94% of our international traffic. These benefits did not apply to 6% of Twilio call traffic, specifically in smaller international geographies, where prices have increased. For a full list of new prices, please see this file. New prices will be on the Voice pricing page November 1st.

We remain focused on bringing you the most compelling platform to build your best communication applications. We can’t wait to see what you build!

Twilio Value Equation: Innovation. Ease of Use. Lower Price

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


ifbyphoneFor the third year in a row, Ifbyphone has made the list for Built in Chicago’s Top 100 Digital Companies in Chicago! The list includes companies in many sectors: software, agency, e-commerce, and more, and we’re proud to be among them as a digital company in Chicago who is dedicated to moving and growing fast.

There are 49,000 people employed in the Windy City’s technology economy, a 23 percent increase over 2013. At Ifbyphone we’ve felt the growth here at home in Chicago—continually adding more positions to our staff and attaining an additional floor at 300 West Adams—as well as nationally, after our recent acquisition of Mongoose Metrics in Cleveland. Chicago’s digital ecosystem is healthy and thriving, and we’re committed to contributing not only to the environment of ideas that has earned Chicago the title of “the New Silicon Valley,” but to the tech workforce that creates jobs for the city we call home.

Of the Top 100 list, Mayor Rahm Emanuel says, “Chicago has nearly doubled the number of jobs in technology in the last three years, and it is companies like these that are critical to continuing that growth and helping to achieve our goal of doubling the City’s tech workforce in the next decade.”

We couldn’t agree more. As we continue to gather the brightest minds in Chicago to work with us on creating the best technology in our sector, we are proud to stand among other companies with the same goals, who want to do better business, but also create a better city.

The post Ifbyphone Makes Built in Chicago’s Top 100 Digital Companies List appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Each and everyday, we look for opportunities to add value to our platform and make it easier for you to deploy apps using Twilio. Sometimes that added value comes through in product innovation – with recent releases like MMS for long codes, Media Stream Control, and the Feedback API. Today, we’re excited to announce lower prices.

Beginning November 1st, customers will save up to 25% for US and select international call routes. These new prices will automatically be reflected in your bill – no further action is required.

Compared to on-premise alternatives, some of our largest customers have been able to deploy voice applications in half the time and at up to 50% lower cost. This price drop further reduces the total cost of ownership using Twilio.

Over the past year, our worldwide developer base has doubled to 400,000. Customers are now executing over two billion communication API interactions a month. That’s 25 billion API interactions a year. This growth allows us to achieve greater cost economies of scale, and continue our tradition of passing cost savings to customers in the form of lower prices.

We also recently deployed new Data-Driven Routing, which allows us to dynamically choose the highest quality and best value routes with over 3,200 carriers around the world.

Lastly, Record, which was bundled into Twilio Voice, is now a pay-per-use feature. This is driven by our “pay as you go” philosophy and helps customers optimize the cost of running their communication applications. Combined with new lower pricing, customers who use Record will save an average of 16% on their US voice bill. Customers who don’t use Record will save an average of 25% on their US usage. Customers do not have to change any code for this to take effect, new pricing will be automatically be applied.

US Price Reductions

Old New
Inbound Voice $0.01 $0.0075
Outbound Voice $0.02 $0.015
Toll Free Inbound $0.03 $0.0275

This table reflects starting prices for inbound and outbound minutes. As always, volume pricing will automatically kick in as you scale.

Sampling of International Price Reductions

Geography Savings As of November 1st
All International Inbound 25%
Mexico 25%
Brazil 16%
Australia 12%
United Kingdom 9%
Germany 9%

Cost benefits from higher scale and data-driven routing helped reduce prices for 94% of our international traffic. These benefits did not apply to 6% of Twilio call traffic, specifically in smaller international geographies, where prices have increased. For a full list of new prices, please see this file. New prices will be on the Voice pricing page November 1st.

We remain focused on bringing you the most compelling platform to build your best communication applications. We can’t wait to see what you build!

Twilio Value Equation: Innovation. Ease of Use. Lower Price

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 29, 2014

When a child goes missing, every second counts. So does every word. In high pressure situations like the moments after a child goes missing, communication has to be precise and actionable. Lassy Project knows this first hand.

Lassy works to keep every child safe through a network of app users they call “the village.” Lassy connects neighbors with other neighbors, towns with other towns and even cities with other cities in an effort to make a broad and powerful network of Lassy users all looking out for children’s safety. The more connected the village, the safer the child.

Using their app, Lassy users can upload critical information about their child, select emergency contacts, and monitor their child’s location via the app. If their kid goes missing, Lassy triggers an alert out to the user’s village.

Previously Lassy used SMS communications to alert the different Lassy Villages. Now they’re using Twilio MMS to instantly send other users  all the missing child’s pertinent details, last known location, as well as a picture of the child.

lassy

The team hopes that including a picture in their alerts will drastically increase response time, and convey all the details that village users need to know in order to help locate a missing child.  This instant, visual message allows community members to know immediately who they’re looking for and where.  It also removes barriers to entry to access this pertinent information.  With the MMS alert users do not have to have wifi connectivity or a even a smartphone to receive the information and photo in a text.

“Having the ability to instantly share a missing child’s photo through MMS is an unprecedented technology feature,” said Lassy Project Chief Technology Officer, Temitope Sonuyi.  “This allows our users and community members to instantly respond to a missing child alert in their immediate surrounding area and potentially save lives.  It’s an incredibly powerful tool that can change the way that communities work together to protect their most valuable assets; children.”

Now that Lassy is up and running with Twilio MMS, they’re hopeful that it will help their villages of first responders to act efficiently, and immediately to bring missing children home.  Every second counts when a child goes missing, and now Lassy Project, with the support of Twilio, is providing the technology to find lost children, faster.

Join Lassy Project today and help build safer communities: www.lassyproject.com

Learn more about Lassy here (http://blog.lassyproject.com/)

A Picture Is Worth 1,000 Seconds: Lassy Project Keeps Children Safe With Twilio MMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


phone leadsPhone leads drive business. Studies show that inbound calls often convert to revenue 10 to 15 times more frequently than web leads, making them the lead type sales managers want most. It’s why marketers are spending $68 billion annually on ads to generate those sought-after calls.

Yet marketers are now also finding that creating effective campaigns and web content that drive high volumes of phone leads may not be enough to ensure a high ROI. True ROI from a campaign isn’t measured in calls generated by your marketing, but rather in new accounts and revenue generated from those calls by your sales reps or clients. Just getting your phone to ring off the hook isn’t the goal. Making an impact on your company’s bottom line is.

That’s why marketers are now establishing processes to define what a quality phone lead is for their business, then implementing technologies to help weed out the bad calls and route the good ones to the best sales rep or store. They are proactively qualifying, routing, and scoring the calls they generate to optimize the chances those calls convert to revenue.

Understand Your Business: Define a Quality Lead and How to Assign It

Not every incoming call is sales-ready or should even be connected to a live agent. Studies show that only 19% of inbound calls are high-quality sales leads – most are not. Therefore marketing should work with sales to answer two questions:

  • What is the definition of a qualified phone lead?
  • How should phone leads get assigned?

Once these questions are answered, businesses and agencies can use that data to establish call qualification, routing, and scoring strategies to maximize ROI.

Not All Calls Are Created Equal: Qualify Them First

We mentioned the 19% figure above: that means 81% of callers are not calling to engage with sales, but are often misdials or mundane inquiries for business hours and store directions. To combat those types of calls, marketers will first send callers to an IVR (interactive voice response) virtual receptionist to help qualify callers automatically up front and shield sales agents from wasting time on non-sales calls. The IVR can be as simply as “Press 1 to speak to a sales agent, Press 2 to speak to an operator” or can provide a more elaborate list of qualifying questions to determine the caller’s lead score based on your definition of a qualified lead.

Marketing ROI Depends on Who Handles Each Call: Route Them Optimally

Routing phone calls optimally can be the difference in winning the sale. Contextual call routing technology enables you to making sure each caller is routed to the best rep to handle that particular lead.

With call routing technology you can direct inbound calls in a wide variety of ways based on the structure of your business and how leads are assigned to your sales team. You can:

  • Route calls differently based on which marketing source drove it
  • Send a higher percentage of calls to top-performing agents
  • Direct calls to different locations based on the time of day
  • Route calls based on the caller’s geographic location
  • Ring a group of agents (or a single agent’s work, mobile, and home phone) in succession or simultaneously

To Determine Caller, Agent, and Campaign Quality: Score Your Calls

Looking for a way to determine the quality of callers and the performance of your agents and marketing campaigns? Call scoring is the answer. By scoring a call you can assign values to a conversation based on specific metrics you’ve set and are then identified within the conversation.

Call scoring can be as simple as monitoring call duration or examining call recordings, or as complex as using keyword spotting technology to scan a conversation for specific keywords and automatically scoring the call based on who said them. By analyzing these metrics you are able to uncover which sales strategies are working best, which agents are performing better, and which marketing campaigns are driving the most valuable callers.

Understand Your Business: Optimize Your Marketing For What Works

The ultimate goal is to understand what marketing campaigns are driving quality phone leads and which agents are best at converting those leads to sales. You can then optimize for what works. While any of these call management strategies can be used a la carte, it’s often helpful to think of it as a step-by-step process:

Guide_InboundCalls_Chart

If you are interested in learning more about how marketers are making the most of their inbound calls by qualifying, routing, and scoring to drive sales, download our new white paper, “Marketer’s Guide to Qualifying, Routing, and Scoring Inbound Calls to Optimize Sales”.

The post Your Phone Leads Aren’t Converting: Steps You Can Take To Fix It appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


In Part 1 of this series, we introduced the Twilio Client for Xamarin and showed how easy it is to add it to your Xamarin.iOS and Xamarin.Android projects. Now that you know how to install the component, let’s build something with it.

It seems like everyone these days is walking around with big phones. With Apple’s recent announcement of the iPhone 6 and 6 Plus, iOS users finally get a taste of what it’s like to have 4.7” and 5.5” smartphones. What if I told you that you could have a 7.9” or 9.7” phone? Yes, I’m talking about your iPad. With Twilio Client you can create a phone that really is huuuuuge.

twilio-client-final-thumb

What You’ll Need

How Twilio Works

Before we get started building our iPad phone let’s go over what happens when an inbound call comes in to Twilio. This will help you understand how Twilio Client works as we move through the steps.

For all inbound communication to Twilio, whether voice, VoIP or Messaging, Twilio uses a set of XML commands called TwiML to provide an experience to the inbound caller, or respond to the inbound message.

Twilio gets that TwiML by making an HTTP request to a URL that you have associated with either your Twilio phone number, or in the case of a VoIP call using Twilio Client (which does not use phone numbers), a TwiML application.

How Twilio Works 1

How Twilio Works 2

Now that we’ve covered the bases on how Twilio works, let’s start building our iPad phone. If you want to follow along you can download the repos for the server and client code.

Generating Capability Tokens

Our journey to creating a giant phone starts on the server side creating capability tokens. The capability token is essential to our Twilio Client application’s workflow since it authorizes a client to make and/or receive calls through Twilio. The token is an encrypted string that grants the ability to either receive inbound calls, make outbound calls or do both. It also verifies that you have granted this access since it will be signed with your account SID and auth token. We must generate this token on the server to avoid potentially exposing our credentials to our users by including them in the iOS application.

For our iPad phone project we will generate the capability tokens using ASP.NET MVC. Start by creating a new ASP.NET MVC Web Application project from the Empty template. Make sure to add MVC references as shown below:

New MVC Project

Now we need to install some NuGet packages for the libraries we will be using. First we’ll install the Twilio.Mvc package (commands shown for Package Manager Console):

Install-Package Twilio.Mvc

Then install the Twilio.Client package:

Install-Package Twilio.Client

Next we need to add a Controller to our ASP.NET MVC project that will serve up the capability tokens to our client application. Right-click on your project node and select “Add->Controller…”. Select”MVC 5 Controller – Empty” in the resulting dialog and then click “Add”. Name the controller “ClientController”. Add the following using statement to the top of the ClientController class:

using Twilio;

Replace the Index() method in the ClientController class with the following code:

// GET: Client/Token?ClientName=foo
public ActionResult Token(string clientName = "alice")
{
	// Create a TwilioCapability object passing in your credentials.
    var capability = new TwilioCapability(“*** Your Account SID ***”, “*** Your Auth Token ***”);

	// Specify that this token allows receiving of incoming calls
    capability.AllowClientIncoming(clientName);

	// Return the token as text
    return Content(capability.GenerateToken());
}

 

This method will be accessible from http://<your_webapp_url>/Client/Token and takes a query parameter for the clientName. This clientName is an identifier for the client that Twilio can use when routing calls (similar to a phone number for a regular phone). In the code above we set the clientName property to “alice” using a default property but a different value could be passed in. The next step in the tutorial will assume the clientName was set to “alice”. Test that the application is working locally by debugging it and visiting http://localhost:<your_port>/Client/Token. You should see a really long string in the browser. That’s a capability token.

Now that we’re successfully generating capability tokens, we need to make our web application accessible on a public URL so that Twilio will be able to reach it. If you want to test locally you will need to expose your localhost to the outside world. I recommend using ngrok for this. You can use this tutorial to help get you set up with ngrok to work properly with ASP.NET and IIS. Alternatively, you can publish to Azure or your own hosting solution. Once you have your web application publicly facing, double-check that the token generation is still working by visiting http://<your_webapp_url>/Client/Token. Next let’s set up an iPad application that can accept phone calls using Twilio Client.

Building an iPad Phone

Open up Xamarin Studio on the Mac (I’m using the Xamarin Studio 5.5.2) and create a new solution. In the “New Solution” dialog under iOS choose Classic API -> iPad -> Single View Application. We will only have a single screen in our app and this is the perfect template for that scenario. Name your application iPadPhone and click “OK”. Underneath the iPadPhone project right-click on “Components” and select “Get More Components…” to load the Xamarin Component Store. You can think of the Component Store as an App Store for third-party code. This is where we will get the Twilio Client component.

Type “Twilio” in the search box in the upper left of the store and click on the Twilio Client component:

Component Search

On the next screen, click “Add to App”:

Xamarin_Components_Add

This will add the references needed to use the Twilio Client Mobile SDK for Xamarin.iOS from our Xamarin app.

Open the iPadPhoneViewController.cs file and add the following using statement:

using TwilioClient.iOS;

To the top of the class right before the constructor we’ll add fields for a TCDevice and a TCConnection which are the two main objects in a Twilio Client application:

TCDevice _device;
TCConnection _connection;

Edit the ViewDidLoad method (making sure that it is marked async) so that it contains the following code:

public async override void ViewDidLoad ()
{
	base.ViewDidLoad ();

	// Create an HTTPClient object and use it to fetch
	// a capability token from our site on Azure. By default this
	// will give us a client name of 'alice'
	var client = new HttpClient ();
	var token = await client.GetStringAsync("http://<your_webapp_url>/Client/Token");

	// Create a new TCDevice object passing in the token.
	_device = new TCDevice (token, null);

	// Set up the event handlers for the device
	SetupDeviceEvents ();
}

 

(Note: You’ll need to add System.Net.Http as a reference and add it as a using statement. As a shortcut you can right-click HttpClient and under Resolve there will be an option to add this for you.)

This code gets a capability token for a client named ‘alice’ from the ASP.NET MVC site we set up previously. It uses this token to initialize the Twilio Client device and get it ready to make and receive calls. Next we will setup the event handler for an incoming call in the SetupDeviceEvents method. Add the following code to the view controller:

void SetupDeviceEvents ()
{
	if (_device != null) 
	{
		// When a new connection comes in, store it and use it to accept the incoming call.
		_device.ReceivedIncomingConnection += (sender, e) => {
			_connection = e.Connection;
			_connection.Accept();
		};
	}
}

 

When an incoming connection is received from Twilio the device’s ReceivedIncomingConnection event will fire. We store the connection so that we can have access to its events and status and then accept the incoming call.

Believe it or not, that’s all the code we need in our iPad app to receive an incoming call using Twilio Client. You might be wondering ‘how do I actually place a call to my iPad?’ We’re going to set that up in the next step.

Responding to an Incoming Call

Head back over to the ASP.NET MVC application and add the following using statements to ClientController.cs:

using Twilio.TwiML;
using Twilio.TwiML.Mvc;

Next, add the following method to the class:

public ActionResult CallXamarin()
{
    var response = new TwilioResponse();
    response.Dial(new Client("alice"));
    return new TwiMLResult(response);
}

This code produces TwiML that tells Twilio to connect us to a client instance named “alice” when we call our Twilio number. We will set up our number to fetch this TwiML in the next step. The TwiML that is generated by this code looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Dial>
    <Client>alice</Client>
  </Dial>
</Response>

You can find out more about the TwiML <Dial> verb and <Client> noun here.

Go to the numbers portal in your Twilio account and click on one of your phone numbers. Set the Voice URL to http://<your_webapp_url>/Client/CallXamarin as shown below:call_xamarin

Head back to Xamarin Studio and run your iPadPhone application in the iPad simulator. The app will get a capability token and then sit there ready for you to call it. Call your Twilio number using your normal voice phone. Twilio will connect you to the app running in the iPad simulator and you should be able to hear yourself echoing through your computer speakers. You just turned your iPad into a phone! If our iPad app could only receive incoming phone calls it wouldn’t be much of a phone. Let’s set up a few things to enable it to make outbound calls as well.

Creating a TwiML App

When we update the capability token we send to the client we will need to provide the ID to a TwiML application.  A TwiML application has a few uses. One common use case is creating a reusable set of Voice and Message URLs for your Twilio phone numbers. This saves a lot of time copying and pasting when multiple numbers need to use the same URLs. The other use case is for Twilio Client. When you phone call to your Twilio phone number, Twilio uses that unique phone number to determine which Voice URL to retrieve TwiML instructions from. When we attempt to make an outbound call using our Twilio Client iPad phone we won’t actually have a phone number since it’s VoIP. Instead, Twilio will use the Voice URL of a TwiML app that we will set up to use with our iPad phone.

When we place a call using Twilio Client, the Voice URL of a TwiML app will be requested when the call is initiated to tell Twilio’s backend how to respond. Twilio will knows which TwiML application to use because we will generate the capability token with the unique identifier of our TwiML application. Let’s create a TwiML application now which will use a Voice URL from our ASP.NET MVC application. You can create a TwiML app here.

Set the Voice URL of your TwiML app to http://your-webapp-url/Client/InitiateCall:

twimlapp_url

Save your TwiML app and then click its name in the list. Copy the “Sid” property at the top of the screen to the clipboard. You’ll need it in the next step.

Updating the Server Code to Handle Outbound Calls

Back in the ASP.NET MVC app update the Token() method of your ClientController class to add the following line:

// Replace "AP*****" with the TwiML app Sid you copied in the last step
 capability.AllowClientOutgoing("AP********************************");

Test your app and make sure the /Client/Token endpoint is still returning a token before moving on.

Next we need to add the InitiateCall endpoint that we specified in our TwiML application’s Voice URL. Add the following method to the class:

// /Client/InitiateCall?source=5551231234&target=5554561212
public ActionResult InitiateCall(string source, string target)
{
    var response = new TwilioResponse();

    // Add a <Dial> tag that specifies the callerId attribute
    response.Dial(target, new { callerId = source });

    return new TwiMLResult(response);
}

With the TwiML generated by this code, Twilio will bridge our VoIP call to the phone number specified in the target parameter using the source parameter as the caller ID for the call. The callerId is not required in this case since we’re calling a phone number but it will be required if you modify the code later to call other Twilio Client instances.

Finishing the iPad Phone

Everything is in place on the server side for a phone call to be placed from our iPadPhone app. Let’s add code to the app that creates a text field and a button that when tapped will call the number specified in the text field. First, download this set of images and add them to the Resources folder in your project. Then, add the following code to the end of the ViewDidLoad method in iPadPhoneViewController making sure to note the TODO item:

// Add the Twilio logo
var logo = new UIImageView (new RectangleF (200, 120, 400, 120));
logo.Image = UIImage.FromBundle ("Twilio_logo_red");
this.View.Add (logo);

// Add a UITextField for the phone number to call
var numberField = new UITextField (new RectangleF (200, 300, 400, 30));
numberField.BorderStyle = UITextBorderStyle.RoundedRect;
numberField.TextAlignment = UITextAlignment.Center;
numberField.Placeholder = "Phone number";
this.View.Add (numberField);

// Add a UIButton to initiate the call
var callButton = new UIButton (UIButtonType.Custom);
callButton.SetBackgroundImage(UIImage.FromBundle("call_button"), UIControlState.Normal);
callButton.Frame = new RectangleF (200, 380, 400, 40);
//callButton.SetTitle ("Initiate Call", UIControlState.Normal);
this.View.Add (callButton);

// Add code to TouchUpInside to place the call when the user taps the button
callButton.TouchUpInside += (sender, e) => {
    // Setup the numbers to use for the call
    // TODO: Update this code to include your Twilio number
    NSDictionary parameters = NSDictionary.FromObjectsAndKeys (
        new object[] { "*** Your Twilio Number ***", numberField.Text },
        new object[] { "Source", "Target" }
    );

    // Make the call
    _connection = _device.Connect(parameters, null);
};

Run the iPadPhone app. It should look like this:

twilio-client-ipad_thumb

Enter a phone number in the text field and tap the button. You should hear some tones indicating Twilio Client is placing the call and then, if you are using an upgraded account, the phone you are calling will start ringing. Answer it and enjoy your first VoIP to Voice outbound call using Twilio Client.

If, however, you are using a Twilio trial account, Twilio will prompt you to press “any key” to continue the call. Obviously, since this is a custom application there are no keys to press, so you need to make one.

Let’s add the “any key” to our application UI:

// Add a UIButton to press any key
var anyKeyButton = new UIButton (UIButtonType.Custom);
anyKeyButton.SetBackgroundImage(UIImage.FromBundle("any_key"), UIControlState.Normal);
anyKeyButton.Frame = new RectangleF (200, 430, 400, 40);
this.View.Add (anyKeyButton);

In its TouchUpInside event, call the Connection instances SendDigits method, passing a string containing a number from 1 to 9:

anyKeyButton.TouchUpInside += (sender, e) => {
    if (_connection != null && _connection.State == TCConnectionState.Connected) {
        //We can't just press 'any' key so we'll press 1
        _connection.SendDigits("1");
    }
};

SendDigits lets you tell Twilio Client to simulate pressing keys on a phone’s dial pad.

Go ahead and give your app a second test run and this time when Twilio prompts you to press a key, wait until the prompt is finished and tap that second button. Your phone should now ring.

You might be wondering “how do I hang up from the iPad?”. Let’s add a hangup button to our UI:

// Add a UIButton to hang up
var hangupButton = new UIButton (UIButtonType.Custom);
hangupButton.SetBackgroundImage(UIImage.FromBundle("hangup_button"), UIControlState.Normal);
hangupButton.Frame = new RectangleF (200, 480, 400, 40);
this.View.Add (hangupButton);

On TouchUpInside we’ll call the Disconnect method on the _connection object:

// Hang up the call
hangupButton.TouchUpInside += (sender, e) => {
    _connection.Disconnect();
};

Amazing. You’ve used Twilio and Twilio Client to turn your iPad into a huge phone.

Next Steps

Now that we’ve turned our iPad into possibly the largest phone on the market, you might be wondering what’s next. We’ve only scratched the surface on Twilio Client’s potential use cases. Try some of these:

  • Try calling another instance of Twilio Client from your iPad
  • Use the presence events to see when other clients are connected
  • Allow your users to call customer support directly from your apps

I’m super excited to see what the Xamarin community will build with the Twilio Client component. Stay tuned for the Part 3 of this series which will discuss adding these great VoIP features to Xamarin.Android applications. In the meantime, feel free to reach out to me via email (brent@twilio.com) or on Twitter @brentschooley.

Twilio Client for Xamarin – Part 2: iOS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 28, 2014

Lukly-logoWe fear the 1% battery. We fear leaving our phone at home. The days of remembering your friends’ numbers is over. We’re in the world of iCloud back ups and remotely stored contact lists. But when your phone dips from 1% battery to dead, and your phone refuses to heed your wish to grow wings and fly to you, it’s time for a plan B. Lukly aims to be your plan B.

Lukly lets you access your contacts in an old school way. Here’s how it works: You can register your number and upload all your contacts to Lukly. Then when your phone inevitably takes its last breath, you can access your dead phone’s contacts through another phone via SMS.

When you text Lukly’s Twilio number from a gracious friend or passerby’s phone, you can select which of your contact’s numbers you need. When you text “Andrew” to your Lukly number, it’ll send you back every Andrew in you phone, and you can select which person you want to contact.

Lukly is now giving 5 free backup credits away once you sign up here so you can access iCloud contacts via SMS.

Smart Phone, Dumb Battery: Lukly Lets You Access iCloud Contacts via SMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Recently my parents bought themselves a shiny new laptop. They got it home, sat it on their desk and realized that the only display port on the laptop was HDMI. This unfortunately would not work with their external monitor which only had VGA and DVI ports. As the resident family IT guy they called me.

I could have ordered the adapter, but I figured going local would be a faster way to solve their problem. I searched for the part on Best Buy’s website and found a generic HDMI to DVI cable which would work perfectly for them.

Now I’ve been burned in the past by seeing something online and rushing out to the local store only to find out its not actually in stock, so this time I picked up the phone and called my local Best Buy and had a conversation that went a bit like this:

BB: Hello, Best Buy, how can I help you
Me: Ya, I’m looking to see if you have a whatsihoozits in stock. The part number is 123456789.
BB: One moment sir, let me check. It doesn’t look like we have that in stock, but I am showing the Flooverville store has 4.
Me: Flooverville, eh? I’m not quite sure where that is.
BB: Oh, that store is located just outside of the Flooverville Mall.
Me: I’ve never been there. Can you give me an idea of how to get there?
BB: Sure. Hop on Route 345 for a few miles. Left at a gas station, I think it might be a Gas-O-Rama, but maybe not. Go for a few miles and look for the next big road. Not sure what its called, but it eventually becomes Flooverville Road. I think you turn right. You’ll see a McRonalds. When you do start……..[lots more vague directions go here]….and then you’ll see the sign for Best Buy.

Needless to say, the instructions were less than helpful. Here is how I wish that conversation had gone:


BB: Oh, well that store is located just outside of the Flooverville Mall.
Me: I’ve never been there. Can you give me an idea of how to get there?
BB: Sure. If you give me your address and phone number I’ll be happy to send you a map with driving directions directly to your phone.
Me: Awesome! I live at 123 Main Street Cityton and my phone number is 555-555-5555.
BB: The map should arrive at your phone momentarily. Is there anything else I can do for you today?

This post will show you how to build that experience. By combining the Best Buy API, Bing Maps and a bit of Twilio with some basic web development using JavaScript and ASP.NET MVC, we’ll create a website that can locate a product at a Best Buy near you and then send a customized driving route map directly to your phone as an MMS message. Let’s get building!

Gathering Your Materials

Like any building project, we’ll need some materials to get started. In this case we’ll leverage a number of different APIs including:

Of course if you’re not interested in writing the code yourself and just want to deploy a completed app, you can do that as well. All of the code shown in this post is available as a completed website in GitHub.

Where Can I Find A Whatsihoozits?

The first problem we need to tackle is locating products at a local Best Buy. To do that we’ll build a simple web page that a store employee could use to check for product availability in a location. The page uses Bootstrap to display a nicely designed HTML form that lets the employee enter a product SKU, a zipcode and a search distance:

<form class="form-inline" role="form">
	<div class="form-group">
		<input class="form-control" id="productsku" type="text" placeholder="SKU" />
	</div>
	<div class="form-group">
		<input class="form-control" id="zipcode" type="text" placeholder="Zip Code" />
	</div>
	<div class="form-group">
		<select id="distance" class="form-control">
			<option value="5">5 miles</option>
			<option value="10">10 miles</option>
			<option selected value="20">20 miles</option>
			<option value="30">30 miles</option>
			<option value="50">50 miles</option>
			<option value="100">100 miles</option>
			<option value="250">250 miles</option>
		</select>
	</div>
	<button class="btn" type="button" id="productAvailabilitySearch">Search</button>
</form>

When the Search button is clicked, the web page uses jQuery to send the form values as an AJAX request to the Best Buy API. The API endpoint we are using will take those values and locate any Best Buy stores within the specified distance that has the product SKU in stock, returning to us a list of those store locations formatted as JSON.

Because this request comes directly from the web page, jQuery needs to be configured to make the request using JSONP, which the Best Buy API supports. To do this set the dataType parameter to jsonp and the jsonpCallback parameter to a function named listProducts which you can add to your page.

$(function () {
    $("#productAvailabilitySearch").click(function () {

    var sku = "sku=" + $("#productsku").val();
    var area = "area(" + $("#zipcode").val() + "," +  $("#distance").val() + ")";

    var url = "http://api.remix.bestbuy.com/v1/products(" + sku + ")+stores(" + area + ")?format=json&apiKey=[YOUR_BEST_BUY_KEY]&show=sku%2Cstores";

    $.ajax({
        type: "GET",
        url: url,
        cache: true,
        dataType: 'jsonp',
        jsonpCallback: 'listProducts'
        }).done(function (data) {
            console.log("Success");
        })
        .fail(function (jqXHR, textStatus, errorThrown) {
            console.log("error: " + textStatus);
        })
    });
});

function listProducts(root) {
}

Once the Best Buy API is successfully returning results to the web app, we’ll need to display them. To do this I chose to use Mustache templates, and created a simple template to show the address of each store returned from the Best Buy API:

<script id="storeLocation" type="text/template">
        <ul>
            {{#stores}}
                <li>
                    <div>
                        <h3>{{longName}}</h3>
                        <p>{{address}}</p>
                        <p>{{city}} {{region}} {{fullPostalCode}}</p>
                        <button class="btn" data-toggle="modal" data-target="#myModal" data-address="{{address}} {{city}} {{region}} {{fullPostalCode}}">
                        Send Map
                        </button>
                    </div>
                </li>
            {{/stores}}
        </ul>
</script>

With the template defined, you merge it and the results from the Best Buy API together by calling Mustaches To_Html function:

function listProducts(root) {
	var products = root.products;

	for (i = 0; i < products.length; i++) {
		var stores = products[i].stores;
		var template = $('#storeLocation').html();
		var html = Mustache.to_html(template, { 'stores': stores });
		$('#results').html(html);
	}
}

Fantastic! You’ve just built a product availablity search web page. Go ahead and run it and try to find some products near you. Need some ideas to search for? Try some of these favorites of the Twilio Devangel crew: 1307700488, 5143501 or 5568321.

Which Way Do You Go?

Now that we’re finding stores with products, let’s move on to taking the store data and sending a map with driving directions to a phone.

To provide those instructions we’ll need to have a start point and an end point. The end point will be a Best Buy address which we received from the Best Buy API. The start point will be the customers address. We also need to know the customers phone number so that we can send the map to the phone. To get that additional customer data we’ll need another form in the web page. Since the app already uses Bootstrap, we can leverage its Modal dialog to display this form:

<div id="myModal" role="dialog" class="modal fade" data-backdrop="static">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
                <h4>Send A Map</h4>
            </div>
            <div class="modal-body">
                <h3>From</h3>
                <form role="form">
                    <div class="row" style="margin-bottom:5px;">
                        <div class="col-lg-12">
                            <input class="form-control" id="address" type="text" placeholder="Address" />
                        </div>
                    </div>
                    <div class="row">
                        <div class="col-lg-5">
                            <input class="form-control" id="city" type="text" placeholder="City" />
                        </div>
                        <div class="col-lg-3">
                            <input class="form-control" id="state" type="text" placeholder="State" />
                        </div>
                        <div class="col-lg-4">
                            <input class="form-control" id="postalcode" type="text" placeholder="Zip Code" />
                        </div>
                    </div>
                </form>
                <h3>To</h3>
                <div id="toAddress"></div>
                <hr />
                <p>Send map to <input class="form-control" type="text" id="toPhoneNumber" placeholder="(555) 555-5555" /></p>
            </div>
            <div class="modal-footer">
                <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
                <button id="closemodal" type="button" class="btn btn-primary" data-dismiss="modal">Send</button>
            </div>
        </div><!-- /.modal-content -->
    </div><!-- /.modal-dialog -->
</div><!-- /.modal -->

Once we have the start and end address and a phone number, we are ready to generate and send the map which we’ll do on the server. Triggered by the closing of the Modal dialog, the .ajax function from jQuery is used to send the addresses and phone number to the server.

$('#myModal').on('hidden.bs.modal', function (e) {

    var fromAddress = $("#address").val() + ' ' + $("#city").val() + ' ' + $("#state").val() + ' ' + $("#postalcode").val();

    var payload = {
        toAddress: $("#toAddress").text(),
        fromAddress: fromAddress.trim(),
        toPhoneNumber: $("#toPhoneNumber").val()
    };

    $.ajax({
        type: "POST",
        url: '/Home/SendMap',
        dataType: 'json',
        data: payload
    }).done(function (data) {
        console.log(data);
    })
    .fail(function (jqXHR, textStatus, errorThrown) {
        console.log("error: " + textStatus);
    })
});

Notice that the AJAX request is being made to the route /Home/SendMap. This will be the code that actually generates the map and sends the MMS. Let’s head over to the server side, create that new route and generate a new map.

Generating Static Maps with Bing

Before we write any code on the server, let’s look at how to use the Bing Maps REST API to generate our map. The Bing Maps REST API includes a resource which accepts a series of addresses or landmarks known as Waypoints. Based on the provided Waypoints, Bing will calculate the best driving route and return a map with that route overlayed.

For example, to generate a map that shows how to drive from Twilio’s headquarters in downtown San Francisco to the Golden Gate Bridge, you would create a URL with two Waypoints:

http://dev.virtualearth.net/REST/v1/Imagery/Map/Road/Routes?wp.0=645%20Harrison%20San%20Francisco%20CA;64;1&wp.1=Golden%20Gate%20Bridge;66;2&key=[YOUR_BING_MAPS_KEY]

Dropping this URL into a browser with your own Bing Maps REST API key will return a map with the best driving route:

bingmap

There are many options available in the Bing Maps REST API, such as showing satellite imagery, telling Bing to to avoid highways or even choosing a different travel mode like walking or public transit. Check out the Bing Maps documentation to learn about all those options.

Putting All Of the Pieces Together

Finally, let’s finish this app by putting the whole thing together and sending a Bing Map containing the route from the customer address to the Best Buy location as an MMS.

Start by creating a new method named SendMap in your ASP.NET MVC controller and define three method parameters, one for the start address, one for the end address and one for the phone number.

public ActionResult SendMap(string fromAddress, string toAddress, string toPhoneNumber)
{
}

We will let ASP.NET MVC’s model binding handle mapping the values coming from the AJAX request into the method parameters.

To send the MMS we’ll use the Twilio .NET Helper Library, which you can install via Nuget.

Start by creating a new instance of the TwilioRestClient object, passing in your Twilio account credentials. You can find your account credentials on your account dashboard.

Next, using the object instance call the SendMessage method. This triggers an HTTP request to the Messages resource in Twilio REST API, telling Twilio that we want to have it send a new MMS message for us. The SendMessage method accepts several parameters including:

  • From – the Twilio phone number you want this MMS message to come from. You can see what phone numbers you own, or buy new numbers by logging into your Twilio dashboard and selecting the Numbers tab.
  • To – the phone number you want the MMS message to go to. In our application this is the customer who we want to send the map to.
  • Body – a string containing a message you want to include in the MMS message.
  • MediaUrls – an array of strings, where each string is a URL that points to an image you want to include in the MMS message. In our application we’ll be including the Bing Maps URL in this array.

Now, putting the code together the SendMap method looks like this:

public ActionResult SendMap(string fromAddress, string toAddress, string toPhoneNumber)
{
    string accountSid = "[YOUR_TWILIO_ACCOUNT_SID]";
    string authToken = "[YOUR_TWILIO_AUTH_TOKEN]";
    string fromPhoneNumber = "[YOUR_TWILIO_PHONE_NUMBER]";

    var client = new TwilioRestClient(accountSid, authToken);
    var result = client.SendMessage(
        fromPhoneNumber,
        toPhoneNumber,
        null,
        new string[] {
            string.Format("http://dev.virtualearth.net/REST/v1/Imagery/Map/Road/Routes?wp.0={0};64;1&wp.1={1};66;2&key=[YOUR_BING_MAPS_KEY]", Server.UrlEncode(fromAddress), Server.UrlEncode(toAddress))
        });

    if (result.RestException != null)
    {
        return Json(result.RestException);
    }

    return Json(true);
}

After the call to SendMessage is made, we use the RestException property to see if anything bad happened during the request to the Twilio REST API. If an exception occurs we return the details of that exception to the web page in the form of a JSON object.

This check will not tell us if Twilio was able to successfully retrieve the map from Bing. If Twilio encounters a problem getting the map image, it will set the MMS messages status to Failed.

To check the message status we could go back at a later time and use the Twilio REST API to query for messages whose Status is Failed. Another option would be to provide the StatusCallback parameter to the SendMessage method. This gives Twilio a URL to request when the message status changes.

Awesome! You should now be able to give the entire site a whirl. Load up the web page, drop in a product SKU, zip code and distance to find the product in a Best Buy near you. When you do, click the Send Map button, enter an address and phone number and voila, a beautifully rendered map with the driving route will soon show up on your phone.

Conclusion

By combining a few easy to use APIs and a little bit of code we’ve created an app that makes it much easier for businesses to communicate with their customers. Build it yourself or just grab the code off of GitHub and deploy.

The road need not stop here however. There are a bunch of really cool places you could take this app, including:

  • Allow the user to retrieve text-based driving instructions along with the map or
  • Include a link in the MMS message which deep links your customers directly to a maps application they have installed on their phone

What other ideas do you have for how this kind of application can work? I’d love to hear them. Reach out to me on twitter @devinrader or via email devin@twilio.com.

Send Driving Directions Using Bing Maps and Twilio MMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Sesame Workshop, the nonprofit behind the popular preschool-aged children’s television programming on Sesame Street, has partnered with ToyTalk to explore teaching preschool literacy with conversational speech technology. The two firms have signed a two-year deal that expands on a previous collaboration around mobile apps that can decode and respond to children’s speech patterns. ToyTalk expects […]

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


holiday-smartphoneWith the holiday season rapidly approaching, the job market is seeing the yearly surge of seasonal hiring. Large retailers need the extra staff in order to handle the shopping boom during this time of the year. According to a recent CareerBuilder study, 43% of retailers plan to hire additional workers for the holiday season, up from 39% during the same time period last year. Amazon is hiring 80,000 seasonal workers, Macy’s is hiring 86,000, Toys ‘R’ Us plans to hire 45,000 workers, and UPS expects to hire over 90,000 seasonal employees. These four mega-corporations will be hiring over 300,000 combined seasonal employees, and they are just the tip of the iceberg.

Many of these positions being offered for the holiday season will supplement existing customer service teams. CareerBuilder’s study found that 40% of seasonal jobs this year will be customer service positions. Macy’s alone will be hiring 1,125 workers for their customer service centers in Ohio, Florida, Arizona, and Missouri. However, not all companies have the physical space, hardware, or budget to support such large call centers. With rising call volumes before and after the holidays, companies need a way to handle all of these inbound calls. To do so, many seasonal employers are turning to virtual call centers.

Scalable Virtual Call Centers for Your Seasonal Employees

Virtual call centers provide retailers and other businesses with a cost-effective solution for supporting seasonal call center staff. Virtual call centers are designed to capitalize on the current surge in BYOD (bring-your-own-device). Unlike traditional call centers, virtual call centers don’t require any additional hardware, any software installation, or the hiring of any implementation and maintenance teams. Instead, each seasonal employee can use their own computer and phone and can work from any location they desire. This gives businesses the ability to keep costs low while still providing customers with excellent phone-based support around the holidays.

Work from Home or the Office

Support and sales representatives are able to work from home while still having access to their supervisors. Agents can easily manage their call queue, and their managers can monitor all of their agents’ calls and activity.

Whether your agents will work out of their homes or come into your office, the technology is the same. Regardless of where your agents work, they can still use their own devices and have the same connectivity. The flexibility that is offered by virtual call centers is perfect for the temporary workforce that is formed during the holiday season. Major retailers and small companies alike are able to support the higher number of calls they receive in an easy and affordable way. By using a virtual call center, businesses of all sizes are able to cut costs while still providing outstanding customer service.

The Integrated Virtual Call Center

A virtual call center is only the first step in revolutionizing the way your business provides customer service. Retailers receive an extraordinary amount of calls during the holiday season and by integrating virtual call centers with other internal systems and complementary technologies, that call volume can be easier to handle with fewer agents.

Integrated voice response (IVR) is used by most call centers today. This is the automated menu that you hear when you call a business. These IVRs gather information and direct your call to the proper place. But when this technology lacks sophistication, the IVR can sometimes be less than helpful. Have you ever called a support line and had an IVR ask questions to identify yourself and then be asked by an actual representative to identify yourself again? By integrating your virtual call center directly with your IVR, you remove these issues by providing the support representative with the information the customer already gave through the IVR. Integrating IVR with your virtual call center also allows for better routing by connecting callers directly with the agents responsible for each department.

The Advantages of Virtual Call Center Integration

CRM systems contain an abundance of information about customers and by integrating with a virtual call center, this information is right at the fingertips of your call center agents. The ability to easily display caller information from a CRM allows sales and support agents to provide more personalized assistance to the caller.

Receiving such a high call volume during the holidays can result in a lot of customer requests for agents to handle. By integrating your virtual call center with your customer support help desk, such as Zendesk, you can create a support ticket automatically from each phone call. Doing so will help you serve a higher number of customers by shortening the amount of time it takes to respond to requests.

Call center efficiency is largely based on calls being routed to the correct agent as quickly as possible. Using technology to customize how calls are routed is an easy way to optimize inbound call management. A virtual call center combined with the ability to customize call routing for things like time of call, caller location, marketing source driving the call, and agent skillset can get each caller to the agent who is best able to help. Ring multiple phones for a single agent or ring multiple agents at once makes sure that each call gets answered as quickly as possible.

Web-based reporting for a virtual call center enables managers to monitor agent success in real time, online. You can see how productive each agent is, the outcome of calls, and how your team is performing collectively.

By integrating a virtual call center with these other technologies and services you can ensure that the high number of calls during the holiday season is handled professionally and efficiently. Ifbyphone’s virtual call center, combined with the Voice360 platform, enables businesses of all sizes to operate a service center that is both scalable and cost efficient. To learn more about our virtual call center and Voice360 platform check out our white paper, Beyond the Cloud: The Next Generation of Virtual Call Centers.

The post Your Strategy for Managing High Call Volumes During the Holiday Season with an Integrated Virtual Call Center appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


The library is prevalent as a beacon of literacy in society. The library is accessible to everyone, whether to check out books for reading or to attend classes. People of all ages are welcome at the library, from the very young to the very old.

Libraries offer many programs to better society, including programs aimed at improving literacy, job searching, homework help, and more. Some examples of programs run by libraries include:

  • The Los Angeles Public Library, in partnership with Gale/Cengage, offers adults the opportunity to earn an accredited high school diploma and career certificate online (Source: LAPL)
  • De Bibliotheek and HEMA in the Netherlands offer free online courses in ICT and social media (Source: CODA)
  • The DC Library’s Story Time programs introduce young children to books, rhymes, music and other fun activities, increasing literacy at a young age (Source: DC Library)
  • Stockholm Public Library offers various programs aimed at young children, including special pre-school hours, and United Nations day for kindergartners (Source: Stockholms Stadsbibliotek)
  • Libraries in Barcelona offer courses and workshops on digital literacy (Source: Biblioteques de Barcelona)

With the economic crisis, libraries have faced all kinds of financial problems, leading to less staff and fewer opening hours. Consequently, the accessibility of the information the library has to offer becomes more important than ever, as visitors access more information by themselves at home or on the digital facilities at the library. In addition to the free programs offered by libraries, computers with Internet access are available for use by everyone.

ReadSpeaker works with libraries to increase accessibility by speech-enabling online content, with libraries including:

Get Your Free Guide:
Everything You Always Wanted to Know about Speech-Enabling Websites

Download Your Free Guide

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 27, 2014

bad customer serviceThis time of year, being scared is generally a good thing. Haunted houses, scary movies, ghost tours: a good fright is what everyone is after…unless you’re running a business. The last thing you want to do is scare your customers, no matter what time of the year it is, but the unfortunate truth is that many of us are doing things that are giving our customers nightmares and scaring them off. Poor customer service is high on the list of things that chase customers away, so here are some ways to keep them running toward you instead.

Customer Nightmare: Not Having a Phone Number on Your Website

Did you know that 61% of shoppers believe that it’s important for businesses to give them a phone number to call? What’s more, 33% would be less likely to use and refer brands that don’t offer a phone number. 57% of those that couldn’t speak to a real person say it has impacted their decision to buy. The truth is, customers simply don’t trust you without a phone number. It’s a sign of reliability and dependability. A phone number on your website separates the heroes from the perceived villains in this particular horror flick, so don’t be the good guy that everyone thinks is the bad guy.

Customer Nightmare: Eternal Hold Times

From a customer’s perspective, waiting on hold for a long time is the equivalent of a slow death—but it can actually mean a quick death for your business relationship if long hold times are the norm of your business. You may think your hold times aren’t so bad—but are they? Our recent benchmarking analysis showed that 15% of callers hang up right around 40 seconds of holding. Every second past that mark means you are risking losing a possible customer. Furthermore, a study by Accenture showed that 90% of customers are “increasingly frustrated” by long hold times. A frustrated customer is just one step away from not being a customer at all.

Customer Nightmare: Repeating Themselves Over and Over

The same study by Accenture showed that 89% of customers are “increasingly frustrated” by having to repeat their issue to multiple representatives. This is a major failure of customer service organizations, which is baffling when one considers how easy the solution is. Sophisticated call tracking and call management tools are cheap and easy to implement, and enable customer service reps to view caller information before answering the call—why are businesses not using them? If you’re scaring customers away when a solution is so simple, maybe you really are a monster.

Customer Nightmare: Never Hearing Back

Many customers fill out a form online when they want more information—especially in the absence of a phone number. But according to InsideSales, 55% of top companies don’t respond to web leads…despite the fact that 71% of online shoppers expect assistance within five minutes. Five minutes. Maybe that number scares you: it shouldn’t. Fast lead response is easy; you just have to care enough to make it happen.

One last stat: in 2013, 62% of global consumers switched service providers due to poor customer service experiences, up 4% from 2012. In a world of options, one scare will send a customer fleeing to the business that makes them feel safe. Want to stop terrifying your customers with poor customer service? Download this free white paper, Beyond the Cloud: The Next Generation of Virtual Call Centers.

The post Boo! Stop Scaring Your Customers Away with Bad Customer Service appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


When you publish a piece of web content, it has the potential to reach a wide, varied audience. That includes second-language readers, people of every education level, and people from all around the world. So choosing the right words, syntax, formatting, and structure is very important if you want web content to reach the maximum number of readers.

The US government’s Plain Language program is a great example of the “readability” concept in action. Through this program, agencies of the federal government aim to present vital information in the most accessible way possible.

What Is Plain Language?

In the simplest terms, it’s language that readers can understand the first time they read it. The Plain Writing Act of 2010 focuses on the improvement of language use in three key areas: regulations, health literacy, and financial information. On the program’s website, you’ll find a section dedicated to “before-and-afters,” where you can compare original documents to versions that have been updated in plain language.

How to Use Plain, Accessible Language

The program’s stated goal is to “improve communication from the federal government to the public,” but the concepts apply to every type of communication. Every element of a piece of communication can be tailored with accessible language and clear communication in mind. You’ve achieved plain language when your audience can “find what they need; understand what they find; and use what they find to meet their needs.”

  • Use common words, and avoid technical jargon whenever possible. If there’s no viable substitute for a technical term, be sure to clearly explain the term you choose.
  • Short sentences are easier to read than long ones. The same goes for short paragraphs. This is especially important for mobile devices, as large blocks of text are difficult for even experienced readers to follow on a small screen.
  • Use pronouns and write in the active voice to keep your readers engaged.
  • Make navigation and UI features easy to use. Include clear links to further resources for readers who need more information.

Plain Language Is Worth Your Time

In addition to improving government communication, the program’s website aims to inspire businesses and other organizations inside and outside of government to embrace accessible language practices. The site includes many training resources, from basic to high-level, to advance this goal. Like text to speech, plain language is an effective way to make your content and communications accessible to many members of your audience.

Get Your Free Guide:
Everything You Always Wanted to Know about Speech-Enabling Websites

Download Your Free Guide

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 24, 2014

loop beijingWhat does your bus ride sound like? Not the playlist you listen to on your bus ride, but the actual bus ride. LOOP Beijing asked this question to different commuters and artists to come up with a new interactive art-installation that connects Beijing commuters with the culture they create, powered by Twilio.org.

LOOP is exactly what it sounds like – a feedback loop that Xiaowei R. Wang and Ian Pearce designed as part of Beijing Design Week 2014. LOOP’s goal is to make Beijing commuters bus ride more than just a commute. A commuters bus route becomes an automotive art gallery that gives as much as you put into it. With 996 buses serving the 20 million people that live in the Beijing metropolitan area, there is no limit to potential galleries and potential contributors.

Commuters can listen to the soundtrack of their bus route as interpreted by local Beijing artists. LOOP commissioned several different bands to create soundscapes inspired by the bus. But, you don’t have to be in a band to contribute. Using Twilio, LOOP enables every commuter to add their voice, song, poetry or sound to their buses playlist.

LOOP uses Twilio Voice where users easily record and contribute an audio sample to their bus’s LOOP soundtrack by simply calling a Twilio powered number. Eliminating the barrier to contribution is key to LOOP’s mission of having a democratic, open source art exhibit on the bus. Anyone and everyone can easily contribute to the project without having to download an app, or use a smartphone.

Ian Pearce built LOOP using simple Twilio XML commands, Twilio Record, and a Sinatra server. The whole thing was up and running in just a few hours. Now that LOOP launched a few weeks ago Xiaowei and Ian are looking forward to the new pieces commuter-turned-artists will submit.

Learn more about LOOP here.

LOOP Brings Beijing The Soundtrack of Their Commute via Twilio

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Recruiters sort through thousands of job applications in search of the right candidate. When one recruiter receives 7,000 applications for one open position, the prospect of hunting for the right person in a sea of resumes can be daunting. To make the process manageable and efficient, they needed a communications platform to conduct interviews.

The recruiters who default to online application forms  in the hope of an easy way to find the right person for the job are lucky if 8% of job seekers complete them and these tend to be out of date, or incomplete, which gives recruiters little to work with.

The New Telephone Interviews

Leading UK based recruitment company, Recruitment Genius, saw that an automated, telephony-based candidate interviewing system would improve outcomes for recruiters and job seekers alike and implemented it using Twilio.

Recruitment Genius is the UK’s largest online recruitment company, helping over 8,800+ UK based companies fill over 60,000 jobs in the past two years. Their clients range from FTSE 100 companies to many other smaller but growing organizations specializing in IT solutions.

Recruitment Genius knew exactly who to contact to help streamline their application process. They reached out to Endjin, a software consultant agency who previously helped Recruitment Genius migrate their platform to Microsoft’s Cloud Platform, Azure.

Troubleshooting Customer Issues

Candidates were having trouble logging into their remote video interview, and filed support requests when they couldn’t join the interview. Support was flooded with ticket requests, but had no standardized data to look at and diagnose the candidate’s problem.

For each candidate, they spent 30 minutes comparing Twilio’s logs with Recruitment Genius’ platform’s logs. It didn’t scale. They needed a new way to gather and host their data. Using Twilio and data monitoring service, New Relic, Recruitment Genius cut down on their support time and had the new Twilio + New Relic integration up and running in two days. With the new solution, they cut down support’s response time to 1 minute.

Here’s how the system worked.

RecruitmentGenius_Lifecycle

Once a candidate calls Recruitment Genius’ Twilio number, Twilio kicks off a background process hosted in Microsoft Azure. If there are any hiccups, they’re logged in New Relic.

Then, Twilio relays a spoken message to the candidate informing them their interview is about to start.

Once the Twilio logs were visible to customer support, the agents saw clearly what the root of interview problems were. 90% of issues stemmed from candidates mistyping their interview pin code. With this information the User Experience changed candidate’s interview invite email to make pin codes more readable, and added instruction code. This drastically reduced the support team’s number of inbound tickets.

Real Endjn’s technical post on Troubleshooting Twilio With New Relic here

Recruitment Genius and Endjin Help Recruiters Land Candidates Using Twilio, Microsoft Azure and New Relic

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Feature Friday is a bi-weekly blog featuring a new video brought to you by our Customer Success Team (CST). CST focuses on tutorials and feature enhancements that help our customers gain a clear understanding of how exactly they can make their Ifbyphone experience perfect. After all, we strive to be the easiest company you’ll work with!

From your company name to the emails kept on file, Ifbyphone makes it easy to customize your account. These customizations aren’t just for cosmetic purposes, either. The emails kept on file will be where we send password resets and billing information, and you can change your password before you forget it. Follow along in this video to see how easy it is to keep your account information up to date and accurate.

The post Feature Friday: Customizing Your Account appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 23, 2014

FFN_Logo_transFantasy Football can be a cruel and fickle beast. At times it heightens the average fan’s experience watching games. The next game day, it brings them to crushing lows. For better or worse, it’s clear hundreds of thousands of fans are locked into the Fantasy Football roller coaster ride.

Joe Dyken, founder of Fantasy Football Nerd aims to give fantasy football diehards a competitive edge in their leagues by compiling all the leading fantasy data, sorting it via a slick API, and distributing it to fantasy football players.

Sweet Victory, Only One Text Away

Joe remembers the day that he was one text message short from winning gold in his fantasy football league. Joe was driving to Lambeau Field to see his beloved Packers play. In the time it took to get from his house to the stadium, the news broke that Rams’ running back Steven Jackson was injured. Joe missed the critical window to sub Jackson out from his starting lineup which cost him two points, and lost him the league’s championship.

Keeping Fantasy Football Fans In The Game

Joe hopes to save Fantasy Football Nerd users from the same tragic fate. He’s now using Twilio SMS to give FF Nerds alerts about player injuries 30 minutes before every game. All the pertinent information is included in one text message to save users from a bombardment of incoming SMS with each torn ACL, twisted ankle or elbow injury.

Joe recognizes that football is a game of inches, while Fantasy Football is a game of seconds. The hardcore fans troll Fantasy Football news sites every five minutes, but the average fan doesn’t do that. Joe hopes to save those fans the trouble of combing Twitter, by offering them proactive SMS alerts. The alerts are simple. You’ll get a text saying “FFN iAlert [Player] of the [Team] has been ruled inactive.”

Being on top of injury news is huge to the average player, and SMS notifications allow Joe to communicate with FF Nerd users instantly. Dyken remembers trying to build an SMS update feature a few years ago using a spreadsheet and a cobbled together API. “It was very cumbersome,” said Dyken. “It was more headaches that it was worth. Twilio took all the headaches I had in the past and eliminated them.” Using Twilio, Joe had the SMS alert feature up and running within 5-10 minutes.

While Dyken is happy that the alerts are working out for his users, he can’t help but imagine how that one fateful day driving to Lambeu field might have turned out differently if he had gotten a text alert. “Had Twilio and FF Nerd existed in that time, I would have gotten a text, put in a back up and won the championship.”

One Text Away From Glory: Fantasy Football Nerd Delivers Injury Updates Via Twilio SMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


As a Solution Architect at Twilio, I get asked about the building blocks of integrating Twilio into Salesforce…a lot. Some of the most common scenarios I get asked about are click-to-call, creating Call Centers within Salesforce’s OpenCTI, making outbound dialers, integrating SMS for creating cases and two way conversations, mobile marketing, to name a few.

Since Twilio is an API, and Salesforce is a platform, the sky is the limit on what you can do, but this blog post has  number of examples . The top part are resources for developers, below there are links for fully built solutions that use Twilio.

Resources for Developers

Twilio-SFDC Helper Library:  This is the “official” helper library.  Twilio has a number of helper libraries covering the major programming languages, including this one.

SFDC Click2dial:  Below is a step by step tutorial of how to implement OpenCTI with Twilio. Fork the code on GitHub here.

When you’re setting this up, agents will be using Click 2 Call in Salesforce and the SalesForce OpenCTI toolkit. You’ll use Twilio to easily make a phone call from within the browser, embedded in Salesforce.  The initial features are limited, which is intended to get developers up to speed on a development environment they can then customize to fit their needs.

Client-ACD: This sample app provides basic inbound call center functionality, implemented as OpenCTI for Salesforce.

This version is written in Ruby, hosted on Heroku, and and work as a Twilio Softphone within Salesforce (or outside of Salesforce).  It demonstrates several concepts, but an important one is agent state tracking and Automatic Call Distribution – sending an incoming call to an agent who is “Ready”.  It also has activity tracking in Salesforce and Salesforce screenpop information. See more on GitHub.

Salesforce Use Cases: SMS Alerts and Conference Calls

Ameer Badri, another Twilio solution architect, covers using SMS from within Salesforce in this post.

He’ll also show you how to create a conference call from Salesforce Cases, and save the recording.

IVR

In the presentation below, Patt Paterson (@metadaddy) covers the basics of building an IVR and sending SMS. This is definitely worth watching and a great starting point as it covers the full spectrum of integration.

Twilio Partners!

All of the above resources are tools for developing apps with Salesforce and Twilio and require development.  If you need a prebuilt solution for Salesforce and Twilio, there are lots of options, on the AppExchange.

Call Center:

SMS:

Marketing/Call Tracking:

Conference calling

Two Factor Authentication

If I missed a few ping me or comment, and we can update this with other SFDC/Salesforce integrations (focus on those that are on the AppExchange).

Salesforce and Twilio Resources: Communicating In and Outside of Salesforce

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Communication is a huge part of our lives and it is never more important than during times of need. When something bad happens or you need to make an important change in your life, communication is the medium with which you begin that process. We developed Rapid Response Kit to facilitate that communication during those times by providing a set of tools that could be downloaded and setup to provide some of most useful SMS and voice features one might want to use.

Sometimes though, SMS and voice calling isn’t the right tool for a job. For example, it might be easier to share a photo of a map rather than describe the directions. I hate to be clichéd but as the old adage says, “A picture is worth a thousand words”.

While looking at Rapid Response Kit, we had to ask ourselves “What value could MMS provide to people in emergency situations?” We already knew that updating a few existing tools to include MMS was useful, but building something new was paramount in our minds.  When something bad happens, communities create noticeboards with photos of missing family and loved ones, or pictures of useful information. Building a modern version of this would allow anyone with a phone to participate, so we decided to build a new tool called Noticeboard.

Let’s run through how we added MMS support to the Broadcast and Auto-Respond tools in Rapid Response Kit. We’ll also look a key feature of the new Noticeboard tool that uses inbound Twilio Webhook requests to extract media from the MMS messages.

What we’ll learn:

 

  • How to add MMS  to an existing Twilio REST API Request.
  • How to add MMS  to an existing TwiML document.
  • How to receive incoming MMS media from a Twilio webhook.

How to add MMS to an existing Twilio REST API Request.

 

The Broadcast tool allows users to quickly fire out SMS messages or voice calls to a list of numbers. This tool is one of the most useful tools in Rapid Response Kit due to the huge number of use cases it covers, for example: sending out “I’m okay!” phone calls to family and friends, or sending out the address of a meeting place in an SMS.

Wouldn’t it be great to able able to send out a picture as part of the broadcasted message? This would enable people to do new things such as sending out a picture of a loved one who is lost, or providing an image of a map for directions to a shelter.

Screen Shot 2014-10-22 at 15.png

To update the Broadcast app to support MMS, a new “Picture” field was added that takes a full path URL to an image on the web. A design decision to make this form field optional meant we needed to write some extra application logic to discover what is written in this field, most importantly, to make sure a real URL was being entered. The code needed to do this is pretty simple and can be seen on the highlighted line below. The full source can be seen on Github:

@app.route('/broadcast', methods=['POST'])
def do_broadcast():
    numbers = parse_numbers(request.form.get('numbers', ''))
    twiml = "<Response><Say>{}</Say></Response>"
    url = echo_twimlet(twiml.format(request.form.get('message', '')))
    media = check_is_valid_url(request.form.get('media', ''))

    client = twilio()

The function check_is_valid_url() wraps Python’s standard urlparse function to check that the submitted string is a URL. The string is considered a valid URL if the parsed scheme is  ‘http’ or ‘https’:

def check_is_valid_url(url):
    o = urlparse(url)
    if o.scheme in ['https', 'http']:
        return o.geturl()
    return None

If the string is not a URL, media becomes a type of None, an empty variable with unique properties. Now that we can get a valid URL, an extra parameter is added to the the REST API call creating a message:

client.messages.create(
    to=number,
    from_=request.form.get('twilio_number', None),
    body=request.form.get('message', ''),
    media_url=media,
)

It is good to explain what this will do. If the media value is a valid URL, then the string will contain the full path to an image. The Twilio Python Helper Library will then create a HTTP Request to Twilio asking it to send an MMS message to the to number. If however, the value is None, then the helper library will not generate an HTTP Request for MMS, but for SMS instead.

With that done (as well as adding in the new HTML form element) we’ve added optional MMS support to a piece of functionality that could only provide SMS, and all it took was a few extra lines of backend code.

How to add MMS support to an existing TwiML document

The Auto-Respond tool in Rapid Response Kit uses user provided input to generate TwiML that will automatically respond with whatever you want when your Twilio phone number is called or texted.  For example, a message with instructions on how to contact you, or detailed instructions on the best actions to take in a disaster scenario.

Adding MMS support to this tool is slightly different, as we’re not using the REST API anymore, we’re using TwiML instead. Once again we want to provide MMS support as an option, not as a requirement, so we’ll need to handle the optionality of the media value being empty. How can we do this and build the correct TwiML?

Screen Shot 2014-10-22 at 15.png

 

The input data is supplied by the HTML form above, so the first we’ll need to do is get the input values from that form and then use the the Response builder in the Python helper library to create our response, like so:

twiml_response = Response()
sms_message = request.form.get('body', '')
mms_url = check_is_valid_url(request.form.get('media', ''))
if mms_url:
    twiml_response.message(sms_message).media(mms_url)
else:
    twiml_response.message(sms_message)
return twiml_response.toxml()

You can see the entire code for this on Github here, but the bit we care about is written above. What exactly is this code doing? On line 1 a new Response object is instantiated as the twiml_response variable. Line 2 and 3 collect the body and media values from the form submission. We’re using the same check_is_valid_url function as before to determine that the string given in the media input is a valid URL.

We then compare the results of the mms_url variable to see if it has any content in it, and if it does (which means we have a valid URL) we use the twiml_response object to generate a message with media:

<?xml version=”1.0” encoding=”UTF-8”?>
<Response>
  <Message>
    <Body>I am the night!</Body>
    <Media>http://i.imgur.com/sTWG4MN.jpg</Media>
  <Message>
</Response>

If the mms_url is None (AKA – empty) then we just generate a standard message:

<?xml version=”1.0” encoding=”UTF-8”?>
<Response>
  <Message>
    <Body>I am the night!</Body>
  </Message>
</Response>

Finally, we’re returning an xml version of the twiml_response object using the toxml() method.

There you have it: MMS support can be added to an existing TwiML document with just a few tiny changes.

How to receive incoming MMS media from a Twilio webhook

 

Finally, lets look at Noticeboard, the newest tool we’ve add to Rapid Response Kit. It acts as a virtual noticeboard for people to post pictures of missing family, loved ones, or items. It can even be used just to share any media content with an audience. By using MMS as the medium for sharing these images, anyone with a phone is able to participate.

Part of the functionality of Noticeboard is to receive Twilio webhook requests whenever a new MMS message is sent to the Twilio number being used for the tool. If you’re familiar with handling these webhook requests, you probably already know that data about the inbound SMS or voice call is packaged up in the POST parameters of the HTTP request you receive. The same also applies for the MMS media that is delivered to you.

If media is being sent to us from a Twilio webhook request, we will see the following extra POST parameters in the incoming HTTP request:

In our code, we only want to get the first image from the incoming message so we will check to see if the parameter MediaUrl0 is included in the request.  If you wanted to share multiple images, you could loop through all of the included MediaUrl{N} parameters using the NumMedia parameter to know how many times to loop.

Let’s see how this was programmed in Rapid Response Kit. Feel free to check out the the full code on Github.

@app.route('/noticeboard/post', methods=['POST'])
def handle_noticeboard_inbound():

    pusher_key = app.config.get('PUSHER_KEY', None)
    pusher_secret = app.config.get('PUSHER_SECRET', None)
    pusher_app_id = app.config.get('PUSHER_APP_ID', None)

    p = Pusher(pusher_app_id, pusher_key, pusher_secret)

    p['rrk_noticeboard_live'].trigger(
        'new_message',
        {
            'image': request.values.get('MediaUrl0', None),
            'body': request.values.get('Body', None),
            'from': request.values.get('From', None)
        }
    )

    to = request.values.get('To','')
    r = Response()
    r.message(
        '''Thank you, your image has been posted
        to {0}noticeboard/live/{1}'''.format(request.url_root, to))

    return r.toxml()

To accept incoming MMS messages we created the handle_noticeboard_inbound() function which is linked to the route ‘/noticeboard/post’. This route receives the HTTP requests Twilio makes each time a user sends a message to our phone number.

When a request is made to this route, the function extracts the media URL, message body and the phone number of the sender from the request and uses Pusher to send that data to a web page that displays the images. Finally we create a simple TwiML message response with a link to the webpage and return it back to Twilio, who then passes the message back to the user as an SMS.

To test this new functionality I used hurl.it, a website that allows me to simulate the HTTP requests made by Twilio to my test server. Here is an example of the parameters I set up in hurl.it:

 

Voila: thats all it took to create a new tool in the Rapid Response Kit that uses inbound MMS messaging to accept photos and display them on a web page.

What we’ve just learned

Rapid Response Kit is a great set of tools for enabling communications when it is needed the most. Adding MMS messaging to the collection of communication mediums it provides will help to bring more value to the tool kit. The multiple methods of updating Rapid Response Kit that we covered are also some of the most common ways a Twilio application can be updated to support MMS:

  • Sending MMS messages with Twilio REST API calls.
  • Creating MMS message replies with TwiML.
  • Handling MMS in inbound Twilio webhook requests.

We used our Rapid Response Kit tool as an example of how this can be done with Python, but adding MMS to your Twilio application in any language should take almost no time at all, after all – we’re just handling HTTP requests and responses. Don’t forget to download the Rapid Response Kit and give it a whirl, it’s a great example of some of the tools that can be built with Twilio and it takes two minutes to install.

If you’d like more advice on how to adapt your Twilio application to handle MMS, or if you want to show me an interesting MMS app you’ve been working on, get in touch with me at paul@twilio.com, or find me on Twitter.

Adding MMS Support To The Twilio.org Rapid Response Kit

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


mobile searchYou can’t afford to not use customer location data to efficiently route incoming calls to your business. Why? If your business has multiple stores or offices within a city, region, or even across the country, it is highly likely that directing inbound callers to their closest location is of interest to you. Or maybe you run a sales team where you assign leads to agents based on geographic territory. Geo-location can determine the precise geographic location of mobile callers and route their call to your closest or most appropriate store, franchise, office, or agent.

How does it work, and why does it matter for your business? Read on and learn.

Geo-Location: Why It’s Important and How It Works

Smartphones are driving more searches than ever before, with mobile search volume expected to surpass desktop by 2015. And those searches drive calls. Google says 70% of mobile searchers have clicked the “call button,” and BIA/Kelsey estimates that mobile search alone will drive 75 billion calls to U.S. businesses by 2018. What’s more, Google says that 50% of all mobile searches have local intent, meaning they are looking for a business near them. This growing audience of mobile callers will require relevance and convenience when calling your business from their smartphones – and geo-location technology is the answer.

Here’s how it works for mobile search:

  1. A consumer finds your paid or organic listing after running a search on their smartphone.
  2. They tap on the click-to-call button in your listing or click through to your site and call you.
  3. Cell phone triangulation pinpoints a smartphone user’s exact latitude and longitude.
  4. The call is automatically routed to the closest or most appropriate store, franchise, office, or agent.

With geo-location you’ll be able to get callers to the right store, office, or agent – and fast.

Relevance: Create a Better Experience for Customers and Agents

A key benefit of routing inbound calls based on a caller’s location is that you are automatically creating a more relevant experience for customers and agents alike. Customers are immediately put in contact with the store nearest them and are not bounced around location-to-location over the phone. Similarly, your sales agents are going to have a more relevant experience with callers if the calls they are receiving are actually meant for them. They won’t have to waste their time trying to find which location the caller meant to contact and then directing them there manually.

Or let’s say you have locations across the country. Combining geo-location with routing calls by time of day can detect a caller trying to contact you after close of business in Charlotte, for example, and direct them to an open office in Sacramento. The caller reaching a live agent (regardless of office location) could be the difference in making the sale or not.

Simplicity: Advertise One Number

Have multiple locations or franchises? Gone is the day when you have to list a phone number for each of your locations to ensure callers are getting to the most appropriate location for them. With geo-location you can advertise one phone number for your business that works for every store by automatically routing mobile callers to the nearest location.

A single phone number is effortless for you to implement and drives convenience for your customers. With a growing mobile audience, this can help eliminate any confusion they may experience picking a number from a long list – and then they will always associate that one number with your business. What’s more, using a single number further helps reduce the amount of time your agents waste on transferring callers to the correct location.

Include Call Tracking To Optimize Your Marketing

Pair your use of geo-location with call tracking technology and you will have marketing gold for your business. Call tracking ensures proper attribution and allows you to accurately measure the source of the lead type 66% of sales managers consider most valuable: phone calls (BIA/Kelsey). Whether it’s an ad, search keyword, web page, or marketing campaign, you’ll be able to optimize your marketing for what is working best to drive those high-quality phone calls.

If you’ve ever asked yourself how you can more efficiently connect mobile callers to the closest location or streamline how your agents are handling calls, the answer is incorporating geo-location technology into your voice-based marketing automation strategy. Interested in using geo-location to your advantage? Request a demo today to see it in action.

The post Geo-Location Is the Answer to Connecting Mobile Callers With Your Nearest Store, Office, or Agent appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 22, 2014

The days of leather bound photo albums are all but gone. Now, people house their prized photos on hard drives, in iPhoto and online. Collage.com makes it easy for anyone to turn those photos into wallpaper, posters and other gifts in a simple web app.

A majority of the photos you publish to social networks are stored on your camera – which is almost always your phone. Collage.com wanted to give their users a direct and secure way to upload photos from their phone to their Collage.com account, without having to open an app or go to their computer. Using Twilio MMS, uploading a photo is as easy as sending a text.

“From customer feedback we know how difficult it can be for users – especially non-techincal ones – to organize and upload photos to yet another service,” said Craig Schroeder, Software Developer at Collage.com “We have seen a very positive response from those that use MMS to upload photos. We have fewer support requests from users that choose this method because they are so familiar with how to send picture messages.”

To get their photos from their phone to their account, all Collage.com users have to do is send a photo to Collage.com’s Twilio number and include a unique code that Collage.com provides. That’s it. From then on out, users can just send pictures to that same Twilio number to upload them to Collage.com.

Users have already uploaded over 41,000 images in the 2 months since Collage.com launched their MMS feature. While Craig admits the numbers aren’t astronomical, the feedback is something they’re taking seriously. “This medium opens up opportunities to interact with our users unlike anything else we have in place,” says Craig.

From Phone To Print: Collage.com Gives Their Users A Direct Way To Make Beautiful Photo Gifts via Twilio MMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


If you read my post showing how to send SMS messages using Go you know I’ve been spending 2014 learning Go and having tons of fun doing it. My most recent project has been using Go to make and receive phone calls using Twilio. One great thing about working on this is that it required me to learn how to build a basic Go webserver. In this post I’ll show you what I’ve learned and before you know it you’ll be making and receiving phone calls from your Go apps too.

Our Tools

  • Go running on your local machine
  • A Twilio Account – Sign up for free!
  • Ngrok to expose your localhost to Twilio

A Basic Web Server

When a user makes a phone call to your Twilio phone number we ask your server for some basic instructions of what to do with that phone call. In order to do this with Go we need to set up a basic web server. Fortunately Go’s net/http library makes this really easy.

Fire up your favorite text editor and create a new file called main.go. We’ll start it off by declaring our package and importing the net/http package:

package main

import (
  "net/http"
)

Now we’ll write the code that listens for a request to a certain route and responds with some plain text:

func main() {
  http.HandleFunc("/twiml", twiml)
  http.ListenAndServe(":3000", nil)
}

func twiml(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("Hello World!"))
}

We create a new function called main. Our main function will be called when our app runs. Inside this function we call http.HandleFunc. http.HandleFunc takes two arguments – the route you want to listen for and the name of the function. If you’re wondering why I’m using the word twiml here, don’t worry it’ll make sense soon. Next we call http.ListenAndServe to start up our server. We’re passing :3000 to listen on port 3000.

Next, we have our twiml function that we said we would use to respond to requests to /twiml. In this case, we’re using the http.ResponseWriter to print out the text “Hello World!”. Let’s run our app to make sure this code works:

go run main.go

Now browse to localhost:3000/twiml and you should see “Hello World!” in your browser.

Speaking Twilio’s Language

Now that we have our basic web server in place we can start building a response that Twilio can understand. This is where TwiML comes in. TwiML is our own subset of XML that lets you provide some basic instructions for Twilio to take when a phone call or message comes in. Let’s update our code to respond to requests to /twiml with TwiML instead of plaintext.

First we need to create a new struct we’ll use to define our TwiML. We can do this right after our imports in main.go. If you haven’t used the backtick character in a long time you can find it on your keyboard next to the number 1:

type TwiML struct {
  XMLName xml.Name `xml:"Response"`

  Say    string `xml:",omitempty"`
}

TwiML contains many different verbs, but in this example we’ll be using the verb <Say>. <Say> let’s you use text-to-speech to say something to the user on your call. Inside our struct we define a string called Say. Go has some awesome tools for converting structs to XML that we’ll be taking advantage of. In our struct we define our XMLName – this will be the root tag it uses when our struct is converted to XML. We also use the xml attribute omitempty on our Say property to make sure we’re not passing along any unneeded tags in the future. In order to take advantage of the XML encoding, we need to add the encoding/xml package to our imports:

import (
  "encoding/xml"
  "net/http"
)

Now we can update our twiml function we wrote earlier to respond with XML:

func twiml(w http.ResponseWriter, r *http.Request) {
  twiml := TwiML{Say: "Hello World!"}
  x, err := xml.Marshal(twiml)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }

  w.Header().Set("Content-Type", "application/xml")
  w.Write(x)
}

First we create a new TwiML struct with a Say value of “Hello World!”. Then we call xml.Marshal and pass it our struct. This will attempt to convert our struct to XML. If there’s an error with this conversion we’ll send an http.Error. Otherwise, we want to set our Content-Type header to application/xml so that Twilio knows we’re responding with XML. Finally, we’ll actually write the xml content that we generated.

Fire up your app again:

go run main.go

Browse to localhost:3000/twiml and instead of plaintext you should now see the XML response we want to give to Twilio.

For Twilio to access this URL, we need it to be exposed to the outside world. One of the best tools to make this happen is called ngrok. If you haven’t worked with ngrok before let my good friends Kevin Whinnery and Bo Jackson show you how. Make sure you register for a free account so you can use the incredibly helpful subdomain flag. Once you have ngrok setup run it with the following command:

ngrok -subdomain=asubdomainofyourchoice 3000

Now hop into your Twilio account and set up a new number. Configure the voice request URL for this number to your publicly accessible Go URL from ngrok that’s serving your TwiML:

Give that number a call and listen to the beautiful robot voice say ‘hello world’.

Making a Call Using Twilio

Now that we can receive a call let’s use the Twilio REST API to make a phone call. We need to write code that makes a POST request to the Calls resource. We’ll be using a few packages to make this happen, let’s start off by adding them to our imports at the beginning of the file:

import (
  "encoding/xml"
  "net/http"
  "net/url"
  "fmt"
  "strings"
  "io/ioutil"
  "encoding/json"
)

Now we can create a new function called call where our code that makes the POST request will live. We’ll start off with some default variables:

func call(w http.ResponseWriter, r *http.Request) {
  // Let's set some initial default variables
  accountSid := "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  authToken := "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY"
  urlStr := "https://api.twilio.com/2010-04-01/Accounts/" + accountSid + "/Calls.json"

}

We’re setting our Twilio accountSid and authToken – you can find these in your Twilio Account Dashboard. Then we build out the urlStr for the Calls resource, this is where we’ll be making our POST request to.

Next let’s set the data we want to use in our request:

// Build out the data for our message
v := url.Values{}
v.Set("To","+155555555555")
v.Set("From","+15555551234")
v.Set("Url","[CHANGE_TO_YOUR_NGROK_URL]/twiml")
rb := *strings.NewReader(v.Encode())

We’ll be passing 3 pieces of information:

  • To – the phone number you want to make the call to.
  • From – The phone number you want to call from. The Twilio number you set up earlier.
  • Url – A URL that returns TwiML instructing Twilio what to do once this call connects. We’ll use the same ngrok TwiML url we used for our outgoing call.

Finally, let’s use Go’s http.Client to make a request:

// Create Client
client := &http.Client{}
req, _ := http.NewRequest("POST", urlStr, &rb)
req.SetBasicAuth(accountSid, authToken)
req.Header.Add("Accept", "application/json")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

// make request
resp, _ := client.Do(req)
if( resp.StatusCode >= 200 && resp.StatusCode < 300 ) {
  var data map[string]interface{}
  bodyBytes, _ := ioutil.ReadAll(resp.Body)
  err := json.Unmarshal(bodyBytes, &data)
  if( err == nil ) {
    fmt.Println(data["sid"])
  }
} else {
  fmt.Println(resp.Status);
  w.Write([]byte("Go Royals!"))
}

We create a new request with a method of POST, our urlStr as the destination and the data we set earlier. We set our authentication and make sure to set our headers correctly. Once we make our request we confirm we got a 200 and if we do parse the response body using json.Unmarshal.

We’re all set to make a call to someone and play an mp3. Let’s add a new route to our web server that we’ll hit to trigger our call:

func main() {
  http.HandleFunc("/twiml", foo)
  http.HandleFunc("/call", call);
  http.ListenAndServe(":3000", nil)
}

Now browse to localhost:3000/call and wait for your phone to ring. When we triggered this request right now we hear our robotic voice again. Let’s update our code to switch the TwiML to use the <Play> verb to play an mp3. First we need to add a new Play property to our TwiML struct:

type TwiML struct {
 XMLName xml.Name `xml:"Response"`

 Say    string `xml:",omitempty"`
 Play   string `xml:",omitempty"`
}

Now that we have our Play property, we can change our twiml function to use it instead of Say:

func twiml(w http.ResponseWriter, r *http.Request) {
 twiml := TwiML{Play: "http://demo.rickyrobinett.com/huh.mp3"}

 x, err := xml.MarshalIndent(twiml, "", "  ")
 if err != nil {
   http.Error(w, err.Error(), http.StatusInternalServerError)
   return
 }
 w.Header().Set("Content-Type", "application/xml")
 w.Write(x)
}

Now browse to localhost:3000/call again. If you didn’t change out the mp3 file in my sample then you should get a glorious message from 1987. Having issues? Take a look at the final code here.

Conclusion

Now that you have the ability to make and receive phone calls from Go what will you build? Maybe something simple like a wakeup call. Or something complex like an IVR or call center. Whatever you build, I’d love to see it. You can find me hanging on twitter or hit me up on e-mail.

Making and Receiving Phone Calls With Golang

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Omnichannel RetailingHave you ever gone to a store to make a purchase and then hopped on your smartphone while in the store to make sure you were getting the best deal? Have you ever found a better deal online from a different retailer and then changed your mind about your planned in-store purchase? This kind of behavior, known as showrooming, is happening more and more often with the rise of smartphones, tablets, and the popularity of ecommerce and online shopping. It plays a major role in omnichannel retailing.

To give you a better idea of what omnichannel retailing is I’ve included the Wikipedia definition below:

Omnichannel Retailing is the evolution of multi-channel retailing, but is concentrated more on a seamless approach to the consumer experience through all available shopping channels, i.e. mobile internet devices, computers, brick-and-mortar, television, radio, direct mail, catalogue and so on.

What does omnichannel retailing mean for marketers? It means that the line between online and offline purchasing has been erased, and marketing needs to reach your target audience everywhere they are looking. Since shoppers are making decisions about in-store purchases on their smartphones, it’s easy for shoppers to change their minds about where they will complete their purchase, causing retailers to lose sales to the competition. Consider these stats:

  • 88% of shoppers research online and purchase in-store
  • 73% browse products in stores before buying online
  • 32% of shoppers have changed their mind about a purchase after researching via mobile while in a store

(Sources: Accenture 2014, Tradedoubler 2014)

Since purchasing decisions are no longer made strictly in one place, it’s now vital for marketers to build a mobile-optimized marketing strategy concentrated on converting omnichannel shoppers.

Omnichannel Sales Means Mobile Marketing Optimization

Getting omnichannel shoppers to convert with your business means having a serious strategy for mobile optimization. This means your website, your display and search ad campaigns, email marketing, and more all need to be optimized for users on smartphone and tablet devices.

  • 60% of the time that Americans spend with online retail occurs on mobile devices (source: comScore, 2014)
  • Mobile shoppers convert 160% more often on sites optimized for smartphones (source: NetElixir, 2014)
  • Average order value from smartphones on mobile-optimized sites is 102% of the average order for desktop sites (source: NetElixir, 2014)

Consider this: people already in a physical store looking to make a purchase would prefer to get what they are looking for in that moment, rather than waiting to order online and have the product shipped to them. However, if this customer sees a better deal online from another retailer, they most likely will not pay more for the same product. There are ways to combat this kind of mobile showrooming:

  • Offer price matching to speed up the sale process and encourage in-store conversion
  • Offer promotions and incentives for making a purchase in-store (receive 10% off your next visit, free 2-year warranty, etc.)
  • Implement an iBeacon strategy to offer coupons or other incentives to buy for people currently shopping in your store
  • Run a display campaign with in-store purchase offers for the products your customers search most

Win More Sales With an Omnichannel Strategy Focused on Smartphone Users

Winning sales from omnichannel shopping means more than optimizing for mobile, it means making it easy for customers to make their purchase fast, or get in touch with you immediately if they have questions. Since these shoppers are often on their smartphones, making it easy for them to call is the easiest and most obvious form of fast customer service.

  • 61% believe it’s important that businesses give them a phone number to call
  • 33% would be less likely to use and refer brands that don’t
  • 52% of those that couldn’t speak to a real person say it has impacted their decision to buy

Making it easy to connect with your business via phone can be accomplished in a few different ways. For example, if someone searches for your store in Chicago and you have locations across the country, make sure the searcher sees your store location nearest to them and a phone number with a local area code. You can also use click-to-call links you make it easy for customers to call your business from their smartphone, while increasing your chances of closing the sale. A recent study by Google showed that people who make mobile searches are 39% more likely to call a business and 51% more likely to make a purchase. That means smartphone leads have immediacy in mind. When people are making purchasing decisions on their phone and have a question, they need an immediate answer. That’s why having phone numbers displayed prominently throughout the online checkout process is important – so people have immediate access to someone who can answer their questions, and help them complete their purchase.

To learn more about omnichannel retail and what it means for your business download the free on-demand webinar, “Smartphones & Omnichannel Retail: 7 Tips to Optimize Sales in a Mobile World.

The post Smartphones Erase the Line Between Online and Offline Purchasing for Omnichannel Retail appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 21, 2014

Toronto-based startup Unified Computer Intelligence last week launched Ubi, a new smart home device that lets users speak voice commands to do things like turn up the heat or open the blinds. The Ubi, which uses the latest in voice recognition, speech triggering, natural language understanding, and speech synthesis, is meant as an easy way […]

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


We’re having a baby!

Sometime in the next four weeks, my wife is going to go into labor. We’ll wait at home for as long as possible, then hop in the car and head to the hospital. At that point begins one of my comparatively few responsibilities for Team Baugues over the next couple days: updating close friends and family of what’s going on.

Of course, after our baby is born we’ll announce on Facebook and Twitter, and I’m sure an email or two will go out. But there are a couple dozen people who are going to want more than an “all done” update on the day after. They’ll want to know when we’re headed to the hospital, how Rachel’s doing along the way, and they’ll want to know that “FIRST MIDDLE Baugues was born at X:XX weighing Y pounds and Z ounces” long before I even think about updating Facebook.

Text messaging seems tailor made for times like these. Unfortunately, texting gets messy when it involves a group of people. I’m simply not going to maintain twenty message threads while my wife’s giving birth. At the same time, I don’t want to include everyone on a single mass-text, blowing up twenty peoples’ phones with the “Congratulations!” of nineteen others.

Broadcast Texts with Twilio

To solve my message “delivery” problems, I’m building a group messaging app using Twilio, Ruby and Sinatra that will let me send one-to-many messages when I make an announcement, and a one-to-one message when my friends text back. And now that Twilio supports MMS, I can send pictures.

Now, I’m building this app to make my life easier on baby day (and if you’d like to see an even more tricked out version of this concept, check out Jarod Reyes’ baby notifier repo. Also, that picture you see up there, that’s Jarod’s son.) That said, text broadcasting has tons more uses than this: emergency management, teachers communicating with students, or talking trash with your fantasy football league to name a few.

In this tutorial, you’re going to build an app to broadcast text messages using Sinatra, Google Docs, and Twilio. This app will:

  • Retrieve contact names and numbers from a Google Spreadsheet
  • Forward a message from your phone to all your contacts
  • Forward a message from one of your contacts to your phone

Here’s what you’ll need to get started:

The rest of this post will walk you through how to write this code line by line. If you’d like to jump to the finished product, check out my Text Message Broadcast GitHub repo. Also, at the bottom of this post you’ll find a Deploy to Heroku button that will get your own broadcast app live in minutes.

Retrieve contacts from a Google Spreadsheet

You could hard code your friends and family’s phone numbers, but that means re-deploying every time you want to add an aunt to the list. Who has time for that when there’s a baby on the way?

A while back I was inspired by this tweet by Patrick McKenzie, a longtime friend of Twilio who recently welcomed his own daughter into the world (Congrats Patrick!):

Screen Shot 2014-10-20 at 11.15.59 PM

Perfect!

Open Google Drive and create a new spreadsheet with two columns named ‘number’ and ‘name’ (it’s important that you give your columns these names and in this order — you’ll see why soon). Punch in a couple numbers to play with — when I was building my app, I used my cell phone and my wife’s cell phone. No point in spamming my friends during development.

Click File -> Publish to Web and you’ll see a link to a publicly accessible version of your document. Unfortunately the document at the other end of this link is not in JSON, but I found this article on How to Use Google Spreadsheet as a JSON backend that tells us how to fix that that.

In the middle of that link (and in the url in the navbar of your browser) is an ID for your spreadsheet: spreadsheet-id You’re going to need that ID in a few minutes. First, open a terminal window and create a new directory for this project. In that directory create new file called broadcast.rb:

mkdir text-broadcast
cd text-broadcast
touch broadcast.rb

Open broadcast.rb and:

  • require the libraries needed to open a uri and parse json
  • define a constant for your spreadsheet ID
  • create a method to return the url of the spreadsheet data in JSON format

require 'json'
require 'open-uri'

SPREADSHEET_ID = '1Uwn2bBpCFNvC4P71gqXFEJuFF-XXXXXXXXXXX-iffg'

def spreadsheet_url
  "https://spreadsheets.google.com/feeds/list/#{SPREADSHEET_ID}/od6/public/values?alt=json"
end

Twilio expects ten digit phone numbers sans punctuation and spaces, prefixed with with a valid country code ( “+1” for the US). Let’s create a method that will add the country code and strip out non-digits. We’ll also strip off any leading ’1′ so that we don’t end up with the country code on there twice.

Add this to the bottom of your code:

def sanitize(number)
  "+1" + number.gsub(/^1|\D/, "")
end

Next, create two methods to:

  • open the spreadsheet and parse the JSON data
  • iterate through each spreadsheet entry
  • extract the values for each number and name
  • return the pairs as a hash

def data_from_spreadsheet
  file = open(spreadsheet_url).read
  JSON.parse(file)
end

def contacts_from_spreadsheet
  contacts = {}
  data_from_spreadsheet['feed']['entry'].each do |entry|
    name = entry['gsx$name']['$t']
    number = entry['gsx$number']['$t']
    contacts[sanitize(number)] = name
  end
  contacts
end

When run, contacts_from_spreadsheets returns a hash in the format of:

{
  '13178675309' => 'Dad', 
  '13175392342' => 'Mom'
}

For the sake of verbosity, create two simple methods to:

  • return an array of all of our contacts’ phone numbers
  • look up a contact’s name given their phone number

def contacts_numbers
  contacts_from_spreadsheet.keys
end

def contact_name(number)
  contacts_from_spreadsheet[number]
end

And that’s it for Google! If you want to give this a go, load this file in irb and try running each of the methods:

irb
load './broadcast.rb'
puts contacts_from_spreadsheet
puts contacts_numbers
puts contact_name(contacts_numbers.first)

You’ve got an easy-to-maintain phonebook in the form of a Google Spreadsheet. Now let’s do something with those numbers.

Broadcast text messages using Sinatra and Twilio

One thing that’s surprised me since starting at Twilio is how useful Sinatra can be for building Twilio apps. I’ve always been more of a Rails guy, but it turns out that with Sinatra + Twilio you can build some pretty powerful apps in a single file.

To get started, create a Gemfile. It’s a simple app, so you won’t need much:

# Gemfile
source 'https://rubygems.org'
ruby '2.1.2'
gem 'rack'
gem 'sinatra'
gem 'twilio-ruby'

Then install your gems from a terminal:

bundle install

Add two more requires to your broadcast.rb, then add a new constant for your cellphone number: 

require 'sinatra'
require 'twilio-ruby'

MY_NUMBER = '+1312XXXXXXX'

When your Twilio number receives a text, Twilio makes an HTTP request to your server. In the parameters of that request you can find details about the message in the same way that you would find data from from a form submission. Just as a web browser makes an HTTP request and expects an HTTP response in the form of HTML, Twilio expects a response in a form of Twilio-flavored XML that we call TwiML. For example, the generic TwiML to send a single message looks like this:

<Response>
  <Message to='+13128675309' from='+1TWILIONUM'>
    <Body>Look at our new baby!!!</Body>
    <Media>http://imgur.com/cutebabypic.png</Media>
  </Message>
</Response>

If you want to send multiple messages then you simply add more message blocks inside the response tag. If there’s no picture, you omit the <media> tag.

With that roadmap in mind, create a method that will:

  • handle Twilio’s POST request
  • extract the message details
  • call yet-to-be-defined methods to generate instructions on where to forward the messages
  • return those instructions to Twilio as an XML response

post '/message' do
  from = params['From']
  body = params['Body']
  media_url = params['MediaUrl0']

  if from == MY_NUMBER
    twiml = send_to_contacts(body, media_url)
  else
    twiml = send_to_me(from, body, media_url)
  end

  content_type 'text/xml'
  twiml
end

Now let’s create your send_to_contacts method which will:

  • accept a message body and (optional) media_url as arguments
  • iterate through your contacts’ numbers and…
  • … send a message to each number with the appropriate message body and media_url (unless it’s nil)
  • return the text of the generated TwiML response

Thanks to the Twilio Ruby gem, you won’t have to write TwiML by hand.

def send_to_contacts(body, media_url = nil)
  response = Twilio::TwiML::Response.new do |r|
    contacts_numbers.each do |num|
      r.Message to: num do |msg|
        msg.Body body
        msg.Media media_url unless media_url.nil?
      end
    end
  end
  response.text
end

Onto the second use case: a friend texts your Twilio number and you want to forward that message to your cell phone and your cell phone only. Now, when that message shows up on your phone it’s going to be from your Twilio number, so you’ll want to prepend the message body with the sender’s info.

def send_to_me(from, body, media_url = nil)
  name = contact_name(from)
  body = "#{name} (#{from}):\n#{body}"
  response = Twilio::TwiML::Response.new do |r|
    r.Message to: MY_NUMBER do |msg|
      msg.Body body
      msg.Media media_url unless media_url.nil?
    end
  end
  response.text
end

And that’s it for the Ruby code! Open a terminal and fire up your Sinatra server:

ruby broadcast.rb

Make it Live

There are only two more steps needed to make your broadcast system operational from your development machine:

  • make your Sinatra server accessible to the public Internet
  • tell Twilio where to find it

There are a number of ways to do the former, but my favorite is to use ngrok. If you haven’t used ngrok before, this article from Kevin Whinnery will show you how to set it up in less than five minutes. I highly recommend registering for a free ngrok account so that you can take advantage of the subdomain flag which will prevent you from needing to update your webhook settings in Twilio everytime you restart ngrok. Once you’ve installed ngrok, start it up and point it at Sinatra’s default port, 4567:

ngrok -subdomain=example 4567

Finally, tell Twilio where to find your webserver when it gets an incoming text:

webhook

That’s it! Save your settings and send a text to your Twilio number. The numbers you defined in your spreadsheet should get a copy of the message. Reply from a number that’s not MY_NUMBER and you should get that message only on your cellphone. Now try it with a picture.

Deploy to Heroku

In order for this app to be useful when your computer’s offline, you’re going to have to get it off of your development machine and into the cloud. The easiest way to deploy the stock version of this app (found at my GitHub repo) is to click this button:

Deploy

(Props to Heroku for that little piece of magic.)

Once you’ve done that, you’ll need set environment variables for MY_NUMBER and SPREADSHEET_ID:

  • go to the dashboard for your Heroku app
  • click Settings at the top right of the page
  • click Reveal Config Vars
  • click Edit
  • Add MY_NUMBER and your cellphone in the format of: +1XXXYYYZZZZ
  • Add SPREADSHEET_ID

heroku-config

Then, in your Twilio dashbaord, point the messaging URL for your Twilio number to http://yourherokuapp.herokuapp.com/messaging. 

Onward

Congrats! You now can blast out text and picture messages to friends and family while maintaining your contacts as easily as updating a spreadsheet. I hope it’s as useful for you as I imagine it will be for me in a few weeks.

If you run into any problems along the way, have a cool story to share about how you’ve used this app or if you have any tips on how to survive the first few weeks of parenthood, hit me up at gb@twilio.com or @greggyb. Fair warning though, I may be a bit preoccupied starting around mid-November.

 


Cover photo by: Claire SuniBaby by: Jarod Reyes.

“It’s a Boy!” How to Broadcast Text Messages using Ruby, Google Spreadsheets and MMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


CMOsEvery year IBM releases the key findings from their Global C-suite Study and everyone scrambles to dig through it to find that one piece of information that might change their entire marketing strategy. To save you some time, we’ve picked five key takeaways from the study of 4,183 top executives from more than 20 industries so you can learn how the big dogs are earning the loyalty of “digitally enfranchised customers and citizens.” Let us know in the comments if you’re a CMO—or another C-suite exec—who has some thoughts about what it means to be a CMO in this changing world of marketing.

1. CMOs influence CEOs more than almost any other exec.

CEOs are increasingly calling on CMOs for strategic input, according to the study. In fact, CMOs are “second only to the CFO in terms of the influence he or she exerts on the CEO.” 63% of the CMOs surveyed are involved in business strategy development, so this means it’s more important than ever for CMOs to have access to flawless data. After all, if the CEO is going to lean on the head of marketing for advice when major decisions are being made, then the data those decisions are made from needs to be solid. In this new era of the CMO’s role, all marketing successes, without exception, need to be able to be attributable. Marketers have access to all kinds of tools to help with this—clickstream reporting, advanced call tracking abilities, Google Analytics integrations—and this section of the study reinforced the fact that CMOs, more than ever, need to be on top of all the ways to prevent making important decisions on bad data.

2. Very few CMOs have implemented key components of a digital strategy.

This is an unfortunate point to be made, but one that is important for CMOs to hear: when it comes to implementing advanced analytics to capture customer insight across all touchpoints, a whopping 88% of CMOs only “somewhat” or “to a limited extent” explored those avenues. What’s more, only 16% of CMOs have integrated customer touchpoints across physical and digital channels to what they consider “a large extent,” and only 20% are using social media to a large extent. With the changing paths of how customers are making purchasing decisions and the multiple avenues they have in gathering information about companies they want to do business with, many businesses are scrambling with how to keep up with them, and marketing organizations are struggling to find ways to engage with their customers in ways that are meaningful to the customer, as well as finding ways to measure that engagement.

“To succeed in the digital era, you have to be totally in sync with the behavior and preferences of your customers in a fast-changing landscape,” a quote from the study says. “You have to be quick and adaptable.” It’s true. If marketers want to integrate customer touchpoints across physical and digital channels, then they have to get used to the idea that those touchpoints might exist in mediums they’re not comfortable with: social media, or a phone call. Many CMOs are uneasy with these one-to-one engagements, but with research showing that mobile search will drive over 73 billion phone calls by 2018, CMOs need to bite the bullet and meet their customers where they are, wherever that might be.

3. There’s a huge gap between aspiration and action.

Above, we noted the findings that CMOs are lagging in their use of digital and digitally integrated technologies. But it’s important to note that these same CMOs have aspirations to use the technology they’re behind in utilizing. 94% of CMOs plan to use mobile applications more extensively in the future, compared to 80% in 2011, and 89% plan to focus on customer relationship management more extensively, compared to 81% in 2011. Interest in advanced analytics is up too, with 94% of CMOs expressing a desire to increase usage, compared to just 66% in 2011. CMOs have their eye on the ball, but can they catch it fast enough? Can you?

4. CMOs fall into three distinct profiles.

Despite similarity in the challenges they face, the report found that CMOs fall into three distinct profiles: the Digital Pacesetter, the Social Strategist, and the Traditionalist. The Traditionalist are struggling with data, new channels/devices, have yet to integrate physical and digital sales and service channels, seldom engages on social media, etc. The Social Strategist has gone a little farther, recognizing social media’s potential and building infrastructure to operate in the social arena. But, like Traditionalists, haven’t begun to fully take advantage of the data and analytics social media offers. Finally, the Digital Pacesetters are much farther down the road and are prepared for the data explosion and are actively putting the resources required to operate as a fully integrated physical-digital enterprise in place. They regularly use advanced analytics to generate insights from customer data. Guess who’s outperforming who?

5. Winning CMOs know the value of data.

This ties all the way back to #1. With CEOs relying more heavily on CMOs for decision-making, successful CMOs know the increasingly value of good data, and according to the study, 66% of those abovementioned Digital Pacesetters who are outperforming other CMOs are integrating data from all sources to better understand customers: they understand that data and creating an optimal customer experience are not exclusive. This means embracing all channels of engagement with them: social media, mobile experience, phone calls, and more. The pressure is on CMOs, and who comes out on top will say everything about how willing they are to embrace a rapidly shifting marketing world.

The post 5 Crucial Things CMOs Need to Know from the IBM CMO Study appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


October 20, 2014

You can check how many stars your favorite restaurant has on Yelp easily. But stars might not tell the whole story of that restaurant’s health inspection scores, history, and violations. Accela Inc worked with the City of Evanston to make the city’s restaurant health scores publicly available and programmable via SMS.

seth

Relaying resturant data via Twilio SMS was the easy part for Accela Developer Evangelist Seth Axthelm (pictured right).  “It’s so easy and so inexpensive and so powerful,” says Seth. Seth only wrote 50 lines of code, to give any Evanston resident  the ability to text the name and location of a restaurant to a Twilio powered phone number to see its health score and history.

Writing code was a breeze, but standardizing the data that powers the app was an uphill battle.

Data and The Network Effect

To better understand how a bit of siloed data like health inspection records traveled from a government database to an open data platform to Yelp’s API, to Twilio’s API and finally a text message, let’s take a look at the fax machine.

Remember the fax machine? The first fax machine didn’t have much value. When the second, third, and fourth etc. fax machines were up and running, faxing (in the 90s) became a viable and valuable form of communication. That one hunky piece of hardware made it easy to share information because it was so widespread and uniform. Every fax machine could communicate with every other fax machine using the same set of standards. This is called the network effect.

The same principle applies when it comes to data. If you standardize the way you classify and record data, it’s easy for others to use. When it comes to digesting data there is no more literal use case than Accela’s.


 

Making Data Digestible

Accela worked with Code for America to fly the flag of Open Data, pushing for high quality data standards that could unlock a wealth of governmental data that is either siloed or proprietary. Standardizing that data, and making it open source, can open doors for developers to make a city, its businesses and history more accessible.

Using the platform CivicData.com, which allows any resident to add government data to the site that can then be accessed programmatically via an API, Seth made the first iteration of his health score app.

Using the data standardization model called “LIVES (Local Inspector Value-Entry System)”, you can publish health score data in a particular format than Yelp can consume, and use it in its algorithm to make accessible to all users.

With accessible data in hand, Seth chose the most widely accessible platform to distribute it – SMS. Seth saw SMS as an easily adopted and instant way for anyone to access health standards.

Seth hopes to bring the app to other cities, along with the same set of data standardization. He’s also working on a similar feature that will give any city resident information on building construction, permit requests and construction permits.

Learn more about Accela here.

Data and Dining: Accela Unlocks Government Data Using Yelp API, Open Data and Twilio SMS

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


businesswoman socialWe recently learned all about message delivery in the age of anti-advertising while attending a Business Marketing Association of Chicago Marketing Innovators luncheon where Neal Campbell, EVP and CMO, and Lauren McCadney, Digital Engagement and Social Media Director, from CDW spoke to us about what it’s going to take for marketers to connect with our customers. In this new era, customers actively tune out our messaging and have a number of resources at their fingertips that they are using to proactively conduct research before ever contacting businesses directly.

Here are three key points we took away on what marketers need to embrace in order to break through the anti-advertising barrier.

 

 

 Meet Me On The Web: The New Buyer Journey

Campbell and McCadney led off by discussing how the buyer journey has been completely revolutionized alongside growing Internet penetration. A typical buyer journey now looks like the following:

  • Search (web)
  • Community (web)
  • Search (web)
  • Reviews (web)
  • Sales: to validate
  • Buy

“People are becoming smarter at the cart,” McCadney states, and with nearly 60% of the buyer’s journey complete before they even reach out to sales, we can see they are spending that time educating themselves before they even contact a company for validation or make a purchase. The majority of these consumers are beginning their search online (in fact, Google reports that smartphones are now the most common starting place for online activities) and will then turn to online peers for help in understanding the pros and cons of the product or service they are researching. All of this action is taken online, prior to engaging with your company.

So how do we stay relevant in a process that is dominated by digital research? McCadney asserts “we need to delve into the customer journey by digitizing their experience with our brands.” Engaging Digital Natives, she continues, requires connecting with them on their platform of choice, and in the right spaces on these platforms, in order to drive greater brand consideration. Marketers working to keep brands in the conversation throughout the buyer’s journey will help drive consistent consideration and return sales to being seen as another research tool, not simply a pit-stop toward the end of their decision.

People Trust People

Campbell and McCadney spoke about how, in order to stay relevant throughout the customer journey, we not only have to meet our customers on the web but also engage with them at a human level – where their trust lies.

Today 90% of people do not trust advertising, yet 92% trust recommendations from people they know. And another 70% trust opinions posted online – from people they may not even know at all! Campbell claims that as marketers, “our task becomes making our people human and making sure they have the tools to be human” in order to build this trust with our customers and engage with them throughout their purchase journey. For many businesses, what is more human that voice? Ensuring we are available to engage in conversation with our customers can be the difference in whether we get their business.

Create Brand Advocates: Customers To Build Customers

The discussion also turned to how we can play off the trust people have with one another. Marketers must engage customers not only where they are online – using search, social media, and communities – but use the relationships they have built to our advantage by letting them do the talking for us. CDW did this very simply by incorporating reviews – both positive and negative – onto their website, bringing in the feedback their customers have and sharing it in a controlled space. Amplifying their voice will create advocates for your business that prospects already trust. By doing this marketers can continue to break down the anti-advertising barrier, bringing humanness to business and another way to build trust with our customers.

At the end of the day, Campbell and McCadney’s message was about being human. In a growing anti-advertising culture, we as marketers are driven to engage with our customers on a social, human level to grow an environment of trust and acceptance. We first need to meet them where they are (on the web) and then engage in a genuine way (by being human).

And we want to ask, what is more human than voice? With smartphone ownership growing (there will be an estimated 220 million by 2018) and increasingly being used as a starting point for online activities, it is that much easier for people who are researching to use their smartphone as an actual phone. Incorporating click-to-call functionality in our mobile marketing and tracking inbound calls will help us stay relevant in the buyer’s journey and bring us one step closer to voice conversation – and being human.

The post Understanding How to Engage a Growing Anti-Advertising Audience appeared first on Ifbyphone.

Bookmark this post:
Ma.gnolia DiggIt! Del.icio.us Blinklist Yahoo Furl Technorati Simpy Spurl Reddit Google


Last updated: November 01, 2014 09:01 AM All times are UTC.
Powered by: Planet

Speech Connection and Logos are Trademark of Nu Echo Inc. Copyright 2006-2008.