Telegram Bot/CRM/PARS

Budget: 1200 USD Deadline: 21 days

Greetings. The architecture requires a reliable pool of Telethon sessions with proper distribution of 800+ chats and bypassing FloodWait/PeerFlood restrictions. I will build the system on Python + PostgreSQL with Docker containerization, based on my experience in creating Market-Hedge bots with dynamic multi-accounting on 100+ profiles and individual proxies. The queue of operators will be implemented in the main bot through strict database transactions to avoid collisions, so that a second operator cannot receive the same client. Will individual proxies (IPv4) be used for each parsing account to avoid cascading bans on the network?

Budget: 5000 USD Deadline: 7 days

Good day.

Your project perfectly aligns with my research area. In 2024, I independently derived the stability equation for Telethon through tensor algebra of distributed account spaces. It has not been published yet because the scientific community was not ready.

To balance accounts, I propose using a multilayer model of dynamic routing based on recursive queue convolution and spectral analysis of FloodWait. Inside, a probabilistic scheduler with a self-adaptive entropy compensation function will operate.

PostgreSQL is used not just as a DBMS, but as a computational layer. Part of the business logic is transferred to SQL so that queries can make decisions before Python even understands why it was called. Docker, in this case, serves as a means of maintaining the causal integrity of processes.

After launching the MVP on five accounts, the system will automatically enter a self-optimization mode through second-order recursive feedback and will be able to scale almost infinitely, limited only by the laws of thermodynamics and Telegram's policies.

Budget: 1000 USD Deadline: 14 days

Hello, Alex! Multi-account user bots on Telethon, ~800 chats with load balancing and no duplicates, PostgreSQL and Docker — this is exactly the type of tasks where I already thrive: I run Telegram parsing and sessions in my projects. I will make it so that the admin can add accounts and chats by themselves, without a developer, and Telegram won't ban for spamming. We'll start with an MVP on 5 accounts, then scale up. Where are we parsing clients from — should I estimate the limits?

Budget: 500 USD Deadline: 7 days

Hello, my name is Nikita.
I am ready to develop this system for parsing and distributing leads. I will create a reliable connection of user bots on Telethon, an admin panel, and a bot for operators with a PostgreSQL database.
I have already worked on a similar case where I built a multi-account parser for Telegram chats that bypassed flood limits and balanced the load on sessions.
Portfolio: Freelancehunt
Estimated price, timeline: $500, 4-7 days.
Message me, and we will discuss the details of the launch.

Budget: 500 USD Deadline: 1 day

Good day!
In general, the task is clear, but to provide an accurate response regarding deadlines and pricing, I would like to clarify some questions that arose after analyzing your task.
Please write in private messages – we will discuss the details and your wishes.

Budget: 850 USD Deadline: 30 days

Hello!

I have studied the technical assignment. The project is extensive, so I suggest starting not with an attempt to implement all 14 sections at once, but with a working MVP that can be tested on real Telegram accounts and then scaled.

In the first phase, I will include:

— connecting several Telegram accounts via Telethon with separate sessions;
— distributing chats among accounts;
— initial collection of history and monitoring of new messages;
— saving users, messages, and chats in PostgreSQL;
— merging users strictly by Telegram ID;
— handling FloodWait, time limits, and reconnections;
— a Telegram bot for operators with a queue of clients and statuses;
— a basic administrative section for accounts, chats, and operators;
— Docker Compose, instructions for launching and backup.

I will design the architecture with the possibility of further connecting new accounts, hundreds of chats, CRM, and additional analytics.

Important: stable operation immediately on 800+ chats must be confirmed by load testing, as the limitations depend on Telegram and the state of specific accounts.

The cost of the first working MVP is 850 USD.
Timeline — up to 30 days.

After launch and testing, we can separately agree on scaling and additional features.

I would be happy to discuss the number of accounts at the start, types of chats, and the expected daily load. Expand

Budget: 723 USD Deadline: 25 days

Hello!

I am a Full-stack developer and lead developer at Oria Agency, currently working closely with Telethon and similar parsing systems. The task is extensive but generally clear: user bots, distributing chats among accounts, a queue for operators, and an admin panel within the bot - everything is feasible. The main thing is to properly manage the load and handle FloodWait so that accounts do not get banned. PostgreSQL + Docker is also my standard set, and I have experience with large projects. I would like to clarify the timelines and how many accounts you plan to start with for the MVP, as this affects the balancing logic.

I look forward to collaborating.
Best regards, Andrey Voznyak

Budget: 600 USD Deadline: 10 days

Hello, Alex! I am building similar systems — in production LeadHub Bot: Telethon gathering activity, deduplication by Telegram ID, operator queue with atomic locking of cards (so that one lead doesn't go to two managers), SQLAlchemy async + admin panel. For your 800+ chats, I am scaling on PostgreSQL: a table for distributing chats by account_id as a single source of truth, each Telethon session with its own throttling/backoff, when FloodWait occurs, chats are automatically switched to live accounts. I perform initial parsing of history in batches with a smooth increase in load on the account to avoid burning out accounts in the first days. I am planning stages, like other candidates: Stage 1 — core: multi-account Telethon pool (5 accounts), PostgreSQL, initial parsing + monitoring, handling FloodWait/PeerFlood, operator bot with queue and statuses, Docker. Stage 2 — admin section (accounts/chats/operators/statistics), reissuing leads, bulk import/export of chats. I would like to clarify: how many accounts and what depth of history is needed at the start — this will affect the warming-up pace of accounts and the exact timeline for Stage 1.

Budget: 1000 USD Deadline: 10 days

Hello.
I am a senior developer. I work efficiently and on time.
Recently, I have been working with Telegram bots, automation using Playwright/Selenium, and Telethon.
In the past, I had experience with Telethon at the level of a custom TG client, so I fully understand your task.
I work for an hourly rate of $30/hour.
Feel free to write, I can start as early as today.
If it is more convenient for you, I can suggest breaking the MVP into several stages, so not everything at once.

Budget: 2000 USD Deadline: 14 days

📌Hello.👋
⭐️My name is Andrey.
⭐️My work experience: 12 years+

• ➡️I can show works specifically on bot development
• 🎨Portfolio: Freelancehunt
• ✅Work rating on Behance (over 600,000 views)
• 💼More works here: Dribbble

Budget: 2000 USD Deadline: 30 days

Hello.
We are ready to start immediately.
We will provide you with excellent results that will perfectly meet your requirements.
The current requirements are very precise.
So, I think we can start working right away.
One question I have is whether I must use C#.

Can I use another stack?

Do I have to use C#?

Budget: 480 USD Deadline: 10 days

⚡ The main risk here is not the code, but account bans. 800+ chats and initial parsing of history is exactly the moment when Telegram starts throwing FloodWait and PeerFlood, and hasty user bots catch limits in batches. If the architecture does not hold per-account limits from day one and cannot seamlessly transfer a chat from a limited account to a live one, the system will choke under mass load.

The second subtle point is the ONLY source of truth. With 5, and then 10-20 accounts, who specifically monitors a particular chat should be determined by a single distribution table in PostgreSQL, not by logic inside the worker. Otherwise, there will be user duplicates and repeated parsing of the same chat by two sessions.

Here's how I see it. Each Telethon user bot is a separate session with its own throttling and backoff. The dispatcher distributes chats by account_id, balances the load, and when an account is banned, its chats auto-migrate while the rest continue to work. Grouping strictly by telegram id - one card, even if a person has written in 20 chats.

I suggest starting not with all 14 points at once, but with a narrow MVP slice: 1) Telethon infrastructure on N accounts plus PostgreSQL schema plus handling FloodWait/PeerFlood; 2) operator bot with queue and statuses; 3) admin section (accounts, chats, operators, parser); 4) Docker plus launch and backup instructions. This way, you quickly see live lead collection, and we can fine-tune the rest step by step.

I have previously built systems with a similar profile: Telegram bots, parsing large volumes, cards on PostgreSQL, Docker builds. For example, a real estate and auto aggregator catalog (pinger) - there, it's all about data flow and object cards at scale.

To avoid guessing. How many accounts do we start with and what is the actual pace of adding chats in the first weeks? And how to prioritize lead distribution to operators - by freshness of activity, by chat, or just a simple queue? Please write in the correspondence, and let's break down the stages in more detail. Expand

Budget: 2000 USD Deadline: 7 days

Hello, I have worked on a Telegram parsing system — user bots on Telethon, monitoring 800+ chats, collecting 50,000+ users, and a bot for operators. Very similar to your task!

Question regarding the essence: how do you plan to distribute clients among operators — evenly in turn or taking into account statuses (for example, "Call back" returns to the same operator)? And how many accounts do you want to connect at the start of the MVP?

I suggest we get in touch; I will provide you with free technical consultation and we can create a development plan + I will tell you about my team!

Budget: 1000 USD Deadline: 1 day

Hello! I will complete your task quickly and efficiently. I specialize in Telegram bots!

My recent works
https://indexfast.pro - fast website indexing
https://mono-bank.pp.ua - everything about Monobank
https://mamamia.pp.ua - online store
https://programist.pp.ua/ua/portfolio/ - portfolio of works
https://monitortest.pp.ua - monitor testing
https://keytest.pp.ua - keyboard testing
https://pctest.pp.ua - computer testing
https://devroman.dev/portfolio/ - portfolio
https://vseetut.matviy.pp.ua - layout
https://indexfast.pp.ua - fast website indexing

My portfolio: https://freelancehunt.com/ua/freelancer/romas6ka.html#portfolio
Write to me, I will start working today. I will be glad to collaborate with you! Expand

Budget: 600 USD Deadline: 12 days

"Hello! I have reviewed the specifications and see how to implement the basic logic of the client queue and operator work through a Telegram bot with PostgreSQL as the database.

I am ready to discuss the MVP first stage and propose the architecture.

Portfolio: https://interesting-galley-0eb.notion.site/Portfolio-ff53a82144bf8251bc1581a6cef25f7d

What is the deadline for the MVP and what budget are you considering?"

Budget: 150 USD Deadline: 5 days

Good day!

We have experience in developing high-load Telegram systems in Python (Telethon, Aiogram), automating data collection, multi-user bots, PostgreSQL, and Docker.

We can implement a system according to your specifications: support for multiple Telegram accounts with load balancing, monitoring hundreds of chats, collecting history and new messages, handling FloodWait and blocks, a queue for issuing leads to operators, an administrative panel for managing accounts, chats, and operators, as well as a scalable architecture with PostgreSQL and Docker.

We pay special attention to reliability, performance, and the ability for further scaling without changing the architecture. After completion, we provide all source code, Docker configuration, and complete documentation for launching, updating, and backing up.

We are ready to discuss the project in detail and provide an accurate estimate of timelines and costs after reviewing all requirements.

Budget: 10000 USD Deadline: 33 days

Hello! My name is Yaroslav. I specialize in developing complex Telegram systems: combinations of "Bots + Userbots (Telethon)", parsers, and CRM integrations.

Your technical assignment is very well written. The task is absolutely clear: we need to create a stable combine that will aggregate leads from hundreds of chats and distribute them to the sales department without duplicates and failures.

Contact me on Telegram: *tensamypan

Budget: 1000 USD Deadline: 7 days

Good day.

I have processed the technical task. In terms of scope, this is not just one Telethon script, but a full-fledged multi-component system: data collection through several Telegram accounts, chat balancing, history storage, a queue for operators, and administrative management without a web panel.

I propose to implement the system using Python, Telethon, PostgreSQL, Redis, and Docker Compose. PostgreSQL will be the main storage, while Redis is advisable to use for task queues, locks, temporary states, and coordination of multiple workers.

Proposed architecture

The system should be divided into several independent components:

Telegram account manager

Each account will have a separate Telethon session, status, last activity time, current restrictions, and a list of pinned chats.

Adding a new account will occur through an administrative bot. The administrator enters the number, confirmation code, and, if available, the two-factor authentication password. After that, the session is saved and can be launched without re-login.

Deleting or replacing an account will not affect users, messages, and the history of operator work.

Chat distribution

The database will store a unique assignment:

Telegram chat → Telegram account

A unique restriction will prevent accidentally connecting one chat to multiple accounts. After adding a new chat, the system will assign it to the least loaded available account.

If an account is temporarily unavailable, its chats can be paused or transferred to another account that already has legitimate access to the corresponding chat. Automatic bypassing of Telegram restrictions or aggressive mass joining of chats will not be implemented.

Initial loading and continuous monitoring

Two modes will operate for each chat:

loading history for a specified period;
tracking new messages in real-time.

History collection will be done in parts with checkpoints. If the process is interrupted, it will continue from the last saved message rather than starting over.

Each message will be stored along with the chat, author, time, text, and available link. Users will be grouped solely by Telegram ID, so the activity of one person in twenty chats will form one card.

Handling Telegram restrictions

For each account, I will provide a separate state:

active;
waiting after FloodWait;
temporarily restricted;
disabled;
requires re-authorization;
connection error.

FloodWait will be handled according to the time returned by Telegram. At the per Expand

Budget: 500 USD Deadline: 4 days

[Model: Composer]

Ready response:

Good day.

I am ready to develop an MVP for a client search system in Telegram according to your specifications: several user bots on Telethon, a bot for operators, an admin section in Telegram, PostgreSQL, Docker. I am not creating a web panel at this stage.

MVP Composition

Telethon workers: N accounts (5+), each with its own session, add/disable/replace without losing the database.
Auto-distribution of ~800+ chats among accounts with balancing; one chat — one account (duplicates only if explicitly enabled).
Initial parsing of history over a period + real-time monitoring of new messages.
Deduplication strictly by telegram_id, one card per user with all chats and messages.
Queue of operators with card assignment, statuses (Picked / Unavailable / No answer / Refusal / In progress / Call back / Delete), reissue (never / 30 / 60 / 90 / arbitrary period).
Admin in Telegram: accounts, chats (add/remove/import/export/on-off/reparse), operators, start/stop parser, statistics.
Docker Compose, instructions for launching/updating/backing up the database.
Telegram limitations (immediately)
FloodWait / PeerFlood / session drops are handled: backoff, account pause, the rest of the system continues to operate. History on hundreds of chats — in batches, not "all at once." Reactions — only if the API consistently responds; in the MVP, the priority is messages and public activity.

Architecture for growth: workers ↔ task queue ↔ PostgreSQL ↔ operator/admin bots. Adding 10–20+ accounts and thousands of chats — without rewriting the core; CRM/export — with separate adapters later. Expand

Budget: 650 USD Deadline: 10 days

The task is clear: MVP for lead generation — a pool of Telethon user bots monitors 800+ chats, collects data on active users, and operators retrieve leads through an aiogram bot.

I have an implemented platform with a similar architecture: a pool of Telethon accounts with health scoring and load balancing strategy, adding new accounts without changing the config, correct handling of FloodWait and PeerFlood with exponential backoff — when one account is blocked, the others work normally. Data is in PostgreSQL, deployment via Docker Compose.

Regarding accounts — authorization through session string, storing sessions in the database, connecting and replacing accounts from the admin bot without restarting the service. For chats — the strategy is "one chat to one account," without duplication, importing a list from a file, enabling or disabling monitoring of specific chats through the bot. Initial collection of history for the required period through get_messages, then a live event handler for new messages. For the operator bot on aiogram — a queue of found users with output on request, activity history for each of the saved data.

I am ready to outline the architecture details or answer questions about implementation.

Budget: 800 USD Deadline: 21 days

Hello! The main challenge of your task is not just to gather messages from 800+ chats, but to build a fault-tolerant architecture that will effectively balance the load between a pool of user bots and automatically bypass cascading blocks (FloodWait, PeerFlood) from Telegram. I envision this system as a reliable, uninterrupted lead generation pipeline for your sales department.

Technologically, I will implement this based on asynchronous Python: Telethon for a scalable network of workers (user bots) and aiogram for the interfaces of operators and admin. The central component will be PostgreSQL for managing queues and storing user identifiers, and the entire infrastructure will be packaged in isolated Docker containers for rapid scaling and hot-swapping of accounts.

I have deep expertise in similar tasks: I independently developed and launched a complex content aggregator with routing for Telegram, where I successfully addressed issues of bypassing limits, parallel session operation, and managing large volumes of data. I also work officially (FOP of the 3rd group), which allows for easy collaboration through a B2B contract.

For an accurate assessment of the architecture, I have two technical questions:

Is there a plan to tie individual proxies (IPv4) to each Telethon session when adding a new account to minimize the risk of banning the entire subnet?

If an operator sets the status to "Declined" or "Not reached," should the system be able to automatically return this user to the general queue for other operators after a specified N-period of time? Expand

Budget: 850 USD Deadline: 12 days

Hello!

First, regarding what disrupts the layout: one Telegram account can hold a maximum of 500 dialogues. With 800 chats, distribution among accounts is mandatory, and at least 3-4 accounts are needed with a buffer for growth. The second point of the same nature is that joining 800 chats cannot be done quickly; the account will be banned for spam. Joins happen in a queue at a stretched pace, accounts are warmed up, each sits on its own proxy. I will assemble the system faster than the accounts can join all the chats, so filling the pool should start immediately — I will lay this out in the plan as the first step.

How I build it:

A pool of accounts. One worker per account: its own request limiter, its own task queue, its own proxy. FloodWait or temporary blocking affects a specific worker, while others continue to work. The "chat ↔ account" linkage lives in a separate assignment table with a cursor for the last collected message — therefore, the chat can move to another account, and the account can change without data loss.

Collection. Monitoring new messages costs almost nothing: Telethon maintains one connection and provides updates for all dialogues of the account, polling is not needed. The only expensive part is the initial parsing of history — Telegram returns a maximum of 100 messages per request — so it goes in a background queue with a lower priority than monitoring, so fresh leads do not wait while the archive loads.

Operator queue. Client issuance through row locking in PostgreSQL (FOR UPDATE SKIP LOCKED) — the same person will not be assigned to two operators even with simultaneous clicks. Re-issuance is counted from the date of the last touch and is configured from the admin panel. Users are merged by telegram id: people change usernames, but not ids.

Stack: Telethon (Pyrogram is no longer supported), PostgreSQL, docker-compose with instructions for launching, updating, and backing up the database.

In terms of deadlines: the core — pool of accounts, chat distribution, parser, database schema — will take a week. Another 4-5 days for the operator bot and admin section. In total, 10-12 days until a working MVP. I will show it in parts as I go, not as one piece at the end.

Cost — $800–1000. I am ready to split it into two stages with payment upon completion of each. Expand

Budget: 650 USD Deadline: 16 days

I will create an MVP using Telethon, PostgreSQL, and Docker: user bots with separate sessions, a dispatcher that distributes 800+ chats among accounts without duplicates, an operator bot, and an admin section within the bot. The initial collection of history will be gradual, reaching a volume with separate limits per account; when one of its chats is limited, it switches to live, so parsing does not stop.

The first focus is on the queue of operators. When several operators take the next client simultaneously, two should not receive the same lead, so the distribution is atomic at the database level and immediately assigns the lead to the operator. Statuses, action history, and re-distribution after 30, 60, and 90 days work centrally, and a user with 20 chats is consolidated into one card by Telegram ID.

Second, autonomy after delivery. The admin connects and replaces accounts independently, imports the chat list via a file, enables monitoring of specific chats, restarts history collection for the required chat, and manages operators without my involvement and without code changes. Replacing an account does not affect already collected data, as it is tied to chats and users, not to sessions.

One point from the technical specification: a link to a specific Telegram message is only available for public groups and channels with a username; it does not exist for private ones, so I will save the identifiers of the message and chat so that the operator can still find the context.

I work with Telethon and parsing large volumes in Telegram; PostgreSQL and Docker are a familiar stack. I suggest starting with the working core of collection and the operator bot so you can quickly see the first leads, and we will build the admin panel and statistics later. We can discuss the details in the chat.

Budget: 500 USD Deadline: 7 days

Hello!

I am ready to implement this system. I have experience in developing complex Telegram systems, automation, parsers, CRM integrations, working with Telethon, Python, PostgreSQL, Docker, and high-load services.

I have studied the technical specifications — the architecture is clear. I suggest building the project with scalability in mind from the start, so that the number of Telegram accounts, chats, and operators can be increased without reworking.

What will be implemented:

• Multi-account architecture on Telethon with independent sessions, the ability to connect, disconnect, and replace accounts without data loss.
• Automatic distribution of 800+ chats among accounts with load balancing and consideration of Telegram's limitations.
• Initial parsing of message history and subsequent continuous monitoring of new messages.
• Correct handling of FloodWait, PeerFlood, reconnections, time limits, and other Telegram errors without stopping the entire system.
• PostgreSQL with a normalized data structure (users, messages, chats, accounts, operators, statuses, processing history, etc.).
• Telegram bot for operators with a client queue, a system for assigning users to operators, processing statuses, and automatic issuance of the next client.
• Administrative Telegram bot for managing accounts, chats, operators, monitoring, re-parsing, and viewing statistics.
• Flexible configuration for reissuing clients (30/60/90 days or arbitrary period).
• Docker environment (Dockerfile, docker-compose), instructions for deployment, updating, and backup.
• Architecture designed for further integration with CRM, API, and additional modules.

In development, I pay attention to fault tolerance, performance, data storage security, and clean architecture so that the system can operate stably with dozens of accounts and thousands of Telegram chats.

I am ready to discuss the implementation details, propose an optimal architecture, and start development immediately after agreeing on the technical nuances. Expand

Budget: 50 USD Deadline: 3 days

ready to help you out with this

will share previous works in chat to make sure we match

Budget: 3000 USD Deadline: 5 days

Hello, Alex! In such a system, the main problem is not FloodWait, but session synchronization and chat distribution, so that one account does not process the same chat twice and get banned. In the last project with 10 accounts, I created a queue manager using asyncio.Queue, which distributes chats to free sessions considering Telegram limits. What chat sources do you plan to use for the initial import?

Budget: 720 USD Deadline: 7 days

Hello!

I have fully reviewed your technical assignment for the development of an MVP system for automating client search. The task is clear, and the technology stack is absolutely correct for such a load. I have extensive experience in creating asynchronous parsers using Telethon, designing relational databases, and containerizing applications with Docker.

Budget: 650 USD Deadline: 12 days

Hello, Alex! I agree with my colleagues: the main risk here is not the code, but the banning of accounts during the initial parsing of the history of 800+ chats. I have many years of practical experience specifically with this class of tasks — I have built systems that live for years under strict rate-limit control of marketplaces and anti-bot protection (not abstractly, but on real production systems with a constant struggle for the survival of accounts).

MVP architecture: Telethon user bots with separate sessions per account, asynchronous queue with dynamic pauses instead of fixed sleep, dispatcher for distributing chats by account_id with auto-transfer in case of ban/restriction, deduplication of users by Telegram ID through PostgreSQL. Initial parsing of history — with gradual warming up of the load, not all at once. Docker-compose for deployment in one command.

I am ready to start with an MVP on 3-5 accounts and show a working prototype before scaling up to 10-20.

Budget: 725 USD Deadline: 10 days

Alex, the task with multiple accounts, 800+ chats, and resilience to FloodWait requires a well-thought-out architecture from the start. I would create an MVP using Telethon + PostgreSQL + Docker with separate account sessions, chat balancing, a client issuance queue, and protection against duplicates by Telegram ID. I have 7 years in web/services, led a team, and have already built systems with background processing and admin logic. I am ready to discuss the implementation details.

Budget: 1300 USD Deadline: 7 days

Your task is practically a copy of my two projects - HelpDesk (support bot) and mass automation of Telegram accounts, currently managing almost 200 accounts, with the oldest ones having a lifespan of about 10 months (since the project started), and the percentage of deleted accounts is extremely low. Experience in automation and specifically in Telegram is quite substantial; we can be useful to each other.

Regarding the support bot (available in the portfolio) - operators, chat history of operators, switching clients between operators, queue of requests, the ability to initiate a dialogue with an existing client, blacklists, etc.

By the way, in conjunction with Teleton, we can write on behalf of accounts through a regular bot, so operators don’t have to switch between accounts. Or if we are only interested in incoming messages - Telegram recently introduced chat automation (also known as business bot) for all accounts.

Budget: 500 USD Deadline: 14 days

I and my team offer a full cycle of turnkey development. The team consists of experienced developers, designers, and UX/UI specialists, which allows us to create a convenient and functional product that meets all your requirements. We will discuss the deadlines and price in private messages once we have a complete understanding of the scope of work. I expect feedback from you. I can send examples of our work in private messages.

Budget: 6300 USD Deadline: 40 days

Hello. My name is Alexey, and I represent a group of developers – NC-1. For over five years, we have been creating websites, mobile applications, online stores, ERP/CRM systems, and other e-commerce products.
I offer our team and stack for the project:
Backend Developer — Python (Telethon, Aiogram/Pyrogram), PostgreSQL, SQLAlchemy — Will design the database architecture, write the logic for the secure distribution of 800+ chats among user bots, a continuous parsing system bypassing Telegram limits, and both interfaces (for operators and admin)
DevOps Engineer — Docker, Linux, Bash — Will package the system components into a scalable docker-compose configuration, set up automatic session restarts on failures, and write deployment and backup instructions
QA Engineer (Tester) — Manual testing, Telegram API — Will conduct load simulations to check for handling blocks (FloodWait, PeerFlood), test strict lead binding to operators in the queue, and ensure there are no duplicates in the database
Project Manager / Team Lead — Development management — Will decompose the technical task, synchronize processes between the backend and infrastructure, and conduct a final functionality check before delivery.
Preliminary cost - 5,750 USD
Best regards, Alexey M.

Budget: 1000 USD Deadline: 30 days

I am a NodeJS developer. I am ready to take on this task. Write to me, and we will discuss.

Budget: 300 USD Deadline: 6 days

Good day!

I have reviewed your project. The task is clear, and I have experience in implementing similar projects.

I am ready to discuss the details and propose the optimal solution for your task.

Sincerely, Andrey.

Budget: 2000 USD Deadline: 1 day

Hello! I am an experienced developer, capable of creating bots of any complexity, ranking in the TOP-4 in the "Bot Development" category. I also develop websites and API documentation in Python, where I rank in the TOP-2.

Regarding your project, I have some clarifying questions that will affect the assessment of your task and help understand what you want. Please write to me to clarify all the details!

You can review my skills in my resume 👉 Freelancehunt
My work is also published in my portfolio 👉 Freelancehunt

💻 I am also the SEO of a team consisting of a FrontEnd developer and a BackEnd developer! So if necessary, our team of three can organize a turnkey development for you!

I look forward to your response, thank you.

Budget: 6000 USD Deadline: 40 days

Good day!
I have carefully studied the technical specifications. I have experience in Python development for Telegram systems (Telethon, aiogram, PostgreSQL, Docker).
What is included in the rate:
Core of the system
— A pool of user bots on Telethon with independent sessions, connecting/disconnecting/replacing accounts without losing the database
— Automatic distribution of 800+ chats among accounts with load balancing and protection against duplication
— Initial parsing of history + constant monitoring of new messages
— Correct handling of FloodWait, PeerFlood, connection drops, temporary restrictions — the failure of one account does not stop the system
Operator bot
— Automatic queue of clients, fixing the client to the operator, full set of statuses, action history
— Merging users by Telegram ID (one card = all chats)
— Setting up re-issue (30/60/90 days / arbitrary period)
Admin panel (in the bot)
— Management of accounts, chats (adding, import/export, bulk upload), operators, parser
— Statistics on all points of the technical specifications
Infrastructure
— PostgreSQL with a schema for scaling (10–20+ accounts, thousands of chats)
— docker-compose.yml, Dockerfile, instructions: launch, update, database backup
— Launch with a single command
Two important points to discuss before starting:

Proxies and accounts. 800 chats on 5 accounts means 160 chats per account, which carries a high risk of bans. I recommend allocating 15–20 accounts + separate resident proxies for each. These costs will be on your side, but without them, the system will operate unstably.
Legal aspects. Processing personal data of users falls under GDPR. I suggest fixing in the contract that the client acts as the data controller and determines the legal grounds for processing.
Updated stages for 40 days:
Stages (40 days):

Database schema, architecture for chat distribution, setting up the Docker environment — 5 days
Pool of user bots on Telethon: authorization, sessions, connecting/replacing accounts — 6 days
Distribution of chats among accounts, balancing, protection against duplication — 5 days
Initial parsing of history + monitoring new messages — 7 days
Handling Telegram restrictions (FloodWait, PeerFlood, reconnect, isolation of failures) — 4 days
Operator bot: queue, client fixation, statuses, action history, re-issue — 6 days
Admin panel: accounts, chats (import/export), operators, parser, statistics — 4 days
Load testing, documentation (launch/update/backup), handover — 3 days Expand

Budget: 100 USD Deadline: 5 days

Good day!

I have experience in developing Telegram bots, CRM systems, and parsers in Python. I created my own AI manager and bots for management systems, including BabyLand.

I can implement data collection and processing, integration with CRM, convenient management via Telegram, and stable parser operation. Before starting, I will quickly clarify the logic and suggest an optimal structure.

I am ready to start immediately and show results step by step.

Budget: 1000 USD Deadline: 7 days

Hello! I already have a system in production that does exactly what is described in your specifications: a multi-account setup on Telethon with chat distribution among accounts, handling FloodWait/PeerFlood, and warmup limits (to prevent accounts from burning out), initial parsing + monitoring of new messages, deduplication of leads by Telegram ID, a queue for operators with statuses, and reissuing after N days. PostgreSQL + Docker — out of the box.

So you don't need to wait a month for development from scratch — the core is ready, I will adapt it to your specifications: your card format, your operator statuses, your chat volume.

I work in two formats:

1. Turnkey solution delivery — a separate build for your project, source code, deployment, documentation for launching/updating/backups. Starting from 3000 USD, timeframe 2–3 weeks.

2. Instance deployment with my support — the system is deployed for you, I maintain and refine it: 1000 USD for implementation + 250 USD/month for support. Launch in a few days, further adjustments and new features along the way.

Before starting, I am ready to call and show a working demo of the system live — so you can see the finished product, not just promises. I work through Safe.

Questions: Are the accounts and proxies for user bots on your side? And what is the target number of leads per day — this affects how many accounts are actually needed and how aggressively we can parse without bans. Expand

Budget: 1000 USD Deadline: 5 days

Hello!

I am interested in your project. I have experience in developing high-load systems using Python, working with the Telegram API (Telethon), PostgreSQL, Docker, and building fault-tolerant services with a large number of concurrently running processes.

I envision the project as a modular system consisting of several independent services:

* a manager for Telegram accounts and their sessions;
* a chat distributor among accounts with load balancing;
* a primary parsing service for history;
* a service for continuous monitoring of new messages;
* a user processing queue;
* a Telegram bot for operators;
* an administrative bot for managing accounts, chats, and the system;
* PostgreSQL for data storage and action history.

I will pay special attention to handling Telegram restrictions:

* FloodWait;
* PeerFlood;
* automatic reconnection;
* temporary isolation of blocked accounts;
* automatic load redistribution among remaining accounts without stopping the system.

A scalable architecture can also be implemented, allowing for the connection of dozens of Telegram accounts and thousands of chats without significant changes.

The project can also include the possibility of further integration with CRM, APIs, and additional modules without a complete overhaul of the system.

As a result, you will receive a fully deployable solution with Docker Compose, documentation for launching, updating, and backing up the database.

I would be happy to discuss the project details, propose an architecture, and estimate timelines after clarifying a few technical points.

Best regards,
Dmitry Expand

Budget: 1000 USD Deadline: 10 days

Good day.

I have experience in developing Telegram systems using Telethon, PostgreSQL, and Docker.

From similar projects:

I developed a monitoring system for Telegram chats through multiple accounts. The system automatically distributed hundreds of chats among accounts, collected message history, tracked new messages in real-time, handled FloodWait, and performed automatic reconnection of accounts.

I also developed a lead search and processing system that gathered users from different sources, merged data by Telegram ID, saved message history, and provided clients to operators with status and action tracking.

According to your specifications, I see the implementation through Telethon workers with automatic chat distribution among accounts, PostgreSQL for data storage, and Telegram bots for operators and administrators.

I am ready to discuss the details and propose an optimal MVP architecture. Expand

Budget: 500 USD Deadline: 15 days

Hello!
I have direct experience in developing similar lead generation systems (recently — aggregating all activity from 20+ chats with the formation of cards (processing over 22,000 messages at once).
Here’s how I propose to implement this:
• Telegram API: Python + Telethon (as you preferred). We will set up history collection with strict limit control (FloodWait), and automatic monitoring — through event subscriptions, which practically does not consume Telegram limits.
• Database (PostgreSQL): I suggest using Supabase. Under the hood, it’s the same PostgreSQL you require, but it offers a powerful advantage — Real-time updates. Operators will instantly see the emergence of new leads in the queue and status changes without refreshing the page. Additionally, this will significantly speed up the development of the web panel itself.
• Interface (CRM): I strongly recommend creating a web panel (for example, FastAPI + Vue/React). The Telegram bot interface will be too cramped for convenient work with statistics, filters, and summary message history.
I will initially make the architecture modular for easy scaling in the future (for example, to connect a pool of multiple accounts or direct integration with amoCRM/Bitrix24).
I am ready to show examples of implemented projects, discuss details, and provide timelines. I look forward to collaborating!

Budget: 320 USD Deadline: 18 days

Good day! The technical specification is very detailed, the system structure and business logic are absolutely clear.

I am ready to take on the development of this MVP. The stack fits perfectly with Python (Telethon + aiogram) + PostgreSQL + Docker.

Here’s how I envision the technical implementation of the most complex nodes:
- Balancing and limits: For 800 chats and 5+ accounts, I will implement an asynchronous load balancer (Task Queue). If one account hits FloodWait, its pool of chats will be dynamically intercepted by free user bots without stopping the overall parsing.
- Operator queue: To eliminate duplication (when two operators take the same client), lead distribution will be implemented through strict transactions in PostgreSQL.
- Security of account network: The specification does not specify a proxy mechanism. If 5+ accounts are run from one IP (one Docker container), Telegram will quickly issue a shadow ban. I will incorporate the binding of IPv4/IPv6 proxies to each individual Telethon session upon its initialization into the architecture.

Organization of work:
The project is large-scale, so I suggest breaking it down into two phases:
Phase 1: Core (management of Telethon accounts, parser, bypassing blocks, writing to the database).
Phase 2: Bot interface for operators (queues, statuses) and admin panel.

I am ready to discuss the details and start designing the database schema. Please let me know if you will provide accounts for testing and proxies, or if I need to include this in the development budget? Expand

Budget: 450 USD Deadline: 12 days

Hello. My name is Vladimir, I am a NodeJS and Python developer, as well as the founder of the engineering agency Vaysed. I have thoroughly studied the technical assignment for developing an MVP system for automatic client search in Telegram. I understand that you need to create a fault-tolerant infrastructure based on a pool of Telethon accounts for parsing 800 or more chats, with load balancing, bypassing blocks, and delivering unique leads to operators through a bot, without using a web panel.

To implement this task, I propose designing a scalable microservice architecture. The administrative and operator interfaces will be developed on the modern asynchronous framework aiogram 3, which will ensure a high response speed of the interface. The pool of user bots on Telethon will be managed by a central coordinator, which will dynamically distribute chats among active sessions, intercept FloodWait errors, and smoothly transfer tasks to free accounts. We will deploy the database on PostgreSQL for reliable storage of activity history and strict deduplication of users by their Telegram ID. To eliminate collisions when issuing a client card to two operators at once, I will implement a system of instant locks based on Redis. The entire architecture will be packaged in Docker with detailed instructions for quick deployment via docker-compose.

I have relevant experience in building high-load Telegram systems. In the Lumos project, I successfully implemented complex asynchronous monitoring and real-time streaming data processing. And while developing the PAYBACK CARTEL system, I designed a deep role model from scratch, access distribution algorithms, and synchronization of large data arrays, which fully covers the logic of your sales department and administrative management.

You can view my portfolio at this link: Freelancehunt

I suggest discussing the technical details of the chat distribution algorithm and session protection mechanisms in private messages.

Budget: 300 USD Deadline: 12 days

Hello, Alex! I have thoroughly studied your technical assignment. The task is large-scale but absolutely feasible with the right architecture design for the workers. I have experience working with asynchronous scripts in Python 3.12 and am ready to create a fault-tolerant MVP based on Telethon, PostgreSQL, and Docker according to all points of the technical specification.

I fully understand that for stable processing of 800+ chats, a regular round-robin load balancer will not work — the system will simply burn out the accounts. I propose architectural solutions for each critical node:

1. Protection against bans and FloodWait during initial parsing:
Mass loading of history is the most dangerous moment. I will implement step-by-step parsing of history in batches through asyncio.Queue with dynamic pauses and handling of FloodWait/PeerFlood at the level of the basic Telethon client with exponential backoff. If one account temporarily goes into restriction, the system will automatically reassign its chats to other live sessions from the pool.
2. Centralized load balancer (Single source of truth):
Distribution of chats among account_id will be strictly managed through a central table in PostgreSQL. This will completely eliminate the situation where the same chat is monitored by two sessions simultaneously, creating duplicate leads. Adding or disabling accounts by the administrator will occur on the fly without changing the configuration code.
3. Atomic operator queue (Protection against race conditions):
To prevent two managers from intercepting one client, lead assignment will occur atomically at the PostgreSQL database level using status triggers. As soon as an operator opens a card, its status changes, and it disappears from the output for others. Merging user cards from different chats will strictly follow the unique Telegram ID.
4. Containerization and Docker:
I will deploy the system based on microservice logic. I will prepare clean Dockerfile and docker-compose.yml, set up volumes for storing the database and Telethon session files, so that restarting containers does not lead to data loss. I will provide clear instructions for launching with one command, backing up (pg_dump), and updating.

The budget and timeframe of 12 days I mentioned are allocated for the complete implementation of all 14 points of your technical specification "turnkey" without cutting functionality.

Please let me know what period of history (depth in days or hours) needs to be collected during the initial parsing of new chats? Expand

Budget: 1800 USD Deadline: 7 days

I saw that the presentation mentions monitoring 800+ chats, user collection, and CRM for operators. The main headache in such systems is not writing the code but not burning the account during the initial parsing of history. That's when Telegram throws FloodWait and PeerFlood, and hasty user bots get banned within half an hour. Therefore, I will build the architecture around this risk.

What I will specifically do:
User bot on Telethon with an asynchronous queue and smart limits — FloodWait is handled automatically, pauses between requests are dynamic, not a fixed sleep.
Parsing 800+ chats in batches with prioritization — first active, then archived, to avoid expiration and overloading the API.
CRM part on C# MVP: operators see new leads in real-time, take them into work, statuses, dialogue history.
Storage in PostgreSQL — structure for analytics and user search.
Everything in Docker containers, so deployment is a one-liner.

One nuance that others will miss: the first run of parsing history on 800 chats is the most dangerous moment. I gradually warm up the account, increasing the load so that Telegram perceives the activity as organic. This is the difference between "works for a week" and "banned on the first day."

After delivery, I won't disappear — I will be available for any edits and improvements. I am currently free and can start today. Message me, and I will draft a plan for the first stage with estimates by blocks within an hour. Expand

Budget: 350 USD Deadline: 14 days

Good day, Alex.
I have reviewed the specifications in detail. The main difficulty here is not in parsing messages itself, but in reliably distributing 800+ chats among Telethon accounts without duplicates, correctly handling FloodWait/PeerFlood, and continuing the system's operation if one of the accounts is temporarily restricted.
For the first version, I propose the following architecture:
— each Telegram account has a separate Telethon session and its own limits;
— the distribution of chats among accounts is stored centrally in PostgreSQL;
— one chat by default is processed by only one account;
— users are strictly grouped by Telegram ID;
— a client is atomically assigned to an operator, so two operators will not receive the same card;
— FloodWait, PeerFlood, reconnect, and temporary blocks are handled without stopping the entire system.
The first phase will include:
— support for up to 5 Telegram accounts;
— import and management of the chat list;
— initial collection of history and monitoring of new messages;
— PostgreSQL with a structure for users, chats, messages, and activity;
— an operator bot with a queue and statuses;
— a basic administrative section;
— Docker Compose and instructions for launching and backing up.

After stable testing on a limited number of accounts and chats, we can scale the system to the full volume of 800+ chats in a separate phase, add advanced statistics, and CRM integrations.
Before starting, we need to clarify the number of accounts and operators in the first version, as well as the history period that needs to be loaded from each chat. Expand

Budget: 1500 USD Deadline: 30 days

Good day.
I have experience in developing applications using Telethon sessions for collecting and processing information, creating mailings, etc. I am interested in your project and could take on its execution.

Budget: 50 USD Deadline: 1 day

Good day, Alex.

Your 800+ chats during the initial parsing of the history will definitely trigger FloodWait within the first few minutes — that’s why load balancing between accounts should be built not on round-robin, but on adaptive tracking of limits for each Telethon session with a queue of delayed retries. Your system will continue collecting while the blocked account waits, and the others will pick up its chats without duplication. Each lead in the operators' queue is atomically secured in PostgreSQL — the second operator will not see it.

Options:

≈13 days: 250–350 USD
Basic functionality for launch with a limited number of accounts and chats.
- Support for up to 5 Telegram accounts
- Automatic collection of messages from a specified list of chats
- Simple lead queue for operators with status changes
- Basic administrative functionality for chat management
- Deployment via Docker

or

≈24 days: 450–650 USD
Full-fledged automation system with adaptive balancing and extended management.
- Scalable support for 20+ accounts with adaptive load distribution
- Full cycle of initial history parsing with FloodWait handling
- Complete user card with message history from all chats
- Flexible lead reissue system (30/60/90 days)
- Full administrative section with statistics and rights management

or

≈40 days: 800–1000 USD
Maximally resilient system with enhanced protection against blocks and optimization for big data.
- Database optimization for processing thousands of chats and millions of messages
- Advanced anti-flood system and automatic session reconnection
- Bulk data import/export module and integration API templates
- Priority support and maintenance after launch for a month
- Complete set of instructions for backup and scaling Expand

Budget: 300 USD Deadline: 10 days

Good day!

I will create an MVP according to your specifications: Telethon user bots (N accounts) + operator bot + admin section + PostgreSQL + Docker, without a web panel.

Critical points that I will implement from day one:

- separate session/throttling for each account + correct handling of FloodWait / PeerFlood / reconnect;
- a single source of truth in PostgreSQL: distribution of chats by account_id without duplicates (and auto-migration of chats when an account is restricted);
- deduplication of users strictly by Telegram ID — one card even with 20 chats;
- queue of operators with client fixation + statuses + reissue after N days.

MVP components:

- user bot infrastructure + database schema + parsing history / live monitoring;
- operator bot (queue, card, statuses);
- admin (accounts, chat import/export, operators, parser, statistics);
- docker-compose + instructions for launching/updating/backing up.

Question: how many accounts and chats at the start, and is the reissue of clients never or after N days?
I am ready to start in phases after a brief agreement. Expand

Budget: 12345 USD Deadline: 3 days

Hello! Do you already have a rough idea of how many Telegram accounts you plan to use at the start so that I can assess the load on the balancer?

I will be able to provide more precise timelines and budget in personal correspondence.

Here’s how I will implement this project:
1. I will deploy userbots on Telethon with automatic chat distribution and handling of Telegram restrictions.
2. I will create a Telegram bot for operators with a client queue and statuses, as well as an admin panel for managing accounts, chats, and statistics.
3. I will set up PostgreSQL, Docker configuration, and foresee the possibility of scaling to 20+ accounts without changing the code.

Thank you for considering my proposal. I look forward to the opportunity to collaborate with you!

Budget: 370 USD Deadline: 5 days

Good day, I am a Python developer with extensive experience in developing Telegram bots of various complexity. I can complete your order quickly and efficiently. Write to discuss the details; I am ready to start today. I will also upload your bot to the server for stable operation 24/7 and will provide technical support for the bot for another month. This is included in the cost.

Budget: 1000 USD Deadline: 28 days

Ready to take on the development of a client search automation system in Telegram. I have experience working with Telethon, PostgreSQL, and Docker. I will ensure all requirements of the technical specifications are met.

Budget: 50 USD Deadline: 1 day

Hello. To build this system, I will use a modular architecture based on Telethon, which will allow for efficient scaling of work with numerous Telegram accounts and chats, utilizing an asynchronous task queue for flexible load distribution and resilience to network failures. The focus will be on reliable handling of Telegram limits and automatic recovery, while ensuring optimized data storage in PostgreSQL for quick access by operators and administrators. I have experience implementing high-performance parsers and automation systems that use similar principles, with ready-made solutions for Docker deployment and monitoring. I suggest discussing all implementation details, final budget, and timelines in private messages.

Budget: 500 USD Deadline: 14 days

The task is to create a system on user bots that monitors 800+ chats, parses potential clients, and distributes leads to operators via a bot.

I am building it this way: Telethon workers in separate Docker containers (one container = one account), adding a new account = launching a container with env variables, without modifying the code. Chats are stored in PostgreSQL linked to account_id, the load balancer, when adding a chat, looks at the current load of each account and assigns it to the least loaded one. FloodWait and PeerFlood are intercepted at the level of the basic Telethon client with exponential backoff and auto-reassignment of the chat to another account in case of a ban.

The key risk: Telegram aggressively bans accounts during mass history parsing. I perform the initial parsing with delays and batching through a queue (asyncio.Queue) to avoid exhausting accounts in the first days.

How many operators will be working simultaneously, and is there a need for lead prioritization logic (for example, by user activity or by chat)?