Nearly three months building an automation platform with AI and no coding background. Looking for technical direction, help getting it finished, and advice on turning it into a service business

Describe the problem/error/question

What is the error message (if any)?

Please share your workflow

(Select the nodes on your canvas and use the keyboard shortcuts CMD+C/CTRL+C and CMD+V/CTRL+V to copy and paste the workflow.)

Share the output returned by the last node

Information on your n8n setup

  • n8n version:
  • Database (default: SQLite):
  • n8n EXECUTIONS_PROCESS setting (default: own, main):
  • Running n8n via (Docker, npm, n8n cloud, desktop app):
  • Operating system:

Nearly three months building an automation platform with AI and no coding background. Looking for technical direction, help getting it finished, and advice on turning it into a service business.

Hey everyone. I’m looking for an honest outside perspective from developers, automation builders, technical founders, or anyone who has gone from building an internal tool to providing it as a paid service.

I’ve spent close to three months building a business automation platform using ChatGPT and Claude. I have no formal coding background, no outside developer helping me, and no technical cofounder. I’m a “vibe coder,” but I’m trying to understand what I’m building and make responsible decisions about it.

I know the operational side of the business very well because I do this work myself. My challenge is turning that knowledge and the pieces I’ve built into a reliable product and service.

At this point, I’m looking for help figuring out whether I’m on the right track, what needs to change, and whether paying someone is the best next step.

I’m keeping company names, client information, and proprietary workflow details private, but here’s the overall picture.

1. The problem I’m trying to solve

I work in a regulated, document-heavy field where a lot of administrative work involves:

  • Receiving job documents by email.

  • Reading PDFs and extracting information.

  • Organizing files into the correct folders.

  • Entering the same information into different systems.

  • Completing forms on external websites.

  • Tracking job status and revised documents.

  • Finding the correct employee credentials and supporting records.

  • Saving receipts, screenshots, and confirmations.

  • Checking that required steps were actually completed.

I understand these workflows from doing and managing them. I’m trying to reduce the repetitive work and make the process easier to track and verify.

2. What I’m trying to build

The goal is a central platform where I can:

  1. Receive or import a job document.

  2. Extract the relevant information.

  3. Review and correct that information.

  4. Approve it before an important automated action.

  5. Start the appropriate workflow.

  6. See whether it is waiting, running, completed, or needs attention.

  7. Access the original documents and resulting confirmations.

I want to operate this remotely through a usable interface, rather than opening scripts and moving between folders and browser windows.

One of my biggest unresolved questions is the actual application format: should this be a web application I log into through a browser, an installed desktop application, a mobile application, or a combination?

I don’t necessarily need every format. I need help understanding which format fits the workflow and how the interface connects to the automations behind it.

3. The tools involved so far

ChatGPT and Claude

These have been my only technical guidance. I use them for planning, code generation, troubleshooting, and deciding what to build next.

Python

I have scripts for document processing, extracting and organizing information, and automating portions of the workflow.

Selenium and browser automation

Some tasks require interacting with external websites. These systems don’t necessarily offer a convenient API, so browser automation is part of the approach.

Supabase

This is being used for the developing database/backend side of the platform.

n8n

I’m incorporating n8n for workflow orchestration and integrations. I’ve also connected Claude to n8n through MCP.

A major question is what should actually live in n8n, what should remain in custom Python, and whether I’m creating unnecessary overlap.

A web interface and a Python background worker

I’ve reached the stage of running a developing web interface and worker locally. I need an independent assessment of how these components should communicate and whether the structure makes sense.

Mac, Windows, and Tailscale

I use a Mac and a Windows work computer, with Tailscale for remote connectivity. Some files and existing workflows are tied to the work computer or shared folders.

To be clear, this is the collection of tools and components involved. I’m not saying everything is fully integrated, finished, or ready for production.

4. What I’ve accomplished so far

I’m past the idea stage, but I’m not at a dependable finished product.

I have:

  • Existing Python scripts for processing and organizing job documents.

  • Browser automation for portions of the external administrative workflows.

  • Work on the underlying job records and database.

  • A developing dashboard and background worker.

  • Defined business rules around document revisions, review, approval, and supporting records.

  • Started incorporating n8n into the broader approach.

Some individual pieces work. My difficulty is connecting everything into one system that I can understand, maintain, and trust.

5. The roadblocks I’m facing

I don’t know whether the architecture is appropriate.

Because I’m not a developer, I can’t confidently judge whether the tools are being combined sensibly or whether the project has become more complicated than necessary.

I don’t know the right boundary between the app and the automation.

For example, if I click “Run” in a dashboard from another location, what receives that request? Where should the task execute? How does the dashboard get progress updates? What happens if the computer running the automation is offline?

I don’t know what should run locally versus in the cloud.

Some tasks involve local or shared files and existing browser-based workflows. I need help understanding whether to keep a dedicated Windows machine running, move certain components to a server, or use a hybrid setup.

I need a usable application, not just working scripts.

I want an interface where I can manage the process without needing to understand the code every time something happens. I’m unsure how far I am from that or what work remains.

I need reliability around important actions.

I need to know what happens when a website changes, a login expires, a document is difficult to read, a task fails halfway through, or the same document arrives twice.

A retry should not accidentally create a duplicate submission. A revised document should not silently overwrite information that was already approved.

I’m relying on AI to build the system and assess its own work.

ChatGPT and Claude can help me keep moving, but I don’t have an independent person checking the underlying decisions. I don’t know which issues are normal development friction and which indicate a bigger problem.

I’m struggling to define “finished enough.”

I need a realistic first version and a clear stopping point. I don’t want to keep adding infrastructure or features without getting something dependable into use.

6. My business goal

I currently work as an employee in the business whose workflows informed this project.

My goal is to explore providing these services through my own company under a business-to-business contractor arrangement. That would involve me operating and maintaining the platform and delivering the work as a paid service.

I’m not just thinking about selling someone software and walking away. The service could include running the workflows, monitoring failures, handling exceptions, and maintaining the system.

Initially, the business I currently work for would be the potential first client. Longer term, I’d like the option to provide a similar service to other businesses, with separate data, settings, and workflows.

This is a proposed direction, not an existing signed arrangement. I need help understanding what should be technically and commercially ready before I make that transition.

7. Technical questions I would appreciate help with

  1. Does the overall approach make sense?
    Is n8n + Supabase + Python + browser automation + a dashboard a reasonable combination for this problem? What would you simplify, and why?

  2. What application format would you choose first?
    Would you build a web application, a desktop application, or something else? What requirements would actually justify a native app?

  3. How would you split the responsibilities?
    What belongs in n8n, the Python worker, the database, and the user interface? How do you avoid building the same logic in multiple places?

  4. How would remote operation work?
    How should a dashboard securely start work on a separate computer or server and show the result?

  5. How would you handle local files and browser sessions?
    What approach works when an automation needs access to shared folders, downloaded documents, or a third-party website with an authenticated session?

  6. What reliability features are essential for the first version?
    I’m thinking about job queues, retries, duplicate prevention, logs, approvals, backups, and recovery. What is essential now, and what can wait?

  7. How would you assess the existing project?
    What would you need to review before recommending that I continue, refactor certain parts, or rebuild a specific component?

  8. How can someone with my experience use AI more effectively?
    What development process would help me keep a consistent architecture and avoid accepting changes I can’t evaluate?

8. Should I pay someone at this stage?

I’m open to paying for qualified help. I’m trying to understand what kind of engagement would actually move this forward.

Would you recommend starting with:

  • A scoped architecture and code review?

  • A senior developer who can work alongside me?

  • An automation specialist familiar with n8n and Python?

  • Someone who can take responsibility for getting a defined first version into use?

What should I ask that person to deliver?

Ideally, I’d want an assessment of what exists, the main risks, what can be reused, and a prioritized plan to get a usable version running. I would also need explanations and a handoff I can understand.

What is a realistic scope for that first engagement? How do I evaluate someone’s competence when I don’t have the technical background to judge their answers?

I’m also interested in how people structure a project like this so they retain access to the code, infrastructure, accounts, and documentation.

9. Ownership and legal questions

There is an employment-related ownership question here that I want to handle properly.

The platform grew out of workflows I know through my current job. I’ve discussed the idea internally and received encouragement to pursue it, but I don’t want to assume that this settles ownership or gives either side particular rights.

Before pitching a contractor arrangement, I want qualified advice on the existing situation and on how a future agreement should work.

For people who have been through something similar:

  • Did you consult an attorney before demonstrating, deploying, or offering the system commercially?

  • What type of attorney helped with the combination of employment-related IP questions and software/service contracts?

  • How did you establish who owned the existing code and who would own future improvements?

  • Did you distinguish your reusable platform from the client’s data, documents, and company-specific configurations?

  • How did you structure the client’s right to use the system while protecting your ability to serve other clients?

  • What happened to the software, data, and ongoing workflows if the service agreement ended?

  • Did you pursue copyright registration or other protection? At what stage, and what did your attorney explain that it would and would not accomplish?

  • How did you address AI-generated code, third-party packages, and open-source license obligations?

  • What contract provisions mattered most for ongoing maintenance, support, scope changes, security responsibilities, and liability?

I’m looking for people’s experiences and referrals to the right kind of professional. I understand that a forum cannot determine ownership or replace a review of my actual employment documents and circumstances.

10. What I’m asking this community for

The most useful help would be:

  • An honest assessment of whether this approach fits the problem.

  • A practical next step based on the stage I’m at.

  • Guidance on what information I should prepare for an independent technical review.

  • Recommendations for the type of professional I should hire first.

  • Forums, communities, or places to find credible hands-on help.

  • Experiences from people who turned an internal automation project into a paid service.

I’m not expecting anyone to build the platform for free, and I’m not looking for encouragement without substance. I’ve put close to three months into this, I understand the business problem, and I’m willing to learn or pay for the right help.

I need to know how to get from a collection of partially working components to a dependable service, and how to handle that transition properly from both the technical and business sides.

You’ve described a real, document-heavy operating workflow and a clear need to separate the app, orchestration and browser worker. A scoped first step could be an independent architecture review that lists what works, flags reliability and security risks, and defines a small dependable v1. Employment and IP ownership questions are best kept with a lawyer who knows software and employment agreements. Happy to start with sanitised examples.

Hi @Markspooran

You are at the stage where an independent technical review can save you time and prevent unnecessary rebuilding. I work with Python, n8n, Supabase, AI integrations, and Claude Code, and I’d recommend auditing what you’ve already built before adding more infrastructure.

Review your existing code, workflows, and database architecture. Define clear responsibilities for n8n, Python workers, Supabase, and the dashboard. Design secure remote execution, job tracking, retries, and duplicate prevention. Identify what can be reused versus what needs refactoring. Create a prioritized MVP roadmap with documentation and a clear handoff.

@Markspooran I’d start with the web interface you already have and a paid review of one complete job before deciding on a rebuild. Pick the document-to-submission process you most need working. That gives the review a concrete question: what needs to change for you to operate this one process reliably?

Your tools could fit together like this, subject to checking the actual code and workplace requirements:

  • The web app handles review, approval and progress.
  • The backend checks permissions and records jobs, document revisions and approvals in Supabase.
  • An authorized Windows worker handles the local files and browser sessions. n8n coordinates integrations; working Python scripts can stay Python.

Clicking Run would save an approved job for the worker to pick up. An unclaimed job stays queued if the machine is unavailable. Show the worker’s last contact separately from the job’s last confirmed step. If contact disappears after submission, the outcome is unknown. First establish whether the actual website provides a dependable way to find that submission by a reference or receipt. If the result can’t be established, send it for manual review instead of resubmitting.

Before accepting the first version, I’d want to see a few tests with dummy data: change a document after approval, submit the same input twice, interrupt a submission before its confirmation is saved, and restore a sample job with its files and history from backup. Does the system prevent an old approval being used, recover without duplicate submission, and leave an understandable record when human review is needed? Run those only against an authorized test destination.

For that first review, I’d identify who can approve or start a job, where worker credentials live, and what the audit record captures.

Before connecting a live website, confirm that it permits automation. Keep the employment/IP questions with a qualified adviser, and establish what you’re allowed to share before granting access.

I can offer an initial written review of one agreed document-to-submission path for €180, capped at four hours. Before payment, I’d check a redacted outline and confirm that the review fits that limit. You’d get a map of the path, findings tied to the code or checks we can actually perform, a keep/change recommendation and a proposed implementation step. Anything untested would be listed. This is a review, not a full-platform or compliance audit; implementation is quoted separately. We’d agree the inputs, payment method and delivery date before starting.

For something you can inspect first, here is a 58-second walkthrough and source ZIP. It shows an operator linking or separating enquiries, approving them and reading back the resulting Tasks from a local EspoCRM test. Replaying the retained operations adds no further Tasks in that recorded test. It uses fictional data; the n8n engine runs offscreen. It isn’t evidence of your external website’s submission behaviour.

If that first step suits you, email marchuk0andrii@gmail.com with the process you want reviewed and one thing that currently fails. An outline is enough to check fit—no credentials or customer documents for that first message.

Sir did you got your answer. I also have the same question

Hi @Markspooran,

Your questions about the dashboard-to-worker boundary, offline execution, revised documents and duplicate submissions fit the kind of architecture assessment I can help with.

I’m a Brazil-based Solution Architect with professional experience in APIs, integrations, cloud, data modeling, technical documentation and validation.

I’d propose a small, paid review of one critical journey—from document intake and approval to execution and confirmation. Deliverables would include a component responsibility map, prioritized reliability and security findings, a failure-recovery and idempotency review, and a practical MVP roadmap with a written handoff.

We could start asynchronously with a redacted process outline and sanitized diagrams or examples you’re authorized to share. No credentials, customer documents or production access would be needed. Employment and IP ownership questions would remain with your legal adviser.

Are you still considering paid technical help? If so, which journey is the priority, what currently fails, and what budget and timeframe do you have in mind? We could agree a fixed fee, deliverables and acceptance criteria before starting.

Hi Mark,

I hope you’re well. You’ve already spent three months getting the pieces in place, so I’d focus on making one workflow dependable before adding anything else.

The dashboard-to-desktop hand-off looks like a useful starting point: show whether the worker has picked up the job, keep the status accurate if it disconnects, and make retries safe so a failed run doesn’t create a duplicate submission.

My closest example is Switchboard, an internal sales and operations system for an Australian AI voice company. I worked on matching call transcripts to the right CRM records and capturing notes and follow-up tasks. The workflow covered 20+ calls a week, and I estimate it saved each person 1–2 hours of documentation and follow-up work a day.

For your setup, I’d suggest reviewing one complete workflow first, then giving you a short list of what can stay, what needs fixing and how we’ll know it’s ready to use. That gives the work a clear finish line.

Which workflow would you most like to get working from start to finish?

Thanks,
Dhruv

Hi Mark, I would start with one document → review/approval → submission path. The first risks I would check are a document changing after approval, duplicate intake, and a website timeout where the submission outcome is unknown.

I work on n8n/API business workflows, product implementation and reliability testing. My public n8n quotation prototype demonstrates deterministic validation and fail-closed handling of missing or unsupported inputs: GitHub - nassaj2011/n8n-ai-quote-reliability-case-study: Production-safe AI quoting workflow with exact catalog matching, deterministic pricing, hallucination guards, and failure-state handling. · GitHub

For a first paid milestone, I can review one agreed path from a redacted process outline and the relevant n8n workflow/worker handoff. You would receive a concise flow map, a prioritized risk list with reproducible test cases, and a v1 implementation roadmap with acceptance criteria and clearly marked unknowns. This is an architecture and reliability review of that path; implementation and any full Python/Selenium code audit would be separate.

My proposed price is $120 fixed, capped at six hours, subject to checking the redacted outline first. I could deliver the written review within three working days of receiving the agreed inputs. We can agree the payment method and access boundaries before starting. Which single process would be most useful to review first?

Hi @Markspooran, would a small paid Python validation task be useful for this project? A possible first step is one document-extraction JSON payload: required fields, type/date checks and duplicate-document test cases, using synthetic examples before any live integration.

I work remotely from Hungary and would review and test the resulting code. My current sample is a local JSON-export validator with synthetic data and eight earlier passing checks; it is not a deployed n8n/Selenium system.

If that scope fits, please share the expected input/output structure, one redacted failing example, your budget range, acceptance criteria and payment method. Scope, price and timing would need agreement before starting.

Hi Mark,

I’ve worked on data collection systems involving browser automation, background workers and dashboards, so the problem of keeping the interface and the actual execution state consistent is familiar.

I’d start by reviewing one document-to-submission process rather than the entire platform. In particular, I’d check what happens when a document changes after approval, when a worker loses its connection, and when a website submission succeeds but the confirmation isn’t recorded.

For €120 fixed, I can review one agreed path and return a written architecture map, the main risks supported by the code or tests, reproducible failure cases, and a prioritized plan for getting that path dependable. I’d aim to deliver within three working days after agreeing on the scope and receiving sanitized materials.

I use AI-assisted development and testing, but I’d distinguish reproduced findings from recommendations or assumptions. No production credentials or sensitive customer documents would be needed for the initial discussion.

If you’re still considering an independent review, which single workflow would you want checked first?

Vine

For the first review, I would ask for a decision document you can use even if a different developer implements the changes: which business rules currently exist in more than one component, which component should own each rule, and the evidence behind each keep/change recommendation.

A redacted process map, component list, dummy input, expected result and two reproducible failures should be enough to scope that review before granting wider access. Agree the review deliverables and fee separately from any rebuild.

Which single workflow must the first usable release support, and are you currently seeking proposals for an independent review?

@Markspooran — I think the smallest paid step here is **not another build**. It is a bounded review of **one complete job from input to final submission**.

I can do that as a fixed **US$75 first review**:

- you send a sanitised repo/workflow export + one representative job path (no production credentials);

- I map the actual boundaries between the web app, Supabase/backend, n8n, Python workers and the authorised Windows/browser worker;

- I identify the top reliability/security failure modes: duplicate jobs, partial writes, retries, stuck states, credential/authority leakage, ambiguous completion;

- I return a one-page **keep / change / remove** architecture map, the 5 fixes I would do first, and a smallest dependable v1 acceptance checklist;

- if the current design is already good enough in an area, I will say so rather than proposing a rebuild.

**Acceptance:** the review must tell you, for that one job, what component owns each step, what evidence proves completion, what can safely retry, where a human must approve, and what you can defer until after the first paying customer.

I’m strongest on exactly this transition: turning partially working automation into a bounded, recoverable system with explicit state, idempotency, failure routing and effect verification. I would keep the employment/IP questions separate for legal counsel rather than pretend an architecture review can settle those.

If that scope is useful, reply with the one job you most need working and I’ll keep the review to that boundary.

Mark, I’d make “finished enough” an operator test: can you follow one document from arrival to a verified result, and understand what to do when it stops, without opening the code?

One distinction worth keeping in your design is the machine’s status versus the job’s outcome. A worker going offline tells you where the machine is, not whether the external website accepted the last action. That needs its own “needs checking” state. The absence of a saved receipt is not evidence that nothing happened.

For the first review, I’d choose one document type and one external destination. Ask the reviewer to hand you a short responsibility map, findings tied to the actual files inspected, and five acceptance checks you can run with synthetic data: duplicate input, concurrent workers, interrupted submission, expired login and a revised approved document. Have them list what they could not verify, too. That makes their work easier for you to assess.

I’ve drawn a starting plan from your post, including three clickable failure scenarios: workflow review outline. These are illustrations, not a claim that I’ve inspected your system.

If you decide to buy help, I can offer that bounded review for $650 USD, split $325 at kickoff and $325 at handoff: up to four hours reviewing one n8n export, two relevant Python modules (up to 1,000 lines total), a redacted schema and a walkthrough; then a 45-minute handoff. Delivery is three working days after an agreed start and the materials. Scope and the payable total would be confirmed before payment; implementation is separate. An optional 20-minute Zoom can establish fit first.

An outline with invented sample data is enough for that first conversation. Keep employer/client material private until sharing permission is clear. Which single document-to-result path would save you the most time if it became dependable?

Hi Mark, the duplicate-document/retry case you mention looks like a useful place to start.

I can offer a small Python implementation task: take one document-processing function that currently fails, add a reproducible test, fix the agreed behaviour, and leave you the code, tests and a short explanation of how to run them. For example, we could use a synthetic document arriving twice and agree on the expected result before changing anything.

My proposed price is US$75 for that one task, subject to seeing the relevant code and confirming it fits. I’d ask for payment through PayPal within three days of acceptance. No platform rebuild or ongoing support commitment is included.

This would be a small implementation task; it wouldn’t replace the broader architecture review you’re looking for. I don’t have client n8n case studies to claim.

If that smaller step is useful, could you share a redacted outline of one failing Python step and its expected output? No employer documents, customer data or credentials. We can settle the scope, acceptance checks, delivery date and fees before starting.

:high_voltage: THE ARCHITECTURAL BOUNDARY: SHIFTING FROM VIBE-CODING TO A RESILIENT B2B SERVICE ENGINE

Hi Mark (@Markspooran),

First off, congratulations on pushing past the idea stage independently! Transitioning from localized “vibe-coding” scripts to an economically viable, production-grade B2B automation platform is where 90% of internal tools either break or scale into major businesses.

In regulated, document-heavy environments, handling non-deterministic AI extractions, managing local vs. cloud files, and ensuring absolute transactional data integrity are severe infrastructure boundaries. A naive retry loop halfway through an external form submission can trigger devastating duplicate ledger entries or silent overwrites.

In my self-hosted Python and n8n clusters natively managing over 1.2M+ daily external webhook payload vectors, here is how I systematically map the exact boundaries to resolve your roadblocks:

:one: The App vs. Automation Boundary (n8n vs. Custom Python)

  • What lives where: Treat Supabase + a lightweight Web UI (Next.js or Streamlit) strictly as your “State & Control Plane” (where you review, edit, and click “Approve”). Treat n8n strictly as your “Orchestration & Event Plane” (handling API routes, status propagation, and email intakes). Move heavy, custom heavy-lifting like complex PDF parsing or Selenium scripts to your Python background worker.
  • How they talk: The UI should never invoke Python directly. When you click “Approve” on your dashboard, it mutates a row in Supabase. Supabase triggers a Realtime/Webhook event straight to an n8n webhook intake node, which subsequently pushes the execution task to your Python background worker queue.

:two: The Hybrid Architecture Boundary (Local vs. Cloud)

  • The Cloud Layer: Host your Web UI, Supabase DB, and primary n8n instance in a secure cloud network (AWS/DigitalOcean Docker clusters). This ensures your control panel is accessible remotely from any browser, 24/7, even if your local office computers drop connection.
  • The Local Worker: Keep your dedicated Windows/Mac environments connected via Tailscale strictly as “Local Execution Daemons.” Run an n8n self-hosted worker or a local Python listening script locally. It listens to the cloud queue, manipulates the local shared folders/browser automations, extracts the resultant receipts, and commits the execution logs back up to the cloud Supabase layer. If the local machine goes offline, the cloud queue safely holds the task—preventing dropouts.

:three: Eliminating Duplicates & Race Conditions (Crucial for B2B Delivery)

  • Redis Idempotency Gates: To guarantee that a website timeout retry or a double document ingestion never triggers a duplicate submission or mutates a finalized record, you must enforce a strict write boundary. I deploy native Redis lock primitives (INCR + TTL gates) straight at the intake layers. If a document hash or unique ID attempts a repeat execution within a specified TTL, the system intercepts it within 45ms, blocking downstream ledger corruption.
  • Schema Hardening: Wrap probabilistic Claude/ChatGPT document extractions inside rigid, hardcoded Pydantic schemas before writing to Supabase to prevent unvetted null fields or structural data drift.

:four: Defining “Finished Enough” for your MVP

  • Stop adding features. Your MVP is stable when you have exactly one end-to-end path working without human code intervention: [Document Intake via Email] :right_arrow: [Automated Pydantic Parsing into Supabase] :right_arrow: [Human Review Dashboard UI with Approve Button] :right_arrow: [Selenium Execution with Log Confirmation].

:laptop: You can directly audit how I architect these exact state-locking sub-graphs, error-trigger handlers, and containerized ingestion boundaries straight from my repository:
:backhand_index_pointing_right: https://github.com

You have the deep domain operational context—which is the hardest part to buy. To scale this into a dependable B2B service business without code anxiety, what you need right now is an independent, rigorous architectural audit over your existing backend scripts.

Drop a small mock sample of your current document schema layout or a specific integration bottleneck you are facing, and I’m happy to break down the exact node wiring to establish clean execution boundaries over it!

Best regards,
Sheetal Katre
India | Technical Contractor

Hi Mark, you’ve already done the hard part: you know the workflow and have working pieces.

Short answers to your big questions:

  • Format: start with a web app. You only need a desktop app if a task must touch files on one machine, and a small worker on that machine can handle that.
  • Who does what: the dashboard and Supabase hold the jobs and their status. One worker picks up jobs, runs the Python/browser steps and writes progress back. n8n is only the glue (email in, notifications out). Keep each rule in one place.
  • Reliability: give every job an ID and a status (waiting, running, needs review, done). A retry checks the status first, so nothing is submitted twice, and a revised document creates a new version instead of overwriting the approved one.

I’m a full-stack developer (Next.js, Supabase, background jobs). I built Kunji (kunji-two.vercel.app), a live store with an order queue, admin approvals and an audit trail, which is the same pattern you need. Code: UzairJIqbal (Uzair Javaid) · GitHub

If it helps, I can do a fixed-price review of what you have (with sanitised examples) and give you a one-page plan for a dependable v1. Happy to chat.

Nope I feel like I was looking for advice and direction and evryone wants to offer their service as a $$$ grab if just not all bots

Honest take from someone who builds these for a living: don’t hire anyone to “finish the platform” yet. What you want first is a scoped architecture review — a few hours, fixed price. Someone technical looks at what exists and hands you: what to keep, what to simplify, the 3 biggest risks, and a prioritized plan to get v1 into actual use. That answers your n8n-vs-Python question with your real code in front of them, instead of guessing.

Rule of thumb on the split: n8n owns orchestration and integrations (the “when this, then that” between systems). Python owns the heavy document work that needs real code. If the same logic lives in both places, that’s the first thing to kill.

I do exactly these small fixed-scope reviews — $200 to assess what you’ve got and give you the prioritized plan. Happy to do it, but either way: get the review before committing to a bigger build.

Hi @Markspooran, your bottleneck seems to be verifying one complete document job, not adding more tools. I work on NeuroCore, combining Python, n8n and browser automation. My verifiable demo is an isolated CSV-to-report workflow with duplicate rejection and audit outputs. I do not claim prior paid client n8n deployments. I can offer a paid first step: USD 85 fixed for a 2-hour asynchronous review of ONE redacted document-to-approval-to-submission path, delivered within 48 hours after agreed inputs. Deliverables: a one-page architecture map (dashboard, Python worker, database, n8n), top three failure and duplicate-submission risks with test cases, and a keep/change list with v1 acceptance criteria. No rebuild, production access or sensitive customer data in this stage. We can use synthetic documents and a sandbox. Employment/IP ownership needs separate legal advice. If interested, DM a redacted outline of that one workflow and what currently fails. We agree the fixed scope and protected payment before work. Poland (CET/CEST), asynchronous.

Hi Mark. I’ve been building software for over 20 years. A few of the things you’re stuck on don’t necessarily need another tool or a rewrite.

For a handful of employees, your architecture could be perfectly reasonable. I’d look at where it actually breaks before changing it. You don’t need to solve hypothetical scale problems today.

For the boundary between the app and automation: the app is where people review documents, approve actions and see status. n8n coordinates the steps and integrations. Python handles the custom processing. Keep the business rules in one place so you’re not maintaining two versions of the same logic.

Local versus cloud is a separate decision. If the local setup meets your needs, there’s no reason to move just to call it a cloud application. Revisit it when uptime, remote access, maintenance, cost or security gives you a concrete reason.

Your scripts are already useful software. Making them usable by somebody else means packaging the dependencies and configuration, handling permissions, and making failures understandable. That’s different from starting over.

For reliability, start with logging, tests, backups and a clear way to recover failed jobs. Make sure a retry can’t submit the same thing twice. Those engineering practices matter whether you keep n8n or write more Python.

You’re right to want a human reviewing the AI’s work. Particularly around permissions, sensitive data and anything that submits information to another system. Another AI saying the code looks good isn’t enough.

“Finished enough” is your MVP: one useful workflow that another employee can run and recover when something fails. Get that working, then improve it in small releases. Version control, automated tests and CI/CD help you make those changes without breaking what already works.

Happy to give you 30 minutes of my time, free, to talk through the questions and help you figure out what actually needs attention. If there’s something you need built after that, we can discuss scope and rates.