I've been dealing with email sending costs for various projects, and let me tell you - most email services charge way too much. That's until I discovered Amazon SES (Simple Email Service).

The Cost Comparison That Blew My Mind

Most email services want to charge you $10-50 per 1,000 emails. That adds up fast when you're sending transactional emails, notifications, or marketing campaigns.

Then I found out Amazon SES charges just $0.10 per 1,000 emails.

Let me repeat that: ten cents for one thousand emails.

That's 100x cheaper than most of their competitors. For real.

The Initial Hiccup

Now, there was one thing that initially caught me off guard. Amazon SES starts you in a "sandbox" mode that only allows you to send 50 emails per day. At first, I thought "Well, that's useless for anything real."

But then I discovered you can request a quota increase straight from the AWS console. You just need to:

1. Fill out a simple form explaining your use case
2. Provide a legitimate business reason
3. Submit and wait for approval

Update: I requested to increase my quota to 50,000 emails per day and got approved! The approval process was surprisingly smooth - took less than 24 hours.

The Quota Journey

Starting at 50 emails/day → Requested increase → Now at 50,000 emails/day

And the best part? This isn't even the max. I can still see options to request even higher limits when I need them. I'll update this post once I see how high they're actually willing to go.

Why This Matters

For developers and businesses sending emails at scale, Amazon SES is a game-changer. The cost savings are insane, and once you move past the initial sandbox limitation, you get access to one of the most powerful email infrastructures on the planet.

Combine that with AWS Lambda and API Gateway, and you've got a fully serverless email solution that scales automatically and costs almost nothing.

Bottom Line

When people ask me about email sending services now, my answer is simple: "Use Amazon SES, request the quota increase, and stop overpaying for email."

The initial 50 email limit is just AWS being cautious. Show them you're serious, and they'll give you the access you need. At $0.10 per 1,000 emails, you literally can't find anything better.

What started as a simple shell script to convert PNG files to WebP quickly became a pain in the ass. You know that feeling when a quick hack grows into something you dread using? That was me, manually running conversion commands every single time I needed to optimize images.

I knew there had to be a better way, so I started looking for open source solutions. That's when I discovered imaginary - a powerful image processing API built on top of libvips. The performance was incredible, but there was one problem: no open source UI existed for it.

The "Why Not?" Moment

Instead of settling for command-line tools or paid services, I thought: "Why not build the UI myself?"

So I did exactly that. I created ImageMate - a modern, fast, and completely private image conversion tool with a beautiful web interface.

My First Docker Image!

The best part? I created my first-ever Docker image to make deployment dead simple. Want to try ImageMate? Just run this one command:

docker run -d --name imagemate -p 3000:3000 -p 9000:9000 edgium/imagemate:latest

That's it! Open http://localhost:3000 and you're ready to convert images like a pro.

Open Source = Community Power

I pushed everything to GitHub because I believe tools like this should be free and accessible to everyone. The response has been incredible - seeing other developers find value in something I built to solve my own problem feels amazing.

Check it out: github.com/edgiumtech/ImageMate

What's Next?

This project taught me that the best solutions often come from your own frustrations. When you're annoyed by a workflow, there's probably a better way - and sometimes you have to build it yourself.

ImageMate is just the beginning. I'm already thinking about what other developer pain points I can turn into open source solutions. 🚀

I just sold my first web application as a freelancer, and it feels absolutely incredible.

After months of hard work, I successfully delivered Cargozy USA - a logistics platform that I built from scratch using React and Next.js. This wasn't just a simple website; it was a complex application with dynamic pricing calculators, real-time dashboards, and multi-platform integrations.

The moment of truth came when the client saw the final product. Their reaction was everything I hoped for - they were thrilled with both the functionality and the polished design. Seeing something I coded from zero become a real business tool that people actually use daily? That feeling is indescribable.

This first freelance success has completely changed my perspective on what's possible. It's given me the confidence to take on bigger, more complex projects and shown me that I can deliver professional-grade applications that make a real difference.

What's next? I'm already working on my next freelance project, and the momentum from this win is pushing me to aim even higher. The freelance journey is just getting started, and I can't wait to see where it takes me! 🚀

The YouTube Backend Adventure

Just finished building a YouTube-like backend and holy shit, this was the most fun I've had coding in forever. I haven't felt this challenged and excited about a project in years.

The MinIO Revelation

MinIO S3 was the MVP here. Getting multipart uploads working felt like unlocking a cheat code. Breaking 2GB videos into 5MB chunks and watching them reassemble on the server? Pure magic.

But the real game-changer was S3 notifications. Setting up webhooks that fire automatically when uploads complete felt like I was building something that actually works in the real world.

The Cleanup Saga

Building the cleanup system was surprisingly satisfying. Created a cron job manager with colored output because why not make it look good? The admin routes with API key auth made me feel like I was building something production-ready.

Why This Mattered

This project reminded me why I love backend dev. It's not just CRUD—it's architecting systems that handle real problems. Node.js + PostgreSQL + MinIO + thoughtful API design = something that actually works.

The satisfaction of watching a video upload, process, and stream back is something I'll remember. This project reignited my passion for building complex systems.

Here's to more backend adventures! 🚀

Recently, I was working on a real-time chat application using Socket.IO and needed to scale it to handle more concurrent users.

I decided to use PM2's cluster mode by setting the instances option to max and exec_mode to cluster in the ecosystem.config.js file. That's when things got interesting! Users kept getting disconnected and experiencing connection loops. After investigation, I discovered that Socket.IO needs special handling when running across multiple processes.

The solution required two key components:

First, implementing a Redis adapter for Socket.IO to share connection state between instances. This allows events emitted from one process to be received by clients connected to another process.

Second, explicitly setting the transport mechanisms on both server and client sides with transports: ["websocket", "polling"] to prevent transport negotiation issues.

Scaling WebSockets isn't straightforward, but when done right, it's incredibly rewarding!

I’ve been developing a WebSocket service for a client—an advanced mobile chat application that lets users send messages to each other. At one point, we realized we needed to queue messages whenever a user’s app was running in the background. Initially, we stored these messages in a MySQL database, but soon found it wasn’t the best approach.

That’s when I decided to use Redis for background message storage. As a result, our read times improved by at least 10x. Redis also comes with plenty of useful features like message expiration, priority, and batching.

I’m really happy with this solution! It wasn’t easy to implement, but it was definitely worth it.

The Magic of Expo OTA Updates

Today, I discovered that I can use expo-updates to release over-the-air (OTA) updates for both stores, and it’s been an absolute game-changer for my workflow. Instead of waiting days for App Store or Google Play approvals (which can be a real pain), I can now fix small bugs and push those changes live almost instantly.

This has boosted my confidence tremendously: no more holding my breath over tiny updates or minor fixes that used to get stuck in a frustrating backlog. With expo-updates, the turnaround time for addressing issues has dropped from days to mere minutes—allowing me to maintain a smoother, more efficient release cycle.

I've been developing a Node.js WebSocket service for the mobile app I've been working on for almost a year now. Sometimes (though very rarely), it can take 2–3 seconds to deliver a message. I've always wanted to add optimistic message updates for a better user experience, but never quite found the time—until now. I finally implemented it, and here's a quick look at how it turned out:

I just released an npm package that uses Reanimated to deliver super smooth performance with no issues. Here's the story behind it:

I was using a package called burnt, but it didn't allow adding toast messages with more than one line. When I asked the maintainer to add that feature, he just brushed it off and never got around to it. So I said, "Fuck it, I'll create my own and actually maintain it." And here it is!

So, I created my own package that not only includes the functionality I needed but also ensures ongoing maintenance and support. And here it is!

Check it out on NPM: smooth-push package

I've always loved how X (formerly Twitter) animates the Tab bar on the Feeds screen—when you scroll down, it slides up, and vice versa. It feels so smooth and natural!

I recently set out to recreate this animation, and while it's not a perfect 1:1, it's pretty darn close. To pull it off, I used:

• React Navigation Material Top Tab Navigator
• Reanimated v3
• Context API

I'll be honest: it took a solid four hours of staring at my screen, tweaking code, and trying not to tear my hair out. But in the end, I'm really happy with how it turned out!

I finally learned what the ~ (tilde) and ^ (caret) symbols really do in a package.json file. My mobile app started crashing after a TestFlight update, and it took me three hours to figure out that it wasn't my code—it was those evil version symbols!

• Caret ^: Allows updates to minor and patch versions automatically
  (e.g., ^3.10.1 covers any version >=3.10.1 but <4.0.0).
• Tilde ~: Allows updates to patch versions only
  (e.g., ~3.10.1 covers any version >=3.10.1 but <3.11.0).

What I learned??: Don't use NPM packages unless you have absolutely no other option. 😑

I've successfully migrated the entire build and deployment process for both iOS and Android apps from my local environment to GitHub Actions. It's a major win, given how resource-intensive iOS builds can be!

FYI-1: GitHub offers 2,000 free build minutes per month.
FYI-2: I realized something was amiss. GitHub counts macOS usage at 10x the normal rate, and since I have to use macOS for iOS builds, this uses up my free minutes much faster.

I've finally finished my Node.js app, and it feels both stable and completely under my control. This is my first backend service using WebSockets, and it will soon go into production to handle user-to-user messaging.

Below is a list of packages I believe every Node.js application should include for logging, error handling, and overall stability:

• helmet, express-rate-limit, winston, datadog, health route, pm2

On a personal note, I also recommend using:

• typescript, eslint, prettier, husky + commitlint

Datadog has become one of my absolute must-have tools for logging in every project I work on. Once I started out as a software developer, I realized pretty quickly that building an app without logging is like driving blindfolded—you have no idea what's going on under the hood.

Today, I've successfully integrated Datadog into all of my React, React Native, Node.js, and Debian-based applications. Now I'm finally in control—and it feels fantastic!

Pro Tip: Datadog is on a whole other level. I still can't believe how much they let you log even on their free tier. Seriously, check them out; you won't regret it!