After a harrowing experience being unable to communicate in a foreign country, I wanted to help eliminate language barriers by offering instant real-time access to human translators using the power of technology. My co-founder Ryan, had a similar experience in China and we soon began designing our first human-powered translation app. Some months later, we were ready to raise capital and applied for a spot on Shark Tank, the popular ABC show which gives entrepreneurs the chance to pitch their ideas to veteran investors.
In order to prepare for the spike in VerbalizeIt app downloads from appearing national TV, we took several important steps, which will help us generate the most productive outcome:
Do Your Homework Before we stepped in front the sharks, we conducted extensive background research to better understand how the show would impact the number of downloads of our app. This meant researching how much traffic was generated from the show to previous companies, websites, social media pages, and app stores. Understanding precisely how much pick-up we expected to receive was crucial when preparing our servers. We now do this before every marketing campaign.
Test, Test, Test and Test Some More Though VerbalizeIt is still young, we’ve found it effective to identify the successes we’ve already had. In our company’s young history we’ve had several spikes in downloads from press, events, and marketing campaigns. All of these spikes have informed the improvements to our new app and our deeper integration with Twilio. We filmed Shark Tank only months after incorporating and before we had a working iPhone app. With the showing airing shortly, we’re confident that our tests have put us in the best possible position to succeed.
Cherish Your Time As a software as a service company, Twilio saves us precious development time. Because Twilio offers an easy-to-use API, clear documentation, and an out of the box learning experience, getting our developers up to speed was painless and easy and allowed us to continue to press forward on the other aspects of our SaaS platform.
Keep It Real Through Twilio’s platform we now have a dynamic environment where customers can call via a typical phone line or our mobile app wherever they are in the world. This allows us to seamlessly route calls to our translators all over the world from any device to any device. We also have an “on-off” switch for our translators to alert the Twilio platform when they’re available to take live translation calls. This functionality when coupled with clear-call quality, have put us in the best position to connect real people across language barriers all over the world.
To watch Kunal and Ryan pitch to “the sharks” on the season finale of Shark Tank, tune in to ABC on Friday, May 17 at 9 p.m. EST or sign up for VerbalizeIt updates where remind you about the show’s airing. You can also learn more about their developer offering and how to embed a live-translator into your application at www.verbalizeit.com.
In honor of all the developers in town for Google I/O, we’re giving away tickets to a midnight showing of Star Trek: Into Darkness tonight (5/15) at The Metreon. So park your cloaked Klingon Bird of Prey in Golden Gate Park (like Captain Kirk) and get ready for an awesome time.
There are two ways to win tickets:
Find us at Google I/O and wear your Twilio shirt. Wear your Twilio redshirt for a hi-five and Vulcan salute.
Text 415 “INFIX-YO” [415-463-4996] and answer a Star Trek trivia question to unlock the Eventbrite registration for the event.
We will be on scene in the lobby of The Metreon before showtimes to hand out tickets everyone registered on Eventbrite. Look for the Twilions in the red track jackets and stay tuned to our Twitter feed for updates.
Ameer is Solutions Architect at Twilio, specializing in building high volume, low latency solutions for customers. He has over 15 years of experience in building solutions. The following is syndicated content, originally published on Salesforce’s developer blog.
When it comes to case management, the shorter your response time is the happier your customers will be. I recently published an article on Salesforce’s development blog, showing you how to improve your case management response time using a Twilio SMS integration.
Situation Trigger SMS alerts to Case Team Members for High Priority Cases
One of your customers has called to report a critical issue. The call center agent
creates a “high” priority case and assigns a case team to work on the issue.
Creating the case fires a trigger that notifies the assigned team member(s) via SMS. The entire team is simultaneously notified, enabling them to understand the issue and to start resolving it as quickly as possible.
Let’s dive into the code…
Prerequisites
To begin, you’ll need an account with Twilio and a Twilio phone number (requires login).
You’ll also need a Salesforce account where you can do the development.
This trigger calls an Apex method, which has all the business logic to produce a list of case team members, and the message that needs to be communicated via SMS.
trigger trg_case_send_sms on Case (after insert, after update) {
//Call the Apex class to Send out SMS messages
TwilioSMSAsync.sendSMSCaseTeamList(Trigger.newMap.keySet());
Step 2: Creating the Apex method to send SMS message
The Apex method “TwilioSMSAsync.sendSMSCaseTeamList” has the business logic
to determine when to send the SMS message. In our use case, we want to send the
SMS when the Priority of the case is ‘High’ (seen annotation 1 in Figure 1) and to
the entire assigned case team (see annotation 2 in Figure 1). The text message
is completely configurable by the Force.com developer. In the example code, we
specify the Case Number, Case Contact Name, their Account Name and a URL for the
SFDC case record in the SMS message.
Note: The method sendSMSCaseTeamList is specified as @future(callout=true) since
it asynchronously makes external calls to Twilio REST APIs when the trigger fires.
The Apex method does three things in the following order:
a) Gets the case details for creating the SMS message body b) Gets the list of case team members associated with the case c) Using the Twilio SMS API, sends a SMS to each of the case team member in
real-time
public class TwilioSMSAsync {
@future (callout=true)
public static void sendSMSCaseTeamList(Set Ids) {
String caseNumber = '';
String caseContactName = '';
String caseContactAccountName = '';
String caseTeamMemberContactId = '';
String contactName = '';
String toNumber = '';
String messageBody = '';
String SFDC_hostnameUrl = URL.getSalesforceBaseUrl().toExternalForm();
// Get Case Info
for (Case c: [SELECT Id, CaseNumber, AccountId, ContactId, Priority FROM Case WHERE id
IN :Ids]) {
// Only send SMS to case team members if the Priority of the case is set to ‘High’
if (c.Priority == 'High') {
caseNumber = c.CaseNumber;
for (Contact cc: [SELECT Name FROM Contact WHERE id = :c.ContactId]) {
caseContactName = cc.Name;
}
for (Account cca: [SELECT Name FROM Account WHERE id = :c.AccountId]) {
caseContactAccountName = cca.Name;
}
// Create the SMS message body
messageBody = 'SFDC High Priority Case ' + caseNumber + ': ' + 'For ' +
caseContactName + '@' + caseContactAccountName + ' ' + SFDC_hostnameUrl + '/' + c.Id ;
// The TwilioAPI helper class looks up your Twilio AccountSid and AuthToken from your
current organization, in the TwilioConfig custom setting.
// You can configure TwilioConfig by going to Settings->Develop->Custom Settings-
>Twilio_Config, and your AccountSid and AuthToken
// can be found on the Twilio account dashboard
TwilioRestClient SMSclient = TwilioAPI.getDefaultClient();
// Iterate through all the Case Team Members and send them a SMS notification
for (CaseTeamMember ct : [SELECT MemberId FROM CaseTeamMember WHERE
ParentId = :c.Id]) {
caseTeamMemberContactId = ct.MemberId;
for (Contact cc: [SELECT name, MobilePhone FROM Contact WHERE id
= :caseTeamMemberContactId]) {
contactName = cc.name;
toNumber = cc.MobilePhone;
// Format (+) the toNumber
toNumber = '+' + toNumber.replaceAll('\\D', '');
// Setup the params for SMS message
Map<String,String> params = new Map<String,String> {
'To' => toNumber,
'From' => '<You_Twilio_Provisioned_PhoneNumber_Goes_Here>',
'Body' => messageBody
};
//Send SMS out via Twilio
TwilioSMS sms = SMSclient.getAccount().getSmsMessages().create(params);
}
}
}
}
}
}
Summary
Now, you have a working example of sending SMS in real-time to case team
members, enabling the service support team to respond to critical customer
issues effectively. Since the Twilio REST API helper library is written natively in
Force.com, it’s easy to integrate with other Salesforce Objects or Case Management
applications like ServiceMax.
In future posts, we’ll show you how to extend this further so your case team
members can respond to the SMS message, essentially, creating a bi-directional SMS
messaging system.
Twilio provides the tools to solve a wide range of communications needs. For
instance, with Twilio’s Force.com helper library, we can implement:
Click to call: Easily integrate Click2Call within Site.com or any website
Conferencing: Enable Conference calling within Salesforce
Interactive Voice Response (IVR) System: Build context aware IVR systems based on Salesforce data.
This is a very bare-bones implementation, but it should provide a decent framework for you to expand it with additional filters and more intelligent queries.
To begin, we need to go over to the Google API Console and create a new application. Once you have created the application, make sure to enable the Google Custom Search Service, then head to the API Access tab and get your API key. We do not need OAuth 2.0 for this project.
In the Sites to Search field feel free to enter any domain, we will delete it later
Head to the Setup tab under ‘Edit search engine’ – under the Sites to Search dropdown select “Search the entire web but emphasize included sites”
Select the domain name you entered on the list below and Delete it
Now you have a Custom Search Engine that searches the entire web.
Be sure to copy down the CX parameter from your URL – we will be using this later.
Coding the SMS
Now that our setup is complete, we can proceed to the code. For this project, we only have one route – /receivesms. Create a file named app.rb with the following contents:
Make sure you go back in and enter your Google API key on line 7 and your Custom Search Engine ID (CX) on line 15. You’ll also notice that we are only returning the top 3 results at this point, you can customize this number or add additional filters as per the API documentation for Custom Search. To finish up, we will need a Gemfile and a config.ru file (to deploy on Heroku)
Then you can deploy this to Heroku or your favorite hosting service, set up your Twilio number’s SMS URL to be http://yourapp.com/receivesms – and then you can get back to sending your search queries to Google via SMS!
It takes a village to raise a child. But, what does it take to keep that child safe? John Guydon asked himself this question following 5th grader Jessica Ridgeway’s tragic kidnapping in his home state of Colorado back in October 2012.
John Guydon is a entrepreneur, not a cop, military veteran, or security specialist. When he set out to find a way to prevent child abduction and keep neighborhoods safe, he turned to what he knew — communication.
As CEO of SMS marketing platform, Duffled, John helps companies keep in touch with their customers via SMS. John created The Lassy Project, to empower parents with the communication tools they need to keep their kids safe.
The Lassy Project uses real-time messaging and GPS tracking to keep parents updated on their child’s whereabouts, and alerts them in real-time if anything goes wrong.
Here’s how it works. Parents set up their Lassy profile by entering in their phone number, zip code and their child’s mobile phone number, which will act as a GPS beacon. Then they map typical routes their kid takes from home to school, from their friends house back home etc. Lassy registers these routes in their mapping client. If your child is somewhere they shouldn’t be, Lassy recognizes that and you’re notified immediately via Twilio SMS.
Lassy relies on local networks of users they call villages, to help spread the word and help out when a child goes missing. Think of the village as an on demand search and rescue team comprised of Lassy users. Co-founder Temitope Sonuyi says, “The ability to press a button and all of the sudden have hundreds of people looking for your child and knowing where they’re at right now, on a map and being able to see it, is unprecedented.”
Parents and village members can see where their child, or a missing child, is on a map and real-time. They can then share alerts via SMS, and forward updates on social media channels. John Guydon says the goal is to get critical information distributed instantly to “turn hours into seconds.”
The Lassy Project is working on developing their network of users. As they say, “the bigger the village, the safer the kids.” They’ve recently received endorsements from the Fraternal Order of Police in Colorado and are working with local businesses to establish and map “safe spots” where kids can go if they’re in trouble.
To learn more about the Lassy Project, visit their website here.
Myself and other developers have been giddy with glee at the recent release of Google Glass, one of the first largely available wearable computing platforms. After the Glass Foundry hackathons in January, I couldn’t wait to start building awesome applications such as GlassTweet with the Mirror API and helping others do the same.
Today, I’d like to debut the first tutorial on building Twilio applications for Google Glass, where you will learn how to receive SMS messages via a Twilio phone number on your Google glass and how to respond to them using the Glass voice commands.
Glass can send and receive SMS by default via the MyGlass Android app. However, I often use Twilio phone numbers for people I would not be comfortable giving my real phone number to. I wanted to be able to receive SMS just through my Glass device, not my phone, and only receive SMS from certain people.
If you’d like to see the end result, check out the video below before getting started:
Let’s Get Started
The first step is to follow the Mirror API quickstart guide – while this guide is for Python, the steps for creating a new Mirror Application in Google’s API console are the same as for Ruby. Once you have your Client ID and Secret, we can move on.
A few more basics before we get started: If you haven’t used Sinatra before, I recommend giving a quick look at their README. For those of you coming from a Python background, it is a similar framework to Flask. If you are new to Twilio, make sure you have signed up for an account and have upgraded it so that you can send outgoing SMS to unverified numbers. I would also recommend reading some of our Quickstart tutorials.
Now let’s dive into some code! First off, lets set up our Gemfile and config.ru:
Next we have to set up our data store. We will need to store OAuth credentials and the user’s Twilio phone number. For this, I decided to use the awesome data_mapper gem. Let’s create a new file and set up our database schema:
All we are doing here is forcing the application into SSL mode, defining our schema, requiring the necessary gems for our application, and telling DataMapper to run an automatic migration whenever we deploy our application. This is a great feature and makes it really easy to add new fields to our table in the future. Now that our data store is all set up, we can start writing our before block, which is evaluated before any route is processed.
Our before block thus far is doing some basic configuration of the different Google and Twilio API libraries. We put in our Client ID and Secret from Google’s API console, and we put in our Account Sid and Auth Token from our Twilio Dashboard. We also need to put in the base_url of our application. In my case, I pushed my app to Heroku but you can host it on any server that can run Ruby. I would recommend using a host that supports SSL.
Note that we are authorizing our application with the glass.timeline and userinfo.profile scopes – this gives us access to a user’s basic Google account data as well as their Glass device. We won’t need more than that for this application but if you wanted to expand it in the future you could certainly add more Google services here such as GMail or G+. We also initialize our @glass and @oauth2 objects based on the Google gem’s discovery documents.
Now that all of this basic setup is complete, we can finish up our before block by adding the following code:
Here we are dealing with three different incoming hits to our application. The first is /subcallback, which is the route that Google will send user-initiated responses to – in this case we look up the user’s auth token based on data passed along from the Mirror API callback. The next is if session[:token_id] – this situation occurs when a user is already logged in to our service, so we look at their session cookie. And the last is if we are receiving an SMS – in this case we get the user’s auth token by looking up their phone number from Twilio’s POST parameters. We end this block by refreshing the token if needed and redirecting the user to the Google OAuth login screen if they have not yet authorized their account. Now we can go ahead and create the routes for OAuth authentication.
Our first route, /oauth2authorize, redirects the user to Google for authorization. Our second route, /oauth2callback, is where the user is redirected to after completing the authorization flow. First we create a new TokenPair database entry for the user to store their OAuth credentials and we also store it in the session cookie for when they return to the website.
Next we make a request to the Twilio API to search for available US phone numbers. We then purchase the first available number and assign it to the user to be saved with their TokenPair.
And lastly, we make a request to the Mirror API to subscribe to timeline card INSERT notifications. We will get an INSERT notification when the user clicks on the Reply button on their Glass in order to reply to an SMS. Once all of this is completed, we redirect them to the root route.
Here we verify that they have authenticated their account by querying the Google Userinfo API to retrieve the user’s name and provide them with a simple greeting and we inform them of their new Twilio phone number that we purchased earlier. Now that all of our authentication code is written, we can write the routes that handle incoming and outgoing SMS messages. The first of these two routes is /receivesms – Twilio will make a request to this route every time it receives an incoming SMS message to your phone number.
When we receive the incoming SMS, we create a new timeline card on the user’s Glass. This card is given the REPLY menu action, which allows them to speak a reply to the message. We also give it a READ_ALOUD menu action to have the Glass read the SMS message aloud to the user.
We then set an HTML block to be displayed as well as the text we want spoken to the user. Most importantly, we set the sourceItemId to our SmsSid – this allows us to pass along Twilio’s SMS message identifier so that we know who to reply to later. We finish by returning a blank response to Twilio, though you could add your own SMS auto-reply here if needed.
When the user “Replies” to the message on their Glass, Google will make a request to /subcallback. The first thing we need to do is pull up the timeline item that was created for the user’s new Reply. This timeline item contains the transcribed speech-to-text from Glass. We then look up the timeline card that the user was replying to, which represents our incoming message that we created in the previous method (/receivesms). This card contains the SmsSid so that we can look up the message and find out who the sender was. We then make a request to Twilio to send an SMS from our user’s Twilio phone number to the sender of the original message, with the text that they spoke to Glass.
Now our application is completed. You should be able to run a bundle install and push this straight to Heroku or to the host of your choice, navigate to the base URL, and then start sending and receiving Twilio SMS messages on your Glass device. You can see the full application on Github here.
To get started on a more complex application, I recommend my scaffold project GlassRails, which is a very basic setup to get you going with OAuth and the Mirror API with Ruby on Rails.
If you have any questions, feedback, or conspiracy theories about Skynet please feel free to Tweet @jonmarkgo or e-mail me at jonmarkgo@twilio.com
In the midst of a noisy, chaotic home-remodeling, Ben Dyer was inspired to found a company. I use the term “inspired” loosely. Ben really needed to found Powered Now. Contractors working on Ben’s house gave him wildly different quotes and contracts. Some were printed spreadsheets, and some were chicken scratches on a spare piece of paper. Ben decided he needed to come up with a better way for both contractors and clients to manage contacts.
Ben’s solution, Powered Now, provides an end-to-end platform for contractors to easily generate and manage invoices, quotes and certificates while on site. Just two years into their journey as a company, the app won Best Mobile App At The Next Web Conference, and are expanding rapidly.
“Our number one goal is to arm tradesmen and women with tools to do their paperwork more easily, more quickly and more professionally. Nobody goes into business to do admin,” says Ben. Their tablet based application allows tradesmen to easily log details of their project, contracts, record of payments, and customers’ information in one simple dashboard.
Powered Now uses Twilio SMS to keep customers in touch with contractors. When there’s a new quote or update on a job site, Powered Now sends the customer an SMS notification.
With the Best Mobile App Award in hand, they’re looking to keep improving their platform. “In the future, we’re looking to incorporate voice into the App, its one of the most highly requested features from our users,” says Ben.
To learn more about Powered Now, visit their website here.
Twilio is hiring for a Senior Visual Designer. We’re looking for someone for can think critically, design beautifully, and bring the story of cloud communication to life in an icon. You can find the job listing here.
From wire-framing, to meeting with muralists, to ordering 10,000 embroidered Twilio patches, there’s rarely a “typical” day for Senior Visual Designer, Alicia Pompei. For this Day In The Life Feature, we talked with Alicia about how she got to Twilio, the philosophy behind her work, and why you must always have a creative brief for everything.
To apply for the position of Twilio Senior Visual Designer click here.
And now the story of one developer evangelist who feared missing out on Arrested Development’s season four premiere, and the one company which provided him the tools to be notified when it’s live…It’s Twilio Development.
Jonathan Gottfried woke up one morning realizing it would be a huge mistake if he wasn’t the very first to see the premiere of Arrested Development Season 4 on Netflix. He knew it would be released on May 26th, 2013, but not exactly when. Midnight that day? And is that midnight, OC time? The 26th is a Sunday too. Would he have time to brunch at Skip Church’s and fill up on a Skip’s Scramble before the premiere?
Well Jon is an ideas man and luckily for the rest of the Arrested Development fans, he built BananAlerts to notify him when the new season was live on Netflix. At first we were not optimistic it could be done, but he didn’t take “not optimistic it could be done” for an answer.
After some quick hacking with the Twilio API, he was able to write a Ruby application using Sinatra and Datamapper on Heroku to let people subscribe to SMS alerts. He then wrote a scraper using Nokogiri to detect when Season 4 goes live and notify all of the subscribers.
Jon accepts the fact that if you blog about an app, you’re going to get hop-ons. So go ahead, text ANN to 619-EGG-VEAL (619-344-8325) to opt in to BananAlerts.
VerbalizeIt co-founder Kunal Sarda (pictured right) shares four keys to preparing your communications app, which he and co-founder Ryan Frankel learned from appearing on the ABC Television series “Shark Tank.”
