Automate Kudos/Recognition certificates generation to PDF

Hey team, Darian Vance here. Let’s talk about a small task that can quietly spiral out of control: recognition certificates. Our ‘Kudos’ program is fantastic for morale, but someone has to actually make the certificates. For a while, that someone was me, and I was manually editing a template and exporting a dozen PDFs every single Friday. It was a 30-minute task that broke my focus and was prone to typos. I finally automated it, and now it takes zero minutes of my time. This is a classic DevOps win: automate the repetitive stuff so you can focus on the real engineering challenges. Let me show you how you can get that time back.

Prerequisites

Before we jump in, make sure you have the following ready:

• Python 3 installed on your system.
• A code editor you’re comfortable with.
• A certificate template image (PNG or JPG format).
• A TrueType Font file (.ttf) for the text you want to use.

The Step-by-Step Guide

We’re going to build a Python script that reads names from a list, writes them onto our template image, and saves each one as a separate PDF. Simple, effective, and very powerful.

Step 1: Project Setup

First, get your project folder organized. I usually create a main directory, let’s call it cert_generator. Inside, I like to have a clear structure:

• output/: This is where our finished PDF certificates will be saved.
• assets/: A place to store your certificate template image and your font file.

I’ll skip the standard virtualenv setup since you likely have your own workflow for that. The main library we need is Pillow, which is fantastic for image manipulation in Python. Go ahead and install it in your environment. You can typically do this by running pip install Pillow in your terminal.

Step 2: Prepare Your Data Source

We need a list of people to recognize. The easiest way to manage this is with a simple CSV file. Let’s create a file named recipients.csv in the root of your project folder. The structure should be straightforward:

name,reason,date
"Alicia Keys","For outstanding debugging on the new microservice","2023-10-26"
"Bob Marley","For excellent teamwork during the production outage","2023-10-26"
"Carlos Santana","For mentoring the new junior engineers","2023-10-26"

Step 3: The Python Script

Now for the core logic. Create a new Python file, let’s call it generate_certs.py, in your root project directory. We’ll build this script piece by piece.

First, we import the necessary libraries and set up our file paths. Using constants at the top makes the script much easier to maintain later.

import csv
from PIL import Image, ImageDraw, ImageFont

# --- Configuration ---
TEMPLATE_PATH = "assets/certificate_template.png"
FONT_PATH = "assets/Arial.ttf"
OUTPUT_DIR = "output/"
RECIPIENTS_CSV = "recipients.csv"

# --- Main Logic ---
def create_certificate(name, reason, date):
    """Generates a single certificate PDF for a recipient."""
    try:
        # Load the template image
        img = Image.open(TEMPLATE_PATH).convert("RGB")
        draw = ImageDraw.Draw(img)

        # Load fonts
        # You might need different sizes for different text elements
        name_font = ImageFont.truetype(FONT_PATH, size=60)
        reason_font = ImageFont.truetype(FONT_PATH, size=30)
        date_font = ImageFont.truetype(FONT_PATH, size=25)

        # --- Text Placement (X, Y coordinates) ---
        # These coordinates will depend entirely on your template image.
        # (0,0) is the top-left corner.
        draw.text((600, 450), name, font=name_font, fill="black", anchor="ms")
        draw.text((600, 580), reason, font=reason_font, fill="black", anchor="ms")
        draw.text((350, 720), date, font=date_font, fill="black", anchor="ms")

        # Save the certificate as a PDF
        # We sanitize the name to create a valid filename
        safe_filename = "".join(c for c in name if c.isalnum() or c in (' ', '.')).rstrip()
        output_path = f"{OUTPUT_DIR}{safe_filename}_certificate.pdf"
        img.save(output_path, "PDF", resolution=100.0)
        print(f"Successfully created certificate for {name}")

    except FileNotFoundError as e:
        print(f"Error: Could not find a required file. {e}")
    except Exception as e:
        print(f"An unexpected error occurred for {name}: {e}")

if __name__ == "__main__":
    print("Starting certificate generation...")
    try:
        with open(RECIPIENTS_CSV, mode='r', encoding='utf-8') as csvfile:
            reader = csv.DictReader(csvfile)
            for row in reader:
                create_certificate(row['name'], row['reason'], row['date'])
    except FileNotFoundError:
        print(f"Error: The data file {RECIPIENTS_CSV} was not found.")
        
    print("Script finished.")

Pro Tip: Finding Coordinates
The trickiest part is getting the text placement (`(X, Y)`) just right. My go-to method is simple trial and error. Open your template in a basic image editor (like MS Paint or Preview on Mac) which shows pixel coordinates as you move your mouse. Get a rough estimate, run the script for one person, and adjust the values until it looks perfect. The `anchor=”ms”` argument I used helps center the text horizontally, which makes life a lot easier.

Step 4: Running and Automating the Script

To run it manually, just navigate to your project directory in the terminal and execute the script:

python3 generate_certs.py

You should see it print a success message for each person in your CSV and find the generated PDFs in your output/ folder. For automation, a simple cron job is perfect. On a Linux-based server, you could set it to run every Monday at 2 AM with a line like this:

0 2 * * 1 python3 generate_certs.py

This “fire and forget” approach is what we’re aiming for. Now the process runs on a schedule without any manual intervention.

Common Pitfalls (Where I Usually Mess Up)

• Font Not Found: The script will fail if it can’t find the `.ttf` file. I always double-check that the `FONT_PATH` constant is correct and the file is actually in my `assets/` directory.
• Incorrect File Paths: In my production setups, I often use helper functions to build paths to ensure they work across different operating systems. For this simple script, just be careful with your slashes and relative paths.
• Long Text Overflow: The current script is simple and assumes the ‘reason’ text will fit on one line. If you have very long recognition messages, the text will run off the certificate. A more advanced version would include logic to wrap text into multiple lines, but for most “Kudos” programs, a single line is often enough.

Conclusion

And there you have it. We took a manual, error-prone task and turned it into a fully automated workflow with a simple Python script. This is a small project, but it perfectly captures the DevOps mindset: identify inefficiency, apply the right tools, and give yourself and your team more time to focus on what truly matters. Now go and get that time back!

Cheers,
Darian Vance

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions