On the day Make.com was turned into a low-code platform, the video demonstrates how adding custom code unlocks complex data transformations and greater flexibility. Let us guide you through why that change matters and what a practical example looks like.
It covers the advantages of custom scripts, a step-by-step demo, and how to set up a simple server to run automations more efficiently and affordably. Follow along to see how this blend of Make.com and bespoke code streamlines workflows, saves time, and expands capabilities.
Why I turned make.com into low-code
We began this journey because we wanted the best of both worlds: the speed and visual clarity of make.com’s builder and the power and flexibility that custom code gives us. Turning make.com into a low-code platform wasn’t about abandoning no-code principles; it was about extending them so our automations could handle real-world complexity without becoming unmaintainable.
Personal motivation and context from the video by Jannis Moore
In the video by Jannis Moore, the central idea that resonated with us was practical optimization: how to keep the intuitive drag-and-drop experience while introducing small, targeted pieces of code where they bring the most value. Jannis demonstrates this transformation by walking through real scenarios where no-code started to show its limits, then shows how a few lines of code and a lightweight server can drastically simplify scenarios and improve performance. We were motivated by that pragmatic approach—use visuals where they accelerate understanding, and use code where it solves problems that visual blocks struggle with.
Limitations I hit with a pure no-code approach
Working exclusively with no-code tools, we bumped into several recurring limitations: cumbersome handling of nested or irregular JSON, long chains of modules just to perform simple data transformations, and operation count explosions that ballooned costs. We also found edge cases—proprietary APIs, unconventional protocols, or rate-limited endpoints—where the platform’s native modules either didn’t exist or were inefficient. Those constraints made some automations fragile and slow to iterate on.
Goals I wanted to achieve by introducing custom code
Our goals for introducing custom code were clear and pragmatic. First, we wanted to reduce scenario complexity and operation counts by collapsing many visual steps into compact, maintainable code. Second, we aimed to handle complex data transformations reliably, especially for nested JSON and variable schema payloads. Third, we wanted to enable integrations and protocols not supported out of the box. Finally, we sought to improve performance and reusability so our automations could scale without spiraling costs or brittleness.
How low-code complements the visual automation builder
Low-code complements the visual builder by acting as a precision tool within a broader, user-friendly environment. We use the drag-and-drop interface for routing, scheduling, and orchestrating flows where visibility matters, and we drop in small script modules or external endpoints for heavy lifting. This hybrid approach keeps the scenario readable for collaborators while providing the extendability and control that complex systems demand.
Understanding no-code versus low-code
We like to think of no-code and low-code as points on a continuum rather than mutually exclusive categories. Both aim to speed development and lower barriers, but they make different trade-offs between accessibility and expressiveness.
Definitions and practical differences
No-code platforms let us build automations and applications through visual interfaces, pre-built modules, and configuration rather than text-based programming. Low-code combines visual tools with the option to inject custom code in defined places. Practically, no-code is great for standard workflows, onboarding, and fast prototyping. Low-code is for when business logic, performance, or integration complexity requires the full expressiveness of a programming language.
Trade-offs between speed of no-code and flexibility of code
No-code gives us speed, lower cognitive overhead, and easier hand-off to non-developers. However, that speed can be deceptive when we face complex transformations or scale; the visual solution can become fragile or unreadable. Adding code introduces development overhead and maintenance responsibilities, but it buys us precise control, performance optimization, and the ability to implement custom algorithms. We choose the right balance by matching the tool to the problem.
When to prefer no-code, when to prefer low-code
We prefer no-code for straightforward integrations, simple CRUD-style tasks, and when business users need to own or tweak automations directly. We prefer low-code when we need advanced data processing, bespoke integrations, or want to reduce a large sequence of visual steps into a single maintainable unit. If an automation’s complexity is likely to grow or if performance and cost are concerns, leaning into low-code early can save time.
How make.com fits into the spectrum
Make.com sits comfortably in the middle of the spectrum: a powerful visual automation builder with scripting modules and HTTP capabilities that allow us to extend it via custom code. Its visual strengths make it ideal for orchestration and monitoring, while its extensibility makes it a pragmatic low-code platform once we start embedding scripts or calling external services.
Benefits of adding custom code to make.com automations
We’ve found that adding custom code unlocks several concrete benefits that make automations more robust, efficient, and adaptable to real business needs.
Solving complex data manipulation and transformation tasks
Custom code shines when we need to parse, normalize, or transform nested and irregular data. Rather than stacking many transform modules, a small function can flatten structures, rename fields, apply validation, and output consistent schemas. That reduces both error surface and cognitive load when troubleshooting.
Reducing scenario complexity and operation counts
A single script can replace many visual operations, which lowers the total module count and often reduces the billed operations in make.com. This consolidation simplifies scenario diagrams, making them easier to maintain and faster to execute.
Unlocking integrations and protocols not natively supported
When we encounter APIs that use uncommon auth schemes, binary protocols, or streaming behaviors, custom code lets us implement client libraries, signatures, or adapters that the platform doesn’t natively support. This expands the universe of services we can reliably integrate with.
Improving performance, control, and reusability
Custom endpoints and functions allow us to tune performance, implement caching, and reuse logic across multiple scenarios. We gain better error handling and logging, and we can version and test code independently of visual flows, which improves reliability as systems scale.
Common use cases that require low-code on make.com
We repeatedly see certain patterns where low-code becomes the practical choice for robust automation.
Transforming nested or irregular JSON structures
APIs often return deeply nested JSON or arrays with inconsistent keys. Code lets us traverse, normalize, and map those structures deterministically. We can handle optional fields, pivot arrays into objects, and construct payloads for downstream systems without brittle visual logic.
Custom business rules and advanced conditional logic
When business rules are complex—think multi-step eligibility checks, weighted calculations, or chained conditional paths—embedding that logic in code keeps rules testable and maintainable. We can write unit tests, document assumptions in code comments, and refactor as requirements evolve.
High-volume or batch processing scenarios
Processing thousands of records or batching uploads benefits from programmatic control: batching strategies, parallelization, retries with backoff, and rate-limit management. These patterns are difficult and expensive to implement purely with visual builders, but straightforward in code.
Custom third-party integrations and proprietary APIs
Proprietary APIs often require special authentication, binary handling, or unusual request formats. Code allows us to create adapters, encapsulate token refresh logic, and handle edge cases like partial success responses or multipart uploads.
Where to place custom code: in-platform versus external
Choosing where to run our custom code is an architectural decision that impacts latency, cost, ease of development, and security.
Using make.com built-in scripting or code modules and their limits
Make.com includes built-in scripting and code modules that are ideal for small transformations and quick logic embedded directly in scenarios. These are convenient, have low latency, and are easy to maintain from within the platform. Their limits show up in execution time, dependency management, and sometimes in debugging and logging capabilities. For moderate tasks they’re perfect; for heavier workloads we usually move code outside.
Calling external endpoints: serverless functions, VPS, or managed APIs
External endpoints hosted on serverless platforms, VPS instances, or managed APIs give us full control over environment, libraries, and runtime. We can run long-lived processes, handle large memory workloads, and add observability. Calling external services adds a network hop, so we must weigh the trade-off between capability and latency.
Pros and cons of serverless functions versus self-hosted servers
Serverless functions are cost-effective for on-demand workloads, scale automatically, and reduce infrastructure management. They can be limited in cold start latency, execution time, and third-party library size. Self-hosted servers (VPS, containers) offer predictable performance, persistent processes, and easier debugging for long-running tasks, but require maintenance, monitoring, and capacity planning. We choose serverless for event-driven and intermittent tasks, and self-hosting when we need persistent connections or strict performance SLAs.
Factors to consider: latency, cost, maintenance, security
When deciding where to run code, we consider latency tolerances, cost models (per-invocation vs. always-on), maintenance overhead, and security requirements. Sensitive data or strict compliance needs might push us toward controlled, self-hosted environments. Conversely, if we prefer minimal ops work and can tolerate some cold starts, serverless is attractive.
Choosing a technology stack for your automation code
Picking the right language and platform affects development speed, ecosystem availability, and runtime characteristics.
Popular runtimes: Node.js, Python, Go, and when to pick each
Node.js is a strong choice for HTTP-based integrations and fast development thanks to its large ecosystem and JSON affinity. Python excels in data processing, ETL, and teams with data-science experience. Go produces fast, efficient binaries with great concurrency for high-throughput services. We pick Node.js for rapid prototype integrations, Python for heavy data transformations or ML tasks, and Go when we need low-latency, high-concurrency services.
Serverless platforms to consider: AWS Lambda, Cloud Run, Vercel, etc.
Serverless platforms provide different trade-offs: Lambda is mature and broadly supported, Cloud Run offers container-based flexibility with predictable cold starts, and platforms like Vercel are optimized for simple web deployments. We evaluate cold start behavior, runtime limits, deployment experience, and pricing when choosing a provider.
Containerized deployments and using Docker for portability
Containers give us portability and consistency across environments. Using Docker simplifies local development and testing, and makes deployment to different cloud providers smoother. For teams that want reproducible builds and the ability to run services both locally and in production, containers are highly recommended.
Libraries and toolkits that speed up integration work
We rely on HTTP clients, JSON schema validators, retry/backoff libraries, and SDKs for third-party APIs to reduce boilerplate. Frameworks that simplify building small APIs or serverless handlers can speed development. We prefer lightweight tools that are easy to test and replace as needs evolve.
Practical demo: a step-by-step example
We’ll walk through a concise, practical example that mirrors the video demonstration: transform a messy dataset, validate and normalize it, and send it to a CRM.
Problem statement and dataset used in the demonstration
Our problem: incoming webhooks provide lead data with inconsistent fields, nested arrays for contact methods, and occasional malformed addresses. We need to normalize this data, enrich it with simple rules (e.g., pick preferred contact method), and upsert the record into a CRM that expects a flat, validated JSON payload.
Designing the make.com scenario and identifying the code touchpoints
We design the scenario to use make.com for routing, retry logic, and monitoring. The touchpoints for code are: (1) a transformation module that normalizes the incoming payload, (2) an enrichment step that applies business rules, and (3) an adapter that formats the final request for the CRM. We implement the heavy transformations in a single external endpoint and keep the rest in visual modules.
Writing the custom code to perform the transformation or logic
In the custom endpoint, we validate required fields, flatten nested contact arrays into a single preferred_contact object, normalize phone numbers and emails, and map address components to the CRM schema. We include idempotency checks and simple logging for debugging. The function returns a clean payload or a structured error that make.com can route to a dead-letter flow.
Testing the integration end-to-end and validating results
We test with sample payloads that include edge cases: missing fields, multiple contact methods, and partially invalid addresses. We assert that normalized records match the CRM schema and that error responses trigger notification flows. Once tests pass, we deploy the function and run the scenario with a subset of production traffic to monitor performance and correctness.
Setting up your own server for efficient automations
As our needs grow, running a small server or serverless footprint becomes cost-effective and gives us control over performance and monitoring.
Choosing hosting: VPS, cloud instances, or platform-as-a-service
We choose hosting based on scale and operational tolerance. VPS providers are suitable for predictable loads and cost control. Cloud instances or PaaS solutions reduce ops overhead and integrate with managed services. If we expect variable traffic and want minimal maintenance, PaaS or serverless is the easiest path.
Basic server architecture for automations (API endpoint, queue, worker)
A pragmatic architecture includes a lightweight API to receive requests, a queue to handle spikes and enable retries, and worker processes that perform transformations and call third-party APIs. This separation improves resilience: the API responds quickly while workers handle longer tasks asynchronously.
SSL, domain, and performance considerations
We always enforce HTTPS, provision a valid certificate, and use a friendly domain for webhooks and APIs. Performance techniques like connection pooling, HTTP keep-alive, and caching of transient tokens improve throughput. Monitoring and alerting around latency and error rates help us respond proactively.
Cost-effective ways to run continuously or on-demand
For low-volume but latency-sensitive tasks, small always-on instances can be cheaper and more predictable than frequent serverless invocations. For spiky or infrequent workloads, serverless reduces costs. We also consider hybrid approaches: a lightweight always-on API that delegates heavy processing to on-demand workers.
Integrating your server with make.com workflows
Integration patterns determine how resilient and maintainable our automations will be in production.
Using webhooks and HTTP modules to pass data between make.com and your server
We use make.com webhooks to receive events and HTTP modules to call our server endpoints. Webhooks are great for event-driven flows, while direct HTTP calls are useful when make.com needs to wait for a transformation result. We design payloads to be compact and explicit.
Authentication patterns: API keys, HMAC signatures, OAuth
For authentication we typically use API keys for server-to-server simplicity or HMAC signatures to verify payload integrity for webhooks. OAuth is appropriate when we need delegated access to third-party APIs. Whatever method we choose, we store credentials securely and rotate them periodically.
Handling retries, idempotency, and transient failures
We design endpoints to be idempotent by accepting a request ID and ensuring repeated calls don’t create duplicates. On the make.com side we configure retries with backoff and route persistent failures to error handling flows. On the server side we implement retry logic for third-party calls and circuit breakers to protect downstream services.
Designing request and response payloads for robustness
We define clear request schemas that include metadata, tracing IDs, and minimal required data. Responses should indicate success, partial success with granular error details, or structured retry instructions. Keeping payloads explicit makes debugging and observability much easier.
Conclusion
We turned make.com into a low-code platform because it let us keep the accessibility and clarity of visual automation while gaining the precision, performance, and flexibility of code. This hybrid approach helps us build stable, maintainable flows that scale and adapt to real-world complexity.
Recap of why turning make.com into low-code unlocks flexibility and efficiency
By combining make.com’s orchestration strengths with targeted custom code, we reduce scenario complexity, handle tricky data transformations, integrate with otherwise unsupported systems, and optimize for cost and performance. Low-code lets us make trade-offs consciously rather than accepting platform limitations.
Actionable checklist to get started today (identify, prototype, secure, deploy)
- Identify pain points where visual blocks are brittle or costly.
- Prototype a small transformation or adapter as a script or serverless function.
- Secure endpoints with API keys or signatures and plan for credential rotation.
- Deploy incrementally, run tests, and route errors to safe paths in make.com.
- Monitor performance and iterate.
Next steps and recommended resources to continue learning
We recommend experimenting with small, well-scoped functions, practicing local development with containers, and documenting interfaces to keep collaboration smooth. Build repeatable templates for common tasks like JSON normalization and auth handling so others on the team can reuse them.
Invitation to experiment, iterate, and contribute back to the community
We invite you to experiment with this low-code approach, iterate on designs, and share patterns with the community. Small, pragmatic code additions can transform how we automate and scale, and sharing what we learn makes everyone’s automations stronger. Let’s keep building, testing, and improving together.
If you want to implement Chat and Voice Agents into your business to reduce missed calls, book more appointments, save time, and make more revenue, book a discovery call here: https://brand.eliteaienterprises.com/widget/bookings/elite-ai-30-min-demo-call