Make.com Developer Needed for Data Processing and AI Integration Workflow

[mario_2025]

We are looking to hire a developer experienced with Make.com (formerly Integromat) to finalize an automated workflow. The objective is to select the most relevant information from a source system (e.g., Google Sheets), gather related external data, and utilize an AI service (e.g., OpenAI) to synthesize the information into a structured output.

Core Workflow Requirements:

The scenario involves several key phases:

1. Inputs and Data Retrieval: The scenario must accept input parameters (date ranges, keywords, volume limits) and retrieve matching records from the primary data source.

2. Scoring and Filtering Logic: The workflow needs to iterate through the records, parse metadata (stored as JSON within the records), and calculate a “Priority Score.” This score is based on matching the metadata against the input keywords and their associated confidence levels.

3. Sorting and Selection: The aggregated results need to be sorted using multi-level criteria: first by the calculated Priority Score (highest first), and second by date (newest first). The workflow then selects the “Top N” records (e.g., the top 15).

4. External Data Fetching: The scenario needs to fetch external information for the top records (e.g., via HTTP requests to URLs listed in the records). This step requires standard error handling (e.g., using the Resume directive) to manage potential timeouts or failed requests.

5. AI Integration and Output: The collected data is combined, formatted into a prompt, and sent to an LLM API for synthesis. The final generated content is saved to a cloud document (e.g., Google Docs).

6. Tracking/Counter: The workflow utilizes a Make.com Data Store to manage a persistent counter, ensuring every output has a unique identifier.

Current Status and Challenges:

We have an architectural outline and a prototype of this workflow already built. However, we have encountered implementation challenges. Specific areas needing attention include the correct application of array manipulation functions (map, filter, sort, slice), implementing the multi-level sorting logic, and configuring the error handling properly.

Opportunity:

We need a developer to take our existing outline, resolve the implementation issues, and deliver a stable, working solution. We are interested in establishing a working relationship for future automation projects if this initial engagement is successful.

[Pathfinder_Automate]

Hello @mario_2025 , welcome to make.com community, I have worked and have experience with Make.com and l will love to collaborate with you on this you can schedule a call Here and you can checkout my upwork profile Here, for my pastworks and certifications

[chhaya]

Hello @mario_2025

Thanks for sharing the requirements.

We have extensive experience building complex workflows, including data retrieval, multi-level sorting, AI integration, and error handling. I can take your existing prototype, resolve the implementation challenges, and deliver a stable, production-ready solution.

I’d be happy to discuss your requirements and help establish a long-term automation partnership.
You can check out our website and Upwork, or book a Consultation Call

Thanks & Regards
Chhaya Choudhary

[andres]

Zach, we can help. Let’s meet on Zoom to go over the details.

Book a time of us here https://connex.digital/book/make

Talk soon!

[Farhan_Ahmed]

Hi, I specialize in Make.com (Integromat) and have built complex automations involving Google Sheets, APIs, error handling, and AI integrations. I can take your existing outline, fix the array manipulations, implement the multi-level sorting, and ensure your workflow runs smoothly end-to-end. Once stabilized, I’ll deliver a structured solution that generates unique AI-driven outputs and stores them properly.

You can check out my profile here: https://www.upwork.com/freelancers/farhana401

Or directly book a call here:https://calendly.com/automaxion-meet

[vdwintelligence]

Hi Mario,

Thanks for the clear instructions, that really puts into perspective what you want. Therefore, we think we’re the ideal partner to solve this for you.

We are strongly experienced in the use of webhooks and http requests to involve external data into the scenario. We’re ready to rock this for you.

Send me a DM to schedule a call together. This will be free of charge.

Jeroen

[Jeffrey_Arnold]

Hi Mario:

I’m the owner of 4Spot Consulting, a Make Gold Partners with deep experience building secure, scalable automations on Make.

One thing that sets us apart from many other Gold or Platinum partners is that we’re not simply task-masters who just “do what we’re told.” Our role is to be your strategic consultants — guiding you with solid business advice on what you could, should, and shouldn’t look to automate. That way, you’re not just getting a build, you’re getting a partner who helps you avoid wasted time, unnecessary costs, and mis-steps in your automation journey. We’ll share advice and suggestions at every step — not just execution.

We use our OpsMesh™ framework to guide this kind of work. It’s a three-part system (Audit → Build → Maintain):
• OpsMap™ (Audit) — a structured review that uncovers inefficiencies and gives you a clear, prioritized plan.
• OpsBuild™ (Build) — putting the automation and workflows into place.
• OpsCare™ (Maintain) — ongoing support so everything continues running smoothly as your business grows.

Looking at your request, it’s clear you’ve already put a lot of thought into the design. The workflow you’re describing — data retrieval, JSON parsing, multi-level sorting, error handling, external lookups, and AI synthesis — is exactly the type of advanced automation we deliver. Make can handle all of those steps, both through native modules and secure API/HTTP connections. We’ve done this many times and are comfortable managing the complexity behind the scenes.

The best next step is for us to connect live, review your existing prototype, and walk through the specific points where you’re running into challenges (array manipulation, sorting, error handling). From there, we can stabilize what you’ve built and get you a production-ready solution.

We have a team of trained experts, so you will always have someone on our side available to help.

Please use this link to schedule a time with us:
https://4spotconsulting.com/30

Looking forward to helping you get this workflow across the finish line and working with you on future projects.

Keep Automating,
Jeff
____________________________________
Jeff Arnold • “The Automated Recruiter Guy”

4Spot Consulting • 4SpotConsulting.com
11700 W Charleston #170-160 • Las Vegas • NV • 89135
O: 702-721-9763 • C: 702-525-9763
Book an Appointment • LinkedIn • Jeff@4SpotConsulting.com

[Greatness_Workflows]

@mario_2025

We are looking to hire a developer experienced with Make.com (formerly Integromat) to finalize an automated workflow. The objective is to select the most relevant information from a source system (e.g., Google Sheets), gather related external data, and utilize an AI service (e.g., OpenAI) to synthesize the information into a structured output.

Core Workflow Requirements:

The scenario involves several key phases:

1. Inputs and Data Retrieval: The scenario must accept input parameters (date ranges, keywords, volume limits) and retrieve matching records from the primary data source.
2. Scoring and Filtering Logic: The workflow needs to iterate through the records, parse metadata (stored as JSON within the records), and calculate a “Priority Score.” This score is based on matching the metadata against the input keywords and their associated confidence levels.
3. Sorting and Selection: The aggregated results need to be sorted using multi-level criteria: first by the calculated Priority Score (highest first), and second by date (newest first). The workflow then selects the “Top N” records (e.g., the top 15).
4. External Data Fetching: The scenario needs to fetch external information for the top records (e.g., via HTTP requests to URLs listed in the records). This step requires standard error handling (e.g., using the Resume directive) to manage potential timeouts or failed requests.
5. AI Integration and Output: The collected data is combined, formatted into a prompt, and sent to an LLM API for synthesis. The final generated content is saved to a cloud document (e.g., Google Docs).
6. Tracking/Counter: The workflow utilizes a Make.com Data Store to manage a persistent counter, ensuring every output has a unique identifier.

Current Status and Challenges:

We have an architectural outline and a prototype of this workflow already built. However, we have encountered implementation challenges. Specific areas needing attention include the correct application of array manipulation functions (map, filter, sort, slice), implementing the multi-level sorting logic, and configuring the error handling properly.

Opportunity:

We need a developer to take our existing outline, resolve the implementation issues, and deliver a stable, working solution. We are interested in establishing a working relationship for future automation projects if this initial engagement is successful.

I get where you’re stuck building the outline is one thing, but getting multi-level sorting, array manipulation, and error handling bulletproof in Make.com is often where even strong prototypes break down. What you really need is a stable, production-ready scenario where inputs flow cleanly, data is scored and filtered properly, external fetches don’t break the chain, and the AI output lands in the right format every time.

That’s exactly what I can help with. I’ve built advanced Make.com scenarios that combine JSON parsing, multi-step scoring logic, error-resilient HTTP fetches, and LLM integrations. For your workflow, I’ll finalize the array operations (map, filter, sort, slice), implement robust error handling with retry logic, and ensure the scoring/selection works exactly as described. The end result will be a working solution that saves outputs to Google Docs with unique IDs tracked in a Make Data Store no more uncertainty about stability.

Let’s have a chat about this on a call. You can schedule a call here.

[Deborah1]

Dear mario_2025,

I would be glad to assist with finalizing your Make.com workflow. I have strong expertise in scenario design, array manipulation (map, filter, sort, slice), and multi-level sorting logic, which directly matches the challenges you’ve highlighted. I’ve successfully built workflows integrating Google Sheets, Data Stores, HTTP requests, and LLM APIs (OpenAI) to automate complex data processing and content generation.

I can help resolve the current issues in your prototype, ensure robust error handling, and deliver a stable, scalable solution. Beyond this project, I would be interested in supporting your future automation initiatives as well.

Looking forward to discussing the details.

Best regards,

Oluwadunni Deborah

[Hashlogics]

@mario_2025

We are looking to hire a developer experienced with Make.com (formerly Integromat) to finalize an automated workflow. The objective is to select the most relevant information from a source system (e.g., Google Sheets), gather related external data, and utilize an AI service (e.g., OpenAI) to synthesize the information into a structured output.

Core Workflow Requirements:

The scenario involves several key phases:

1. Inputs and Data Retrieval: The scenario must accept input parameters (date ranges, keywords, volume limits) and retrieve matching records from the primary data source.
2. Scoring and Filtering Logic: The workflow needs to iterate through the records, parse metadata (stored as JSON within the records), and calculate a “Priority Score.” This score is based on matching the metadata against the input keywords and their associated confidence levels.
3. Sorting and Selection: The aggregated results need to be sorted using multi-level criteria: first by the calculated Priority Score (highest first), and second by date (newest first). The workflow then selects the “Top N” records (e.g., the top 15).
4. External Data Fetching: The scenario needs to fetch external information for the top records (e.g., via HTTP requests to URLs listed in the records). This step requires standard error handling (e.g., using the Resume directive) to manage potential timeouts or failed requests.
5. AI Integration and Output: The collected data is combined, formatted into a prompt, and sent to an LLM API for synthesis. The final generated content is saved to a cloud document (e.g., Google Docs).
6. Tracking/Counter: The workflow utilizes a Make.com Data Store to manage a persistent counter, ensuring every output has a unique identifier.

Current Status and Challenges:

We have an architectural outline and a prototype of this workflow already built. However, we have encountered implementation challenges. Specific areas needing attention include the correct application of array manipulation functions (map, filter, sort, slice), implementing the multi-level sorting logic, and configuring the error handling properly.

Opportunity:

We need a developer to take our existing outline, resolve the implementation issues, and deliver a stable, working solution. We are interested in establishing a working relationship for future automation projects if this initial engagement is successful.

Hi @mario_2025

This matches my day-to-day work with Make.com: data retrieval, scoring, multi-level sorting, external fetch with retries, LLM synthesis, and persistent IDs via Data Store. I can take your outline/prototype and make it production-ready.

Approach

• Inputs & retrieval. Parameterized scenario (date range, keywords, limit). Use “Search Rows/Records” or HTTP → JSON parse; normalize into a single array.

• Scoring. Parse record metadata (JSON) and compute a PriorityScore using keyword weights/confidence. Implement with map() + a small JavaScript code step for clarity and testability.

• Multi-level sorting & selection. Stable sort by PriorityScore desc, then Date desc; slice(0, N) to pick Top-N. (Where needed, use an iterator + array aggregator to preserve order.)

• External data fetch. HTTP requests over the Top-N URLs with timeout handling, Resume + limited retries/backoff; collect successes and mark failures.

• AI synthesis. Structured prompt (schema) → OpenAI (or your provider). Save output to Google Docs; return the doc URL.

• Tracking. Make Data Store counter to generate a unique, sequential identifier per output; upsert logs for traceability.

• Hardening. Error routes, idempotency guard (hash of input set), and lightweight observability (execution log row).

What I’ll deliver

• A working scenario wired to your sources (Google Sheets / HTTP).

• Clean scoring function with unit-like test data.

• Correct map / filter / sort / slice usage and proven multi-level sort.

• Resilient HTTP step (retries, Resume) + AI integration.

• Google Doc output with unique ID and metadata.

• Short runbook (inputs, mapping, where to set keys, rollback notes).

Time & rate

• Stabilization and completion of your prototype: 8–12 hours depending on current gaps and external API volatility.

• Rate: $30/hr. If you prefer, I can quote a fixed fee after a quick screen-share of the current scenario.

Quick confirmations

1. Primary source (Google Sheets vs. other) and the exact columns containing metadata JSON, date, URL.

2. Keyword list + weights/confidence rule you want for PriorityScore.

3. LLM provider & model preference; token/latency budget.

4. Expected Top-N (default 15) and execution frequency.

5. Where should logs live (Data Store only, or also a Sheet)?

If you share a sample sheet and the current Make blueprint, I can start immediately and ship a first stable pass the same day.

—
Abdul Basit
CEO, Hashlogics
Portfolio: https://hashlogics.com/portfolio
Case Studies: https://drive.google.com/file/d/1MZLCwijnWGXXjwLx3uXBcwz7D81pl6d2/view
Reviews: https://clutch.co/profile/hashlogics
Call: https://calendly.com/_hashlogics/abdul-basit