Using the Simulator to test your SMS Application

 
A big part of building things is testing them out, and while you can always test SMS apps with your phone, it quickly grows tiring. That's why we built an awesome simulator for TextIt, one that lets you see exactly how things will work for your end user. Not only do we let you interact with a flow right from the same page you use to create it, we also show the simulator moving through the flow in the same way we show real users. This lets you see the path taken as you work through a flow, and of course any edits you make to the flow are immediately reflected when you send the next message.

If you haven't tried it out yet, just go to any flow page and click the little phone icon on the right side of the page, it will slide in and automatically start you down the flow.

Action Logs

As TextIt has become more powerful with the addition of group management, contact variables and email (among others!), we've updated the simulator to keep pace. When you trigger one of these advanced actions in a flow we insert a message to show what happened. If you are using an email action we'll still send you the email so you can make sure it contains the right information. This all ties back to us wanting to enable you to be agile in how you create your SMS applications. If testing is something that took forever and you hated doing, then you'd resist making changes, too scared to break something. Because the TextIt simulator is so easy and quick, you can continuously iterate, confident that everything is working as expected. 

We've been working on putting together similar short videos for other TextIt features. If you have any requests or questions, please send them our way to feedback@textit.in

Integrating TextIt with your Application Just got Easier

One thing we've been pleasantly surprised about is how many customers want to use TextIt to integrate SMS into their applications, essentially calling out to us to trigger a flow and having TextIt take care of all the interactions. After talking through a few different uses cases we're happy to show off some of our new integration points that enable these kinds of interactions.

Webhook Variable Injection

Though TextIt provides flexible ways of storing custom fields on contacts, sometimes you want to look up attributes from an external database, like an order number or patient id. That is now as easy as adding a webhook to your flow action or rule. When a user reaches a webhook in your flow we'll call the URL you configured, passing it the text of the message they sent as well as all the other variables collected. But the best part is that if you return JSON, we'll save those values for use later in the flow.

As an example, if you configure a webhook at the start of your flow that looks up an order, it could return the following JSON:


Then anywhere else in the flow you'll be able to reference the variables via the @extra variables, like @order.description.

Of course since your webhook is receiving all the information that has been collected in the flow, you can use webhooks to save information collected in the same way.

Flow Run API

Another big request was to be able to trigger flows via our API, our newly minted Flow Run API allows just that.  A run is what we call a single pass through a flow by a contact, by using our simple REST endpoint you can list and filter all the runs on your account and retrieve the steps and values collected by each contact who passed through the flow.

You can now also start Flows by making a POST to the same endpoint, optionally passing in a set of @extra variables to use during flow execution. For example, say you wanted to trigger a field worker to perform a survey on a particular water point, you could start a user down a flow with the needed attributes by making the following POST to https://textit.in/api/v1/runs:

We think this provides a really interesting model where TextIt can act as the "SMS Engine" for your application, dealing with tracking state, retries and error conditions while leaving you to focus on your core competencies.

Rules on Custom Variable

This one is less about APIs, but very much a developer feature: you can now create rules that split on a variable of your choice. Typically in TextIt you want to guide a user down a flow based on the text of their response, but we realized that with the addition of webhooks, there are cases where you want to define rules on a different variable instead.

To use our our earlier example of looking up an order id, we may want to route the flow based on @extra.status, so we can send the user back different messaging appropriately. You can now do that, just click on the 'different variable' link when defining your rules.

See them in Action

The easiest way to understand what is possible with the new APIs is to see them in action, so every account now has four sample flows, two of which include webhook calls and custom field rules.  Just visit the flows on your TextIt account and look for the Order Status and Customer Satisfaction Survey flows.

As always, if you have any questions about what is possible, or suggestions on how to make things easier, let us know!  

Why we think TextIt sets the new standard for SMS

We launched TextIt last week and the response has been overwhelmingly positive, people are just giddy with how easily they can build systems that were previously impossible. But not all feedback has been positive, some say that maybe the world doesn't need another solution, that what exists is good enough and people should just use those solutions instead.

It is certainly true that the ICT4D space is filled with hype, filled with solutions built simply for the sake of being built. But I think we can make a strong case that TextIt not only provides a brand new solution, but also a brand new approach.

Before we get into it, I do want to stress that we have a huge amount of respect for what others like FrontlineSMS have done before us. They set the stage, proved what was possible and were pioneers in the space. But we think they've sat on their laurels a bit, become a bit complacent, failing to improve and adapt as conditions have evolved.

Deployment

How an SMS application is deployed is paradoxically both the hardest and least important aspect to its success. In most developing countries, like Rwanda where TextIt was born, it is both expensive and time consuming to connect straight to the carrier in order to send and receive SMS messages. FrontlineSMS solved this years ago by building on top of simple phones which you plug into a laptop running their software.  As messages come in, the laptop processes them and sends back the appropriate response.

That's a workable solution, but it does have some drawbacks. Most importantly, your Frontline deployment is really only available to those in your office, you have to sit down in front of the laptop to send messages or see responses. That means coworkers in different offices can't use the system themselves and it makes sharing results and learnings harder than it should be.

TextIt takes a different approach, instead of having you host the software on a laptop in your office, we host it for you in the cloud. Instead of a modem, we use an inexpensive Android phone and have you install our TextIt application on it. From that point forward, SMS messages on the Android phone will be synchronized with the cloud. It is an incredibly easy system to set up and has proven to be reliable in even the most challenging environments.

But really the biggest advantage to TextIt being cloud-based is how quickly it can continue improving. Just like Gmail gets constant updates and bug fixes, so does TextIt. We add new features and make improvements on a daily basis, all without our users having to do anything.  And all the while we get to learn from them, seeing how we can improve further. That simple difference of having TextIt be hosted and improving daily is what enables it to be so much better.

Flows

There are two main camps current SMS platforms fall in, those that are geared at end users but have limited functionality, and those aimed at developers but which have steep learning curves. Flows give you the best of both worlds, incredible flexibility and power, while remaining simple to understand.

Flows represent a completely different approach to building SMS applications. Virtually every system built today is stateless, each incoming SMS message is dealt with independently from previous ones, without any context of what came before. As someone who programs, I can tell you why, keeping state is really hard to do right.  But the thing is, your users understand state, they remember the conversation, they know their message history, so why force them to interact with you differently than they are used to?

TextIt changes that. A flow lets you leverage SMS in the most natural way possible, as a conversation where you know what the user said before, adapting as necessary. That makes a big difference because suddenly you can build complex systems which require no user training, just like any conversation.

The incredible thing is, flows not only give you this inherit ease of use for your end users, they also give you far more power than you had before. You don't need to understand what "skip logic" is when building a complex survey, you just drag a few arrows around and you've done it, no PHD required. With custom actions like sending emails, forwarding messages and adding contact variables you have the ability to build incredibly powerful workflows, all through the same simple interface.

TextIt adapts to you, gives you the power to build the interaction that best suits your needs, to be creative, to innovate, test, refine and repeat until you've built the best solution possible.

Obsessed about User Experience

Hopefully it shows when you use TextIt, but we are obsessed about having an unmatched user experience. That's no small commitment, it requires a lot of time and effort to constantly be posing to ourselves "is this the best way?" and making the hard decision to change course and do something better. As an example, look at how we display results as they pass through flows. Instead of showing a list of every message that has come in, leaving you to guess how the system responded, we show the messages in the exact same view you use to build the flow. Building interfaces like that isn't easy, it requires a lot of experimentation and more than few false starts, but we think the results are worth it.

That's why being a hosted cloud solution is so important to us, because we can't stand the thought of not being able to make things better for our users every single day.

That kind of polish isn't just for looks, it makes TextIt more accessible to the users we want the most: small and medium sized organizations that aren't reaping the benefits of using SMS in their programs. Anybody can start building sophisticated interactions in a few minutes and start sending messages a few minutes later.

Built with Heart

TextIt comes from our experience of living and working in Rwanda, of building a team here and of wanting to build something that really makes a difference, that raises the bar for what software in the development sector can look like. We may succeed in making a dent, or we may fail completely, but hopefully we do our part in showing what is possible, in making people reconsider the status quo a bit. 

We'd love to hear your thoughts, give TextIt a try and let us know what you think.

Introducing TextIt

Today we're excited to launch TextIt, our new product to help organizations leverage SMS. We've been building custom SMS products for three years in East Africa, and TextIt takes everything we've learned and puts it into an intuitive and powerful package. Our goal with TextIt is to enable every organization in the world to inexpensively use SMS to better accomplish their mission.

At the core of TextIt lies what we call Flows, which you can think of as interactive flowcharts. They are simple to build and understand, for example here's the start of a flow used to register new customers of water filters:

Traditionally, most SMS systems have been built around having users send in very structured messages, in very specific formats. We ourselves have built many such systems, and while they have their place, they require significant training for the users. TextIt takes a different approach, Flows let your users use SMS in a way that is natural to them, as a conversation. Handling unexpected input is much simpler, you simply create friendly error messages when the user makes a mistake. In this example we make sure the user enters either Yes or No before moving onwards:

Another advantage of Flows is you can tailor your messaging based on each response.  So here, we might want to further educate customers who are not boiling their water, which we can do by splitting on their response:

Not only does TextIt record all the steps that a user takes through a Flow, but it also lets you take other actions at any point in a flow.  For example, we might choose to add a user to a Customers group when they are complete and send an email for each new registration. That is just a few clicks in TextIt:

It is hard to overstate just how flexible and powerful this approach is. Because TextIt takes care of tracking the state of each user, you can very simply create sophisticated interactions, interactions that feel natural to the user, both personalized and responsive. That's why we are so excited about TextIt, we think with the power it provides people are going to build some amazing things.

This was just a quick overview of Flows, but it only scratches the surface of what TextIt can do. From custom fields on contacts, to triggering flows off of keywords, to launching in any country with our Android client, there is a lot more to cover.  But before we get to talk about those the best way to discover how it might fit your needs is to give it a try.

It is free to sign up for a TextIt account, give it a spin and let us know what you think.  We work every day to make it a little bit easier, a little bit more powerful, and a little bit better for you, we hope you love it as much as we do.