What It Means to “Cook Beans” as a Nigerian Tech Bro

Micheal (Mikolo): The guy you call when you need a miracle. Known as Mikolo, he’s pulled off some incredible feats of coding wizardry. But there have been times when his magic didn’t work, and the beans ended up overcooked.

Asake Odesomi

Asake Odesomi

— 5 min read
What It Means to “Cook Beans” as a Nigerian Tech Bro

In Nigeria, when someone says they’ve “cooked beans,” it’s not about culinary skills. Instead, it’s a phrase used to describe a situation where something has gone terribly wrong. Especially in tech, it’s like saying, “I’ve messed up big time.” Now, imagine the life of a Nigerian tech bro! A world where the pressure to deliver flawless code is high, deadlines are tight, and the stakes are enormous. In this high-stakes environment, cooking beans can mean anything from a minor glitch to a catastrophic system failure. But what does it truly mean to “cook beans” in tech, and how do we avoid it?

The Beans Cookers: Tales from the Tech Trenches
Every tech team has its stories of beans cooked, and the Sudo team is no exception. Let's introduce you to some of the characters who have had their share of cooking beans.

Abubakar (Mifos):Known for his deep understanding of fintech solutions, Mr. Abubakar is a seasoned developer. However, even the best make mistakes. Whenever he makes an error, he simply “laughs in error” and then quickly dives into fixing it. His calm demeanor under pressure is legendary, but when he cooks beans, the whole team knows it’s serious.
Jeremiah (I Will Look Into It): An exceptional frontend developer, good at centering the "div" and whatever you see. When something goes wrong, his standard response is, “I will look into it, my bad.” And true to his word, he does. But sometimes, even Jeremiah finds himself in the midst of a beans-cooking disaster that requires more than just a glance.
Micheal (Mikolo): The guy you call when you need a miracle. Known as Mikolo, he’s pulled off some incredible feats of coding wizardry. But there have been times when his magic didn’t work, and the beans ended up overcooked. Working at his level, don’t pray he cooks on a Friday, or the whole team won’t have a weekend. His standard response is, “Wo! We will do it another day. I have cooked beans.”
Kedo (1 Page): Always shy to show his code for review, as a frontend developer, he knows everybody can see the error. Even though it looks nice, he still feels there are beans all over the place. His standard response is, “OH.” His deep focus sometimes leads him down complex paths where even he can lose track of the recipe.

How Beans Get Cooked
Beans in tech can get cooked for several reasons. It might be a poorly written piece of code, a missed bug, or even an unforeseen complication during deployment. Sometimes, it’s the simple things that trip us up; like a missed semicolon or a wrongly placed loop. But what exactly happens when the Sudo team finds themselves cooking beans?

  1. Code Writing: The process starts with writing code. Our developers are skilled and meticulous, but no one is immune to mistakes. A typo here, a misaligned variable there, and the beans start simmering.
  2. Quick Fixes & Impromptu Updates: Sometimes, urgent fixes or updates are needed, and rushing can lead to unexpected issues. A quick fix might patch a problem temporarily, but it can also create new issues.
  3. Fixing Bug on Production: Sometimes due to pressure, Developers/Engineers can decide to fix bugs on production, You just say it's just a quick fix, let me not waste time for the write-test-push-deploy process then Bammmmm!!!!! You are eating well-cooked beans for hours. 

Fixing the Cooked Beans: The Sudo Approach
At Sudo, we don’t just cook beans; we fix, avoid and put measures in place. Here’s how we do it:

  1. Rapid Response: As soon as an issue is identified, our team springs into action. Whether it’s Abubakar’s “laughing in error” or Jeremiah’s “I will look into it,” the first step is acknowledging the problem.
  2. Collaborative Problem-Solving: Our team collaborates to diagnose the issue. Whether it’s Micheal bringing his Mikolo magic or Kedo diving deep into the code, we work together to find the solution.
  3. Deployment (Google Cloud Platform & AWS): After testing, it’s time to push the code to production. We use Google Cloud Platform, ensuring our applications are scalable and secure. But deployment can be a tricky process. GCP assists in making sure a build works before removing the old application, and allows us to roll back easily.  
  4. Staging Server: A staging server (also called a sandbox) is where we deploy and test code to simulate the exact conditions of the production application. When a developer pushes code, it goes to the sandbox first, where all testing can be done before merging to production. It’s like a playground. You push your code there, test it, and make sure everything works before the customers see it. Internally, the code is there, but externally, no one sees it yet
  5. Approval: Before any code goes live, it goes through an approval process. This step is crucial in catching any last-minute issues. However, if something slips through, the result can be a pot of beans no one wants to eat on the sandbox, but it never enters into production.
  6. Types of Testing: To prevent beans from being cooked, we conduct multiple rounds of testing:
    • Unit Testing: Focuses on individual components of the software to ensure each function works as intended.
    • Integration Testing: Checks how well the different modules of the software interact with each other.
    • System Testing: Tests the entire system as a whole to ensure that everything works together seamlessly.
    • User Acceptance Testing (UAT): The software is tested in real-world scenarios to make sure it meets user expectations.
    • Regression Testing: Ensures that new code changes don’t break existing functionalities.
    • Performance Testing: Evaluates how the software performs under certain workloads, checking speed, responsiveness, and stability.
  7. Learning from Mistakes: Every time we cook beans, we learn from them. We analyze what went wrong and implement changes to prevent it from happening again. This iterative process helps us improve and avoid future bean-cooking disasters.

Cooking Beans Is Part of the JourneyIn the world of Nigerian tech bros, cooking beans is almost inevitable. But it’s not the end of the world. At Sudo, we’ve embraced the process, learning from our mistakes and improving our systems to ensure we serve only the best. So, the next time you hear about a tech bro cooking beans, just remember, it’s all part of the journey towards building something great.

Read more