generative ai examples: Building Real-World Automation Blueprints

Most tutorials show you a cute prompt and call it a day. They never tell you what happens when that prompt meets real data, edge cases, or a spike in volume. After reading this, you’ll have a working pattern you can copy, a sense of what breaks, and a clear path to a ready‑made blueprint if you’d rather skip the build.

What most guides get wrong about generative ai examples

Many articles treat a prompt like a magic spell. They assume the model will always obey, never drift, and never need guardrails. In practice, a prompt that works in a playground can produce nonsense when fed messy CSV rows or when the temperature creeps up. The missing piece is a feedback loop: you need to check the output, log failures, and adjust the prompt or the data before the next run.

Another common oversight is ignoring the cost of tokens. A prompt that looks cheap in isolation can balloon when you attach long context or run thousands of iterations. I’ve seen solo operators burn through $200 of API credit in a single night because they didn’t truncate inputs or cache results.

How do you keep prompts from drifting when you scale?

Drift shows up as subtle changes in tone, missing fields, or outright hallucinations. The first line of defense is a strict schema. Ask the model to return JSON that matches a known shape, and then validate that JSON before you move on.

Here’s a concrete prompt I use for extracting invoice numbers from scanned PDFs:


You are an expert data extractor. Return ONLY a JSON object with the fields: invoice_number (string), date (ISO 8601), total (number). If a field cannot be found, set it to null. Do not add any extra text.


I wrap this prompt in a function that sends the OCR text, receives the response, and runs a JSON schema check. If the check fails, I log the raw output and retry with a lower temperature. This simple loop has kept my extraction error rate under 2% even when processing 10,000 documents a month.

One thing that trips people up is forgetting to strip whitespace or newline characters from the model’s reply. A trailing newline can break JSON.parse, so I always trim the string before validation.

Example: Cold‑email pipeline using GPT‑4 and Make (formerly Integromat)

Let’s walk through a real automation I built for a freelance outreach agency. The goal: take a list of LinkedIn profiles, generate a personalized first line, and send the email via Gmail.

Tools used: GPT‑4 (via OpenAI API), Make.com for workflow orchestration, Apify for scraping LinkedIn, and Gmail SMTP.

Step‑by‑step (each step is a Make.com module):

• Apify scraper pulls name, headline, and recent post URL for each target.
• A Set variable module builds the prompt: “Write a one‑sentence opener that references the person’s recent post about {{post_topic}}. Keep it friendly and under 20 words.”
• OpenAI module calls GPT‑4 with temperature 0.3, max_tokens 60.
• A JSON validator ensures the reply is plain text (no extra formatting).
• Gmail module sends the email with the generated opener inserted into a template.
• A Router splits the flow: if the email sends successfully, log success; if it fails, send a Slack alert and pause the scenario for 10 minutes.

I ran this pipeline on a list of 500 prospects. The total OpenAI cost was about $6.20 (500 calls × ~12 tokens input + ~30 tokens output at $0.03/1k tokens). Make.com charged $29/mo for the core plan, which gave me enough operations for this volume plus a few test runs.

Here’s the exact prompt I stored in a Make.com variable (note the double curly braces for Make.com syntax):


Write a one‑sentence opener that references the person’s recent post about {{post_topic}}. Keep it friendly and under 20 words.


One‑sentence paragraph: It’s that simple.

Concrete love: I love how Make.com’s visual debugger lets me click a module and see the exact input and output in real time. When a scrape returned an empty headline, I could instantly see why the prompt failed and adjust the fallback value.

Concrete gripe: The free tier of Make.com only allows 1,000 operations a month. When I first tested the scraper, I hit 2,300 operations in a single run and the scenario stopped dead. I had to upgrade mid‑experiment, which felt like a bait‑and‑switch.

Price mention with opinion: $29/mo for the basic Make.com plan is fair for the automation I run; the OpenAI usage is the real variable cost, and at current rates it’s cheap enough to ignore for a side hustle.

— and good luck finding docs for this — the Make.com module for OpenAI doesn’t expose the logprob parameter, so you can’t easily tweak temperature based on confidence scores.

How to debug when your AI pipeline breaks

When something goes wrong, start at the edges. Check the raw input to the model: is it truncated? Does it contain weird characters? Then look at the raw output: is it JSON, plain text, or something else?

I keep a simple logger that writes three lines for each run: input snippet, output snippet, and a status flag. If the flag is error, I dump the full payload to a file named with a timestamp. This habit saved me when a sudden change in the Apify scraper output broke my prompt— I could diff the old and new inputs in seconds.

If the model returns a JSON parsing error, validate the schema with a lightweight AJV check. If the schema fails, see which field is missing or malformed. Often the fix is as trivial as trimming whitespace or providing a default value.

When the error is not in the model but in the downstream step (say, Gmail rejects the address), isolate that step by sending a test email with static content. If the test works, the problem lies in the data you’re feeding it.

Finally, watch your token usage. A spike in cost usually means the prompt grew unintentionally— maybe you attached a full document instead of a summary. Set a hard limit on max_tokens and monitor the usage dashboard daily.

Why you might want the blueprint instead of building from scratch

All the steps above are repeatable, but they take an afternoon to wire together, test, and document. If you’d rather spend that time on client work, we’ve packaged this exact workflow as a blueprint. You can import it into Make.com, plug in your own API keys, and have a running pipeline in under an hour.

For more on this exact angle, AI meeting tools coverage.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault.