DEV Community: Federico Roman

🚀 Send WhatsApp Messages via API with 2Chat

Federico Roman — Wed, 05 Feb 2025 14:09:11 +0000

This quick tutorial will guide you through sending messages via WhatsApp using the 2Chat API.

✅ Requirements

A 2Chat account with a connected WhatsApp number.
That’s it! You’re ready to go.

📌 Steps

Create a 2Chat account and connect your WhatsApp number in the Channel section.
Grab your API Key from here.
Now, let’s send a message using Python!

🐍 Sending a WhatsApp Message with Python

Imagine you have a sender number (+5959123123) and want to message a recipient (+59594545). Here’s how you do it:

import requests
import json

url = "https://api.p.2chat.io/open/whatsapp/send-message"

payload = json.dumps({
  "to_number": "+59594545",
  "from_number": "+5959123123",
  "text": "Hi!",
})

headers = {
  'X-User-API-Key': 'your_api_key_here',
  'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers, data=payload)

print(response.json())  # Check the response

🎯 That’s It!

With just a few lines of code, you’ve successfully sent a WhatsApp message via API. For more details and additional API functionalities, check out the official 2Chat API Docs.

Technical Learnings after 1 month

Federico Roman — Thu, 06 Apr 2023 14:31:52 +0000

After I few weeks of taking a breath I start a job as Software Engineer at a startup working remotly. I come from a fullstack background, previous to this job I work with php and JS/React.

This project has a repo with submodules, a frontend application created with RCA using MUI and a backend with Python using FastAPI and mysql.

I start in the frontend and later move to the backend for an implementation of a new feature, some of the mistakes that I made at the begining were:

I didn't dedicate enough time to understanding the conventions of the translation files. Most of the elements started with feature_name_*, but I omitted the feature_name_ portion. I had a pending ticket to fix this.
In the backend, I used camelCase notation instead of snake_case, which most of the code was written in. This took time to change, since my responses to the frontend were in camelCase. Changing the response in the backend to snake_case required updates to the frontend as well.
Additionally, I didn't have a thorough understanding of the product, which caused delays in designing new components and experimenting with libraries for graphics.

What I learn from this is:

Always verify if a component already exists in the product and use it whenever possible. If the code is too specific to a certain use case, take the time to refactor it into a reusable component.
It's important to take the time to understand the conventions used in the codebase. While it may require an investment of time upfront, following established conventions will save time in the long run and make the codebase more maintainable.

What am I working now, as this is a startup we don't have too much time for improvements or try new things so in my free time I'm including tests with cypress, doing a refactor in the frontend base on this article and making a migration from CRA to Vite.

Configure multiple ssh credentials with git

Federico Roman — Fri, 03 Mar 2023 22:49:09 +0000

If you wish to configure multiple SSH keys on your computer because you use it for both work and personal projects, you need to set up different users in your repository.

Assuming that the first key is referred to as a “personal_key” and the second is referred to as a “work_key," both of which have their own public files extensions, you can edit the config file (~/.ssh/config) to include the following details.

Host work-github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/work_key
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/personal_key

Once saved, go to the working folder where you are running this project from (for example home/dashpy/work) and use command git remote -v. This should bring up something similar to:

$ git remote -v
origin  git@github.com:dashpy/insight.git (fetch)
origin  git@github.com:dashpy/insight.git (push)

We want to change that and tell git that when I'm working in this work project use my work ssh key, so to do that we type

git remote set-url origin git@work-github.com:Company/product.git

Which will tell Git that it should use your work SSH key when this particular working project is used.

The end.

[Recommend] Tips for technical interviews

Federico Roman — Sat, 17 Sep 2022 23:01:47 +0000

Which tips would you recommend for someone who is going to have an interview as a developer?

Run a node app into AWS lambda

Federico Roman — Tue, 06 Sep 2022 00:41:56 +0000

I create this post because I didn't find any information on this when I needed it, or the information was dispersed around the web, so I hope this post helps someone. This is going to be straight and I'm assuming that you already have a private repository in AWS.

Steps

Create your code and ensure that a handler exists.
Setup & upload your Dockerfile with the right parameters.
Configuring AWS.
Close the rest of your browser tabs.

If you are reading this before you write any code make sure to check the repository of AWS and confirm the node version (Some of the node versions are not verified, you can find the supported versions here).

Once you have your Node JS code you need to make sure that inside your main file exists a handler function this is a requisite for lambda functions no matter the programming language.

const https = require('https')
let url = "https://docs.aws.amazon.com/lambda/latest/dg/welcome.html" 

export.handler = async (event) => {

  const promise = new Promise((resolve, reject) => {
    https.get(url, (res) => {
        resolve(res.statusCode)
      }).on('error', (e) => {
        reject(Error(e))
      })
    })

  return promise

}

After you have all your logic we are going to create a container with docker. Your Dockerfile should be similar to this:

FROM public.ecr.aws/bitnami/node:14.20.0

COPY ./source .

RUN npm install --omit=dev


CMD [ "app.handler" ]

In this case, we're using node:14.20 as an image (notice the repository), we install all the packages ignoring devs dependencies (we don't need linters or other tools into the container) and in the CMD we call the function handler.

For testing purpose you can also use node -e 'require("./index").handler()' in CMD.

Then build the container.

docker build -t <name>:<tag> .

Push the files to your AWS private repository using the CLI of AWS (be aware that the following are just dummy data, you need to replace them with your values).

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com

docker tag  <name>:<tag> 123456789012.dkr.ecr.us-east-1.amazonaws.com/<name>:<tag>
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/<name>:<tag>

Lambda is going to run this every time that is being invoked. Now you need to create a repository inside AWS.

After you push your files go into lambda and select create a lambda container function, once there just pick the container from your repository, and set the correct permissions. Once finish the process try to invoke the test, you can place an API Gateway layer so your function can be called from an endpoint.

Some other helpful resources:

AWS Node Lambda container documentation.
Sample of the code inside my personal repo
This one is a video tutorial for python

The one thing that you found hard to scale is?

Federico Roman — Tue, 22 Mar 2022 17:03:44 +0000

Would you rather be a 10x dev or one with imagination?

Federico Roman — Sun, 20 Mar 2022 19:26:16 +0000

Managing unexpected scenarios

Federico Roman — Wed, 02 Mar 2022 23:42:46 +0000

When we develop a product we are aware that often bugs can happen, or unpredictable events can affect the product when the customer is using it. I'm sure that no one wants to get a bad review or a call from an angry customer telling them that the platform that he/she is using is not working correctly. The worst scenario for every team is that one of the critical functionality isn't working.

This is an approach for a small team of developers, very often to keep the product up and running we need to move super fast, sometimes this means leaving things for later and moving on with the critical things.

Scenario: The server is getting loaded with multiple requests from the application so it's throwing errors.

Possible solutions:

Infra-side
Scale horizontally
If you have your servers on the cloud then add another server and configure your load balancer. The customer probably won't notice the delay, however, this means that we are going to pay something $$ for this unplanned scale.

Scale Vertical
Again under the same premise of getting our servers in the cloud we can upgrade the characteristic of the machine (add more RAM, CPU, etc). Again the customer probably won't notice the delay, however, this means that we are going to pay something $$ for this unplanned scale.

Server-side
Verify if your server has a configuration that is limiting the number of requests. In the case of using Nginx if the server is being overloaded with requests, it will start to throw the same response code. Make sure to use CDN for static content & cache strategies for files that are being served like jpg, js, mp3, etc.

Code-level
Add interceptors at frontend level
This means that when the frontend receives a request indicating a memory issue the frontend is going to handle the request that is sent to the server. This means that we need to consider what are the critical functionalities that need to serve and what are the ones that can wait till the server gets fully recovered.

Verify your ORM connections
Verify that you are not using (wrongly) transaction connection in your ORM at backend level, remember that you will block access to the DB if you are using a transaction code (e.g you have a GET endpoint some_domain/users/125, and for some reason, you are opening a transaction and store something in the DB, then close and return the response. This works great ... for at least 20 requests or at least, after the amount is being passed, let's say 30RPS the new requests are being queued, this means that a request that takes 2 seconds is taking 1 minute, and so on).

The most important advice, use proper logs, test the scenario of your catch (in your try{ ...} catch(...) {...}), because of time we don't usually check this, and in the Merge request process is not simple to notice if the process to log is the proper one.

This is everything, for now, let me know what you think and if you consider other tips that can be useful for the people who land in this post.

5 Career advice: Frontend

Federico Roman — Sat, 26 Feb 2022 20:59:28 +0000

I'm almost 8 years old as a developer, start as QA, then went to frontend, backend, and then switch again to frontend, where I did my time focus in UX/UI. Currently, I found myself working as a frontend engineer.

Learn to listen
During my career as a dev, the one thing it was hard to take at the beginning was the feedback. Over the time I work after-hours to try to improve my skills, some of the meetings end up in '... I like this, this and this, but could we improve on this or that ...', so don't take personally the things and work over that.

Do one time at the time
In my case multi-tasking never work, I became obsessed with the use of the board of Jira, I need to get everything in order there, what task was in progress, what needs to be done next, and what was the priority of the tasks so at the end of the day I wasn't too disperse in my head worrying about other tasks.

Learn the basics
At the time I was trying to keep up with the trends, over time this become difficult, probably every day a new JS library pops out. At the same time that a new library comes I notice that it was really familiar to other libraries and if I get the principal concepts of the library/fw I will be able to make the code work. Go to the basics, learn JS, understand the differences between them, the holy bible is You don't know JS.

Don't overestimate soft skills
Most of the devs/Engineers are really good in what they do, but they lack soft skills, be always conscious about that, remember that your career also includes building a reputation, if you had the reputation to be a hard people to work is going to be hard for you move in your company.

Look for something else
Once you learn the basics I'll hardly recommend learning about performance and lastly about design, as devs we are always in the mindset of a developer, like, There should be a link here, and when the user clicks the routing should render the page; but we almost never put in the user seat, try to use your system/app with the mind in blank, like you don't know what happens if you click there, remember this "If the user doesn't understand your system is going to be afraid to use it".

This is everything, for now, let me know what you think and if there is other advice that you should consider for the new ones.

What are you learning and why?

Federico Roman — Thu, 24 Feb 2022 20:49:23 +0000

What are you learning these days and why are looking into?