DEV Community: Shenouda Fawzy

Tiny Checks, Massive Impact

Shenouda Fawzy — Fri, 20 Jun 2025 07:43:12 +0000

Straight to the point — whenever I build a system, the very first thing I implement is a health check for all critical infrastructure components.

I ping the database. I ping Redis. Just simple, lightweight checks.

They may seem minor, but skipping them can lead to serious consequences. At best, you get a false sense that everything is working fine. At worst, the system enters an inconsistent state that's painful to debug and even harder to recover from.

AI Built My Landing Page — I Didn’t Write a Single Line of Code

Shenouda Fawzy — Sat, 26 Apr 2025 04:36:24 +0000

I opened my browser, launched ChatGPT and Claude, and watched as they built my product idea... with zero code from me.

A friend of mine wanted to build an email verification API — a simple service that checks whether an email is real (i.e., not disposable and can receive messages).

Now, I'm a backend guy. I literally don’t know how to center a div.

But I thought... why not try this thing people call "vibe coding"?

What’s Vibe Coding?

Basically the AI is the pilot and the human (that case me) is the copilot.

So, I put myself in the shoe of the customer, were the customer knows nothing about writing code or IDEs.

Therefore, I opened up my browser and launched two free AI models side-by-side, ChatGPT-4 (o4) and Claude Sonnet 3.7.

No code editors. No local setup. Just me, the browser.

The Goal
I wanted to build a clean, simple landing email validation API service (https://sweepemails.com/).

To the Action
I needed to bound the AI model to a context and steer down the conversation to reach to the point of designing the landing page.

Therefore, I started with:

If I'm going to develop an API service that checks for fake emails, who are the top 3 audiences that would benefit from it the most?

ChatGPT replied with, E-commerce SaaS products, Online communities and newsletters, ... etc
And it even suggested me on positioning the product, which I have no clue what does mean, but it turns out is listing of core features, customer pain points and target customers.

First Landing page attempt
And then things started kicks in, when it suggested to me to build a landing page.
I answered:

Yes, build a landing page and include the API usage as tabs for cURL, Go, JS, and Python, with syntax highlighting

As you can see... it's not pretty. Functional? Sure. But not something that screams, “Use me!” It’s more like “a developer built this at 2 AM.". I don't know why it does it like that, does it know that I'm a backend guys, so it tries to mimic me =D.

Now it's turn for the coding beast, Claude Sonnet 3.7

I guess this article is already too long, so the next article will cover converting this ugly landing page to one that is more beautiful and neat.

This will be the end results, and I literally didn't write single line of code myself.

If you're someone like me (a backend dev who’s allergic to CSS), that is good for us.

Thoughts on AI while debugging

Shenouda Fawzy — Sat, 08 Feb 2025 12:33:43 +0000

Recently, I was exploring message brokers, particularly Kafka, leveraging Docker Compose for the setup. Among the services utilized was Kafdrop, a dashboard facilitating the monitoring of Kafka topics and partitions. While the publisher functioned seamlessly, encountering networking challenges within the Docker services hindered the loading of events in the Kafdrop dashboard.

I know that service name can be used as host url to connect with within the application as well as other siblings containers withing the compose. But that didn't work out.

So, I head directly to AI Copilot specifically as it is already installed on my vscode. Given it has access to work space therefore the context as well.
Spent more than hour, but couldn't get the Kafdrop work.

Then I've tried Claud, which give me the fix which turns out it's an env variables with Kafka to let it connect to both publisher as well as Kafdrop.

Telling this story to pinpoint something, that is with the emerge of LLMs and every couple of days we see new LLM coming. Now instead of just Googling and looking for Stackoverflow answers, I spend time trying to different LLMs, I was lucky that I tried Claud as my second shot, who know if I tried other LLMs would I get the fix immediately.

This brings me to a conclusion, at this stage, I'm in a loophole, which means yesterday I was spending time looking for the answer on Google/stackoverflow, now I'm spending time shopping around trying different LLMs hoping to get an answer fixing my issue. Not sure, with new LLMs coming each day, are we really saving time using LLMs looking for the correct answer?

Debugging missing records Golang and CSV

Shenouda Fawzy — Wed, 30 Oct 2024 19:27:35 +0000

During my work on building a utility for data transformation on one of my side projects, I needed to convert a JSON-formatted file into CSV format. I ran into a tricky issue that took nearly an hour to debug before identifying the root cause.

The process should have been simple, consisting of three main steps:

Open the JSON file
Parse that JSON file into a specific struct
Write the data to a CSV file First, to give you an idea, the JSON is an array with 65,342 elements.

func JsonToCSV(data *SrcSheet) {
    // Create file name in a format like "email_241030172647.csv" (email_yymmddhhmmss.csv)
    fName := fileName()

    // Create file
    f, err := os.Create(fName)
    if err != nil {
        log.Println("Unable to create file", err)
        return
    }
    defer f.Close() // Closing to release resources
    w := csv.NewWriter(f) // Initializing CSV writer

    // Add header
    header := []string{"email", "provider", "added_on"}
    if err = w.Write(header); err != nil {
        log.Println("Unable to write header", err)
        return
    }

    count := 0
    for domain, elm := range data.Email {
        if err := w.Write(newRecord(domain, elm)); err != nil {
            log.Println("Unable to add new record", domain, err)
            return
        } else {
            count++
        }
    }

    log.Println("Number of records written =", count)
}

func newRecord(email string, e *SrcElements) []string {
    if e == nil {
        return nil
    }

    DBFormat := "2006-01-02 15:04:05.000"
    addedOn := time.Now().UTC().Format(DBFormat)

    r := []string{email, e.Provider, addedOn}
    return r
}

The code is straightforward: create a new file with a specific name format, defer its closing, initialize the CSV writer, and start writing to the file. Super simple, right?

Steps 1 and 2 worked well, so omitted them. Let’s shift focus to step 3, where something unexpected happened: the CSV output contained only 65,032 records, meaning 310 records were missing.

To troubleshoot, I tried the code with just 7 JSON elements instead of 65,032. Surprisingly, nothing was written to the CSV file at all!

I double-checked for simple mistakes, like missing file closure, but everything looked fine. I then retried with the full 65,032 elements, hoping to get more clues. That’s when I noticed that not only were 310 records missing, but the last record was incomplete as well.

65030 adam@gmail.com, gmail, 2023-03-17 15:04:05.000
65031 jac@hotmail.com, hotmail, 2023-03-17 15:04:05.000
65032 nancy@xyz.com, hotmail, 2023-03-

This was progress—I could now narrow down the issue and focus on w.Write(newRecord(domain, elm)), specifically the w.Write(...) method. I checked the documentation and found the reason:

... Writes are buffered, so [Writer.Flush] must eventually be called to ensure that the record is written to the underlying io.Writer ...

I had forgotten to call w.Flush(). This made sense since, from a performance perspective, the CSV writer buffers writes instead of executing I/O operations every time w.Write() is called. By buffering data, it reduces the I/O load, and calling w.Flush() at the end ensures any remaining data in the buffer is written to the file.

Here’s the corrected code:

...
f, err := os.Create(fName)
    if err != nil {
        log.Println("Unable to create file", err)
        return
    }
    defer f.Close()
    w := csv.NewWriter(f)
    defer w.Flush()

    // Add header
    header := []string{"email", "provider", "added_on"}
...

To confirm, I checked the bufio.go source code and found that the default buffer size is 4K. In the WriteRune(...) method, you’ll see that it calls Flush whenever the buffer reaches its limit.

That’s all! I hope you enjoyed reading. I tend to learn a lot from mistakes—whether mine or others’. Even if there’s no immediate fix, discovering a wrong approach helps me avoid similar pitfalls in the future. That’s why I wanted to share this experience!

Your first PR on your recently joined company

Shenouda Fawzy — Fri, 21 Jun 2024 15:11:36 +0000

Joining a new company can be challenging. You may feel like everyone is watching you and has high expectations. This can be stressful, especially at the beginning.

Here is a simple pull request (PR) you can make during your first couple of weeks as a new joiner. In the software industry, you will often be introduced to an existing codebase and need to run it on your local setup. This process can be straightforward, like running make start or npm start, etc. If it runs smoothly, that's great.

But if it doesn't, you'll likely need to dig deep to get it to work. This may involve installing some dependencies, such as Redis, among others. This is where you will shine.

Take note of every step and action you take to make it work. Finally, refine those steps and update the repository's README file (or create a new one if it doesn't exist). Then, make a PR with that change.

This not only helps others who join after you but also breaks the ice for you.

My effective approach to explore new codebase

Shenouda Fawzy — Sat, 08 Jun 2024 08:21:39 +0000

Whenever I explore a new codebase, whether it is open source or not, I look for three things:

How to log my first "Hello, World!" message
This serves as my flashlight, helping me explore and tinker with different parts of the codebase.

Are there any background tasks/jobs?
This is crucial because these tasks can cause unexpected behavior. For example, I might wonder why a certain part isn't working as expected, only to find out later that a background worker is flipping some field after a few minutes. Understanding this can prevent a lot of frustration and confusion.

The configurations
To see if there is any third party services is being used and have an idea about those third party services. Or port number that could conflict with existing one.

This approach has never failed me, whether the codebase is spaghetti or a piece of cake.

Using UTC time in Golang slog

Shenouda Fawzy — Mon, 18 Mar 2024 07:16:25 +0000

Go introduced slog in Go1.21. That makes logging more flexible and consistent. And when I tried to use it on one of my side projects I found that it logs the time in local timezone, which isn't the best choice for me. Cause for example, I may own a server machine at Stockholm and I live in Egypt, that case when the logs is written, it will be logged in UTC+1 (Stockholm Time), however Egypt is UTC+2. So, I had to interpret it in my mind every time I read a log line. This is tedious. Not only that, imagine a team scattered around the globe, each one will try to do the interpenetration his own. And even sharing log lines won't be efficient for the same reason.

Therefore, a UTC would solve that issue, and wherever I'm located, we will going interpret it straight forward. So, tried to find out how this can be done. But didn't, even asked GPT models, but didn't give me answer (at least the free one) But finally I manged to make it. Here is a full working go program that writes log in UTC time. Further more, it write it in a secure way. The key player here is the ReplaceAttr function in the slog. Where you can override certain log message.

package main

import (
    "log/slog"
    "os"
    "time"
)

func main() {
    cardPan := "4701322211111234"
    cardCvv := "789"
    secLog := SecureLogger()
    secLog.Info("This is secure logger", "secret", cardPan, "secret", cardCvv)
    // time=2024-02-17T15:52:01.119Z level=INFO msg="This is secure logger" secret=47013######11234 secret=***
}

// SecureLogger write logs in a secure way in UTC time
func SecureLogger() *slog.Logger {
    l := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
        ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
            if a.Key == "time" {
                a.Value = slog.AnyValue(time.Now().UTC())
            }

            if a.Key == "secret" {
                // This is probably a card pan, so we can only reveal
                // The first 5 and last 5 and the rest can be masked with #
                if len(a.Value.String()) == 16 {
                    pan := a.Value.String()
                    first5 := pan[:5]
                    last5 := pan[11:]
                    masked := first5 + "######" + last5
                    a.Value = slog.StringValue(masked)
                } else {
                    a.Value = slog.StringValue("***")
                }
            }
            return a
        },
    })

    return slog.New(l)
}

Each log entry has built-in keys which is time, level and message. So I override the time one.
And introduced new secret key, which supposed to be used for logging sensitive elements.

And that's all!