A screenshot goes in, a Jira bug comes out

The previous session ended with a task: take at least three QA problems and automate them with n8n, cloud or local, whichever is easier to get running.

This session builds one of those three end to end, in front of the room, including every failure. That is deliberate. The finished workflow is about fifteen minutes of work; the other ninety are the part nobody puts in a tutorial.

The three problems suggested as starting points, easiest first:

• Requirement to test case generator. Pull the requirement from Jira, apply your template, write the cases. Already built several times in this batch.
• Screenshot to bug reporter. Upload a screenshot, get a filed Jira bug. Needs a model that can actually see images.
• Downtime tracker. Covered later in this page, and running in production.

The room picked the second one.

There is no single right way to get an n8n workflow, and the session was explicit that the easy way is not the one to start with.

The third way is what gets used at work now. Nobody drags nodes for a workflow they have already built twice.

The prompt was not "build me this". Three things went into it before any code was allowed:

1. The problem statement, pasted verbatim from the project brief: input is a UI screenshot plus error logs, output is a Jira bug with steps to reproduce, and the point is that bug reporting is tedious and inconsistent.
2. A constraint on where the file goes. Put it in the agents folder as 08_Screenshot_To_Bug_Reporter_AIAgent.json.
3. A research instruction. "Let us first research which cheaper model we can use. I have access to groq.com and openrouter.io. Let me know what is the plan in the Plan.md file." Plan mode only. Nothing gets created yet.

And one more line that matters more than it looks:

Ask me for the questions that you want me to answer.

The agent came back with four, and the answers are the whole design:

The finished workflow is not an AI Agent node. The model gets exactly one bounded job, look at the image and return JSON, and every other step is a deterministic node.

The form itself carries five fields. Only the first is required:

Not every model can see. Before wiring anything, the model was opened in the Groq playground and given an image with the instruction "tell me what is present in this photo", then a second run asking for the exact text and nothing else.

It read the panelist names off the screenshot and it noticed the watermark. That is the check worth copying: prove the model can read your screenshots before you build around it.

The repository carries the model research that produced this choice, and it is the most useful page in the folder. The short version: Groq's vision lineup shrank. The Llama vision models that most tutorials still name are not on the supported list any more, and the only image capable models left are two Qwen ones, both marked Preview.

Groq bills a flat 2048 tokens per image, and its output is priced five times its input on this model, which is why the JSON schema the model must return is deliberately short. Every field it returns is a field you pay for.

The lesson written into the repo, and it generalises well past this workflow: check the provider's current model list before you design around a model. The one you remember may not be served any more.

You do not import the file. You open it, select all, copy, and paste onto an empty n8n canvas. The nodes and their wiring appear.

That is worth knowing because it makes the workflow a piece of text you can keep in Git, review in a pull request and paste into anyone's n8n.

Nothing worked first time. This is the section to read twice.

The Jira one is the trap. The error names the project, so everyone goes and checks project permissions. The project was fine.

Two settings on the model node came up while fixing this:

• Max tokens. The default in the generated node was low enough to truncate the reply. The node allows far more.
• Temperature. Described in the room as creativity. The workflow runs it at the low end, because a bug report is not a creative writing task.

After the fresh Jira token, the first real ticket appeared: VWO-109. Later, through the UI, VWO-125, with the screenshot attached and readable.

Click Publish, open the node, and you get a production URL. That URL works from anywhere, and it was shared with the room live.

It worked for a handful of people and failed for the rest. The reason is not a bug: a free Groq key has a rate limit, and forty people uploading at once exhausts it. Tickets from the room did land in the backlog, which was the point of the demo, and the workflow was then unpublished.

The n8n form is functional and looks like n8n. If you want to hand this to your team or show it to your manager, they should never see the tool behind it.

That is a second workflow, number 09, identical to 08 except that the form trigger becomes a webhook and a "respond to UI" node is added at the end. Same eight nodes in between.

The direct browser-to-n8n arrow is crossed out for two reasons, both in the repository's proxy file:

• It is a cross-origin request, so you inherit a CORS problem you did not need.
• The n8n URL would sit in code anyone can read from devtools, and anyone who reads it can POST to your workflow.

The proxy forwards the raw multipart body untouched, because parsing it would destroy the boundary that separates the image from the text fields.

Deploying is a token exchange: create a token in the Vercel settings, hand it to the coding agent, and it pushes. Free accounts allow a small number of projects and you can attach your own domain to one of them.

This is the idea worth taking away from the whole session.

Once a UI posts to a URL, what is behind that URL is your business. n8n today, Langflow tomorrow, a hand-written Python service after that, then CrewAI or LangChain. The person using it cannot tell and does not need to.

Two agents already running on that pattern were described:

• Downtime tracker. A QA opens a form in Slack, names the application and the window it was down. Behind it an agent writes to a database. When a manager asks, it summarises the total back into Slack. It turns "the environment was down again" into a number you can take to a developer and QA sync. Permissions restrict the summary view to the manager.
• PR review agent. Triggered by a GitHub webhook when a pull request is raised, or by pasting a PR link into Slack. It reads the diff, checks it against rules kept in a markdown file in a separate repository, runs the lint checks, and posts a review comment. This one is promised as a from-scratch build later in the batch.

Langflow is a visual drag and drop builder for LLM applications. Same idea as n8n, different lineage: it belongs to the Lang family, a set of open source tools that started as open projects and later grew paid tiers.

The single most useful observation in this part of the session: click Code on any Langflow component and you get Python. The canvas is a view over code, and connecting two boxes is connecting two objects. That is why Langflow and LangChain are the same skill approached from two directions.

Where it gets used, from the room: HDFC Bank and Oracle projects use Langflow; some product companies use n8n. It varies by company, and service companies tend to pick whichever is fully open source.

When Langflow is the right choice: rapid prototyping of an agent idea, a team with mixed manual and automation skills, demonstrating a capability to stakeholders, internal tools, wiring an LLM to Jira.

When it is not: high throughput production pipelines, complex state that belongs in LangGraph, anything involving model training or fine tuning, and any team that already knows Python well enough to use CrewAI or LangChain directly.

Langflow is a Python module, so Python comes first. The commands, exactly as shown:

mkdir langflow-qa && cd langflow-qa
pip install virtualenv
python -m venv venv
source venv/bin/activate
pip install langflow
langflow run

On Windows the activate line is venv\Scripts\activate.

Two other routes were shown:

• Desktop app from www.langflow.org/desktop, which wants an email address and gives you an installer. Roughly ten minutes to first launch.
• Docker, which was the route that actually came up first in the room. Steps promised for the next class.

The easiest route, and the one recommended if you do not want to fight it: ask your coding agent to install Langflow and run it in the background. It will check for Python, create the folder, and start it.

Right click the canvas, create a project, name it, click New. Then three components:

1. Chat Input
2. Groq (search for it, click plus)
3. Chat Output

Connect output to input, left to right. That is the whole flow, and the repository stores it as 01_LangFlow_Simple_HelloWorld.json with exactly those three nodes.

The key goes in through the variables icon, not into the node: Add Variable, name it, paste the value, apply. Global variables live under Settings and hold anything you would otherwise paste twice, Groq keys, Jira API keys, and later MCP configuration.

Open the Playground and say hi. The first run failed with "model does not exist" until the model was set to the Qwen model, after which "what is 2 + 2" returned 4.

This week's task, and it is a hard minimum:

• Build at least three AI agent projects. Ideas claimed in the room included a Jira review agent, a vendor licence manager, an interview question generator, auto-updating selectors, a flaky test classifier, defect density, a manual to automation test case converter, a visual differencer, an exploratory charter generator and a duplicate test detector. There are more than fifty ideas in the agents folder if none of those fit.
• Add a UI to them where you can, and publish to Vercel. The combination asked for is a UI plus three agents. An unpublished workflow cannot be reached through Vercel, so publish, then copy the production URL.
• Post them in the thread.
• Install Langflow locally or via the desktop app and confirm it runs.

Announcements

• An extra session on Tuesday evening. Invitations to follow.
• Docker install steps for Langflow come next class.
• The PR review agent will be built from scratch later in this batch.
• Do not reuse the production URL demonstrated in class. It was unpublished. Create your own free account at n8n.io.