Rork × Make (formerly Integromat): Build a No-Code Backend with Webhooks

Setup and context: When Your Rork App Needs a Backend

As you build apps with Rork, you'll eventually run into situations like these:

"I want to automatically save contact form submissions to Notion." "I need Slack notifications whenever someone signs up." "I'd like to send push notifications every morning at 9 AM."

Normally, these tasks require server-side programming. But with Make (formerly Integromat), you can build all of this without writing a single line of backend code.

Make is a no-code automation platform similar to Zapier, but with more powerful data transformation and branching capabilities — and a generous free tier of 1,000 operations per month. By connecting your Rork mobile app's frontend to Make scenarios via Webhook, you can achieve real backend functionality without touching a server.

What Is Make? Understanding the Core Concepts

Make (formerly Integromat) is a no-code automation platform that visually connects over 2,000 apps and services. Rebranded from Integromat in 2022, it's now used by everyone from solo developers to large enterprises.

Three core concepts to know:

• Scenario: The automation "recipe" — defines what triggers which actions
• Module: Each step in a scenario. Actions like "send a Gmail" or "add a row to Notion" are represented as visual blocks
• Webhook: An HTTP endpoint that lets your Rork app trigger a Make scenario from the outside

Compared to Zapier, Make excels at complex data transformations, loops, and error handling. It's also more generous with its free tier (Make: 1,000 operations vs. Zapier: 100 tasks), making it particularly well-suited for indie app developers.

The Big Picture: Rork + Make Integration

Here's how the integration works at a high level:

1. Create a scenario in Make and get a Webhook URL
2. Send an HTTP request from your Rork app to that Webhook URL
3. Make receives the request and automatically runs the downstream actions

Since Rork is built on React Native, you can use the standard fetch API to call any HTTP endpoint. Make's Webhook responds instantly, enabling real-time automation.

Step 1: Create a Make Scenario and Get Your Webhook URL

Start by creating an account at make.com — the free plan is enough to get started.

Once logged in, set up your Webhook:

1. Click "Scenarios" in the left sidebar → "Create a new scenario"
2. On the module selection screen, search for "Webhooks" and choose "Custom webhook"
3. Click "Add" → "Save" — Make will generate a URL like this:

https://hook.eu2.make.com/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

This URL is what your Rork app will call to trigger the scenario.

Tip: Make offers EU and US regions. If you're primarily serving Japanese users, the US region typically offers slightly lower latency.

Step 2: Call the Webhook from Your Rork App

Open your Rork project and implement the Webhook call — for example, in a form submission handler:

// Calling a Make Webhook from a Rork app
// Sends form data to Make when a user submits a contact form
 
const MAKE_WEBHOOK_URL = 'https://hook.eu2.make.com/xxxxxxxxxxxxxxxxxxxxxxxx';
 
const sendToMake = async (formData: {
  name: string;
  email: string;
  message: string;
}) => {
  try {
    const response = await fetch(MAKE_WEBHOOK_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        name: formData.name,
        email: formData.email,
        message: formData.message,
        timestamp: new Date().toISOString(),
        source: 'rork-app', // Custom field to identify the sender
      }),
    });
 
    if (response.ok) {
      console.log('✅ Successfully sent data to Make');
      return { success: true };
    } else {
      throw new Error(`HTTP error: ${response.status}`);
    }
  } catch (error) {
    console.error('❌ Failed to send to Make:', error);
    return { success: false, error };
  }
};
 
// Usage: call this in a button's onPress handler
const handleSubmit = async () => {
  const result = await sendToMake({
    name: 'John Smith',
    email: 'john@example.com',
    message: 'I have a question about your app.',
  });
 
  if (result.success) {
    Alert.alert('Sent!', 'Your message has been received.');
  } else {
    Alert.alert('Error', 'Something went wrong. Please try again.');
  }
};

Once Make receives this request for the first time, it automatically detects the data structure. From there, you can drag and drop the fields (name, email, message, etc.) into any module in your scenario.

Step 3: A Real Scenario — Form → Notion → Email Notification

Let's build a practical automation: when a user submits a contact form in your Rork app, Make saves it to Notion and sends you an email notification.

The flow:

1. Rork app → Make Webhook (receive data)
2. Add a new record to a Notion database
3. Send a notification email via Gmail

Setting Up the Notion Module

Add a Notion module after your Webhook in the scenario.

1. Click the "+" button to the right of the Webhook module → search "Notion"
2. Select "Create a Database Item"
3. Authenticate with Notion and choose your target database
4. Map the incoming Webhook fields to your Notion properties:
   • Name property → {{1.name}}
   • Email property → {{1.email}}
   • Message property → {{1.message}}
   • Date property → {{formatDate(1.timestamp; "YYYY-MM-DD HH:mm")}}

Setting Up the Gmail Notification Module

Add a Gmail module after Notion.

1. Click "+" → "Gmail" → "Send an Email"
2. Configure the recipient, subject, and body:

Subject: [New Contact] Message from {{1.name}}
Body:
You have a new contact form submission.

Name: {{1.name}}
Email: {{1.email}}
Message:
{{1.message}}

Submitted at: {{formatDate(1.timestamp; "MMMM D, YYYY [at] h:mm A")}}

That's it. Every time a user submits the form in your Rork app, Notion gets updated and you receive an email — automatically.

Common Automation Patterns

Here are some popular ways to use Make with Rork apps:

Pattern 1: New User Registration → CRM Entry

Rork Webhook → Make → Add lead to HubSpot/Airtable → Send welcome email

Perfect for managing user growth without manual data entry.

Pattern 2: In-App Purchase → Revenue Tracking

Rork Webhook (purchase complete) → Make → Log sale to Google Sheets → Monthly summary

Pair this with a payment provider like Stripe to auto-update your revenue dashboard.

Pattern 3: Scheduled Push Notifications

Make schedule trigger (daily at 9 AM) → Call Expo Push Notification API

Use Make's HTTP module to call the Expo Push API directly and schedule recurring notifications — no server required.

Pattern 4: Error Alerts → Slack Notification

Rork Webhook (error event) → Make → Post alert to Slack channel

Call the Webhook from your app's catch blocks to get instant Slack alerts when something goes wrong.

Troubleshooting Common Issues

Issue 1: Getting 404 responses from the Webhook URL

Your Make scenario might be turned off. Check the "Scheduling" toggle at the bottom right of the scenario detail screen and make sure it's set to "On". You can also use "Run once" mode for testing.

Issue 2: Data isn't reaching Make

Make sure your Rork request includes the Content-Type: application/json header. Without it, Make may not parse the body correctly. Also double-check that the Webhook URL is correct — a single character difference will break the connection.

Issue 3: Hitting the free plan operation limit

Make's free plan includes 1,000 operations per month. Each module execution counts as one operation, so a 3-module scenario costs 3 operations per run. If you're growing, the Core plan at $9/month is a reasonable upgrade.

Issue 4: Notion fields not getting populated

Make sure the data types match. For example, Notion date fields expect ISO 8601 format (2026-03-31T09:00:00Z). Use Make's formatDate function to ensure the format is correct before passing data to Notion.

Taking It Further

Once you're comfortable with Make × Rork, consider exploring more advanced background job control. If you need scheduled tasks, queues, or retry logic, check out our guide on Background Job Automation with Rork and Trigger.dev.

For developers who want to push towards fully autonomous app operation using AI agents, the article Autonomous Mobile App Architecture — 24/7 Automation with Rork and AI Agents is an excellent next step.

Summary

Here's a quick recap of what we covered:

• Make is a no-code automation platform with a free tier of 1,000 operations/month and support for 2,000+ services
• Any Rork app can trigger a Make scenario via a simple fetch POST request
• You can build multi-step automation (form → Notion → email) without writing backend code
• Scheduled triggers, conditional logic, and loops are all possible through Make's visual editor
• For production use, add a secret token to your Webhook requests to prevent unauthorized triggering

Even without backend development experience, Make gives you the power to add real automation to your Rork apps. Start small with the free plan and expand as your needs grow.