Forem: Rohit Purkait

Understanding Flow’s Lending Protocol Architecture

Rohit Purkait — Fri, 12 Dec 2025 08:14:06 +0000

A Beginner Friendly Guide for Web3 Developers

Lending protocols are one of the most important building blocks in decentralized finance. They let users borrow, lend, and build leveraged positions without intermediaries. Protocols like Aave and Compound defined the standard for collateralized on chain lending. Flow introduces a new approach through its Flow Credit Market (FCM) and the product built on top of it, Flow Yield Vaults (FYV).

This guide explains the context behind Flow’s design, how traditional lending protocols work, and what Flow is doing differently.

1. What Is a Lending Protocol?

A lending protocol is a smart contract system where:

Users deposit assets as collateral
They borrow other assets against that collateral
A health factor keeps the position safe
Collateral is liquidated if health becomes too low

Liquidation ensures the protocol does not end up with bad debt. But liquidation risk is one of the biggest user pain points in existing systems.

2. How Existing Protocols Handle Liquidations

Example: Aave

A typical liquidation flow looks like this:

Your collateral value falls
A Keeper detects your unhealthy position
The Keeper repays some of your debt using a flashloan
The Keeper receives a large chunk of your collateral at a discount

Problems with this approach:

Liquidations are large
Keepers profit from user loss
Liquidations can happen during brief volatility
Positions can get wiped out instantly

This model works, but it is harsh and inefficient for users.

3. Flow’s Architecture: Two Layers Working Together

Flow has two related but distinct systems.

3.1 Flow Credit Market (FCM)

This is the base lending layer. It provides:

Borrowing and collateral management
Health factor logic
Liquidation rules
An automation framework for top ups and draw downs

FCM is similar to Aave in role, but with improvements in liquidation mechanics.

3.2 Flow Yield Vaults (FYV)

This is a strategy built on top of FCM. FYV uses the automation hooks inside FCM to:

Continuously monitor position health
Sell a small portion of yield tokens when collateral drops
Buy more yield tokens when collateral rises
Maintain a stable health band so liquidation never occurs

FYV behaves like an automated rebalancing engine that runs continuously.

4. How Flow Handles Liquidations Differently

Flow’s liquidation system improves upon legacy designs.

Minimal Liquidation

Flow sells only the smallest amount of collateral needed to restore health.

DEX First Execution

Liquidations are routed through a decentralized exchange:

Predictable pricing
No dependency on external bots
Best possible market rate

If a Keeper wants to liquidate, they must beat the DEX price.

Multiple Small Adjustments

If the market keeps dropping, FCM performs several small corrections instead of one destructive liquidation.

5. Why FYV’s Automation Matters

Flow Yield Vaults automate everything a user would manually do.

Example behavior:

If FLOW price drops ten percent, FYV sells ten percent of yield tokens
If FLOW price rises fifteen percent, FYV buys fifteen percent more

This keeps users:

Maximally invested when safe
Hedged when risky
Protected from liquidation

Simulations show FYV achieves higher returns than similar strategies on Aave because:

It avoids liquidation loss
It maintains safe leverage
Automation captures more upside opportunities

6. Key Takeaways for Developers

Lending protocols can be redesigned to be more user friendly

Flow reduces liquidation pain and aligns incentives between the protocol and users.

Automation is becoming essential

Instead of relying on keepers or manual adjustments, Flow builds automated risk management at the protocol layer.

Deterministic liquidation improves user trust

DEX based execution ensures transparent and predictable behavior.

7. Summary

Traditional Lending Protocols

Large liquidations
Keeper profit is user loss
Sudden position wipeouts
No built in protection

Flow Credit Market + Flow Yield Vaults

Automated health balancing
Minimal liquidation
DEX driven execution
Continuous rebalance strategy
Higher return with reduced risk

Flow builds a safer and more efficient foundation for leveraged yield strategies, especially for developers building products on top of lending primitives.

Adding Telegram Notifications to Your Application: A Step-by-Step Guide

Rohit Purkait — Tue, 07 Jan 2025 13:30:49 +0000

Telegram is a powerful and widely-used messaging platform that offers seamless integration with applications through its Bot API. Whether you’re building a monitoring service, a trading bot, or a notification system, Telegram notifications can enhance user engagement by providing instant updates.

In this blog, we’ll walk you through the process of setting up a Telegram bot and enabling it to send notifications to your desired chat.

Why Telegram for Notifications?

• Ease of Use: Telegram bots are easy to set up and integrate with your application.

• Instant Delivery: Notifications are delivered in real-time.

• Global Reach: Telegram has millions of users worldwide.

• Customizable Experience: You can tailor the bot to send messages in any format, including text, images, and even buttons.

Step 1: Create a Telegram Bot

The first step is to create a bot in Telegram using the BotFather:

Open Telegram: Log into your Telegram account.
Search for BotFather: In the search bar, type “BotFather” and select the verified bot.
Start a Chat: Send the /start command to begin interacting with BotFather.
Create a New Bot: Use the /newbot command. You’ll be prompted to:
• Choose a name: This is the display name for your bot.
• Create a username: Must end with “bot” (e.g., MyNotificationBot).
Receive Your Bot Token: Once created, BotFather will provide a token that you’ll use to authenticate API calls. Save this token securely, as it’s your bot’s access key.

Step 2: Get Your Chat ID

Telegram needs to know which chat to send notifications to. To retrieve your chat ID:
1. Start a Chat with Your Bot: Search for your bot’s username in Telegram and send a message (e.g., “Hello”).
2. Use the Bot API: Use the following API endpoint to fetch updates and find your chat ID:

https://api.telegram.org/bot/getUpdates

Replace with the token provided by BotFather.

3.  Inspect the Response: The response will include a JSON object. Look for the chat field, which contains the id. This is your chat ID.

Step 3: Understanding the Telegram Bot API

Telegram provides a simple HTTP-based API to interact with your bot. The endpoint to send a message is:

https://api.telegram.org/bot/sendMessage

Required Parameters
• chat_id: The ID of the chat where the message should be sent.
• text: The message content.

Optional Parameters
• parse_mode: Format text using Markdown or HTML.
• disable_notification: Send messages silently (without sound).
• reply_markup: Add interactive buttons or keyboards.

Step 4: Test Your Telegram Bot

Once you have the bot token and chat ID, it’s time to test. You can use a tool like curl or Postman to send a sample message:

Using curl

curl -X POST "https://api.telegram.org/bot/sendMessage" \
-H "Content-Type: application/json" \
-d '{"chat_id": "", "text": "Hello from my bot!"}'

Using Postman
1. Set the method to POST.
2. Use the URL: https://api.telegram.org/bot/sendMessage.
3. In the body, use the JSON format:

{
"chat_id": "",
"text": "Hello from my bot!"
}

Step 5: Automating Notifications

To integrate Telegram notifications into your application, you’ll need to:
1. Capture the event or payload in your app that triggers a notification.
2. Format the message content dynamically (e.g., using placeholders for data like symbols, signals, or confidence levels).
3. Use the Telegram Bot API to send the message programmatically.

Best Practices
• Secure Your Bot Token: Treat it like a password. Avoid hardcoding it in your application.
• Rate Limiting: Telegram has limits on API requests. Ensure your app respects these limits to avoid being blocked.
• Error Handling: Check the API response for errors and retry failed requests if necessary.
• Use Webhooks: For advanced integrations, consider setting up a webhook to receive real-time updates from Telegram.

Conclusion

Adding Telegram notifications to your application is a straightforward way to enhance communication with your users. By leveraging the Telegram Bot API, you can deliver real-time updates, alerts, or even automate workflows with minimal effort.

This blog covered the setup process up to testing your bot. In the next part, we’ll dive into programmatically sending notifications using a backend service. Stay tuned!

If you have any questions or need assistance, feel free to drop them in the comments below. Happy coding! 🚀

Compiling 2025: My Roadmap for the Year Ahead

Rohit Purkait — Thu, 02 Jan 2025 21:56:10 +0000

This is a submission for the 2025 New Year Writing challenge: Compiling 2025.

As we step into 2025, I’m excited to share my personal roadmap for the year—a mix of new skills, ambitious projects, and career aspirations. It’s all about diving deeper into Web3, building tools to empower developers, and evolving my professional journey.

New Skill: Embracing Web3

The buzz around Web3 continues to grow, and I believe 2025 will be its breakout year. To prepare, I’m delving headfirst into this transformative technology. My learning path includes mastering Solidity, exploring Move by Aptos, and diving into other Web3 tools and frameworks.

Web3 represents the future of decentralized applications, and I’m thrilled to align my skillset with this rapidly evolving space. The potential is limitless, and I can’t wait to see where this journey leads.

Side Projects: Building for the Community

Sepolia Faucet

One of my key projects is creating a Sepolia faucet where developers can purchase Sepolia tokens using INR. Currently, most faucets require 0.001 ETH on the mainnet—a barrier for newcomers just starting out.

By offering a more accessible solution, my goal is to fuel creativity and innovation. Developers will be able to acquire Sepolia ETH with a minimal amount of INR, allowing them to focus on building and experimenting with their dApps. This project isn’t just about simplifying access—it’s about empowering the next wave of Web3 creators.

Just a base sneak peek. Will be launching on 7th Jan, 2025.

Decentralized Identification (DeID)

Another project close to my heart is building dApps around Decentralized Identification (DeID). Our current identification systems are outdated and ill-equipped for the modern era, where data breaches are increasingly common.

Through DeID, I envision a system that allows individuals to securely verify their identity wherever they go, putting control back into the hands of the user. This project is a step toward a future where personal data is safe, accessible, and decentralized—a future I’m eager to help shape.

Career Aspirations: Shifting Focus to Smart Contracts

As a Full Stack Developer, I’ve had the opportunity to work across the technology spectrum, but this year, I’m pivoting toward a specialized path: Smart Contract Development.

My goal is to deepen my understanding of this crucial Web3 component and eventually transition into a dedicated role as a smart contract developer. This shift aligns perfectly with my passion for blockchain technology and the ever-expanding possibilities of decentralized solutions.

Looking Ahead

2025 is shaping up to be a pivotal year for me, full of learning, building, and growing. Whether it’s mastering new skills, developing impactful projects, or pursuing career aspirations, I’m excited for what lies ahead.

To all my fellow developers, dreamers, and innovators—let’s make 2025 a year to remember!

What’s on your 2025 roadmap? Share your journey and join the conversation!