n8n Automation Specialist — Build a Freelancer Deadline & Performance Tracker (Trello ? Google Sheets)

Type: Fixed-price project, fully remote Location: Philippines (remote — you work your own hours) Project fee: USD $220 (approx. ?12,500) for the full build Hourly rate for follow-on work: USD $12/hour (approx. ?685/hour) Estimated effort: 15–20 hours across 2–3 weeks Start: As soon as we find the right person

About us

Penned is a small content agency. We produce written work — articles, copy, translations — through a network of freelance writers, editors and translators. Every job runs through a Trello board, moving through columns as it passes from writer to editor to delivery.

We currently have no reliable way of knowing who submits on time and who doesn't. We know it anecdotally. We want to know it factually, without anyone having to fill in a spreadsheet by hand.

That's what this project is.

What we want built

A system that automatically records, for every job that passes through our Trello board:

Whether the writer, editor or translator submitted before, on, or after their internal deadline — and by how many hours.
Whether the submission was clean (i.e. not flagged by the editor for significant issues).

Those two signals feed a scorecard that tells us, per freelancer, their on-time rate and their clean-submission rate. We'll use that to run fairer monthly reviews and a transparent bonus structure.

We have already written a full specification for this — sheet structure, column-by-column field mapping, formulas, trigger logic. We will send you that document before you start. You are not designing this from scratch; you are building and hardening a design that already exists.

The one change: our spec was originally written around Zapier. We want it built in n8n instead — lower running cost, self-hosted, and we want room to add more automations later without a per-task bill.

Scope of work
1. Build the Google Sheet

A workbook with two tabs, per the spec we'll provide:

Submission Log — one row per submission, 13 columns (A–M). Columns A–I are populated automatically by n8n. Columns J and K are formula-driven (early/on ---------- , and hours early or late). Columns L and M are the only manual entries.
Freelancer Scorecard — one row per freelancer, auto-calculating from the Submission Log: total submissions, on-time count, late count, on-time rate %, average hours early/late, flagged submissions, flag rate %, clean submission rate %, and a weighted combined performance score.

The formulas are already written in our spec. We'd like you to sanity-check them, implement them so they don't break when rows are appended by API, and apply sensible formatting, data validation on the manual columns, and protected ranges so nobody a ---------- overwrites a formula.

2. Build two n8n workflows

Workflow 1 — Writer / Translator submission Triggered when a card moves into the "With Editor" list. Appends a row to the Submission Log containing: timestamp, card name, and the values of the Trello custom fields Client, Service Type, Workflow Tier and Writer / Translator Deadline, plus the assigned card member's name and a hardcoded role.

Workflow 2 — Editor completion Triggered when the Trello custom field "QA Decision" is set to "Ready" on a card. Appends a row with the same fields, but pulling the Editor Deadline custom field and recording the role as Editor.

3. Handover
- Exported workflow JSON.
- A short written SOP (1–3 pages) covering how the workflows run, where credentials live, what to do when it breaks, and how to add a field or change a trigger later.
- A screen-recorded walkthrough (10–15 minutes is plenty).
- A live handover call to answer questions.
- The bits we already know are fiddly

We'd rather be upfront about the hard parts than have you discover them on day four. If any of these are new to you, that's a signal this project may not be the right fit:

-Trello custom fields are not exposed by n8n's standard Trello node. You'll almost certainly need HTTP Request nodes hitting the Trello REST API, and you'll need to resolve custom field IDs and dropdown option IDs into human-readable values before writing to Sheets. Tell us how you'd approach this.

- Trigger reliability. Trello webhooks vs. polling — we'd like your recommendation, and we want to understand the failure modes of whichever you choose.
- Duplicate rows. Cards come back for revisions. A card can enter "With Editor" three times on one job. We need a deliberate decision about whether that's three rows or one updated row — and the logic to enforce it.
- Timezones. Our team is UK-based, our freelancers are spread across several countries, and Trello due dates are stored in UTC. The early/late calculation is worthless if this is wrong. It needs to be right, and it needs to be documented.
- Card members. Trello cards can have more than one member. We need a defined rule for which one is recorded as the freelancer.
- Failure handling. If Google Sheets rejects a write, we want to know — not silently lose a submission. Some form of error workflow or alerting is in scope.
- Deliverables and acceptance criteria

The project is complete when:

- The Google Sheet is built, formulas verified, formatting and protections applied.
- Both n8n workflows are live and running against our real Trello board.
- We have run a joint test with at least five real cards with all custom fields populated, and every field maps through correctly.
- Duplicate-entry behaviour works as agreed.
- Timezone handling is verified against known submission times.
- Error alerting fires when a write fails.
- SOP, walkthrough video and workflow JSON delivered.
- Handover call completed.

Following handover, we ask for 14 days of bug-fix support at no extra charge — for defects in what you built, not for new requests.

You'll be a good fit if you have

Essential

- Demonstrable n8n experience — please show us workflows you've actually built and shipped.
- Comfort with REST APIs, webhooks, and reading API documentation, specifically because the Trello node won't do everything we need.
- Solid Google Sheets skills: COUNTIFS, AVERAGEIF, array-safe formulas, and an understanding of what happens to formulas when rows are appended via API.
- The habit of building for failure — retries, error branches, alerting — rather than building the happy path and hoping.
- Clear written English. Most of our communication will be asynchronous and in writing.
- Reliability. If something slips, we want to hear it from you first.

Nice to have

- Prior Trello API work, especially custom fields.
- Experience with Zapier or Make, so you can tell us where n8n is genuinely the better call and where it isn't.
- Experience writing SOPs or technical documentation for non-technical users.
- Self-hosting experience (see below).
- What we provide
- The full written specification, including exact column and field mappings.
- Trello board access and API credentials.
- A Google account for the Sheet.
- A named point of contact for questions, responding within one working day.
- n8n instance: we have not yet d ---------- between n8n Cloud and self-hosting. Tell us which you'd recommend for a workload of roughly 200–400 executions a month, and whether you'd be able to set up and configure it. If self-hosting is your recommendation and it requires meaningful extra setup work, quote that separately.

Fee

USD $220 (approx. ?12,500) for the complete project as scoped above, paid via Wise or PayPal in two instalments:

$80 (approx. ?4,600) on kick-off, once scope is agreed.
$140 (approx. ?8,000) on acceptance, after the five-card test passes and handover is complete.

This is based on our estimate of 15–20 hours at $12 per hour.

If you assess the scope and believe it's meaningfully larger than we've estimated, say so in your application with your reasoning and your number. We'd far rather negotiate honestly upfront than have someone underbid and then cut corners. We have some flexibility for a candidate who is clearly strong, and we'd rather adjust the fee than the quality.

Follow-on work: USD $12/hour (approx. ?685/hour). This covers changes outside the agreed scope, and any work after the 14-day support window. We anticipate a steady trickle of it — a Content Quality Sheet integration via IMPORTRANGE or VLOOKUP is already on our list, and there are other processes on the board we'd like to automate once this one proves itself. If the first project goes well, we're open to discussing a small monthly retainer for maintenance and ad-hoc automation.

Peso figures are indicative and depend on the exchange rate on the day. Payment is made in USD.

Timeline

We're not in a rush, but we don't want this drifting either. Target is 2–3 weeks from kick-off to handover, with a checkpoint after the first workflow is running so we can confirm the field mapping is right before you build the second.

How to apply

Please send:

- Two or three examples of n8n workflows you've built. Screenshots of the canvas, exported JSON, a Loom — whatever shows the actual work. Anything involving a service whose n8n node was incomplete is especially relevant.
- A short answer to each of these (a few sentences each is fine — we're looking for how you think, not an essay):
- How would you get Trello custom field values, including dropdown selections, into a Google Sheets row?
- Webhook or polling for the Trello triggers, and why?
- A card enters "With Editor," goes back to the writer for revisions, then returns to "With Editor." What should the Submission - Log show, and how would you implement it?
- Your availability over the next three weeks, and your timezone.
- Your fee, if it differs from ours, with your reasoning.

Applications that answer the three questions will be read first. Please open your message with the word "Deadline" so we know you've read to the end.

We'll shortlist within five working days and arrange a short call with our top candidates before awarding the project.