DEV Community: Atharva Sharma

How did the world reach microservices?

Atharva Sharma — Wed, 13 Aug 2025 23:08:15 +0000

Introduction

Imagine a small team in a cramped office, working on a single piece of software. Everything lived in one big package the code, the build scripts, the tests were all tied together in a neat bundle. Deployments were simple: one pipeline, one click, and voilà, the product was live. Back then, it was efficient, even comforting.

But the company grew. The team doubled, then tripled. Suddenly, that “neat bundle” became a battlefield. Developers stepped on each other’s toes, merge conflicts piled up, and one person’s tiny change could bring the whole system crashing down. Releases turned into high-stakes events. “Did we break anything this time?” became the office’s unofficial catchphrase.

So, we tried a fix. We broke the giant package into smaller ones, giving each team their own corner to work in. It helped… for a while. But we were still tied together at the hip during deployments. The real breakthrough came when we started splitting not just code, but responsibility — separate builds, separate deployments, even separate infrastructure. And just like that, the path to microservices had begun.

The Monolith Days

In Monolith architecture all developers contribute to a single, unified code package. Developer1, Developer2, and Developer3 each make their commits directly into the same shared codebase. Once all changes are merged, the entire application is built and deployed as a single unit — first to a beta environment, and then to production. This approach means that any change, no matter how small, requires rebuilding and redeploying the whole system. While simple in setup, it creates a high risk of conflicts, slows down release cycles, and increases the blast radius of failures since every update affects the entire application.

Now imagine, the team grows to 150 developers. All the developers are now committing to the same package, some of them to the same files. After a point it becomes extremely difficult for the developers to keep pulling each other's changes and resolving conflicts.

Modularization

One easy solution to the problem is to divide the code base into multiple packages and give ownership of each package to individual teams. For eg: For an ecommerce platform code for Orders, Inventory, Returns etc. can be split into different packages. All the packages are the built together in the end to be deployed to beta and prod environments.

Now imagine the team grows to a 1000 people. It might happen that there is a certain feature in the returns package that needs to be deployed whereas the orders team is not ready to deploy changes to prod. In this case, returns team needs to wait for orders team to be ready for prod deployment or the orders team will need to revert their changes.

Also, you would need a separate team just to maintain the deployment pipeline and for building consensus between multiple teams.

Microservices

This is where Microservices comes into picture. Along with separate packages, what if we split the deployment pipelines and infrastructure between multiple teams? The combination of a separate package + pipeline + infrastructure is called as a microservice.

Each microservice then interacts with other microservices through APIs.

This gives a team freedom to deploy their own changes whenever they want, without any conflicts. Individual teams manage their own infra and pipelines. Any blockers or failures don't block other teams. The huge code package and build created in Monolith also becomes smaller leading to easier code maintenance, faster builds and deployment times.

The downside of this approach is that there is higher latency between service interactions when compared to a monolith as the infrastructure is separate and services interact via API calls which are network calls.

Conclusion

Microservices aren’t the inevitable destiny of every software project but they’re the result of scaling pains that monoliths and modularization can no longer solve. As teams grow and products become more complex, the need for independent ownership, faster releases, and reduced blast radius pushes organizations toward breaking systems into smaller, autonomous parts.

But with that freedom comes new responsibilities: managing more infrastructure, handling inter-service communication, and keeping an eye on performance overhead. The real lesson? Architecture is a journey. Start simple, evolve as you grow, and choose the approach that best matches your team’s size, culture, and goals not just what’s trending in the industry.

Letting AI Narrate My Past: A Telegram Bot with Google Drive and GenAI Magic

Atharva Sharma — Mon, 04 Aug 2025 00:21:49 +0000

Overview

In the age of cloud storage and AI, our digital memories often remain buried in folders, rarely revisited or shared meaningfully. This project bridges that gap by combining the capabilities of the Google Drive API, Generative AI, and Telegram Bot API to create a personal assistant that not only surfaces photos from your Google Drive but also generates thoughtful, human-like captions for them.

The assistant is designed to automatically pull a random image from a specified Google Drive folder every 24 hours (with modifiable frequency) and send it to a Telegram group. Each photo is accompanied by an AI-generated caption that attempts to interpret or narrate the memory behind the image in a relatable and engaging way.

Architecture

We make use of the following AWS services to implement this assistant:

Lambda:
AWS Lambda is a serverless compute service that lets you run code without provisioning or managing servers. You simply upload your function, and Lambda automatically scales and executes it in response to events such as HTTP requests, file uploads, or scheduled triggers. You only pay for the compute time your code consumes, making it a cost-effective and scalable way to build backend logic or automation tasks.

AWS Lambda is the preferred compute choice for this project because the assistant doesn’t need to run continuously. It only needs to execute once every 24 hours (or at a defined frequency). With Lambda’s serverless model, we can trigger the function on a schedule without worrying about server uptime or manual scaling. This makes it highly efficient and cost-effective, as we only pay when the code runs.
Event Bridge:
Amazon EventBridge is a serverless event bus service that makes it easy to connect and trigger actions based on time-based schedules or events from AWS services. In this project, EventBridge is used to invoke the Lambda function every 24 hours, acting like a cloud-based cron scheduler. It’s reliable, scalable, and requires no infrastructure management—perfect for automating periodic tasks.

Setting Up AWS Lambda and EventBridge

Step 1: Create the Lambda Function

Go to the AWS Lambda Console.
Click “Create function”.
Choose:
- Author from scratch
- Function name: MemoryBotFunction (or your preferred name)
- Runtime: Choose your language (e.g., Python 3.x or Node.js)
Click Create Function.

Step 2: Create a Scheduled Rule in EventBridge

Go to the Amazon EventBridge Console.
Click "Create rule".
Enter:
- Name: DailyMemoryBotTrigger
- Description: “Triggers Lambda every 24 hours”
- Event bus: Leave as default
- Rule type: Choose “Schedule”
Under Schedule pattern:
- Select “Rate expression”
- Example: rate(1 day) for once every 24 hours (You can modify this to rate(6 hours), cron(0 8 * * ? *), etc.)
In Target:
- Choose Lambda function
- Select your Lambda (MemoryBotFunction)
Click Next, then Create Rule.

Integrating with Google Drive

Step 1: Create a Google Cloud Project and Enable Drive API

Go to the Google Cloud Console.
Click Select a project → New Project.
Enter a project name (e.g., MemoryBotProject) and click Create.
Navigate to APIs & Services → Library.
Search for Google Drive API and click Enable.

Step 2: Set Up OAuth 2.0 Credentials

In the Cloud Console, go to APIs & Services → Credentials.
Click Create Credentials → OAuth client ID.
Configure the OAuth consent screen if prompted.
Choose Application type:
- For a backend app, select Web application.
Add authorized redirect URIs if needed (for OAuth flow).
Click Create and download the credentials.json file.

Intregrating with Gemini API

Step 1: Get Access to Gemini API

Sign up or log in to the Google AI studio .
Create a new API key or obtain your access credentials (API key, client ID, secret, etc.).
Make sure to securely store these credentials.

Intregrating with Telegram API

Step 1: Create a Telegram Bot

Open Telegram and search for BotFather.
Start a chat with BotFather and send the command /newbot.
Follow the prompts to:
- Name your bot.
- Choose a unique username ending with bot (e.g., MemoryBot).
After creation, BotFather will provide a bot token. Save this token securely — you will need it to access the Telegram Bot API.

Step 2: Get your group ChatId

Add your bot to the group or start a private chat with it.
Send any message in that chat (or group).
Open this URL in your browser (replace <YOUR_BOT_TOKEN> with your bot token): https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates
Look for the "chat":{"id":...} field in the JSON response — that number is your chat ID.

It's time to write code!

Add the following code to the lambda by navigating to the code tab in lambda console. Make sure to replace the systemPrompt with context for your bot.

const { GoogleGenerativeAI } = require('@google/generative-ai');
const fs = require('fs');
const path = require('path');
const { google } = require('googleapis');
const TelegramBot = require('node-telegram-bot-api');

exports.handler = async (event) => {
    const botToken = process.env.TELEGRAM_BOT_TOKEN;
    const chatId = process.env.CHAT_ID;
    const geminiApiKey = process.env.GEMINI_API_KEY;

    const bot = new TelegramBot(botToken, { polling: false });

    const SCOPES = ['https://www.googleapis.com/auth/drive.readonly'];
    const credentialsPath = '/tmp/credentials.json';
    const rootFolderId = process.env.GOOGLE_DRIVE_FOLDER_ID;

    const credentials = JSON.parse(process.env.GOOGLE_CREDENTIALS_JSON);
    fs.writeFileSync(credentialsPath, JSON.stringify(credentials));

    async function authenticateGoogleDrive() {
        const auth = new google.auth.GoogleAuth({
            keyFile: credentialsPath,
            scopes: SCOPES,
        });
        return google.drive({ version: 'v3', auth });
    }

    async function getSubfolders(drive, parentFolderId) {
        const res = await drive.files.list({
            q: `'${parentFolderId}' in parents and mimeType = 'application/vnd.google-apps.folder' and name != 'videos' and name != 'Bannerghatta'`,
            fields: 'files(id, name)',
        });
        return res.data.files;
    }

    async function getImagesFromFolder(drive, folderId) {
        const res = await drive.files.list({
            q: `'${folderId}' in parents and mimeType contains 'image/'`,
            fields: 'files(id, name, mimeType)',
        });
        return res.data.files;
    }

    async function downloadFile(drive, fileId, filePath) {
        const dest = fs.createWriteStream(filePath);
        await drive.files.get({ fileId, alt: 'media' }, { responseType: 'stream' })
            .then(res => {
                return new Promise((resolve, reject) => {
                    res.data
                        .on('end', () => resolve())
                        .on('error', err => reject(err))
                        .pipe(dest);
                });
            });
    }

    async function generateCaptionWithGemini(imagePath) {
        const genAI = new GoogleGenerativeAI(geminiApiKey);
        const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

        const imageBuffer = fs.readFileSync(imagePath);
        const imageData = {
            inlineData: {
                data: imageBuffer.toString('base64'),
                mimeType: 'image/jpeg',
            }
        };

        // Add your prompt here
        const systemPrompt = ""

        const result = await model.generateContent([
            { text: systemPrompt},
            imageData,
            { text: "Give a short and warm caption for this photo."},
        ]);

        const response = await result.response;
        const caption = response.text();
        return caption;
    }

    async function sendRandomImage() {
        try {
            const drive = await authenticateGoogleDrive();
            const folders = await getSubfolders(drive, rootFolderId);

            if (folders.length === 0) {
                console.log('No folders found.');
                return;
            }

            let selectedImage = null;

            while (!selectedImage) {
                const randomFolder = folders[Math.floor(Math.random() * folders.length)];
                console.log(`Selected folder: ${randomFolder.name}`);

                const images = await getImagesFromFolder(drive, randomFolder.id);

                if (images.length === 0) {
                    console.log(`No images found in folder: ${randomFolder.name}`);
                    continue;
                }

                selectedImage = images[Math.floor(Math.random() * images.length)];

                if (selectedImage.mimeType.startsWith('video/')) {
                    console.log(`Skipping video: ${selectedImage.name}`);
                    selectedImage = null;
                }
            }

            const filePath = path.join('/tmp', selectedImage.name);
            await downloadFile(drive, selectedImage.id, filePath);

            const caption = await generateCaptionWithGemini(filePath);

            await bot.sendPhoto(chatId, filePath, { caption });
            console.log(`Sent image with caption: ${caption}`);

            fs.unlinkSync(filePath);
        } catch (error) {
            console.error('Error sending image:', error);
        }
    }

    await sendRandomImage();

    return {
        statusCode: 200,
        body: JSON.stringify('Image sent successfully!'),
    };
};

Add the following code to package.json:

{
  "name": "your-project-name",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@google/generative-ai": "^0.24.1",
    "dotenv": "^16.4.5",
    "googleapis": "^140.0.1",
    "node-telegram-bot-api": "^0.66.0"
  }
}

Add envrionment variables

This is the final step where we add all the environment variables required for our app to function.

Navigate to: Configuration -> Environment Variables from the AWS console and add the following environment variables:

CHAT_ID - Chat Id received in this step
GEMINI_API_KEY - Gemini API key generated in this step
GOOGLE_CREDENTIALS_JSON - Content of the JSON file downloaded in this step
GOOGLE_DRIVE_FOLDER_ID - Open the google drive folder you want to fetch memories from. The part after /folders/ in the URL is the folder ID
TELEGRAM_BOT_TOKEN - Telegram BOT token generated in this step

Conclusion

Building a Telegram bot that seamlessly integrates Google Drive and Gemini AI to share personalized memories is a powerful way to combine cloud storage, AI, and messaging platforms. By leveraging AWS Lambda and EventBridge, you can automate the process efficiently without keeping the bot running 24/7.

This project not only showcases how APIs can work together to create unique user experiences but also provides a solid foundation to explore more advanced AI-powered automation.

Feel free to customize the bot’s frequency, add more AI capabilities, or expand it to other platforms. The possibilities are endless!

Happy coding and memory sharing! 🚀