What we build with Make.com
Make.com automation with us means designing, building and maintaining scenarios in Make (formerly Integromat) that connect your sales, finance and operations tools, and writing the custom pieces Make cannot do on its own. We are a software development company: senior engineers build the scenarios, review them like code, and work with AI coding agents on the routine parts so you pay for thinking rather than clicking.
Make is a strong middle ground. It is visual enough for an operations manager to read a scenario, and it handles routers, iterators, aggregators, data stores and error handlers better than most no-code tools. The same flexibility is why Make organizations often grow into a tangle of scenarios that nobody fully understands. We build scenarios that stay readable, cheap to run and easy to hand over.
Typical Make scenarios we build
Lead routing and CRM updates. Leads from web forms, ads, email and Telegram are deduplicated, enriched, written to the CRM with the right owner and announced in Slack or Telegram. Leads that match no rule go to a review list.
Order, invoice and payment flows. A paid order creates the customer record, invoice and shipment, payment and delivery status updates arrive through webhooks, and the customer gets notified at each step.
Document processing with AI. Invoices and forms arrive by email or upload, an OpenAI or Claude step extracts the fields into fixed JSON, rules check them against your records, and only confirmed data reaches the accounting system or ERP.
Notifications and reports. Overdue tasks, unpaid invoices, stock alerts and weekly summaries are posted to Telegram, Slack or email from Google Sheets, your CRM or a database.
Data sync between systems. Products, contacts and statuses stay consistent across your CRM, store, accounting and spreadsheets, with a log of every change.
Integrations, including Ukrainian services
Make has its own apps for most international SaaS tools. For Ukrainian businesses the list usually also includes Nova Poshta, monobank or PrivatBank, Prom.ua or Rozetka and KeyCRM or SalesDrive.
| Service | How it connects to Make |
|---|---|
| Telegram, Google Sheets, Slack, Gmail | Make apps |
| OpenAI, Anthropic Claude | Make apps |
| Nova Poshta | HTTP module against the Nova Poshta API, unless a reliable Make app exists at project start |
| monobank, PrivatBank | HTTP module and webhooks against the banks' business APIs |
| Prom.ua, Rozetka | HTTP module against the marketplace seller APIs |
| KeyCRM, SalesDrive | HTTP module and webhooks against their open APIs |
We check Make's app directory for each Ukrainian service at the start of a project, because apps built by vendors or the community appear and disappear. Where none is reliable, we call the API through the HTTP module and keep authentication and common requests in one reusable scenario instead of copying them into every flow. If a service needs request signing or file handling that Make does poorly, we put a small endpoint in front of it and Make calls that.
How we make Make scenarios reliable
Scenarios that run business processes need the same care as code. On every project we:
- add error handlers to modules that call external services, with retries where the API allows it and an alert where it does not;
- store incomplete executions so a failed run can be resumed instead of lost;
- keep a log of processed items in a data store or your database, so the same event is not processed twice;
- split large scenarios into smaller ones connected by webhooks, with clear names and folders;
- move credentials from personal accounts to service accounts your company owns;
- document each scenario: trigger, steps, systems touched, owner and what to do when it fails.
AI steps in Make
Make's OpenAI and Anthropic Claude apps let a scenario understand unstructured input: a free-text email, a scanned invoice, a customer message. We use AI only where the input needs it and keep the rest as rules. Every model output is checked against a fixed structure before it is used, uncertain results go to a person, and we track the credits and model cost per item so AI steps do not quietly become the biggest line on the bill. If a process needs several AI decisions in a row with access to many tools, it is an agent rather than a scenario; see our AI agent development page.
Make pricing: what the platform itself costs
Make's fees are separate from our work. According to make.com/en/pricing, checked on 19.11.2026:
- Make bills in credits. Most actions in a scenario, such as reading, searching, creating, updating or transforming data, consume 1 credit; some AI features can consume more.
- The Router and the error handler modules are not counted.
- The Free plan includes 1,000 credits per month.
- Paid plans are Core, Pro, Teams and Enterprise; annual billing is cheaper than monthly, and extra credits can be bought in bundles.
The exact price depends on the credit volume you choose in the plan selector, and we could not read a fixed figure from the page, so we do not quote one here. The practical point is the billing unit: a scenario with ten modules that runs 5,000 times a month uses on the order of 50,000 credits, so cutting unnecessary modules and filtering early often saves more than switching plans.
When Make is the right choice and when to switch to code
Make is the right choice when flows connect SaaS tools with moderate logic and volume, when a non-developer should be able to read and adjust them, and when the data may live in Make's cloud.
Consider n8n when you need self-hosting or per-run instead of per-operation billing, and Zapier when the main need is a very wide catalog of ready apps for simple flows. Move a flow to code when it runs orders, payments or customer data at volume, writes into your own database or a legacy system, needs approvals, roles and an audit trail, or when credit usage grows faster than the value. Our custom software development team then builds a small service with a queue, retries, logs and tests, and Make keeps the simple edges. Our guide n8n vs Zapier vs custom code covers the decision in detail.
How we work on Make projects
- Review (about 1 week). We map the process or audit your Make organization: scenarios, failures, credit usage, credentials. You get a list of fixes, a plan and a fixed quote.
- Build or repair. Scenarios with error handling, logging and documentation, tested on real sample data.
- Parallel run. New or rebuilt scenarios run next to the old process until the results match.
- Handover. Documentation, a map of all scenarios and access for your team. We can stay on for maintenance.
Our minimum project size is $10,000. We are not an official Make partner; we are a senior engineering team that can also write the code around Make when a scenario needs it. We work from Ukraine with companies in the US and Europe. For broader process automation, see our AI automation services.
Next step
Send us a short description of the process, or screenshots of the Make scenarios that fail or cost too much. We will tell you what to fix in Make, what to move to code and what a fixed quote would look like. Contact us to book a call.