# Builder vs. Code Templates


PDFMonkey offers two ways to create templates: the visual **[Builder](../builder-templates/)** and **[Code Templates](../code-templates/)** written in HTML, CSS, and Liquid. Both produce the same high-quality PDFs. The difference is how you design them, and you'll want to pick the right approach before you start.

## Comparison at a glance {#builder-vs-code-templates}

|                    | Builder                              | Code Templates                             |
| ------------------ | ------------------------------------ | ------------------------------------------ |
| **Design method**  | Visual drag-and-drop                 | Write HTML, CSS, and Liquid                |
| **Dynamic data**   | Logic panel (conditions, repetition) | Liquid tags (`{% if %}`, `{% for %}`)      |
| **Styling**        | Styles panel + Custom CSS editor     | Full CSS control in the template           |
| **JavaScript**     | Custom JS editor + External Assets   | `<script>` tags in template HTML           |
| **Learning curve** | Lower, no coding required            | Higher, requires HTML/CSS/Liquid knowledge |
| **PDF renderer**   | Chromium                             | Chromium                                   |
| **Output quality** | Identical                            | Identical                                  |

## When to use the Builder {#when-to-use-the-builder}

The [Builder](../builder-templates/) is a good fit when:

- You want to create standard business documents (invoices, receipts, certificates, reports) without writing code.
- Non-technical team members need to create or edit templates.
- You want a point-and-click workflow instead of writing markup.
- Your layout needs are straightforward: headers, text content, images, tables, and repeated sections.

## When to use Code Templates {#when-to-use-code-templates}

[Code Templates](../code-templates/) are a better choice when:

- You're comfortable with HTML and CSS. You'll move faster writing markup directly than dragging blocks around.
- You need pixel-perfect control over complex multi-page layouts with custom page breaks.
- Your documents require advanced Liquid logic: nested loops, custom filters, or complex conditionals.
- You have existing HTML and CSS that you want to reuse.
- You need features not yet available in the Builder.

## The Builder does not use Liquid {#the-builder-does-not-use-liquid}

Builder templates use **Vue** under the hood, not Liquid. This means Liquid syntax like `{% if %}`, `{% for %}`, and Liquid filters (`| upcase`, `| date`) will not work in the Builder. Dynamic data is handled through Vue's template engine and the Logic panel instead.

One practical consequence: **variable names that start with a number** are not valid JavaScript identifiers, so you cannot write `{{123varname}}` in a text binding. Use the bracket notation on the payload object instead:

```
{{$docPayload['123varname']}}
```

If you are coming from Code Templates, keep in mind that any Liquid-specific pattern will need to be rethought for the Builder's Vue-based approach.

## Can I switch between them? {#can-i-switch-between-them}

Short answer: no. Builder templates and Code Templates are separate template types. You cannot convert a Builder template into a Code Template or vice versa. Choose the approach that fits your use case before you start designing.

> [!TIP]
> Not sure which to pick? Start with the Builder. If you hit a limitation, you can always create a new Code Template for that specific document. Many teams use both approaches for different document types.


## How the Builder works under the hood {#how-the-builder-works}

The Builder combines Vue components, Tailwind CSS utility classes, and Chromium rendering to turn your visual design into a PDF. You never need to interact with these technologies directly. Both Builder and Code Templates use the same Chromium engine, so the final PDF quality is identical. For details on engine versions and capabilities, see [Our Engines](../code-templates/our-engines.md).

## What PDFMonkey does not support {#what-pdfmonkey-does-not-support}

PDFMonkey does not support importing existing PDF, Word, or other file formats. Templates must be built from scratch, either using the visual Builder or by writing HTML, CSS, and Liquid in Code Templates.


## FAQ

**What is the difference between Builder and Code Templates in PDFMonkey?**

The Builder is a visual drag-and-drop editor that uses Vue under the hood. Code Templates are written in HTML, CSS, and Liquid. Both produce identical high-quality PDFs. The Builder is easier for non-developers; Code Templates offer more layout control and advanced logic.

**Can I convert a PDFMonkey Builder template to a Code Template?**

No. Builder templates and Code Templates are separate types and cannot be converted between each other. Choose your approach before you start designing.

**Does the PDFMonkey Builder use Liquid?**

No. Builder templates use Vue, not Liquid. Liquid syntax like {% if %}, {% for %}, and Liquid filters will not work in the Builder. Dynamic data is handled through Vue's template engine and the Logic panel.
