May 2021 Summaries

You've learned how to trigger a usage alert over a phone call with Node.js using the Twilio API, which allows you to track your usage and set up triggers for specific events. You created a new Node.js project, installed the necessary libraries, configured your Twilio credentials, bought a Twilio phone number, created a TwiML bin, made a call from your application, and finally set up a usage trigger in the Twilio Console that invokes the endpoint to trigger an alert when a certain condition is met.

Twilio's Free SMS service offers businesses a powerful way to communicate with customers through short message service (SMS), boasting a 98% open rate. Businesses can leverage SMS for transactional notifications, promotional campaigns, and alerts, but it's essential to set clear expectations with customers regarding marketing messages. To get started, Twilio provides a free trial account that allows users to test the platform and familiarize themselves with its capabilities. Users can also utilize Quick Deploy apps, which enable simple setup and sending of SMS messages in under 5 minutes. Additionally, Twilio Studio offers a visual application builder for creating custom communication workflows, while the Programmable Messaging API enables businesses to send alerts, notifications, and reminders. To ensure compliance with messaging laws, it's vital to collect contact information from customers and provide opt-out options. When writing business text messages, consider defining the purpose, crafting clear CTAs, keeping them short and sweet, and using SMS templates as a starting point. Ultimately, businesses should prioritize customer preferences and personalize their communications to achieve SMS success.

This tutorial teaches you how to manage recordings of your video calls with Twilio Compositions API using Node.js, Express, and TypeScript. You start by setting up a new project, installing dependencies, and creating an Express server that uses the Compositions API to create, view, download, and delete video compositions. The application also uses Socket.IO for real-time status updates and ngrok to forward requests from your local machine to a temporary public URL. Once you've set up the server, you can record a video call using Twilio Video App React, compose the recording into a playable video file, and view or download it in your browser. The application also includes features for deleting compositions and viewing status updates, making it a useful tool for managing video recordings.

This tutorial guides developers in setting up an SMS usage alert system using Python, Flask, and the Twilio API. To start, they need to create a new Flask project, install necessary dependencies, configure their Twilio account credentials, and set up a Flask application with a /usage-alert endpoint that sends an SMS notification when a certain threshold is reached. Next, they need to create a usage trigger in the Twilio Console that invokes this endpoint, which can be done by setting up a low threshold for voice calls. The tutorial concludes with testing the trigger and verifying its functionality.

This tutorial demonstrates how to set up custom calendar notifications using Postman and Twilio, allowing users to receive SMS notifications for special events such as national fruit holidays. The process involves creating a Postman collection, adding example requests for data storage, mocking the API on Postman servers, setting up an SMS notification with Twilio, running the collection locally in Postman, scheduling a monitor to run on Postman servers, and finalizing the setup by verifying that the code is working properly. The tutorial requires users to have a personal phone number, a free Twilio account, and a free Postman account, as well as basic knowledge of Postman and JavaScript.

A Python solution is presented to extend the standard logging library, sending application failure alerts through Twilio Programmable SMS and/or SendGrid Email APIs. The project set up involves creating a virtual environment, installing required libraries, and setting environment variables for API keys and phone numbers/email addresses. A custom HTTP Transport class is created using Twilio and SendGrid APIs to handle log messages, which are then used by a Logger object with multiple handlers to send alerts via SMS and/or email. The solution provides flexibility in case the code is reused in multiple projects, avoids hardcoding API secrets, and can be easily integrated into any Python project.

Developing software across teams can be challenging due to varying operating system preferences and deployment environments. Docker solves this problem by creating isolated, lightweight execution environments called containers, which share the underlying operating system kernel but run independently. In this article, we'll learn how to use Docker with a Symfony project, including setting up the database, PHP container, Nginx web server, and creating a quote application that uses Doctrine ORM and Twig template engine. We'll also create a QuoteController to retrieve quotes from the database and display them in a view using Bootstrap styling.

By Oluyemi Olususi The article discusses how to use Docker with a Laravel project, providing a step-by-step guide on building an application that can be scaled accordingly to handle both surges and dips in application usage. The tutorial covers the basics of Docker and its benefits in scaling applications horizontally, reducing costs, and improving reliability. It also provides examples of using Docker Compose, creating containers from images and Dockerfiles, and setting up a Laravel application with a PostgreSQL database. The article concludes by discussing how to scale an application using Docker and provides resources for further learning.

In this project, a WhatsApp chatbot is created using the Twilio WhatsApp API, Flask web framework, and Clarifai's image recognition API. The chatbot receives an image message from a user, sends it to the Clarifai API for analysis, and then returns the tags associated with the image as a response. The project involves setting up a development environment, configuring the Twilio and Clarifai APIs, and writing Python code to integrate these services. The chatbot is tested by sending an image message from a WhatsApp sandbox number, which prints the predicted tags on the console and sends them back to the user as a WhatsApp message. This project demonstrates how to use image recognition to analyze media content sent via WhatsApp and provides a starting point for further image recognition projects.

Eurovision is a massive international singing contest that has been around since 1956, where countries across Europe are represented by singing acts and vote on the best performances. Twilio's team has put together five tech projects to build while counting down to this year's Eurovision Final, including an app for virtual parties, a tool to check past contestants and entries, a sweepstakes-style betting pool, lyrics bots that can fabricate convincing songs based on existing ones, and a MIDI composition bot that uses neural networks to create melodies. These projects offer a range of possibilities for building something amazing while waiting for the votes to come in, from party planning to creative songwriting.

Twilio provides a CLI plugin that allows you to manage your infrastructure resources using Infrastructure as Code (IaC). The IaC process involves defining the environment configuration, deploying resources, and switching between environments. In this series, we covered how Twilio's IaC can help with different phases of development, including testing, deployment, and CI/CD pipelines. We also explored how to use Pulumi as a backend for managing infrastructure resources and integrating it with Azure DevOps and GitHub Actions. The key takeaway is that using IaC tools like Twilio and Pulumi can simplify the process of managing infrastructure resources and improve collaboration between developers.

The Serverless Toolkit, a collection of open-source CLI tooling for Twilio Functions and Assets, has released its first major version bump since 2019. The new version includes various bug fixes, new features, and some breaking changes. A key feature is improved configuration support through the introduction of a new `.twilioserverlessrc` file, which allows users to alter out-of-the-box behavior and supports multiple Twilio projects, environments, or commands. Another significant change is the removal of the `.twilio-functions` file, replaced by two new files: `.twilioserverlessrc` for configuration needs and `.twiliodeployinfo` for deployment-related functionality. Additionally, the toolkit now has better support for credentials from the Twilio CLI, improved compatibility with machine-readable output, and a brand-new Assets plugin that allows hosting public static files on Twilio Assets. The release also includes new guides and breaking changes, such as isolated local function execution and the removal of Node.js 10 support.

Twilio Verify is a service used for user verification through numeric codes sent via SMS, voice call, or email. The service is integrated with Flask and SendGrid to send emails to users. A dynamic template is created in SendGrid to hold the email content, and an API key is generated for authentication purposes. In Python, Twilio Verify is used to create a one-time passcode protected login system where users can verify their identity by entering a verification code sent via email. The system authenticates user credentials using Twilio Verify and redirects users to a success page upon successful verification.

Synergy Enterprise Solutions partnered with Dial-A-Doctor Australia, a healthcare service provider, to improve their after-hours medical services using Twilio Flex. The current VoIP system was inadequate, resulting in poor-quality calls and dropped connections. Synergy implemented a custom call flow structure, location-based IVR, ticketing system, and additional features to address these issues. Since the implementation, Dial-A-Doctor Australia has seen improved call quality, reduced dropouts, and enhanced support from Synergy. The partnership has enabled the company to deliver better customer experiences and empower their teams with a more efficient contact centre. With Synergy's ongoing support, Dial-A-Doctor Australia is looking forward to expanding their services through additional channels.

TwilioQuest is a platform that helps students learn programming skills through interactive workshops, with the goal of helping everyone discover their power to change the world with code. The TwilioQuest Student Club Grant provides financial support, Twilio swag, and resources to student group leaders who create and present workshops for their fellow students. To be eligible, groups must meet certain criteria, including being an official or recognized group at an educational institution, creating a safe learning environment, and lowering barriers to learning. The grant will be awarded on a needs-first basis, with priority given to organizations serving underrepresented groups in technology. Student groups can apply for the grant by filling out a quick form and meeting the eligibility criteria. In addition to the grant, TwilioQuest offers a free platform for students to learn programming fundamentals and developer essentials, as well as exclusive benefits when redeeming the GitHub Student Developer Pack.

Twilio's Product Security team created Deadshot, an automated service that monitors GitHub repositories in real-time for sensitive data, such as credentials or SQL statements. The service uses regular expressions to scan pull request diffs and flags issues for a manual review. Deadshot is designed to be a deploy-and-forget solution, requiring minimal maintenance, and can be integrated with Slack channels and Jira tickets. It has proven to be effective in catching sensitive data at Twilio and is now being released as open source, allowing others to benefit from its functionality.

The author of the text wants to build a mute/unmute button for video calls using a Raspberry Pi Pico and MicroPython. The tutorial requires several hardware components, including a Raspberry Pi Pico microcontroller, a push button, a breadboard, jumper wires, and a USB cable. The author also needs Python 3 installed on their computer. The tutorial uses CircuitPython, a variant of MicroPython that supports HID devices, to build the project. The author installs CircuitPython firmware on the Raspberry Pi Pico board, writes a short application that prints a message when the button is pressed, and emulates a keyboard by sending a key to the computer through the USB connection.

Here's a neutral, objective, and interesting summary of the provided text in one paragraph: This tutorial guides developers through building a video application with breakout rooms using Twilio Programmable Video, React, TypeScript, and Express. The tutorial begins by setting up the server-side code for creating breakout rooms and then moves on to implementing the client-side application using React Hooks. The developer learns how to create real-time communication using Socket.IO, add functions for users to join and leave video rooms, and update the Room component to display participants' videos and audio. The tutorial concludes by testing out the completed application with a user interface that allows users to create breakout rooms, join video calls, and mute/unmute their audio.

A Twilio Programmable Video application with breakout rooms is being built using React, TypeScript, Express, and PouchDB. The server handles API calls to the Twilio Video APIs and communicates with a local database. A database is set up to store the associations between main rooms and breakout rooms. Prerequisites include a free Twilio account, Node.js (version 14.16.1 or higher) and npm installed on your machine, HTTPie or cURL, and getting-started branch of the code repository. The project involves creating routes for creating main video rooms, breakout rooms, listing active video rooms, and retrieving an access token to join a video room.

Twilio has proposed an acquisition of Zipwhip, a leading provider of Toll-Free messaging in the US. The partnership aims to deliver high-quality Toll-Free messaging at scale as customers increasingly prefer messaging as their preferred engagement channel. By joining forces, Twilio and Zipwhip will improve the customer experience by enabling businesses to reach consumers on trusted numbers, leveraging a fast and low-friction onboarding process, flexible throughput, MMS, and delivery receipts. The acquisition reflects Twilio's commitment to providing deep connectivity and choice in messaging channels to its customers who are building next-generation customer engagement experiences.

Twilio has acquired Ionic Security, a leading data security platform designed to help businesses enforce access and protection requirements. The acquisition aims to develop Twilio's robust suite of data trust services and create opportunities for developers to build applications with privacy- and security-by-design. Ionic's platform protects sensitive data in demanding security environments, including large enterprises, financial institutions, and government applications. With the integration of Ionic's technology into Twilio's communications services, customers can leverage a flexible and critical security infrastructure capability. The acquisition will accelerate the development of Twilio's data security features, particularly in meeting new global data compliance guidelines.

A Svelte store is a mechanism to share state and data between different components in a Svelte application. To use stores, you need to set up your Svelte app with Node.js, then create a new file called stores.js where you define the initial values of your stores using the writable() function for writable stores or derived() function for derived stores. You can also import and reference these store values in other components. In this example, we created three stores: itemsInCart, cartContents, and totalPrice, with the latter being a derived store that automatically updates when the value of itemsInCart changes. We then imported these stores into our App component to display their current values, and wired up an AddItem button to update these store values whenever clicked.

The Lost Eurovision Song Contest is an unofficial online voting system for the Eurovision Song Contest, which was cancelled in 2021 due to understandable reasons. The system allows users to vote for their favorite songs from previous years by texting a year and country to a specified phone number. Users can also view the current top 10 results by sending a message with "Results" followed by a year. The system is hosted on MongoDB Atlas and uses Twilio functions to interact with users through text messages. The data set for the project is publicly available on GitHub, and users can run their own voting systems using the provided instructions.

Twilio` in combination with `Laravel` made writing the Eurovision voting application easy and quick. The author had most of the code written within a few hours, having tested it with several friends who all found it impressive. Although some features are still pending, such as notifying everyone of the results and statistics about scores, they can be added over time. The app will likely continue to be used even after parties resume, allowing remote participation and inclusion of distant friends. The author is happy with how the application turned out.

Twilio is implementing Content Security Policy (CSP) on its website to improve security and protect customers from web-based attacks such as clickjacking. The policy change will block third-party sites from loading twilio.com in HTML iframes or other framing methodologies, requiring customers to discontinue this practice after May 24th, 2021. However, paid Flex customers will still be able to load their instances in iframes. The change aims to enhance the security of Twilio's services and is part of the company's ongoing efforts to improve customer security.

To set up Twilio CLI, register a phone number and send an SMS using the new number, you need to have a Twilio account and the Twilio CLI installed. You can get a free Twilio phone number as part of your trial account, which provides instant access to local, national, mobile, and toll-free phone numbers in over 100 countries with a developer-friendly API. To register a phone number, use the `twilio api:core:incoming-phone-numbers:create` command, and then verify that it has been successfully added to your account by sending a test message using the `twilio api:core:messages:create` command. With a trial account, you can only send messages to previously registered phone numbers. The Twilio CLI will use your stored credentials or prompt you for login information if they are not set as environment variables.

With Twilio and Python, developers can send MMS messages quickly and conveniently. To start, create a Twilio account and install the required Python dependencies, including the twilio package. Buy a Twilio phone number to use for sending MMS, considering that MMS is only supported in the US and Canada at this time. Write a Python script using the Twilio API to send an MMS with media attached, accessing your Twilio account credentials as environment variables. The script creates a new message instance, sets the media URL, and sends the MMS to a personal phone number from a Twilio phone number. After running the script, replace placeholders with actual phone numbers in E.164 format and save the file. Finally, run the application using the command line to see the MMS sent directly to your terminal.

Twilio Elastic SIP Trunking aims to help organizations save money by optimizing global PSTN trunking costs. By consolidating fragmented services from multiple providers, Twilio reduces soft and hard costs associated with managing relationships, capacity planning, and administrative overhead. The service offers five ways to save money: no channel fees, reduced operations costs, low usage costs, low phone number rental costs, and low optional features costs. With a pay-as-you-go pricing model, automatic scalability, and self-service portal or API for centralized management, Twilio Elastic SIP Trunking can help organizations free up significant resources for strategic projects, making it an attractive option for businesses looking to reduce telecommunications costs.

Asynchronous code in Python uses the asyncio library to enable non-blocking, concurrent execution. The aiofiles library provides a way to read and write files asynchronously, allowing developers to avoid blocking file I/O operations. By using async/await syntax and the aiofiles library, developers can write asynchronous code that is efficient and scalable. The examples in this post demonstrate how to use aiofiles to read from and write to files asynchronously, including reading JSON data from multiple files and writing move lists for each Pokémon. The asyncio library provides tools such as asyncio.ensure_future and asyncio.gather to manage asynchronous tasks and ensure data consistency. Asynchronous code is useful for handling large amounts of data or performing I/O operations that may block other parts of the program, making it an essential tool for efficient Python development.

A user's phone number can be verified using Twilio Verify API, which guarantees that the database only contains users with verified phone numbers. The application will support the ability to register users and allow them to login and view a simplistic user dashboard. During registration, a unique code will be sent to the user's phone, which they will need to use for verification purposes. Once verified, user details will be moved to the main user table in the database. To verify that the application was created successfully, navigate into the yii-verify folder and run the application. The application will be served on localhost on port 8080. Open the site in your browser (http://localhost:8080) where you should see the welcome page. Configure the database connection by opening config/db.php and updating its content. Create migrations for the two database tables that the application will use, user and temporary_user. Modify the default content in the migration files generated above, starting with migrations/m<YYMMDD_HHMMSS>_create_user_table.php. Edit the migration files to create the two tables. Create an Active Record class which can also be considered as a model for the temporary_user table. Create a new form to represent the data requested from the user during the sign up stage. To verify that the application was created successfully, navigate into the yii-verify folder and run the application. The application will be served on localhost on port 8080. Open the site in your browser (http://localhost:8080) where you should see the welcome page. Configure the database connection by opening config/db.php and updating its content. Create migrations for the two database tables that the application will use, user and temporary_user. Modify the default content in the migration files generated above, starting with migrations/m<YYMMDD_HHMMSS>_create_user_table.php. Edit the migration files to create the two tables. Create an Active Record class which can also be considered as a model for the temporary_user table. Create a new form to represent the data requested from the user during the sign up stage. To verify that the application was created successfully, navigate into the yii-verify folder and run the application. The application will be served on localhost on port 8080. Open the site in your browser (http://localhost:8080) where you should see the welcome page. Configure the database connection by opening config/db.php and updating its content. Create a service that allows us to handle SMS verification by using the Twilio Verify API. Create an action in controllers/SiteController.php, named actionVerifyUser, to utilize the newly created form. Modify the main application layout view to display the flash message added to the session whenever a user is verified. Finally, modify the login view to display the flash message added to the session whenever a user is verified. The application will allow users to register and be verified before they can access their details.

SHAKEN/STIR is a caller authentication framework aimed at reducing fraudulent robocalls and illegal phone number spoofing, helping restore trust in the telephone network. Developed by ATIS and the IETF, it uses a signing policy to authenticate calls, with different attestation levels indicating varying degrees of verification. To enable SHAKEN/STIR on outgoing calls, Twilio users need to onboard onto its TrustHub, creating business profiles and submitting for vetting, which can increase the chance of their calls getting answered.

As Lyssa Test reflects on her journey in content marketing, she shares her experiences as an intern at a tech start-up, where she quickly fell in love with the company culture and was able to contribute to product development. She discovered her passion for creating informative content to educate customers and began writing blog posts, guides, and eBooks to help businesses succeed. After facing job loss, Lyssa continued to grow as a content marketer, learning about marketing strategy, SEO, and working with different team sizes. She eventually joined Twilio's Developer Voices team, where she now contributes to the company's legacy of content creation, driven by her love for tech, innovation, and making a positive impact on the world.

Twilio allows developers to send MMS using Java, making it easy and fast to deliver messages without needing to use their mobile device. To get started, you'll need a free or paid Twilio account, some prior knowledge of Java, and a smartphone with active service. You can purchase a Twilio phone number from the Twilio Console, select your country, and check if MMS is available for that region. Once you have your account credentials set up, you can use the Twilio Java helper library to send an MMS by creating a file named SendMMS.java and pasting in some code that initializes the Twilio client and creates a new message instance with the recipient's phone number and a media URL. After saving and compiling the file, you can run it on your terminal to send the MMS.

You've set up a usage trigger with Twilio that sends an SMS notification when your account reaches a certain threshold. To trigger this alert, you made a voice call using the Twilio CLI, which sent an HTTP request to your Express server app. The server received the request and processed it by sending an SMS notification to your personal phone number. You can customize the trigger settings, such as the callback URL, trigger value, and usage category, to suit your needs. With this setup, you can monitor your Twilio API usage and receive alerts when you reach specific thresholds.

Save the Children built a comprehensive digital communications platform to support their humanitarian work during the COVID-19 pandemic and beyond. This platform is designed to be flexible and adaptable to meet the unique needs of various programs across different countries and regions. The organization leveraged technology best practices to integrate digital tools such as multi-channel communications solutions, learning management systems, and data analytics into their operations. A pilot program was launched in Indonesia using a chatbot to provide accurate information on COVID-19 and reduce behaviors that put children and families at risk of contracting the disease. The success of this pilot led to the development of a framework solution using Twilio that allows for quick launch of additional chatbots and interactive communications solutions without significant upfront technology investment. This approach enables Save the Children to scale their digital communications efforts efficiently and effectively, while also exploring future opportunities to harness the power of digital technologies to amplify their impact.

A developer uses the Yelp API to create a system that sends SMS recommendations for florists in a specific delivery area, indicating if they are open or closed. The system involves setting up a Twilio phone number, creating a Twilio Function using the Yelp Fusion API, and adding messaging capabilities to respond to incoming texts with the data received from Yelp. The developer provides step-by-step instructions on how to build this system, including prerequisites such as creating a Yelp account, registering for an API key, and setting up a Twilio account. The system can be customized further to suit different applications, such as choosing restaurants or grabbing photos from business pages.

Implementing email verification in a FastAPI application using Twilio Verify can help prevent fake accounts. The process involves configuring SendGrid and setting up an API key, dynamic template, and email integration with Twilio Verify. A virtual environment is created to install necessary packages, including FastAPI, python-dotenv, aiofiles, python-multipart, uvicorn, and the Twilio Python Helper library. An application settings file, config.py, is created to store configuration variables in a secure manner using environment variables from a .env file. The application includes endpoints for handling form submissions, sending verification codes via email, accepting code submissions, verifying codes, and displaying success pages. Once complete, the server can be run with uvicorn and tested by navigating to http://localhost:8000 and submitting an email address to receive a verification code.

The pandemic accelerated the need for video solutions, with many organizations rushing to use whatever was available without considering their unique needs. To future-proof their video solution, businesses should focus on building a custom application that can scale quickly to meet heightened demand, streamlining the user experience through intelligent customization, and creating active engagement through interactive features. By doing so, companies can enhance customer interactions, differentiate themselves from competitors, and achieve business success.

SMS is a highly effective marketing communication strategy that offers versatility in content and creative campaigns, high average open rates, and the opportunity to personalize messages. When writing SMS text messages, it's essential to remember the character limit of 160 characters per message, but most modern devices can accommodate up to 1600 characters. Templates are a great way to optimize campaigns according to best practices, such as appointment reminder templates that include the date, time, and place, or order confirmation templates with links to products and discount codes. Effective SMS notifications and reminders leading up to appointments can be helpful in reducing no-shows, while abandoned cart reminders via SMS can be mini-nurture campaigns to encourage purchase completion. Marketing and promotions SMS templates should clearly state special discounts or offers and include links to start shopping, while also varying and personalizing the copy to grab recipients' attention and avoid spammy language.

The Twilio Flex platform has partnered with Survey Dynamix to integrate a validated survey solution that enables automatic customer surveys after any type of interaction. This integration allows customers to personalize surveys with relevant context from their agent interaction, resulting in deeper insights and more relevant information. The integration can be deployed worldwide in a matter of days and offers various notification options for immediate action based on customer feedback. The Survey Dynamix integration is now available to Twilio Flex customers, providing an enhanced customer experience and streamlined feedback loop.

Twilio has experienced a security incident due to the recently disclosed Codecov vulnerability, where an attacker modified the Bash Uploader component, potentially exposing sensitive information stored in continuous integration environments. Twilio was notified of the event by Codecov and immediately began its security incident response process, identifying and rotating exposed credentials, notifying affected individuals privately, and conducting thorough investigations to validate the impact of the exposure. To prevent similar issues in the future, Twilio has a robust third-party security team that evaluates its technology supply chain, an active internal service called Deadshot that scans GitHub pull requests for secrets and insecure coding practices, and tooling for Static Application Security Testing to identify security issues and vulnerabilities in code. Despite the incident, Twilio has no indication of any further customer data breaches or issues with product availability or functionality.

Twilio's Serverless Toolkit and the Mandalorian Translator API can be used to build a simple app that translates English text into the Mandalorian language. To start, one needs to sign up for a Twilio account and configure an SMS-capable phone number. The free tier of the Fun Translations API has limitations on the number of requests per hour, but it is sufficient for this example. A paid plan can be used for more extensive use. The Serverless Toolkit provides CLI tooling to develop locally and deploy to Twilio Runtime, making it easy to build web apps quickly. The app makes a GET request to the Fun Translations API with the text to translate, parses the response, and returns a text message containing the translated text and an image of Yoda! To open up the app to the public, configure the function with a Twilio phone number by setting the Function Path in the Twilio Console. The completed app can be viewed on GitHub.