In today’s fast-paced business environment, manual document creation can be a significant time sink for sales teams and administrators. Fortunately, automation platforms like Make.com (formerly Integromat) offer potent solutions for streamlining these processes. Today, we’re exploring how to build a powerful Make.com scenario that connects with PandaDoc to automate document generation with dynamic pricing tables.
I want to thank Jono Catliff for his work on this scenario using Make.com and PandaDoc. His creative approach to automating document generation inspired this blog.
Click the play button below to learn more:
This make.com scenario represents an automation workflow that, when implemented, would create customized PandaDoc documents with dynamically populated pricing tables. This type of automation would be particularly valuable for businesses that regularly generate quotes, proposals, or invoices with varying product configurations.
By building this Make.com scenario, you could leverage the platform’s visual interface to create a seamless flow between your data sources and PandaDoc, enabling automated document creation without manual intervention. This would save valuable time for sales teams while ensuring consistency across all generated documents.
This scenario would be powered by the CustomWebHook module, designed to be triggered by an incoming webhook. When external systems or user actions send data to the dedicated webhook URL, the automation would spring into action. This makes the scenario incredibly versatile, as it could be integrated with CRMs, e-commerce platforms, or custom forms.
The webhook configuration would be set up to receive product and client information used to generate the document. The webhook module’s key advantage here is its ability to accept incoming data from virtually any system that can make HTTP requests, making it ideal for cross-platform integrations.
Once triggered, the first action in the workflow would use the PandaDoc module to retrieve a specific PandaDoc document template. This module connects directly to your PandaDoc account to access existing templates. Using templates would ensure brand consistency while allowing for dynamic content insertion.
This module was chosen because it creates the foundation upon which all subsequent modifications would be made. The template would contain placeholders for client information, pricing tables, and other variable content to be populated during the automation process.
The second module would use JSON to create a standardized JSON structure for PandaDoc pricing tables. This module was selected because it can build complex, nested JSON structures that follow PandaDoc’s required format, including:
This critical step would prepare the proper data structure expected by PandaDoc’s API for pricing tables. The JSON Creator module is ideal here because it handles the complex nesting and formatting required by the PandaDoc API without requiring manual JSON construction.
The third module would also use JSON to create another JSON structure representing the actual product data to be included in the document. This includes:
This second JSON Creator module was included to separate the source data format from the PandaDoc-specific format, making the scenario more flexible. Changes to the source data structure wouldn’t necessarily require changes to the PandaDoc structure.
Next, the scenario would use the JSON module to transform the structured data into manageable components. This module breaks down the JSON into individual elements easily accessed in subsequent steps.
The JSON Parser was chosen because it efficiently converts the JSON string into mapped items that Make.com can process individually. This is essential for the iterative processing that follows.
The workflow would then use two builtin modules to iterate through the parsed data:
These iterators are crucial because they allow the scenario to process each item individually, applying transformations and filters as needed. The BasicFeeder modules were chosen for their ability to loop through data arrays efficiently.
After processing the individual items, the scenario would use two builtin modules to reassemble the data:
These aggregators would include filtering to remove any products with prices of zero or missing prices.
The BasicAggregator modules were selected because they excel at collecting processed items from iterations and restructuring them into the desired format. They’re especially powerful when combined with filters that can exclude unwanted items from the final output.
The final step would use the pandadoc module to create a new document with the processed data. This module was chosen because it provides direct access to PandaDoc’s document creation API with all the necessary options:
The scenario would be configured not to automatically send the document (send = false), giving users the opportunity to review the generated document before sending it to clients. This specific configuration strikes a balance between automation and quality control.
The most obvious benefit would be reduced time spent creating manual documents. What takes 15-30 minutes to develop manually could be generated in seconds with this automation.
By automating the document creation process, this scenario would ensure consistent formatting and eliminate human errors in pricing calculations or product descriptions.
The scenario’s filter conditions in the BasicAggregator module would ensure that only relevant items appear in the final document. By filtering out products with zero prices or missing price information, the scenario would prevent irrelevant items from cluttering proposals.
Because the scenario would be triggered by a webhook, it could be integrated with virtually any system capable of making HTTP requests:
One of the most powerful aspects of this scenario would be its ability to transform data between different formats. By combining JSON creators, parsers, and aggregators, it would efficiently restructure incoming data to match PandaDoc’s specific API requirements.
The scenario would use multiple JSON-related modules (CreateJSON and ParseJSON) for good reason. The separation between data creation and parsing allows for:
You could customize these JSON modules to include additional product information or custom fields specific to your business needs.
The BasicFeeder and BasicAggregator modules would be the workhorses of this scenario. They were selected because:
You could customize the filters and mappings in these modules to implement complex business logic around pricing, product selection, and data transformation.
The final PandaDoc creation module could be customized to:
The scenario would include token fields for both senders and recipients, making it easy to personalize documents with the correct contact information. These tokens could be expanded to include additional personalization fields as needed.
The pricing table structure would include options for tax and discount settings, allowing for complex pricing scenarios. These settings could be customized at both the global level (for the entire table) and the individual product level.
To successfully implement this scenario, you would need:
When building this type of automation, thorough testing would be essential:
The scenario’s modularity would make it easier to test individual components before testing the entire workflow.
Make.com would allow this scenario to be configured for handling up to three errors before the scenario fails, with automatic retries. This would provide resilience against temporary API issues or network problems.
This PandaDoc automation scenario would be particularly valuable for:
Sales representatives could trigger document generation after customer calls, ensuring quotes are delivered promptly while information is fresh. The webhook could be connected to a CRM system to automatically generate documents when deals reach certain stages.
Online stores could automatically generate invoices or order confirmations with detailed product information. The JSON transformation capabilities would be especially useful for converting e-commerce product data into properly formatted pricing tables.
Consultancies and service providers could quickly generate proposals based on specific service packages selected by clients. The filtering capabilities would ensure that only the selected services appear in the final document.
Companies offering subscription plans could automate the creation of subscription agreements with the appropriate pricing tiers. The scenario’s ability to handle discounts and taxes would be particularly useful for complex subscription pricing models.
ThisPandaDoc Generator scenario would represent a powerful tool for businesses looking to streamline their document creation processes. Leveraging Make.com’s diverse modules—from webhooks to JSON processors to iterators and aggregators—would create a comprehensive solution for automating the generation of professional documents with dynamic pricing tables.
The careful selection of appropriate modules shows how Make.com’s component-based approach enables complex workflow automation without custom coding. Each module serves a specific purpose in the data flow, from initial capture to final document creation.
By implementing this type of scenario, businesses could focus more on building relationships and closing deals, rather than spending valuable time on manual document creation tasks. The result would be faster document turnaround times, fewer errors, and a more consistent customer experience.
© 2025, Ron Auer
Affiliate Disclaimers