Business Card AI Generator

Last month I needed to generate 200 business cards for a niche tech conference and realized my usual design tool was too slow for the volume. I wanted a way to feed a list of names and titles into an AI model and get print‑ready PDFs back, without hiring a designer. After a few failed attempts with generic prompts, I built a small automation that now spits out cards in under two minutes per batch.

What you’ll walk away with is a repeatable process: a Google Sheet with contacts, a simple prompt that tells the AI exactly how to lay out a card, and a chain of no‑code tools that turns the text into a print‑ready PDF. You can run it yourself or grab the pre‑built blueprint from the vault later.

Why does the prompt need to be so specific?

When you ask a model like Claude 3 to “make a business card” you get a vague description or a weird image that looks nothing like a card. The model needs explicit constraints: size, bleed, font hierarchy, logo placement, and the exact text fields. Without those, the output is unusable for print.

I started with a prompt that said “create a modern business card for a freelancer”. The result was a colorful illustration with no space for contact info. Adding the line “use a 3.5 × 2 inch canvas, 0.125 inch bleed, place the name in bold 24 pt Helvetica at the top, title below in 14 pt, email and phone at the bottom left, logo bottom right” gave the model a clear grid to follow. The difference was night and day.

What most guides get wrong

Many tutorials suggest feeding the prompt straight into an image generator like DALL·E or Stable Diffusion and calling it a day. Those models excel at art but ignore typography rules; they often render letters as shapes, making the text illegible when printed. I tried that path and ended up with cards that looked like abstract art—definitely not what I handed out at the conference.

One concrete gripe: the free tier of the image API I tested capped resolution at 512 × 512 pixels, which is far too low for a 300 DPI print file. Upscaling introduced blur and made the text look pixelated. That limitation forced me to look for a vector‑friendly approach.

Instead, I switched to a text‑to‑layout method: the AI returns a structured JSON describing each element’s coordinates, fonts, and colors. A separate rendering engine then draws the card using those instructions. This keeps the text sharp and fully editable.

It works.

Concrete example: a real prompt and tool chain

Here is the prompt I use with Claude 3 (first mention bolded). It returns a JSON object that matches a predefined schema:

1. Open a Google Sheet with columns: Name, Title, Email, Phone, Company, LogoURL.
2. For each row, build a prompt string:
   Return a JSON object with fields: name (string), title (string), email (string), phone (string), logo_url (string), layout: {name: {font: "Helvetica Bold", size: 24, x: 0.125, y: 0.25}, title: {font: "Helvetica", size: 14, x: 0.125, y: 0.5}, email: {font: "Helvetica", size: 12, x: 0.125, y: 0.75}, phone: {font: "Helvetica", size: 12, x: 0.125, y: 0.9}, logo: {x: 2.5, y: 0.25, width: 0.75, height: 0.5}}. Use units in inches. The card size is 3.5×2 inches with 0.125 in bleed.
3. Send the prompt to Claude 3 via its API (temperature 0.2, max tokens 500).
4. Parse the JSON response; if any field is missing or malformed, log the error and skip that row.
5. Feed the parsed data into PDFMonkey (first mention bolded) using its template language to draw rectangles and text at the exact coordinates.
6. PDFMonkey outputs a PDF; store it in a Google Drive folder named “Business Cards”.
7. Optionally, email the PDF to the contact using Gmail’s API.

Each step runs in Make (formerly Integromat) (first mention bolded) as a scenario: the Google Sheets watcher triggers the flow, the HTTP module calls Claude, a JSON parser validates the output, and the PDFMonkey module creates the file. The whole scenario takes about 90 seconds for a batch of 50 cards.

What I love about this chain is that the text stays vector‑sharp because PDFMonkey draws actual PDF text objects, not rasterized images. I can open the output in Illustrator and adjust kerning if needed, which saved me hours of rework after the event.

How to debug when this breaks

When a card comes out misaligned, the first place to check is the JSON from Claude. Look for missing fields or swapped coordinates—often a typo in the prompt causes the model to omit the “layout” object. I keep a small validator step that throws an error if the layout key is absent.

If the PDF looks fine but the text is blurry, verify that PDFMonkey’s template is using the “text” element, not an “image” element. I once accidentally mapped the name field to an image placeholder, which rendered the text at 72 DPI and made it fuzzy on print.

Another common hiccup is the Google Sheet watcher firing on every edit, causing duplicate runs. Adding a filter that only processes rows where a “Processed” checkbox is unchecked stops the loop.

Finally, watch the API rate limits: Claude 3 allows 50 requests per minute on the default plan. If you exceed it, the scenario will pause and you’ll see a 429 response. I added a delay of 1.2 seconds between calls to stay safely under the limit.

Cost and value: price mention with opinion

Here’s what I spend each month to keep the automation running:

• Google Workspace (Sheets, Drive, Gmail): $12 per user (already have it).
• Make.com core plan: $29 per month – gives enough operations for ~5 000 card generations.
• Claude 3 API: $0.008 per 1 000 tokens; my average call uses ~650 tokens, so ~$0.005 per card. For 500 cards that’s $2.50.
• PDFMonkey: $9 per month for 1 000 PDFs.
• Total recurring cost: roughly $50 per month.

I think $50/mo is fair for a system that saves me at least ten hours of manual design work each month. If you only need a handful of cards, the free tiers of Make.com and PDFMonkey might cover you, but you’ll hit limits fast.

Adjacent reading: AI meeting tools coverage.

Final thoughts

You now have a clear, step‑by‑step method to turn a list of contacts into print‑ready business cards using AI and no‑code tools. Follow the prompt, watch the JSON, and let the rendering engine do the heavy lifting. 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.