How to Automate Invoice Generation with Make and Notion
Last year, I spent the first Sunday of every month copying sponsor details from my Notion database into a Google Docs template, exporting PDFs, and emailing them to accounting departments. When you run a few blogs and media channels as a solo business owner, small administrative tasks snowball into huge productivity sinks. Missing a payment because an invoice sat in your drafts folder for a week is painful, but spending three hours on manual copy-pasting is completely unnecessary.
I decided to automate invoice generation using Make (formerly Integromat) and Notion. Now, whenever I change an invoice status in Notion from Draft to Ready to Send, Make automatically generates a clean PDF invoice, attaches it to an email, sends it to the client, and updates the status in Notion to Sent. Here is the exact architecture I built, including the edge cases where things usually break.
The Database Structure in Notion
Before touching Make, your Notion workspace needs a clean database structure. The biggest mistake I made in my first build was mixing line items into page body content. Make reads structured properties easily, but parsing blocks inside a page requires complex API calls that make your scenarios fragile.
Set up a dedicated Notion database called Invoices with these specific properties:
| Property Name | Property Type | Purpose |
|---|---|---|
| Invoice ID | Title or Formula | Unique reference number (e.g., INV-2024-001) |
| Client Name | Text or Relation | Name of the company or sponsor |
| Client Email | Where the PDF invoice will be delivered | |
| Amount | Number | Total monetary value due |
| Due Date | Date | Payment deadline |
| Status | Select | Draft, Ready, Sent, Paid |
Keep your status tags clear. I use Draft while finalizing details, Ready to trigger the automation, Sent once the webhook executes successfully, and Paid when funds hit my business account.
Building the Automation in Make
To run this setup, you need a Make account connected to your Notion integration and an email module (such as Gmail, Email by Make, or custom SMTP). Make has a free plan that provides enough execution operations for small invoice volumes, while paid tiers start around the $9 to $10 per month range depending on billing cycles. Always verify current limits on the official Make pricing page before choosing a plan.
Step 1: Setting Up the Trigger Module
Log into Make and create a new scenario. Add the Notion app and select the module titled Watch Database Items or Search Objects.
- Connect your Notion account and select your Invoices database.
- Set the filter condition to trigger only when
StatusequalsReady. - Set the maximum limit to 5 records per run so you do not exceed API limits if you process invoices in batches.
Using a strict filter ensures Make only processes records that are completely filled out, preventing empty or partial PDF creation.
Step 2: Creating the Invoice Document
There are two primary ways to turn Notion data into a PDF inside Make: using Google Docs templates or using HTML conversion. Google Docs templates offer higher design precision for non-coders.
Create a template in Google Docs with dynamic placeholders enclosed in double curly brackets, such as {{Invoice_ID}}, {{Client_Name}}, {{Amount}}, and {{Due_Date}}. Format the page header, line item tables, and payment instructions exactly how you want them to appear.
In Make, add the Google Docs module called Create a Document from a Template:
- Select your Google Docs template file.
- Map the variables from your Notion module to the corresponding placeholders in Google Docs. For example, map the Notion
Invoice IDproperty to{{Invoice_ID}}. - Specify a target Google Drive folder where generated documents should temporarily live.
Follow this immediately with the Google Drive module called Download a File. Select the file created in the previous step and set the target format to PDF Document (.pdf).
Step 3: Emailing the PDF and Updating Notion
Once Google Drive exports the PDF binary data, add your email module—such as Gmail – Send an Email or Email by Make.
- In the To field, map the
Client Emailproperty from the Notion module. - In the Subject line, use dynamic text like
Invoice {{Invoice_ID}} - {{Client_Name}}. - In the Body, write a standard professional message including payment details and bank transfer instructions.
- In the Attachments section, select the file data output from the Google Drive download step.
Finally, append a Notion – Update a Page Item module to the end of your workflow. Set the input Page ID to the ID from the original trigger step, and update the Status property to Sent. This prevents the scenario from picking up the same invoice during the next run.
Common Technical Pitfalls and Workarounds
No automation system works perfectly on day one. During my first month running this system across my channels, I hit three specific technical walls that required adjustments.
1. Multi-line items are difficult in basic templates. If your invoice requires variable numbers of line items (e.g., three blog posts, two video integrations, and an editing fee), standard text replacement in Google Docs breaks down. To handle variable arrays of line items cleanly, you must either use an Iterator/Aggregator module combination in Make to construct an HTML table dynamically, or rely on specialized API tools like Docupilot or HTML-to-PDF converters.
2. Dynamic date formatting issues. Notion outputs dates in standard ISO timestamp format (e.g., 2024-10-15T00:00:00.000Z). If you pipe this directly into an invoice document, it looks unprofessional. Use Make’s built-in string functions inside the mapping field to clean it up: formatDate(date; YYYY-MM-DD).
3. Rate limits and sync delays. The Notion API can occasionally time out when fetching assets or updating statuses quickly. Always configure retry rules on your Make modules by right-clicking the module, selecting Error handler, and adding a Break directive to automatically retry failed requests after a delay.
My Take
Automating invoice generation with Make and Notion is one of the highest-yield workflows a solo operator can implement. It eliminates manual formatting, keeps financial records aligned with execution databases, and reduces the time between finishing a project and getting paid.
However, if your business model relies on heavily customized, dynamic line-item structures for every single transaction, building complex loops in Make can become frustrating. In those cases, using standard dedicated invoicing software like Wave, Quickbooks, or Stripe Invoicing might save you technical headaches. But for solo creators, media publishers, and consultants dealing with standard retainer or flat-rate sponsor agreements, the Notion and Make combo offers unmatched flexibility without recurring software bloat.
FAQ
Is Make better than Zapier for generating Notion invoices?
For document generation workflows, Make offers better control over data array mapping and conditional logic at a significantly lower operational cost. Zapier is slightly easier to configure initially, but Make’s visual canvas makes debugging complex PDF assembly paths much clearer.
Do I need a paid Make plan to automate invoices?
Not necessarily. If you only issue 10 to 20 invoices per month, Make’s free tier provides enough operations to run this scenario. However, if you require higher polling frequency, extra scenario steps, or advanced error handling features, paid plans start in the $9 to $10 monthly range. Check Make’s pricing page for current operation caps.
How do I handle tax calculations in this automated workflow?
The cleanest approach is calculating tax amounts directly inside Notion using Formula properties (e.g., Subtotal * TaxRate). Let Notion handle the math, then map those pre-calculated formula properties directly into your Make scenario variables for the document output.
