DEV Community: Jonny Pabon

8 tips to embrace API documentation with both arms instead of one

Jonny Pabon — Fri, 08 Dec 2023 21:25:21 +0000

Hello! I'm back with another thought I had.

So here is the scoop. I was indulging in some research on API documentation for educational purposes and came up with a few tips after taking a step back. What I realized is that API documentation is overwhelming. This is due to the technical language used, the code snippets provided, and the lack of explanation on what else you can do with a specific endpoint. For me, I need examples, videos (if possible), or use cases to get the full effect.

I found the tips below helpful in taming your brain to go at this with ease instead of going in with no plan and being surprised and slapped as Charlie Murphy did:

Okay, we had a good laugh. Now, let me tell you what you need to do:

Start small and focus on your immediate needs. Treat it like your favorite sandwich, savor each bite, and soon you'll be an expert.
Try to figure out the structure of the documentation. The structure is usually organized like a library with sections such as getting started, authentication, resources, and error codes. Use the table of contents and search bar to guide you. Ain't no shame in using your table of contents game
Use the code examples provided. This is important because you should test APIs using Postman or other software to see how it works. If you're working with a product and need to know what endpoints are in play with your monitoring tool, this will give you an understanding of how things are connecting.
Experiment with the API. Try different calls and parameters to learn limitations. Why? This is crucial to ensure that users understand the API's capabilities and limitations.
Use playgrounds like if available. It's like a sandbox where you can safely test and play with code. Ex: Postman, SoapUI, Insomnia (my favorite), or the bigger names like GCP console or Amazon API Gateway console.
It's always a good idea to join developer communities and forums that are dedicated to the API you are using. There are no silly questions, so don't hesitate to ask them. Share your knowledge with others and learn from them as well, since there is no one right way to do things. You can gain different perspectives from different people.
Be patient. Learning takes time and effort. Embrace failure and know that you will not get it right away. If you're stuck, take a break, revisit the documentation, and ask for help.
Keep up-to-date with the API documentation. It's a living document that evolves, so revisit it periodically to stay informed. Who knows, you might be somewhere sleeping and a question comes up and you are like:

Keep learning and exploring new APIs. The more you learn, the more powerful you become. BE RELENTLESSLY RESOURCEFUL! - Now! Embrace the API with both hands and the heck with the consequences. That's living and part of the journey. #stayhumble #stayfocused #staywarm #enjoylifechallenges #API

Goodbye to Mundane Tasks - Hello to Automating your life with Python

Jonny Pabon — Thu, 07 Dec 2023 15:05:24 +0000

Wake up, sleeping giants! I know it's been a while but I'm back again with another hit for the books.

Do you wish you could clone yourself to complete the mountain of things on your to-do list? Well, Christmas has come early because Python, the scripting language, is here to help you escape towards being productive.

Imagine sipping your favorite beverage while your computer automatically checks your emails, organizes your files, and even schedules your next appointment. It may sound like something out of the movie "Her", but it's possible with the power of Python automation.

NOTE: To my neurodiverse folks, this is something I encourage you all to look into. It will make a difference in your LIFE!

But before you drop it like it's hot, let's break down the process into manageable pieces.

Let's take a walk and think of it like building a robot:

Step 1: Identify the Problem: What's the repetitive task that makes you want to scream into the void? Is it copying and pasting data, filling out forms, or maybe scheduling meetings? Once you've identified the issue, you're almost there.

Step 2: Break it Down: Imagine you're explaining the task to a five-year-old. What are the individual steps involved? Allows you to visualize the type of task you need to get the job done.

Step 3: Choose Your Tools: Python has a vast range of tools like Selenium for web scraping, Pandas for data analysis, and PyAutoGUI for keyboard and mouse control. Choose the right tools for the job and watch your worries disappear.

Step 4: Learn to Code: Hey Humans! You don't need a Ph.D. in computer science to write Python code. There is a vast variety of places to learn all of this. All you need is determination and a mindset that embraces failure as a learning opportunity. By doing so, you can train your brain to think in a completely different way and succeed.

Step 5: Test, Refine, and Repeat: Like any good learner, your Python script needs testing and refinement. Run it through its paces, fix the bugs, and make it the automation beast you know it can be.

Step 6: Sit Back and Relax: Now that your Python script is doing the tasks that you dread, you can chill out and watch it go. The world is yours at this point.

Now, let's move on to the exciting part - how to engage your engineering brain! This example will help solidify this concept.

**1. The first thing to look for is an automation tool:
There are many options available for automating bulk emails, but for this - I will be using Python with the library pyautogui

2. Identify email application elements:
This for me was the fun part as I learned all about the elements needed to automate sending bulk emails. For this, you need to locate the buttons and fields for creating and sending emails. You can then determine how the application handles addresses, attachments, etc.

3. Record or script the process:
Super Important:
Be sure to record your steps with a macro recorder or manually write code to simulate the steps. Include comments about filling the email address field with the Gmail group address and adding updates to the body.

4. Run the automation:
Finally, run the script or macro to automate sending the email. BOOM DONE!

Oh no! I haven't finished yet. Here's an actual code snippet I created to demonstrate this concept.

#Import pyautogui = Automation | time = time delays between actions

import pyautogui
import time

# Store gmail URL in the url variable
url = "https://mail.google.com/"

# Team email group address
group_address = "iamawesome@ohyeahiam.com"

# Fill in the subject line
subject = "New Idea to Share"

# Add in your description of the email 
body_text = "Today, I would like to share something\n\n..."

# Open Gmail in a new tab, add a second delay, write url in the address bar, then automatically submit it.
pyautogui.hotkey('ctrl', 't') 
time.sleep(1)
pyautogui.write(url)
pyautogui.press('enter')

# Give it a time to load after submission
time.sleep(5)

# Locates the compose button and then clicks it
compose_button = pyautogui.locateOnScreen("compose_button.png")
pyautogui.click(compose_button)

# Pass in the group_address variable
pyautogui.write(group_address)

# Subject text can go here
pyautogui.write(subject)

# Body text can go here
pyautogui.write(body_text)

# Once everything else is set, email is sent using send_button
send_button = pyautogui.locateOnScreen("send_button.png")
pyautogui.click(send_button)

# Quick confirmation that this script worked
print("Email Sent via Automation!")

Psssstt! Over here! Always remember that automating your life with Python isn't just about saving time, it's about making life easier for you. It's about saying bye felicia'ing (yep, I made that up) to those time-consuming tasks and hello to a more enriching workflow.

Hope this helps!

Mental Health Goes Digital: How APIs are Helping to Improve Access and Support

Jonny Pabon — Tue, 18 Apr 2023 15:54:06 +0000

Welcome back! I know it's been a minute since I posted. Let's talk about the post I initially wanted to share before my last one.

I know what you are thinking "What do you mean by actual post?". I'll tell you what I mean as I decided to give you the double stuff this week.

Without further ado, on to the good stuff: Imagine scrolling through your favorite social media platform, and wham! You stumble upon a post that captures and deeply resonates with you, and I mean deep-sea diving deep.

Maybe it's a story about someone overcoming anxiety or a tip for managing stress. Whatever it is, you're grateful for having the ability to connect with it and even appreciate the support it provides.

I have always wondered about the technology that makes these moments possible. But look no further, we now will enter the domain of Application Programming Interfaces (APIs), our Dark Knight.

These amazing tools are how we access and share information online, enabling us to connect with people and resources in ways we never thought possible.

From social media platforms to e-commerce sites, APIs are the backbone of many online services, allowing us to interact with websites and apps. But did you know that APIs are used in mental health, connecting individuals with resources and support when they need it most?

APIs for tracking mental health
There are APIs available for tracking mental health data such as mood, anxiety levels, and sleep patterns. These APIs allow individuals to monitor their mental health and share the data with healthcare professionals.

Here are some examples:

Moodscope:
Moodscope is an API that allows individuals to track their moods and receive insights and advice based on their mood data. The Moodscope API provides a simple REST API to access the Moodscope service. You can authenticate with the API using your Moodscope credentials, and then retrieve mood data.

Here's an example of how to use the Moodscope API to retrieve mood data:

import requests
import json

url = 'https://moodscope.com/api/public/v2/login'
headers = {'Content-Type': 'application/json'}
data = {'email': 'your_email', 'password': 'your_password'}

response = requests.post(url, headers=headers, data=json.dumps(data))
access_token = response.json()['access_token']

url = 'https://moodscope.com/api/public/v2/mood'
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {access_token}'}

response = requests.get(url, headers=headers)
mood_data = response.json()

T2 Mood Tracker:
T2 Mood Tracker is an API that allows individuals to track their emotional and behavioral health. The T2 Mood Tracker API is a REST API that uses OAuth2 authentication to authenticate requests.

You can retrieve anxiety data from the T2 Mood Tracker API by first authenticating with the API using your T2 Mood Tracker credentials, and then retrieving anxiety data.

Here's an example of how to use the T2 Mood Tracker API to retrieve anxiety data:

import requests
import json

url = 'https://t2moodtracker.com/api/v1/anxiety'
headers = {'Content-Type': 'application/json'}
data = {'username': 'your_username', 'password': 'your_password'}

response = requests.post(url, headers=headers, data=json.dumps(data))
access_token = response.json()['access_token']

url = 'https://t2moodtracker.com/api/v1/anxiety/entries'
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {access_token}'}

response = requests.get(url, headers=headers)
anxiety_data = response.json()

Ginger.io:
Ginger.io is an API that allows individuals to track their mood, anxiety, and sleep patterns. The Ginger.io API uses OAuth2 authentication to authenticate requests. You can retrieve sleep data from the Ginger.io API by first authenticating with the API using your Ginger.io credentials, and then retrieving sleep data.

Here's an example of how to use the Ginger.io API to retrieve sleep data:

import requests
import json

# Replace with your API credentials
username = 'your_username'
password = 'your_password'

# Authenticate with the API
url= 'https://api.ginger.io/oauth/token'
headers = {'Content-Type': 'application/json'}
data = {'username': username, 'password': password, 'grant_type': 'password'}

response = requests.post(url, headers=headers, data=json.dumps(data))
access_token = response.json()['access_token']

# Use the API to retrieve sleep data
url = 'https://api.ginger.io/api/v2/sleep'
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {access_token}'}

response = requests.get(url, headers=headers)
sleep_data = response.json()

APIs for accessing mental health resources
There are APIs available that provide access to mental health resources such as therapy and counseling services. These APIs can help individuals connect with healthcare professionals and get the support they need.
Here are some examples:

BetterHelp:
BetterHelp is an API that allows individuals to connect with licensed therapists and counselors. The BetterHelp API uses OAuth2 authentication to authenticate requests.

You can retrieve therapist data from the BetterHelp API by first authenticating with the API using your BetterHelp credentials, and then retrieving therapist data.

Here's an example of how to use the BetterHelp API to retrieve therapist data:

import requests
import json

url = 'https://www.betterhelp.com/api/v1/login'
headers = {'Content-Type': 'application/json'}
data = {'email': 'your_email', 'password': 'your_password'}

response = requests.post(url, headers=headers, data=json.dumps(data))
access_token = response.json()['data']['token']

url = 'https://www.betterhelp.com/api/v1/counselors'
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {access_token}'}

response = requests.get(url, headers=headers)
therapist_data = response.json()

My thoughts on APIs for mental health education
Several APIs provide mental health education resources, such as the National Institute of Mental Health's API. These resources can include articles, videos, and other educational materials.

Here's an example of how to use the National Institute of Mental Health's API to retrieve information on depression:

import requests
import json

url = 'https://www.nimh.nih.gov/api/content/condition/depression'
headers = {'Content-Type': 'application/json'}

response = requests.get(url, headers=headers)
depression_data = response.json()

What I get from all of this is the APIs mentioned above offer a solution for individuals interested in mental health support and resources. By using APIs, they can track mental health, connect with healthcare professionals, and even access educational materials.

Lastly, APIs can be easily integrated into apps and websites, making mental health support more accessible than ever before.

Now, you can breathe

Until next time!

[Spoken Word] From Head to Heart: How APIs are Helping to Mend the Broken Parts

Jonny Pabon — Sat, 11 Mar 2023 21:56:58 +0000

[TRUE STORY]

Last night, I had a dream that left me feeling inspired, and in that dream, I dug deep into my heart and mind and found something valuable: solid gold. As I turned it over, I saw a message inscribed on it, and this is what it said:

In a world where mental health can be tough,
Where getting support can sometimes be rough,
Where stigma and shame can leave you feeling alone,
APIs are a tool that we can all own.

From Headspace to Calm to Moodfit,
APIs are providing access to mental health benefits,
Connecting people to resources and care,
APIs are making mental health more fair.

Breaking down barriers and opening doors,
APIs are providing support like never before,
From tracking moods to finding therapy,
APIs are empowering you and me.

With the power of technology at our fingertips,
APIs are providing support with ease and quickness,
Improving lives and making a change,
APIs for mental health are truly amazing.

So let's embrace this innovation with open hearts,
And use APIs to improve mental health and play our part,
To break the stigma and support one another,
APIs for mental health - we're all in this together.

With that said,

Level Up Your API Security: Don't Let Hackers Be the Boss of Your Web App

Jonny Pabon — Fri, 24 Feb 2023 19:55:34 +0000

Welcome back!

For today's post, I figured I would try a new approach using my favorite classic console, Nintendo, so join me as we start visualizing our web app as one of your favorite classic games.

You're the hero or heroine, smashing your way through levels, defeating bosses like a boss. You start feeling like the bosses aren't the main thing you need to worry about anymore, and suddenly you stumble upon the shapeshifting Terminator assassin, T100, lurking in the shadows, who is waiting to steal your data and damage your high score.

Here is where the API security comes in, and think of this as the power-up that helps you defeat the assassin, protect your data and learn some ways to level up your API security game.

First, use encryption like Link's shield in The Legend of Zelda, you know dude with all green and rides a horse looking serious like this:

You get the point, now the use of encryption keeps your data safe from snooping eyes, like a secret dungeon hidden deep within the game.

Next, you can implement access controls that help you keep certain users or apps out of your API, think of a locked door which is pretty typical in a classic dungeon-like game. Goal is to find the key, and you will gain access to the hidden treasure area.

Another part of the holy API grail cup is rate limiting, like Donkey Kong throwing barrels at you as you climb to the top. Rate limiting helps you prevent one user or app from dominating all your API resources, like how Donkey Kong tries to stop you from getting to the next level, but you are just a master at dodging his barrels - a piece of cake, right?

Setting your rate limits is like timing your jumps in the game. Yeah Kong, we know the secret!

Lastly, don't forget about monitoring and logging.

Monitoring and logging provide visibility on your API traffic, so you spot any suspicious activity, like Solid Snake sneaking around undetected.

Just make sure you're logging everything you need to, like the codec messages in Metal Gear Solid.

Remember how Solid Snake uses a codec device to communicate with other characters and gather intel on enemy activity? Similarly, logging everything in your API can help you gather important information about user activity and identify potential security threats.

And just as Solid Snake must be vigilant and aware of his surroundings, you must monitor your API traffic can help you stay on top of any suspicious activity and respond quickly to any threats.

Hope you learned something fun! Until next time.

Get the inside scoop on the 5 most common APIs you use daily (with a Python Build Example!)

Jonny Pabon — Wed, 22 Feb 2023 04:52:27 +0000

Yes! Of course, every person has got to have some API love in their lives. Without it, what is life?

Let's give a cheesy joke a go. Ready?

Why did the chef start using APIs?

They realized that APIs could help them streamline their food delivery process and get delicious meals to their customers faster!

Haha, what? Come on! Did you at least crack a smile? Since I can't see you, I'll assume you were rolling on the floor laughing.

Let's get into some APIs we use and some examples of their usage:

Google Maps API:
Have you ever used Google Maps to find directions to a location? Google Maps API allows other apps to use Google Maps to help you find your way around. In other words, apps like Uber, Lyft, or food delivery services can use Google Maps to help you get to your destination quickly and easily.

Facebook API:
The Facebook API allows other apps to access Facebook data, like your profile or pictures. In other words, you can use apps like Instagram or Spotify to share your favorite music or photos with your friends on Facebook without ever leaving the app.

Twitter API:
The Twitter API allows other apps to interact with Twitter, like scheduling tweets or tracking your followers. In other words, you can use other apps to manage your Twitter account and keep track of all your social media in one place.

OpenWeatherMap API:
The OpenWeatherMap API provides weather data to many apps, including weather apps or travel apps, to help you plan your day or vacation. In other words, you can smoothly check the weather before leaving your house or planning a trip to another city.

My Personal Favorite
Yelps Fusion API:
The Yelp APIs gives information about businesses and locations in your desired area. In other words, when you navigate to Yelp's website or mobile app, you can search for business reviews, photos, ratings, and any business details that are important to you.

APIs are necessary because they allow all your favorite apps and services to communicate with each other, which makes it possible for different companies to provide an encompassing experience for users.

If APIs didn't exist, it would be difficult for apps and services to communicate with each other leading to having a mundane experience across different apps and services. Plus, it would mean that apps would have to build their APIs from the ground up, which would be expensive, most importantly, time-consuming.

For those curious about building APIs, there are web frameworks you can read up on like:

Flask, Django, FastAPI for Python,
Express.js for Node.js,
Ruby on Rails for Ruby,
ASP.NET for .Net

There are several others, but these are a few options. Everyone has their creative way of building APIs, but I figured it would be good to share a quick example of what this would look like in Python using Flask.

If you aren't familiar with Flask, here's a short and simplified bulleted list:

It's a tool used for creating websites and web app with Python
Makes it easier to create different parts of a website
Helps organize the different parts of a website
Allows adding extra features to a website, like a login system or database.
Makes it easier to get information from people who visit a website, like a search term or form submission

Now for the good stuff

Assuming your terminal path points to the working project folder

Do a pip install Flask
Create a new file within that directory folder.
Add from Flask import Flask to import the Flask class at the top of the file.
Create an instance of the Flask class inside of your file and then give your API a name like so app = Flask(__name__)

If you are like me, there may have been some internal self-talk like, "create an instance of the flask class, but why?" Through my research, I found that the Flask class represents your app, and by creating the Flask class instance, you can define your routing and other functionalities. If you do not, well, your app will not work.

After that I was like:

Next, make sure to define your API endpoint by defining a function that will be called when your API is accessed.

@app.route('/')
def hello_world():
    return {'message': 'Hello, World!'}

Explaining the above:
When a client (PostMan, browser, etc.) makes a GET request to the root endpoint (i.e "/") of the Flask app, the hello_world() function will be executed. Which returns a Python Dictionary with a single key "message" and value of Hello, World!

{
    "message": "Hello, World!"
}

Once you understand the fundamentals of creating API requests, you can get pretty awesome JSON responses for yourself in the format shown below :)

{
    "name": "Go Jonny Go Go Go",
    "age": old enough to be awesome,
    "email": "jonnybegood@example.com",
    "address": {
        "street": "123 Forest Ave",
        "city": "MyCity",
        "state": "MyState",
        "zip": "12345"
    }
}

I enjoy Python and most libraries and packages available. A short demonstration is in order using Python, the "Requests", the "JSON" module, and Yelps API. I'll provide each line with an explanation for folks who are curious about my flow.

These modules are used to make the HTTP request and parse JSON responses as expected.

import requests
import json

The lines below are defining the Yelp endpoint and the parameters to include in the API request.

url = "https://api.yelp.com/v3/business/search"
params = {
     "term": "restaurants",
     "location": "Chicago",
     "limit": 10

}

Setting your headers with the API_KEY generated from the app you've created within Yelp. For more information, check out this link.

headers = {
    "Authorization": "Bearer <API_KEY>"
}

I've created a response variable that stores the response from the API and will send a GET request to the Yelp API endpoint specified in the URL. We will include the API authorization header in headers and the search parameter in params.

response = requests.get(url, headers=headers, params=params)

Next, We will need to parse the JSON response returned by the API, which we know is stored in the response variable. We can use the json.loads() method and then store the result within the data variable.

data = json.loads(response.text)

With the data you've retrieved, you can extract the list of businesses from the JSON response data.

businesses = data["businesses"]

The final step would be to loop through the lists of businesses in the businesses variable, and for each business, it extracts the name and rating values, then prints them to your console for review.

for business in businesses:
    name = business["name"]
    rating = business["rating"]
    print(f"{name}: {rating}")

You should get back a response JSON like this:

{
  "businesses": [
    {
      "id": "hBb2RcUVumohfY2kbGKvKQ",
      "alias": "hide-seek-chicago",
      "name": "Hide+Seek",
      "image_url": "https://s3-media2.fl.yelpcdn.com/bphoto/lIX142MB4grB7gZs-plt_Q/o.jpg",
      "is_closed": false,
      "url": "https://www.yelp.com/biz/hide-seek-chicago?adjust_creative=3Q-VbeGWSe3kCIvZvn-AXg&utm_campaign=yelp_api_v3&utm_medium=api_v3_business_search&utm_source=3Q-VbeGWSe3kCIvZvn-AXg",
      "review_count": 79,
      "categories": [
        {
          "alias": "newamerican",
          "title": "American (New)"
        }
      ],
      "rating": 4,
      "coordinates": {
        "latitude": 41.88466,
        "longitude": -87.64899
      },
      "transactions": [],
      "location": {
        "address1": "838 W Randolph St",
        "address2": "",
        "address3": null,
        "city": "Chicago",
        "zip_code": "60607",
        "country": "US",
        "state": "IL",
        "display_address": [
          "838 W Randolph St",
          "Chicago, IL 60607"
        ]
      },
      "phone": "+13126808217",
      "display_phone": "(312) 680-8217",
      "distance": 8950.985739997868
    }

Now it's your turn! I encourage you to try out some of the APIs I've discussed in this article, and share your own experiences in the comments. Together, we can continue to learn and grow as developers.

Until next time - Cheers!

Overcoming the Common Fears in API Troubleshooting and Debugging (well, in my opinion)ミ(☉﹏☉)ミ

Jonny Pabon — Sat, 11 Feb 2023 05:26:49 +0000

A'lil appetizer to keep you interested before the real meal arrives ᕙ(`▿´)ᕗ

API (Application Programming Interface) is a set of protocols, routines, and tools for building software and applications. It acts as an intermediary between two software systems, allowing them to communicate. However, even with the convenience that APIs bring, troubleshooting and debugging can be intimidating for new developers who are just starting to work with APIs.

In other words, An API is like a phone operator that connects two different software systems so they can talk to each other. It's a set of rules that helps the systems understand each other. Using an API makes it easier to build new software, but it can be challenging for new developers to fix problems when they arise.

Now for the good stuff!

I will explore the four common fears I have encountered when debugging/troubleshooting APIs, and provide practical tips and solutions that helped me through these challenges.

Discovered Fear 1: Lack of Understanding of the API
One of the biggest fears of beginners in API troubleshooting is a lack of understanding of the API they are working with.

You should at least understand the API’s functionalities, requirements, and limitations you are using. Checking out the API documentation and experimenting with the API using a testing tool or through a community of developers is a great way to learn.

Discovered Fear 2: Difficulty in Debugging Debugging
APIs can be challenging. Yes you heard me!!! It is especially tough for beginners unfamiliar with the process.

Having a clear understanding of the error messages and be familiar with the tools and techniques used in debugging APIs. This can include using the API’s debugging tools, logging, and monitoring.

Discovered Fear 3: Security Concerns
Keep in mind that APIs often contain sensitive data, and those unfamiliar may be concerned about security issues when troubleshooting and debugging.

All I can say is to follow best practices in API security, such as using secure connections, following authentication protocols, and using encryption. I had my fair share of spending hours researching all about it. No judgement there!

Discovered Fear 4: Performance Issues
Performance issues tend to rear their ugly head when working with APIs, and beginners may be concerned about the impact on their applications. Understanding the API’s performance limitations (READ DOCS) and be familiar with tools and techniques for optimizing API performance, such as caching, compression, and load balancing.

GOOGLE IS YOUR FRIEND, USE THEM!

All in all, API troubleshooting and debugging can be intimidating for new developers, but those fears can be overcomed. I'll say it once more for the people in the back, understanding the API, being familiar with debugging tools and techniques, following best practices in API security, and optimizing API performance, beginners can become confident and effective API troubleshooters and debuggers.

In conclusion, API troubleshooting and debugging is a integral part of API development, and with the right resources and support, beginners can overcome common fears and become ninja API devs.

Hope you are feeling like good ol' nic right about now!

How I became an empathetic and proactive Technical Support Engineer while managing my human emotions?

Jonny Pabon — Thu, 08 Dec 2022 20:17:01 +0000

My first of many posts!

I remember when MySpace was at its best, and I would spend hours building my profile and using JavaScript to make a falling objects effect occur when someone navigates to my page. For those of you who used Myspace, remember how cool it was to have a responsive profile with music. Well, it was for me.

It took a while to figure out how I do this since coding was so new for me at the time. However, the ability to create something that was mine to share was fascinating. I continued to seek more ways to express myself.

I knew others who struggled to implement new technologies into their daily life (like I did and still do from time to time) and needed someone to help them. It was the driving force that sparked my desire to become technically savvy and empathetic to others who needed help achieving their goals.

Okay, Okay - I will give the theatrical dramatics a rest. Have I captured your heart and soul yet? Good. Let's fast forward to where I am now today, and I'll share things I've learned throughout my journey.

To be an empathetic and proactive Support Engineer (in my opinion), take a deep breath and remove your emotion from the situation. For example, a customer calls in regarding a severe incident and has expressed frustration about it. Or it could be a new customer needing help implementing the product you are supporting. Everyone is busy, anxiety kicks in, and imposter syndrome decides to say hello.

One final Giphy, I promise. It's addicting. It's out of my system now.

The ball was in my court in figuring out how to handle the situation. We will use the new implementation for this example.

After taking a breath, I thought about being in the customer position and asked myself the following questions:

What kind of person would you want to support you?
How can I bring value and build rapport with this individual I am meeting for the first time?
What are ways to help increase the customer's adoption of the product they purchased?
[Brain goes into cray cray mode] Am I good enough? Are they going to judge me? Are people listening to me speak on my call? Why am I here today?

Reeling it back to reality, I am sure the last set of questions slips into your thinking process during moments like this, but remember you got hired for a reason, and you are capable of doing this.

Once you are back and ready to take the call, say hello and get them excited about talking to you. After introductions, invite them to talk about their workflow, any pain points, who will be utilizing the product, and what goals they hope to achieve using the product.

Making this a collaborative effort (e.g asking questions about their needs) will help you feel more confident in your suggestions and show you care about their success. I cannot begin to tell you how many failed attempts I have accumulated. I'd rush through conversations and miss opportunities to enrich a customer's experience. All because I didn't feel engaged in the conversation.

Making this a collaborative effort will help you feel more confident in your product suggestions and show you care about their success. I cannot begin to tell you how many times I've failed with this. I'd rush through conversations and miss opportunities to enrich a customer's experience. All because I didn't know to think about it from their perspective so I was less engaged in the conversation.

To get good at this skill, I started my own side business doing implementation consulting for small businesses. It required me to create a plan of action and template questions to help me stay focused and proactive.I understand how this may not apply to other personality types, but if you are planning on being the best you and happen to want to be a Technical Support Engineer with soft skills. Maybe this will help. It certainly helped me.

More to come on Mental Health as a Techie soon!