Twilio
REST API
Technical Support
Teaching
Writing
Empowering Others
App Development
Distributed Computing
Storage Virtualization
New Hire Coaching
Training Content Development
Entrepreneurship
Web Design and Development
Wordpress
Search Engine Optimization
VCP 6.5 DCV | NSS 5.0
HTML, CSS, & Javascript
NodeJS
Scuba Diving
Medicinal and Herbal Gardening
My Story
Growing Up
My story begins in Knoxville, Tennessee where I grew up playing soccer, starting in the local rec leagues and ending with 4 competitive Tennessee state championships and 1 TN High School AAA State Championship. Through that journey, I learned what a healthy and selfless team looks like, and that persistence and dedication are vital to all individual success. My experience playing soccer also taught me how to handle conflict when emotions are high and how not to take things personally, and I’ve come to learn as I’ve gotten older that all these lessons are valuable wherever I go, as almost nothing truly incredible is accomplished alone - it takes a team.
Before receiving my engineering degrees, my natural curiosity led me to several different roles where I’ve gather a wide range of experience. One of the most impactful roles to my development was as a universal technician at Terminix where at 21, I was responsible for maintaining a company vehicle, performing service for all pest and termite contracts in my designated zip code, meeting monthly sales goals, and maintaining customer satisfaction for all my customers. I learned a lot during this time, but the main things were how to educate customers, handle customer satisfaction issues, manage customer emotions, work through pressure, and manage my time while working up to 65 hours a week.
College
When I began my education at NC State, I maintained my work ethic by self financing my education by working through school at Duke Energy and ImageSoft Inc. and managed to maintain a GPA of over 3.75 while doing this. Additionally, during the final year of my degree, I chose to participate in the Engineering Entrepreneurship Program at NC State, during which I developed a startup called Kast Clothing that made custom fit jeans from 3D body scans. After finishing the program, I was accepted into the NC State Entrepreneurship Initiative's Miller Fellowship Program that provided me a stipend for 6 months to continue developing Kast Clothing.
Career
All my experience led me to the cloud-computing software industry working for the leading hyper-converged infrastructure (HCI) company, Nutanix as a Systems Reliability Engineer 1 (SRE1), fixing business critical solutions for customers ranging from PayPal to the Department of Defense. I am proud to say that I was a part of an exceptional support organization that had the highest Net Promotor Score (NPS) and Customer Satisfaction Rating (CSAT) in the industry at the time.
After joining Nutanix, not only did I continue learning technically at a rapid pace, but I also continued developing my customer management skills. After about 1 year and 2 months at Nutanix, I was promoted to SRE2, chosen for a new Support Concierge Program for new potentially large accounts, and selected to coordinate the SRE1 new hire training.
In September 2019, I decided to apply what I learned at Nutanix while taking on a new challenge as a Senior Technical Support Engineer 2 at Twilio. Hired to work on the Live Chat support team, I was trained in all of the core Twilio products allowing me to provide delightful customer experiences by avoiding ticket transfers for customers developing robust multi-product applications.
In March 2020, I joined the Voice product support team where I now primarily focus on API usage and call quality / connectivity troubleshooting. In addition to support tickets, I
also help customers and colleagues find success by writing tutorials on Twilio's public blog and internal troubleshooting guides.
Personal
In my spare time, I also enjoy helping friends and family by developing and managing websites for their small businesses, testing business ideas and building prototypes of my own, playing and watching soccer, traveling, gardening medicinal and edible plants, and since 2018, scuba diving.
Contact
For more information about my entrepreneurial projects and personal interests, see my Projects, Fun, and Volunteer pages. And for more information about my professional experience and education, check my LinkedIn. To contact me directly, email samuelgeddy@gmail.com.
As a member of Twilio's frontline support team, I see firsthand what generates tickets and customers often need help with. In an effort to reduce tickets and help Twilio
customers succeed, I started writing tutorial blog posts for Twilio's public blog.
All of my blog posts have been written after working with multiple customers requesting help. After writing, my posts have consistently decreased tickets
and served as a public resource to provide to customers when they do open a support ticket for the use case.
Below you can find a few highlighted posts published at the time of this writing.
Make and Receive Phone Calls with ony a Phone and Twilio Studio
Using a Twilio number to forward calls to your personal phone is a common and well documented use-case,
but many Twilio customers have asked if they can use only their cell phone to place outgoing calls with
their Twilio number. This guide shows how to build a Studio Flow that will allow you to use your
Twilio number as a full capable proxy, so you can place outgoing calls and receive incoming
calls using only your personal phone.
Forward Voicemail Recordings to Email w/ Studio, Functions, & SendGrid
While the Voicemail Twimlet has email forwarding built in, many Twilio customers find it
limiting and ask if there's a way to forward recordings to email without the Twimlet
or a web server. This document shows how to forward voicemail recordings to email using Twilio
Studio, Functions, and SendGrid.
Build Round Robin Call Forwarding Using Twilio Studio & Functions
One of the most common application workflows – regardless of the context – is round robin routing.
You can build round robin routing in a straightforward way with programming logic. However, to run
this logic, you need a web server which must be managed – introducing a whole new realm of responsibility.
While for larger operations this isn’t a problem, mom and pop shops don’t want to take this on and it often
puts this functionality out of reach.
Now with the help of Twilio’s Runtime suite, including
Twilio Studio and Functions, you can build your own round robin call forwarding application
without worrying about your own web server. In this post, I’ll show you how to set up a
serverless round robin call forwarding solution.
This project started when I was filing my taxes in 2020. Since I had recently purchased a
townhouse, I wondered if if it would make sense to itemize my deductions instead of
taking the standard deduction.
Sine I was young, I had always admired the way many of my elders tracked receipts and kept track of
their sales taxes all year, but in the new world of digital transactions and a near cashless society,
keeping your receipts just doesn't make sense. I also wondered why our sales tax was not automatically
calculated for all digital transactions. My guess was that it just wasn't profitable, and there was no
incentive for entrepreneurs, but in this project, my curiosity set me out to see if it was possible.
Plaid API
The first thing I needed for my project was a way to access the location information for all of my
transactions. To do this, I used the Plaid API. The Plaid API comes with a
great Quicksart, which is what I used to get started.
The Quickstart made it easy for me to get tokens for each of my accounts, and once I had this, I could programatically
access all my transcactions for each account, including the location data for each transaction.
This is what I would use to confirm the sales tax rates for that transaction.
I built this app in Javascript, and since I was just building this for myself and not as an app that I could sell, my goal was to get the information I
needed as quickly as possible; it didn't matter how quick and dirty it was. My thought was that I could set out
by getting a ballpark figure, and if it put my itemized deductions close to the standard deduction amount, I could then
fine tune my process and worry about it holding up to an audit.
With this in mind, I did a few things that should wouldn't be done in production like hardcoding a few values
and printing my output console instead of taking time building a front-end. Since I was just trying to get a ballpack,
I also didn't bother diffentiating city/county taxes, and instead, calculated all my transcactions with North
Carolina location with the Durham city tax rate of 7.5%.
The script I wrote below first initializes the Plaid Client with the Client ID of one of my bank accounts, then
then iterates through all my transactions checking for those with an NC location. To get the transactions, I use the
Transactions resource of the Plaid API, and since this resource has a
limitation of 500 transactions per request, I wrote a loop to get them in increments. When I've found a transaction that
matches my criteria, I print it to console, calculate the sales tax, and add it to the total, which I also print to the console.
// Initialize the Plaid client
var client = new plaid.Client(
PLAID_CLIENT_ID,
PLAID_SECRET,
PLAID_PUBLIC_KEY,
plaid.environments[PLAID_ENV],
{version: '2019-05-29', clientApp: 'Plaid Quickstart'}
);
// Loop through each month since
// api transaction limit is 500
// Define tax year
let year = '2019';
// Define tax vars
let total_sales_tax = 0;
let nc_sales_tax = .075;
// Transactions vars
let total_trans = 0;
let nc_trans = 0;
// Iterate through each month
for (let j=1; j<13; j++) {
// Set month var
let month = j;
// Set month based on j
if (j<10) {
month = '0'+j;
}
// Set start and end dates for month
var startDate = year + "-" + month + "-" + "01"
var lastDayOfMonth = new Date(year, month, 0);
var endDate = year + "-" + month + "-" + lastDayOfMonth.getDate()
// var startDate = moment().subtract(30, 'days').format('YYYY-MM-DD');
// var endDate = moment().format('YYYY-MM-DD');
client.getTransactions(ACCESS_TOKEN, startDate, endDate, {
count: 500,
offset: 0,
}, function(error, transactionsResponse) {
if (error != null) {
console.log(error);
}
else {
let tax_ctr = 0;
for (let i=0; i 0) {
if(transactionsResponse.transactions[i].amount > 0) {
console.log("\nStore Name: " + transactionsResponse.transactions[i].name)
console.log("Amount: $" + transactionsResponse.transactions[i].amount)
console.log(transactionsResponse.transactions[i].location)
// Calculate sales tax cost
total_sales_tax += transactionsResponse.transactions[i].amount*nc_sales_tax;
console.log("Total Sales Tax: " + total_sales_tax)
}
}
}
}
});
}
The script above told me that even at the highest estimate for all my accounts,
I didn't pay enough in sales tax for me to itemize my taxes, but at least I could say that
confidently. Additionally, I think it's likely that the standard deduction rate will change in the future,
and when that happens, this script might be a little more useful.
Avalara API
The last part of this project was using the
Avalara API. While I didn't end up building this
into my script, I did play around with it enough to see that it can be used to dynamically retrieve the tax rates for a given
transactions location. If you ever wanted to build an app to do this, you could use the Avalara API to get your tax rates instead of
hard coding like I did.
// Initialize Client
var client = new Avatax(config).withSecurity(creds);
// Get tax rates of address
client.taxRatesByAddress({
var path = this.buildUrl({
url: `/api/v2/taxrates/byaddress`,
parameters: {
line1: line1,
line2: line2,
line3: line3,
city: city,
region: region,
postalCode: postalCode,
country: country
}
});
return this.restCall({ url: path, verb: 'get', payload: null });
});
// Get tax rates of zipcode
client.taxRatesByPostalCode("US", 27713).then((taxRates) => {
console.log(taxRates)
});
Alpaca API
As a stock trader and developer, I inevitably decided one day in 2019 to see what APIs existed to trade stocks.
I figured this would be extremely common since finance and trading is already done programmatically by many,
but when I checked Fidelity and some other sources, I was surprised to find that it didn't seem to be as accessible as I thought it would be.
After more digging, I found the Alpaca API, and I immediately had to play with it. Alpaca is an API that allows you to make commission-free trades programmatically. The Alpaca API is especially useful with
algorithmic trading, but it can also be used for other purposes. The Alpaca API also comes with a "paper" account, or a sandbox, that can be used for testing.
This is especially useful for testing new trading algorithms or strategies.
I built a few tools with the Alpaca Javascript SDK, and you can find them at the link below.
Below, you can see a few of these tools in action.
Similar to my Sales Tax project, these tools were only built with myself in mind, and therefore, are only used through the console (i.e. they don't have a frontend).
Additionally, these tools are all connected with my paper account, not my live account with real funds.
Account Management
The first thing I built with Alpaca was a tool to check my account balance. I built this primarily as a way to test the API and get comfortable with it. As you'll see in
some of the other tools, I added some functionality to tailor your output by entering either "summary" to get an account summary, or "all"
to get all your account information.
Purchase a Watchlist
One feature I had always wanted when trading with Robinhood and Fidelity was the ability to create a watchlist and then purchase it.
In other words, I wanted the ability to purchase all the stocks on my watchlist in equal amounts with the click of a button, so this is what I set out to
build with Alpaca.
To purchase a watchlist, I wrote a simple json file that included my watchlists, then I wrote a JS function that handled all the rest. For testing, I added
functionality for a test mode that would not actually purchase the stocks and did not rely on the market status (i.e. open or closed).
Position Management
The next obvious thing to build was a tool to manage my positions. In other words, I needed a way to see the stocks I currently owned and sell them.
Stock Finder
This tool goes through all the available daily data for each company in the NYSE and separates the companies into companies with a positive trend (for long positions)
and companies with a negative trend (for short positions). The positive companies are ordered in order of percentage increase over the past 1000 days (or as long as they've been around) in a positive company json, and the opposite is done
in the negative company json.
Positive Trending Companies
Negative Trending Companies
Plant Match
Plant Match is a tool that uses the science of
Companion Planting to help determine the compatibility between plants in your garden.
To use Plant Match, add each plant to the list by clicking the Add Plant button, then click Check
Compatibility to determine if the plants you've selected are Friends, Enemies, or Netrual to each other.
Plants that are Friends provide benefits to each other while plants that are enemies will hurt one or both
of the plants. Neutral plants have no significant affect on each other.
Soil Mixer is a tool to calculate the amount of each ingredient you need in your soil mix.
You can also find the project here on Github.
To use it, input the volume of soil you need (e.g. the volume of your pot or raised bed) and
select the units, pick your soil mix, then add a row for all the ingredients in the soil mix
you're using. Next, add the number of parts (i.e. ratio) for each ingredient to match the mix
you're using. Lastly, click the calculate button when finished to find out exactly you much of
each ingredient you need.
Example Mixes
2 parts potting mix
1 part perlite
1 part peat moss
2 parts compost
1 part perlite
1 part vermiculite
4 parts Peat Moss
3 parts peat moss (screened)
2 parts perlite (horticultural grade)
2 parts topsoil (screened and sterilized)
1 part vermiculite
1 part No. 3 coarse sand
1/4 part charcoal (horticultural grade)
1/8 part bonemeal
1/8 part Dolomitic lime
1/8 part 14-14-14 Osmocote
100 parts peat moss
100 parts vermiculite
1 part lime
1 part blood meal
3/4 part bone meal
107 parts compost
107 parts vermiculite
107 parts peat moss
1.5 parts blood meal
1 part clay phosphate
1 part greensand
VMware PSOD Reader
As a Systems Reliability Engineer (SRE) at Nutanix, I often worked with customers troubleshooting hardware
failures on ESXi clusters, and this regularly includes the VMware Purple Screen of Death (PSOD).
When hardware fails on an ESXi servers and a PSOD is generated at boot, we have to look at the Machine Check
Exception (MCE) that's included in the PSOD to determine what hardware has failed.Specifically, the
MCi_STATUS register within the MCE can tell us what we need to replace.The MCi_STATUS register is displayed
next to the “S:” as shown in the example below.
Working through the KB took a fair amount of time and added to the risk for error,
so when I learned Nutanix nor VMware had an automated tool to translate the error, I decided to build one.
