MeerMost

How We Automated Short-Term Rentals: AmoCRM, RealtyCalendar, and Telegram

A short-term rental business runs on repetitive communication with guests. Every guest needs instructions, the Wi-Fi password, the door code, a checkout reminder. Doing it by hand once is fine. Ten times a week and you're already drowning. Twenty apartments at once turn into chaos. This case study is about how we built a system that took all that routine off the client's team. The tech is simple, the value is huge.

The context: what we started with

The client managed several short-term rental apartments. Bookings came from three booking platforms: Avito, Sutochno, and Yandex Travel. The team worked in WhatsApp and Telegram and kept the schedule in RealtyCalendar. There was no automation at all.

The standard booking path:

  1. The guest books through a booking platform
  2. The manager sees the booking in RealtyCalendar
  3. The manager opens WhatsApp, copies a template, and fills in the guest's details
  4. Two days later, a reminder about check-in time
  5. On check-in day, instructions, the Wi-Fi password, and the door code (different for each apartment)
  6. On checkout day, a reminder about check-out
  7. After checkout, a task for the cleaners

Every step is manual. Every apartment has its own set of passwords and codes. As the number of apartments grew, communication time grew linearly, and so did the number of mistakes. A code sent to the wrong guest, a forgotten instruction, yesterday's details sent out.

The goal

Get the team to handle only non-standard situations: conflict resolution, early check-in, late check-out, cancellations. Move all the routine (sending instructions, passwords, and reminders) into automation.

A secondary goal: when a new apartment is added, communication should be picked up automatically, without rewriting templates.

Architecture

The key architectural decision: don't try to do everything in one tool. Each component does what it's good at and talks to its neighbors through APIs and webhooks.

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Aggregators   │    │ RealtyCalendar  │    │     AmoCRM      │
│ Avito, Sutochno │───▶│ one schedule,   │───▶│ pipeline by     │
│ Yandex Travel   │    │ synced          │    │ booking stages  │
└─────────────────┘    └─────────────────┘    └────────┬────────┘
                                                       │
                                                       │ webhook
                                                       ▼
                       ┌─────────────────┐    ┌─────────────────┐
                       │  WhatsApp,      │    │   Our backend   │
                       │  Telegram       │◀───│ pulls the       │
                       │  via            │    │ instructions    │
                       │  Salesbot/Pact  │    │ for this        │
                       └─────────────────┘    │ apartment       │
                                              └─────────────────┘

Each block:

  • The booking platforms are already connected to RealtyCalendar. It's a standard integration, and we didn't touch anything.
  • RealtyCalendar aggregates bookings from all platforms into a single schedule. It already has a native integration with AmoCRM, and we used it as is.
  • The core pipeline logic lives in AmoCRM. Each booking gets its own deal with stage transitions.
  • Our backend catches webhooks from AmoCRM, works out which instructions to send, and forwards them to WhatsApp/Telegram.
  • Salesbot and Pact serve as delivery tools for messengers. Pact supports the WhatsApp Business API, and Salesbot is built into AmoCRM.

The principle: no in-house integrations with the booking platforms. RealtyCalendar does it better than we would, and there's no point duplicating it.

The pipeline in AmoCRM

The most interesting part here is the deal structure. Every booking goes through a single pipeline with fixed stages:

StageTransition triggerWhat the guest receives
BookedDeal created from RealtyCalendarBooking confirmation + payment details
Instructions sent1 day before check-inFull instructions: address, directions, Wi-Fi, codes
Early check-inAt the guest's request, manual stageTime confirmation, extra charge
Late check-outAt the guest's request, manual stageTime confirmation, extra charge
Check-inOn check-in day, at the booked timeWelcome message, manager's contact
In-stay24 hours after check-in(Silence, the guest is in the apartment)
Check-out4 hours before the end of the bookingCheckout reminder
CleaningAfter checkoutCleaning task for the cleaners

Every automated stage triggers a webhook to our backend. The backend decides exactly what to send.

Why a backend and not just AmoCRM

We could have done everything inside AmoCRM with Salesbot. We didn't, and here's why.

Instructions are unique to each apartment. One apartment has door code 1234, another 5678. In one, the Wi-Fi network is called Home, in another Apartment2. Keeping all that in Salesbot templates is a recipe for disaster. Every new apartment requires copying and editing the entire pipeline.

The solution: apartments are stored in our database as entities with fields: address, door code, Wi-Fi name, Wi-Fi password, instructions, cleaner's contact, check-in time. Using the apartment ID from the AmoCRM deal, the backend pulls the relevant data and inserts it into the message text.

The logic differs by guest type. A guest with a first booking receives detailed instructions. A guest who has stayed before gets a short message: "same door, same code." You can branch that logic in AmoCRM through Salesbot, but it's hard. In code it's five lines.

Payment information is calculated on the fly. Price plus the platform commission plus the security deposit. AmoCRM can't do calculations like that; the backend computes them at the moment of sending.

How one cycle actually works

Day -1. The guest booked through Sutochno a week before check-in. RealtyCalendar received the booking and created a deal in AmoCRM. The deal automatically landed in the “Booked” stage. A trigger fired in AmoCRM and sent a confirmation through Salesbot to Telegram (if the guest provided Telegram) or to WhatsApp via Pact.

Day 0, morning. The “24 hours before check-in” trigger fired in AmoCRM. The deal moved to the “Instructions Sent” stage. A webhook with the deal ID hit our backend. The backend:

  1. Pulled the apartment ID and check-in time from AmoCRM
  2. Pulled the apartment details from its own database: address, Wi-Fi, door code, instructions
  3. Pulled the guest’s phone number and name from AmoCRM
  4. Assembled the message text from the apartment’s template
  5. Sent it to the guest’s WhatsApp via the Pact API
  6. Logged a comment in AmoCRM: “Instructions sent at 09:00”

Day 0, check-in time. The deal moved to “Check-in” on schedule. The guest got “enjoy your stay — if you need anything, message the manager.”

Days 1–N, silence. No messages. The guest lives their life.

Checkout day, 4 hours out. The deal is in “Checkout.” The guest got a reminder about check-out.

After checkout. The deal is in “Cleaning.” The cleaner got the address and time in WhatsApp.

The client’s team didn’t touch any of it for the whole cycle. They open AmoCRM once a day, look at the pipeline, and step in only for exceptions: early check-in, a conflict, a cancellation.

What we got

  • Full automation from booking to guest communication. The team doesn’t write template messages by hand.
  • Every message carries the current details for that specific apartment. Code 1234 won’t go to an apartment whose code is 5678.
  • The AmoCRM pipeline is transparent. At any stage you can see what’s happening with the booking.
  • Adding an apartment is a one-minute job. You go into the backend admin panel, fill in the apartment fields, and it’s automatically picked up into the pipeline.

What didn’t work

Pact for WhatsApp. Sometimes the WhatsApp Business API hangs or rejects messages. We added retries with exponential backoff, which saves it in 90% of cases, but sometimes messages still don’t get through. The fallback: the manager gets a notification that the message didn’t go out and sends it manually.

Telegram bots don’t cover every guest. About half of guests don’t use Telegram. WhatsApp works in Russia, but with caveats (part of the audience doesn’t use it, or they’re on an outdated version). There’s no perfect universal channel, so we do multi-channel delivery with a priority order: Telegram, WhatsApp, SMS as the fallback.

AmoCRM webhooks sometimes arrive late. In rare cases AmoCRM sends the webhook 5–10 minutes late. It’s not critical for our logic (we’re not sending to-the-second messages), but it was annoying during debugging.

What I’d do differently now

I’d put the apartment data in a separate admin tool. Right now it’s in Postgres, and editing it takes a developer. I’d build a small admin panel on the same Next.js and hook it up to that database. The client would edit apartments themselves, without coming to us.

I’d add an AI agent for non-standard situations. Right now an “early check-in” means moving the deal by hand. An AI agent in a Telegram bot could hold the conversation with the guest, understand that they’re asking for an early check-in, and move the deal right away. It’s technically doable (we do something similar in MeerBot). At the time of the project the stack hadn’t matured yet.

I’d build analytics by booking platform. Where guests come from, repeat booking rate for each channel, which manager closes what. Right now that isn’t there; the client looks at overall numbers. With analytics they could shift the ad budget between booking platforms.

When this kind of solution fits

If you have:

  • A business with recurring customer communication (rentals, delivery, education, scheduled services)
  • Multiple locations, branches, or properties with unique parameters (like the apartments in this case)
  • Several sources of leads or orders
  • A team drowning in template messages

This is a working template. The specific stack can be swapped (Bitrix or amoUSe instead of AmoCRM, another tool for the niche instead of RealtyCalendar). The logic stays the same: separate the integrations, keep a central database of properties, and connect the CRM pipeline to your own backend so it fills in current data.

What’s next

Thinking about automating customer communication or your CRM processes? Drop me a line and we’ll talk through your chain and see what can come out of manual mode. If you want a rough sense of the budget, the calculator will do it in a minute.

All articles

Related articles

Taking payments in a Telegram bot: Stars, YooKassa, SBP, or crypto
Business

Taking payments in a Telegram bot: Stars, YooKassa, SBP, or crypto

How to take subscription payments in a Telegram bot: Telegram's rule on Stars, YooKassa and Tribute fees, and crypto. How people actually pay in our bot.

8 min read
When a Support Bot Pays for Itself — and When It Doesn't
Business

When a Support Bot Pays for Itself — and When It Doesn't

A back-of-the-envelope ROI formula, three scenarios by ticket volume, and four cases where an AI support bot won't even cover its own subscription.

12 min read
Remotion: Video as Code in React, and What We Chose Instead
DevelopmentVideo

Remotion: Video as Code in React, and What We Chose Instead

What Remotion is, what people build with it, how much the license costs, and where it's overkill. A breakdown from a studio that produced 60 videos with code but without it.

8 min read