DEV Community: FranP-code

ResearchFlow AI: Helping Students Navigate the Research Maze

FranP-code — Thu, 17 Jul 2025 20:07:44 +0000

ResearchFlow AI: Helping Students Navigate the Research Maze

This is a submission for the World's Largest Hackathon Writing Challenge: Beyond the Code.

Why We Built ResearchFlow AI

Starting a research project is overwhelming.
As students, we've all faced that paralyzing moment when you know you need to "pick a topic," but every path feels too broad, too narrow, or already explored.

During the hackathon, our team decided to tackle exactly that: the initial, chaotic phase of academic research. We built ResearchFlow AI, an AI-powered assistant designed to help students move from "I’m interested in renewable energy" to "Here’s a focused research question, key papers, and a rough outline to get started."

We knew we wouldn’t have time to build an entire academic writing platform, so we intentionally reduced the scope to focus on the first steps—the ones that cause the most stress and often stop students before they start.

The Problem We Addressed

Most students face three huge problems at the start of a research project:

Choosing a Topic: It’s hard to narrow down a broad interest into something specific, original, and researchable.
Finding a Gap: Even if you pick a topic, identifying a genuine research gap is intimidating and time-consuming.
Handling Information Overload: There’s too much literature out there, and most tools don’t help students find or summarize what actually matters.

What We Built: The ResearchFlow AI MVP

✨ Key Features

AI Research Gap Identifier & Topic Refiner
Input a broad idea, and the AI suggests narrower sub-topics and potential research gaps based on recent academic trends.
Curated Literature Collector & Summarizer
The AI fetches a small, highly relevant set of academic papers (5–10) and provides concise, 2–3 sentence summaries of each one. It highlights how each paper relates to your research gap.
Basic Outline Builder
Drag and drop papers or insights into a simple outline (e.g., Introduction, Lit Review Sections). The AI suggests section headings based on the collected literature.

What We Didn’t Build (On Purpose)

To keep the hackathon scope realistic, we focused only on the core research pain points.
We skipped features like:

Grammar/style assistance
Full reference management
Supervisor communication tools
Stress or time management features
Collaboration or co-writing tools

We wanted to keep our prototype tight and impactful.

Tech Stack Snapshot

Frontend: React, TailwindCSS, Shadcn-ui
Backend: Astro
APIs: Perplexity
Database: Supabase's PostgreSQL

How We Measured Success

During the hackathon, we kept asking:

Can a user go from a broad idea to a specific research question with AI assistance?
Do the literature suggestions make sense and save time?
Is the outline builder intuitive and useful?

Early tests said yes to all three, and that’s what kept us motivated.

Reflections: Beyond the Code

Hackathons aren’t just about shipping fast—they’re about collaboration, creative constraint, and community learning.

Working on ResearchFlow AI reminded us of the power of focusing on student pain points instead of just features. We hope this project sparks more conversations about using AI to make academic research less stressful and more accessible.

Shoutouts & Thanks

Big thanks to the mentors, organizers, and fellow hackers who shared feedback and ideas during the event!

If you're reading this and you're a student who’s ever felt stuck at the “Where do I even begin?” phase of research—we see you.
Hopefully, tools like ResearchFlow AI can help make that first step easier.

InboxNegotiator: Turning Debt Reminders into Payment Plans with AI and Postmark

FranP-code — Mon, 09 Jun 2025 03:19:14 +0000

This is a submission for the Postmark Challenge: Inbox Innovators.

What I Built

I built InboxNegotiator, a serverless AI-powered engine that transforms stressful payment reminder emails into manageable, negotiated payment plans.

The concept is simple:

A user receives a payment reminder email from a creditor on the webhook defined on Postmark inbound parsing.
It is being handled by AI to understand the asked debt and generate and generate a legally compliant negotiation response.
The users handle the response to modify it and sent it to creditor.
Everything is tracked on a sleek, real-time dashboard where the user can see the negotiation status, the proposed plan, and projected savings.

It's designed to be a "fire-and-forget" solution to the tedious and often intimidating process of communicating with creditors, leveraging the power of automation and AI to advocate on the user's behalf.

Demo

Live App: https://inbox-negotiator.vercel.app

How to Test:

Create an account on the app.
On onboarding, you will be asked for add an additional email. Go to your Postmark server -> Default Inbound Stream and copy your inbound email address. Put it in in the additional email input.
Go to your Postmark server -> Default Inbound Stream and introduce https://inbox-negotiator.vercel.app/api/postmark on the Webhook input.

Recieve a email asking for a debt. Here's a template for you :)

Subject: Outstanding Utility Bill Payment Due
Body: Dear customer, you owe $1,250.50 to CreditPlus for your January utility bills. Please pay by 2025-06-15 to avoid penalties

(Optional) Add your Postmark Server Token to be able to send a response directly from the app. (You will need to be authorized on Postmark to send emails with the receptor's email address and domain)
In around 30 seconds you will have an AI generated email to negotiate the terms of the debt. Modify it as you want and send it.
Recieve response from creditor.
- Templates:
  - Acceptance: Body: Dear customer, we accept your offer.
  - Rejection: Body: Dear customer, you can't negotiate this debt.
You will get a summary of the performance of negotiation (changes on payment or changes on conditions of the debt).

Screenshots

The Real-Time Dashboard: A clean overview of all active and settled negotiations, built with shadcn/ui.

Timeline & AI Response: The generated negotiation text and a timeline of events.

Code Repository

The complete source code is available on GitHub. Explore the magic behind the curtain!

https://github.com/FranP-code/inbox-negotiator

How I Built It

This project is fully serverless, relying on a modern stack to create a seamless, event-driven workflow.

Tech Stack:

Framework: Astro (using Astro endpoints for the full-stack API)
Email Processing: Postmark Inbound Webhooks
Database & Backend: Supabase (PostgreSQL, Edge Functions for AI, Realtime)
UI: shadcn/ui + HeroUI for a modern, responsive interface.
AI: Gemini's API (called from a Supabase Edge Function)

Of course! Here is a concise and credible "Implementation Journey" section based on your final post. It highlights the key technical decisions and the flow of data through the system.

The Implementation Journey

The entire architecture is an event-driven workflow designed for a fast, responsive user experience. Here's how it operates from start to finish:

The Entry Point: Postmark Webhook
The process kicks off the moment an email lands at the user's unique Postmark inbound address. Postmark instantly parses the email and fires a webhook, sending a clean JSON payload to my Astro API route at /api/postmark.
The API Handler: Astro & Supabase
This serverless Astro endpoint is the central receiver. It validates the incoming JSON, extracts key data—creditor, debt amount, and the email body—and inserts it into a debts table in my Supabase database. This action is fast, ensuring Postmark gets a quick 200 OK response.
The AI Brain: Supabase Edge Function & Gemini
The new row in the debts table automatically triggers a Supabase Edge Function via a database webhook. This asynchronous approach prevents blocking the API route. The Edge Function constructs a detailed, context-aware prompt using the debt information and calls the Gemini API to generate a legally-aware, FDCPA-compliant negotiation draft.
The Real-Time UI: Astro & Supabase Subscriptions
Once Gemini returns its response, the Edge Function updates the debts record with the AI-generated text and changes its status. On the frontend, the Astro app uses the Supabase JS client to subscribe to real-time changes in the database. The moment the record is updated, the dashboard seamlessly displays the new AI draft, ready for the user to review, edit, and send.
Closing the Loop: Handling Responses
The process works in reverse, too. When a creditor replies, their email is also caught by the Postmark webhook. A separate function parses the response for keywords (like "accept," "agree," or "offer") to automatically update the negotiation's status and summarize the outcome for the user on their dashboard.

My Experience with Postmark

Postmark was the absolute cornerstone of this project. The Inbound Parsing feature is a game-changer. It transformed the messy, unstructured world of email into a predictable, developer-friendly JSON payload.

The setup was incredibly straightforward, and the webhook reliability meant I could build my entire application logic on the assumption that I'd receive clean, structured data every time. Without Postmark, this project would have been exponentially more complex.

It's a truly powerful tool for any developer looking to build applications on top of email.

Last words

Thank you for checking out my project!
Made with ❤️ by Francisco Pessano from 🇦🇷

How I made Telegram to Notion Bot

FranP-code — Mon, 09 May 2022 22:34:51 +0000

Hello, good morning everyone, this is my first post on Dev.To

I hope it will be useful to different developers to carry out projects related to Bots in Telegram as well as any project in general.

I will try to make this post as complete as possible, any questions or suggestions do not hesitate to comment.

1. Select the Framework on which to work with Telegram

For a long time I wanted to carry out this small project, around 6 months, and unfortunately I "married" the only framework I knew, Telegraf.

Today, it is outdated and has problems with states, a way to assign variables to a specific user, useful to alter the behavior during the execution and use of the bot.

For this reason, and thanks to a recommendation launched by the NPM package that unfortunately I don't know what it is, I discovered the wonderful Framework grammY.

Important points to choose it

Sessions work thanks to the Sessions and Storing Data plugin
It has a vast and great documentation. Maybe it could be better organized, but it's just a detail.
It is "backward compatible" with the code in Telegraf. In a surprisingly easy way, I migrated my app from Telegraf to grammY. It is not the way demonstrated by them to write an app, but, it worked.

2. Register the Bot on Telegram

This is very simple, accessing the official account of @BotFather (from Telegram obviously), you can register a bot and customize it with your own commands.

The most important ones, /newbot to create one and /mybots to manage them.

3. Make Bot Website

It is necessary for the next steps to create a website with a defined backend, that is, with Node.js, PHP or another backend language that allows queries from the server and not from the client.

It was a huge frustration when I first tried this project and found out that a React site wasn't enough.

This must have endpoints for the privacy policy and the terms of use.

4. Register the public integration in Notion

By accessing Notion's My Integrations, you can register an integration, initially private, and then make it public.

The latter necessarily requires:

Redirect URIs, link to where the user will be redirected after authorizing your integration with their pages or databases in Notion
Company name, or your name in case a company is not working behind
Tagline, small description
Privacy policy, link to the privacy policies that you previously defined
Terms of use, link to the terms of use that you previously defined
Email support, with an email to support the client of your integration

5. Write the operation of the different bot commands

This is the most personal part of all, which will vary from project to project, defining the functionality of the bot.

For this, first of all, I wrote a middleware to check if the bot was in development or production mode. With this, only the user with a certain ID could access the bot's functionalities.

bot.use(async (ctx, next) => {
    if (process.env.NODE_ENV !== "development") {
        await next()
        return
    }

    if (ctx.from.id !== parseInt(process.env.MY_USER_ID)) {
        ctx.reply('⚠️ Sorry, this bot is on development for now... \nStay alert >
        return
    }

    next()
})

Once this was done, I did the development command by command:

Start, where I welcome the bot
On message in the case in which the bot is in development and the account that has accessed is not mine.
Auth, where a state is created saying if an auth code is expected from the user and a link is provided to go to a server to generate the auth code (details later).
Help, where the Github repository of this bot is shown
Roadmap, to return the roadmap of my project
Announcement, to be able to make global announcements for each user that will interact with the project

Additionally I made the necessary Middlewares (functions that are executed before the bot functions) to check if:

The user wanted to authorize the bot, therefore, intervene the message to verify and save his auth code
The user wanted to make an announcement, adding some layers of security in the middle

And some more features, such as detecting when the user taps on one of the buttons that are returned with the Notion databases, among others.

6. Send it to production

Using the railway service, I deployed it to production without much difficulty.

It is noteworthy that every time the bot broke, which happened continuously, the service very quickly notified it by email.

It has a freemium model and has a limit of monthly CPU and RAM usage. From there, it is paid.

7. Publish the beta version

I posted on the Notion subreddit the highlights of my project, initially posting the bot with beta website.

8. Publish the final version

Once the website has been “stunningly” developed, I have to update it on Reddit and publish it on Hacker News, where I got the most traffic to the bot.

9. Design the roadmap

Seeing user feedback on Reddit, I decided to make a roadmap to allow users to track planned features and their progress.

It was advertised within the bot and is available as one of its commands.

10. Post it to Dev.to

Once the vast majority of the work is finished, and I still have to develop additional features, I have to make a post to show it with the great Dev.to community, a site I have frequently visited but where I had never interacted.

I hope you liked this first post.

More information about the Bot

Features

Free
Open source
Unlimited
Forever (at least while I can afford the host of it)

Here is the link to the Bot itself

And here is the link to the repository on Github

Thank you very much and a hug! 🙌