What We're Building

• Each employee who joins the company should get a dedicated company phone number
• That company phone number should forward all calls and text messages it receives to the employee's cell phone. This way, an employee gets a company number for business use but won't need any special hardware or software to use it.
• The system should also be dirt cheap. We should pay for phone numbers but not much else.

Get Started

• Send and receive text messages
• Send and receive phone calls
• Send and receive faxes
• Purchase phone numbers
• Etc.

• Store user accounts (for both internal employees and external users)
• Log users into web apps, mobile apps, and API services
• Handle things like password reset, multi-factor authentication, social login, etc.
• Synchronize with Active Directory, HR systems, and other "corporate" tools to handle single sign-on and centralize your users in one secure location

Create a Twilio Account

Create an Okta Account

1. The reason I'm showcasing Okta here is because Okta is probably the largest and most well-known identity company. They've been around for a long time, many companies use Okta to store employee (and user) accounts, and their APIs are simple to use.

Install okta-twilify

• It looks through all the user accounts you have stored in Okta
• If a user doesn't have a company number assigned to them yet, twilify knows this must be a new employee, so it will purchase and set up a new company number for the new employee
• twilify will then save the new phone number into the user's profile as the primaryPhone field. This way, the user's dedicated work number will always be accessible in their user profile.

$ npm install -g okta-twilify

$ twilify --help
Usage: twilify [options]

Options:
  -v, --version                                           output the version number
  -i, --init                                              Initialize the CLI
  -o, --okta-token <oktaToken>                            Okta SSWS token
  -u, --okta-org-url <oktaOrgUrl>                         Okta Org URL
  -s, --twilio-account-sid <accountSid>                   Twilio Account SID
  -t, --twilio-auth-token <authToken>                     Twilio Auth Token
  -p, --prefix <areaCode>                                 Your company's phone number prefix, e.g. 415
  -f, --twilio-function-base-url <twilioFunctionBaseUrl>  Your Twilio Functions Base URL, e.g. https://toolbox-bobcat-xxxx.twil.io
  -h, --help

Set Up Call Forwarding and SMS Forwarding with Twilio

• You can use Twilio webhooks. This is the oldest and most common way of handling communication logic with Twilio. The idea here is that you can build a web server, host it somewhere, and every time a person calls one of your company phone numbers (or texts one) Twilio will make an API request from their service to your web server and ask for instructions. You will then be responsible for maintaining your web server, defining logic, etc.
• You can use TwiML bins. These are some pre-built pieces of logic that allow you to perform very simplistic tasks with Twilio without the need of a web server. The problem with TwiML bins is that they're XML only (you can't write code in them), so custom logic is pretty limited.
• The final (and newest) option is to use Twilio's new serverless functions. These are all the rage because you (as a developer) can write some JavaScript code in Node, upload it to Twilio, and Twilio will run your code and use that to determine how to handle all inbound calls and messages. This means you don't need to worry about running a web server or anything else!

Create a Call Forwarding Function

• Figure out what employee is being called (based on the phone number)
• Lookup that employee's cell phone number
• Call the employee's cell phone (and also play a nice message)
• Bridge the two calls together so the caller can talk to the employee

const okta = require("@okta/okta-sdk-nodejs");
const MemoryStore = require("@okta/okta-sdk-nodejs/src/memory-store");

exports.handler = function(context, event, callback) {
  const oktaClient = new okta.Client({
    orgUrl: process.env.OKTA_ORG_URL,
    token: process.env.OKTA_TOKEN,
    requestExecutor: new okta.DefaultRequestExecutor(),
    cacheStore: new MemoryStore({ keyLimit: 100000, expirationPoll: null })
  });
  let user;

  oktaClient.listUsers({
    search: 'profile.primaryPhone eq "' + event.To + '"'
  }).each(u => {
    user = u;
  }).then(() => {
    let twiml = new Twilio.twiml.VoiceResponse();

    twiml.say("Please wait. You are being connected to " + user.profile.firstName + ".");
    twiml.dial({
      callerId: event.From ? event.From : undefined,
      answerOnBridge: true
    }, user.profile.mobilePhone);
    twiml.say("Goodbye.");

    callback(null, twiml);
  });
};

• Play a message to the caller telling them they are going to be connected and to please wait
• Call the employee's cell phone and bridge the calls together
• Say "Goodbye." to the caller if the employee hangs up first.

Create an SMS Forwarding Function

const okta = require("@okta/okta-sdk-nodejs");
const MemoryStore = require("@okta/okta-sdk-nodejs/src/memory-store");

exports.handler = function(context, event, callback) {
  const twilioClient = context.getTwilioClient();
  const oktaClient = new okta.Client({
    orgUrl: process.env.OKTA_ORG_URL,
    token: process.env.OKTA_TOKEN,
    requestExecutor: new okta.DefaultRequestExecutor(),
    cacheStore: new MemoryStore({ keyLimit: 100000, expirationPoll: null })
  });
  let user;

  oktaClient.listUsers({
    search: 'profile.primaryPhone eq "' + event.To + '"'
  }).each(u => {
    user = u;
  }).then(() => {
    twilioClient.messages.create({
      to: user.profile.mobilePhone,
      from: event.To,
      body: "From: " + event.From + "\n\n" + event.Body
    }, (err, message) => {
      callback();
    });
  });
};

From: +15554443333

Hi Randall! I hope you are doing well. I was just texting you
to see if you had some time to teach me about JSON Web Tokens
and why I shouldn't use them this weekend? Over coffee, maybe?

Install the Required Dependencies for Your Twilio Functions

Specify Secret Environment Variables for Your Twilio Functions

Use twilify to Provision Your Company Phone System

• Your Okta API token that you created in the setup section
• Your Okta Org URL that can be found on your Okta dashboard page
• Your Twilio Account SID value that can be found on your Twilio dashboard page
• Your Twilio Auth Token value that can be found on your Twilio dashboard page
• A prefix value (the area code that you'd like all your company numbers to share). For example, if you are a San Francisco-based company you might want to set your company prefix to 415 , this way all of your employee numbers look like they are in San Francisco.
• Your Twilio Functions Base URL. This value can be found on the Twilio runtime page. Copy this value (pictured below) and add https:// to the front of it. Mine, for example, is https://toolbox-bobcat-2584.twil.io .

Run twilify and Dynamically Provision User Phone Numbers

$ twilify
Cleaned up the formatting of a phone number (+18182179229) for Randall Degges.
Purchased a new company number (+19253294108) for Randall Degges.

Build More Amazing Stuff with Twilio and Okta

• Build a Simple Web App with Express, React, and GraphQL
• Build a Desktop App with Electron and Authentication
• Build and Understand Express Middleware Through Examples
• Build a Simple REST API with Node and OAuth 2.0
• Create a Basic Android App Without an IDE