---
title: "Server-Side Rendering From a Template: Headless CE.SDK in Node.js, Docker and cURL"
description: "A containerized render service with a queue, retries and idempotency keys. CSV in, PNG, PDF or MP4 out, callable from any language."
url: "https://img.ly/blog/server-side-rendering-headless-cesdk/"
type: "blog"
date: "2026-11-16"
author: "Graeme"
tags: ["CE.SDK","How-To","Creative Automation","Server-side Video"]
---

> This is the markdown version of [Server-Side Rendering From a Template: Headless CE.SDK in Node.js, Docker and cURL](https://img.ly/blog/server-side-rendering-headless-cesdk/). For all pages in one file, see [llms-full.txt](https://img.ly/llms-full.txt). For an index of all available pages, see [llms.txt](https://img.ly/llms.txt).

---

## What You Will Build: A Headless Render Service

By the end of this article you'll have yourself a render service that takes a CSV and a CE.SDK template and returns one finished file per row. You'll get a PDF, a PNG per page, or an MP4, depending on what you're after. This example runs in Docker Compose with a Redis queue, and even has retries with backoff. It also includes an idempotency key per row, so that a pesky crashed worker or a duplicate upload doesn't ruin your session with unnecessary renders or gaps in your work. You can call it over HTTP from Node.js, cURL or Python, so you have options when you build.

Demo: [Export using Renderer](https://img.ly/demos/export-using-renderer.md), IMG.LY's live demo of the CE.SDK Renderer that this service runs. Repo: the [headless render service repository on GitHub](https://github.com/imgly/blog-headless-render-service).

This guide is for anyone that has a template and a data source (like a CSV, a database, or an event stream) and needs images or video whipped up without a person in the loop. If throughput, failures and cost keep you up at night, then this is going to brighten your day.

The sample that gets generated in our demo is a personalized postcard, and can be chained together with direct mail for sending out your creations. [PostBuddy](https://img.ly/case-studies/postbuddy.md), a direct mail platform whose customers design their postcards in CE.SDK, measured a 4× performance difference in one A/B test between a designed postcard and a text-only one.

## Why Rendering a Thousand Files Is an Operations Problem

If you have a template and a thousand rows to get through, and another thousand to process tomorrow, then you probably already know that the render call is the easy part. The hard part is dealing with the fallout from a failed run when row 412 fails, when a worker dies halfway through, or, annoyingly, when someone uploads the same CSV twice.

The first port of call that most teams try is a headless browser that opens the editor page and exports one row at a time. This doesn't scale well because every row pays for a browser launch and a page load, and a crash in the middle leaves you scratching your head wondering which files completed.

Re-running causes hassles of its own because a simple loop renders the finished rows all over again, and manually intervening can miss files that were busy when the process died.

Done right, you'll end up with three checks:

- The output count equals the input count
- A re-run produces zero new files
- You know how many rows per minute one worker handles on your hardware

## Server-Side Rendering Options Compared: Browser Triggers, Hosted APIs, Your Own Headless Service

| Property                                | Browser render triggered per row                                | Hosted rendering API                                                                                                                        | Headless engine in your own service                                              |
| --------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| Where rendering runs                    | A headless browser your script drives                           | The provider's servers                                                                                                                      | Your containers, on your servers or cloud                                        |
| Same template as the interactive editor | Yes, if the page loads the same editor                          | No: templates live in the provider's own editor and format; a few import from Figma or HTML                                                 | Yes: the `.scene` file CE.SDK saves                                              |
| Image, PDF and video from one template  | Whatever the page can export, one browser per render            | Some cover all three; video-first services usually skip PDF, and PDF-first ones skip video                                                  | PNG, PDF and MP4 from the same service and scene format (MP4 needs a GPU worker) |
| Batch throughput                        | Limited by how many browsers you can keep running               | Capped by the provider's API limits, about 1 to 10 requests per second in the docs checked                                                  | Set by how many workers you run (measured below)                                 |
| Retries and idempotency                 | You build both around the browser script                        | Results come back by webhook or polling; none of the APIs checked offers an idempotency key for renders, so you deduplicate yourself        | BullMQ retries with backoff, one job id per row as the key                       |
| Data leaves your infrastructure         | No, if the browser runs on your servers                         | Yes: rows and assets go to the provider                                                                                                     | No: templates, rows and files stay in your containers                            |
| Cost model                              | Your compute plus the editor's license                          | Monthly plans with included credits, used per image or PDF page and per second or minute of video; most stop rendering when credits run out | SDK license ([pricing](https://img.ly/pricing.md)) plus your compute                              |
| Cold start                              | Browser launch and page load per row unless you keep pages open | Queue time on the provider's side: images in seconds, video in seconds to minutes; some offer a short sync mode for images                  | One engine start per worker (0.6 to 2 s in the test run), then per-row work only |
| What you have to operate                | A pool of headless browsers                                     | Nothing beyond your API client                                                                                                              | Redis, the API, the workers, and GPU hosts for video                             |
| What you have to build                  | The page, the browser driver, the queue and retries             | Templates in the provider's tool, plus the API calls                                                                                        | The worker, queue and API in this article                                        |

The issue with the browser approach is that although it reuses your editor, it turns the rendering step into managing a horde of browsers. Using a hosted API removes the operations work, yes, but it also moves your data to the provider and your templates into their preferred format. If you go with [your own headless service](https://img.ly/use-cases/headless-design-engine.md), you keep the editor's template and your data in the same place, and the cost is only your queue and workers that you run.

## Step 1: Map the Template Placeholders to Your Data

The template used here is IMG.LY's sample postcard from the renderer image. Its text already contains the variables `{{first_name}}`, `{{last_name}}`, `{{address}}` and `{{city}}`, and its photo block is named `photo` by `scripts/prepare-template.ts`. A mapping file knows which CSV column fills each one, and which column identifies a row:

```json
// templates/postcard.json
{
  "scene": "postcard.scene",
  "rowId": "recipient_id",
  "variables": {
    "first_name": "first_name",
    "last_name": "last_name",
    "address": "street",
    "city": "city"
  },
  "images": {
    "photo": "photo_url"
  }
}
```

```csv
# data/recipients.csv (header and first two rows)
recipient_id,first_name,last_name,street,city,photo_url
r-0001,Thandi,Mokoena,14 Kloof Street,Cape Town,
r-0002,Lukas,Brandt,Torstraße 112,Berlin,https://img.ly/static/ubq_samples/sample_1.jpg
```

The row id becomes the idempotency key, a file name and a job id, so it is limited to letters, digits, dashes and underscores. An empty `photo_url` keeps the template's photo by default. Filling a row sets each variable and swaps each image fill:

```typescript
// src/template.ts
export function fillRow(
  engine: CreativeEngine,
  mapping: TemplateMapping,
  row: Row
): void {
  for (const [name, column] of Object.entries(mapping.variables)) {
    engine.variable.setString(name, row[column] ?? '');
  }
  for (const [name, column] of Object.entries(mapping.images)) {
    const url = row[column];
    if (!url) continue;
    for (const block of engine.block.findByName(name)) {
      const fill = engine.block.getFill(block);
      engine.block.setSourceSet(fill, 'fill/image/sourceSet', []);
      engine.block.setString(fill, 'fill/image/imageFileURI', url);
      engine.block.setContentFillMode(block, 'Cover');
    }
  }
}
```

For your own template, all you need to do is add `{{name}}` placeholders to its text in the editor and name the image blocks that you want to replace. Then you'll just write the mapping. `npm run check:template` compares the scene, the mapping and the CSV header, and lists any placeholder that doesn't have a column before any rows are rendered.

## Step 2: Write the Render Worker in Node.js

The worker follows the pattern found in IMG.LY's [Node processing before export](https://img.ly/docs/cesdk/renderer/get-started/node-processing-a2e4dc.md) guide: `@cesdk/node` loads the template and fills the row, and then saves the result as a scene archive. The [CE.SDK Renderer](https://img.ly/docs/cesdk/renderer/cesdk-renderer-overview-7f3e9a.md) binary is what exports the archive. Image URLs from the row are fetched during the export, and that's where a dead URL will fail: the renderer cancels the export, exits with code 1 and names the error on stderr as `FILE_FETCH_FAILED`, followed by the URL.

```typescript
// src/worker.ts
export async function startWorker(): Promise<Worker> {
  const engine = await CreativeEngine.init({ license: process.env.CESDK_LICENSE });

  return {
    async render(template, row, format) {
      const rowId = row[template.mapping.rowId];
      // ...
      await engine.scene.loadFromString(template.scene);
      // ...
      // The idempotency check: a row whose files are all there is done.
      // Only finished renders get their final name, so this never skips a
      // file that a crashed worker left half written.
      if ((await Promise.all(outputs.map(({ file }) => exists(join(outDir, file))))).every(Boolean)) {
        return { rowId, files, skipped: true, fillMs: 0, renderMs: 0 };
      }

      fillRow(engine, template.mapping, row);
      const archive = join(tmpdir(), `${rowId}-${randomUUID()}.zip`);
      await writeFile(archive, Buffer.from(await (await engine.scene.saveToArchive()).arrayBuffer()));
      // ...
          const final = join(outDir, file);
          const partial = `${final}.${randomUUID()}.part`;
          const args = ['--input', archive, '--output', partial, '--output-mime-type', MIME_TYPES[format]];
          if (page !== undefined) args.push('--page', String(page));
          // ...
            await run(RENDERER, args);
            await rename(partial, final);
```

There are three choices you need to make when you start processing large volumes. The engine starts once per worker and is reused for every row. Each file is written under a `.part` name and then renamed only when the renderer exits cleanly. This makes sure that a file with its final name is always a complete render. The worker skips a row if that file already exists, which makes this the second idempotency layer after the queue.

If you run it as a script then the same file loops over the CSV with one worker:

```typescript
// src/worker.ts
    for (const row of rows) {
      try {
        const result = await worker.render(template, row, format);
```

That loop is good enough for a one-off batch, but the next three steps make it safe to run every night.

## Step 3: Add a Queue With Retries and Idempotency Keys

`src/queue.ts` puts one BullMQ job on Redis per CSV row, and the job id is the idempotency key. It gets built from the template, the row id and the format:

```typescript
// src/queue.ts
export function jobKey(
  template: string,
  rowId: string,
  format: Format
): string {
  return `${template}.${rowId}.${format}`;
}

export function openQueue(connection: Redis = connect()): RenderQueue {
  return new Queue(QUEUE_NAME, {
    connection,
    defaultJobOptions: {
      // Three tries in all: the first, then 5 s and 10 s later.
      attempts: 3,
      backoff: { type: 'exponential', delay: 5_000 },
      // Finished jobs stay for a day so their status can be read and a repeat
      // post is recognized. After that the worker's file check still skips them.
      removeOnComplete: { age: 24 * 3600 },
      removeOnFail: { age: 7 * 24 * 3600 },
    },
  });
}
```

Adding a row that already has a job doesn't change anything, so if you post the same CSV twice then there won't be any new work queued up. A job that fails is retried instead of being skipped:

```typescript
// src/queue.ts
const existing = await queue.getJob(jobId);
if (existing) {
  // A failed job keeps its id, and BullMQ ignores an add with an id it
  // already has. Retry the failed job instead.
  if (await existing.isFailed()) {
    await existing.retry('failed');
    results.push({ rowId, jobId, status: 'retried' });
  } else {
    results.push({ rowId, jobId, status: 'exists' });
  }
  continue;
}
await queue.add(
  'render',
  { template: template.name, rowId, row, format },
  { jobId }
);
```

Not every failure deserves a retry. Think of a row id that isn't valid or a template that doesn't exist: they fail the same way every time, so we want them to end the job right away instead of spamming the same failure through the whole job. An image URL that returns nothing (the renderer's `FILE_FETCH_FAILED`) still gets its retries, since the host might only be down for a moment:

```typescript
// src/queue.ts
const PERMANENT = [
  // Not FILE_FETCH_FAILED: an image host can be down for a moment, so it gets the retries.
  'Invalid row id',
  'Unknown template',
];
```

Each of the workers renders one job at a time (one engine), and if things are a bit sluggish, then you can add workers to speed things up. If a worker dies in the middle of a render, then another worker takes its job over once the job's lock runs out (which was about a minute in the test run). In the test run a broken renderer path was tried at 0 s, 10.4 s and 20.8 s which was then marked failed. A dead photo URL was tried three times and failed 22.7 s after it was queued, which is what we wanted for that test case.

## Step 4: Expose the Service Over HTTP

`src/api.ts` is an Express 5 app as found in IMG.LY's [Express.js renderer guide](https://img.ly/docs/cesdk/renderer/get-started/expressjs-9f25eb.md), except the difference is that it queues work instead of rendering in the request. `POST /render` takes JSON or a CSV body, `GET /jobs/:id` reports one job, `GET /queue` reports the queue depth and `GET /files/...` gives us the finished files. Each row gets checked before anything is queued:

```typescript
// src/api.ts
// Reject the whole request if any row is unusable, so a batch is never half queued.
const problems: string[] = [];
const seen = new Set<string>();
for (const [i, row] of rows.entries()) {
  const missing = missingColumns(template.mapping, row);
  const rowId = row[template.mapping.rowId] ?? '';
  if (missing.length > 0)
    problems.push(`Row ${i + 1} has no ${missing.join(', ')}`);
  else if (!ROW_ID_PATTERN.test(rowId))
    problems.push(`Row ${i + 1}: invalid ${template.mapping.rowId} "${rowId}"`);
  else if (seen.has(rowId))
    problems.push(
      `Row ${i + 1}: ${template.mapping.rowId} "${rowId}" appears twice`
    );
  seen.add(rowId);
}
```

Queue a CSV:

```bash
curl -X POST "http://localhost:8080/render?template=postcard&format=pdf" \
  -H "Content-Type: text/csv" --data-binary @data/recipients.csv
```

The answer here is `202 Accepted` and there is one entry per row. `status` is `queued`, `exists` (already waiting, running or done) or `retried`. For one row, the response looks like this:

```json
{
  "template": "postcard",
  "format": "pdf",
  "queued": 1,
  "exists": 0,
  "retried": 0,
  "jobs": [
    {
      "rowId": "r-0001",
      "jobId": "postcard.r-0001.pdf",
      "status": "queued",
      "statusUrl": "/jobs/postcard.r-0001.pdf"
    }
  ]
}
```

`GET /jobs/postcard.r-0001.pdf` after the row is rendered, from the test run:

```json
{
  "jobId": "postcard.r-0001.pdf",
  "template": "postcard",
  "rowId": "r-0001",
  "format": "pdf",
  "state": "completed",
  "attempts": 1,
  "files": ["/files/postcard/r-0001.pdf"],
  "skipped": false,
  "error": null,
  "createdAt": "2026-11-13T13:17:04.779Z",
  "startedAt": "2026-11-13T13:17:04.784Z",
  "finishedAt": "2026-11-13T13:17:15.950Z"
}
```

A failed job has `state: "failed"` and the reason in `error`, like `FILE_FETCH_FAILED`. The API has no authentication in this demo, so Compose binds it to localhost. You will need to put it behind your own gateway before opening it to a network.

## Step 5: Run It in Docker and Scale Workers

The service image is IMG.LY's renderer image (`imgly/cesdk-renderer`) with Node.js added, so the worker and the renderer binary both sit in the same container. Compose runs Redis (with an append-only file, so queued or finished jobs can survive a restart), the API, and two workers that share a volume for the renders:

```yaml
# docker-compose.yml
services:
  # ...
  worker:
    image: headless-render-service:local
    command: ['node', 'src/queue.ts', 'work']
    # CESDK_LICENSE. Without it, output is watermarked.
    env_file: .env
    environment:
      REDIS_URL: redis://redis:6379
    volumes:
      - renders:/app/output
    # ...
    deploy:
      replicas: 2
    # docker compose stop sends SIGTERM; the worker finishes its row first.
    stop_grace_period: 60s
    restart: unless-stopped
```

```bash
docker compose up -d --build
docker compose up -d --scale worker=4
docker compose logs -f worker
```

Renders go to a named volume because the renderer image runs as a non-root user, and a bind-mounted folder on Linux usually isn't writable by it. You can watch progress with `GET /queue` or you can look at the worker logs to see how the run is going. In this test run example when we ran `docker kill` on one of the two workers, with two active rows and then `docker compose up -d`, we still ended up with 12 of 12 rows rendered. That gave us files that rendered once and left no `.part` files behind. With three workers running, `docker compose stop worker` allowed the three active rows to finish before the workers exited.

## Step 6: Call the Render Service From Node.js, cURL and Python

The three clients post the CSV, check each unfinished job every two seconds, download finished files and exit with an error if any rows fail. Here is the request that queues the batch, written in each language. The full files are in the repo's README.

```typescript
// examples/node.ts
const batch = await call<Batch>(`/render?template=postcard&format=${format}`, {
  method: 'POST',
  headers: { 'Content-Type': 'text/csv' },
  body: await readFile(csvPath, 'utf8'),
});
```

```bash
# examples/curl.sh
if ! batch=$(curl -sS --fail-with-body -X POST "$BASE_URL/render?template=postcard&format=$FORMAT" \
  -H "Content-Type: text/csv" --data-binary "@$CSV"); then
  echo "$batch" >&2
  exit 1
fi
```

```python
# examples/python.py
batch = call(f"/render?template=postcard&format={fmt}", Path(csv_path).read_bytes(), "text/csv")
print(f"queued {batch['queued']}, already there {batch['exists']}, retried {batch['retried']}")
```

The Node.js version doesn't need any packages, and the Python version only uses the standard library. The cURL version needs curl 7.76 or later and `jq` for it to run. When we ran the tests, each client rendered 12 out of 12 rows, and running a client again printed `already there 12`. It downloaded the files successfully without rendering anything because it already knows that the files are available.

## Step 7: Render Video From the Same Service

The one difference for a video template is that the output `mp4` maps to `video/mp4` and a row produces one file. The worker asks the renderer for access to the GPU. IMG.LY's [compatibility page](https://img.ly/docs/cesdk/renderer/compatibility-139ef9.md) says an NVIDIA GPU is "required for video export", and without the flag the renderer falls back to the CPU, where a video can stall or crawl rather than just render slowly. With the flag, the job fails at once on a worker with no GPU:

```typescript
// src/worker.ts
const MIME_TYPES: Record<Format, string> = {
  pdf: 'application/pdf',
  png: 'image/png',
  mp4: 'video/mp4',
};
```

```typescript
// src/worker.ts
if (format === 'mp4') args.push('--render-device', 'gpu');
```

The template, mapping and CSV work the same as in Step 1, and the template is IMG.LY's sample surf school ad from the renderer image. We turned three of its texts into variables:

```json
// templates/surf-school.json
{
  "scene": "surf-school.scene",
  "rowId": "school_id",
  "variables": {
    "location": "location",
    "call_to_action": "call_to_action",
    "website": "website"
  },
  "images": {}
}
```

```bash
curl -X POST "http://localhost:8080/render?template=surf-school&format=mp4" \
  -H "Content-Type: text/csv" --data-binary @data/surf-schools.csv
```

On a Linux host with the NVIDIA Container Toolkit, IMG.LY's [troubleshooting page](https://img.ly/docs/cesdk/renderer/get-started/troubleshooting-0t9fl1.md) asks for both `runtime: nvidia` and a device reservation on the service. Both are in `docker-compose.yml`, commented out.

<div class="image-column">

![Two frames of the Jeffreys Bay surf school video: the title Jeffreys Bay Surf School over a soft light burst, then Join the Camp over a drone shot of a surfer, each with the website jb.example at the bottom](https://img.ly/_astro/surf-school-video-frames.BzRcPnhc.webp)

</div>

_Two frames of `s-0002.mp4`, rendered from the row for Jeffreys Bay, at 4 s and 17 s. The video is 20.5 s at 1080 × 1920._

## How to Verify: Counts, Re-Runs and Throughput

`src/verify.ts` runs three checks against the running stack: every row has its files, a re-post doesn't make any new files, and a re-post after the jobs are gone (as after the 24 hours a finished job is kept, or a lost Redis) doesn't make any new files either.

```bash
docker compose exec api node src/verify.ts
```

Here is the output on a fresh stack in the test run:

```text
Rows in data/recipients.csv: 12. Format: pdf. Files per row: 1
Check 1, output equals input: 12 of 12 rows have their files (12 files), 0 failed, 0 .part files: PASS
Check 2, re-post: 0 queued, 12 already there, 0 failed before and retried; 0 new files, 0 changed: PASS
Check 3, re-post after the jobs are gone: 12 queued, 12 skipped by the workers, 0 failed before and retried; 0 new files, 0 changed: PASS
```

In this example, the video template passes the same three checks with `node src/verify.ts data/surf-schools.csv mp4 templates/surf-school.json`. You can see 3 of 3 rows, then zero new or changed files were detected on both re-posts.

To check on the throughput, `scripts/load-test.ts` posts 50 new rows and then records the time it takes per row and the peak memory used per worker, along with the machine spec. These are example figures that came from one laptop, rendering on the CPU:

<div class="table-fill">

| 50 postcard PDFs             | 1 worker             | 2 workers            | 4 workers            |
| ---------------------------- | -------------------- | -------------------- | -------------------- |
| Throughput                   | 10.1 rows per minute | 16.4 rows per minute | 20.7 rows per minute |
| Time per row, median and p95 | 4.8 s and 10 s       | 5.8 s and 16.5 s     | 9.3 s and 26.1 s     |
| Peak memory per worker       | 544 MiB              | 537 to 538 MiB       | 524 to 567 MiB       |

</div>

_Intel Core i7-4710MQ (8 logical cores), 15.7 GB RAM, Windows 10, Docker Desktop with 8 CPUs and 7.6 GiB, no GPU._

Gains get smaller at four workers on that example machine (in my defense, it is a ThinkPad and they last forever). Each row takes longer because the workers share eight cores on this test rig. When it comes to video output we used one worker on a desktop with an Intel Core i7-6700K, 15.9 GB RAM and a GeForce GTX 1070, and that took 20 to 29 s per 20.5 s MP4, with a peak of 1.6 GiB per worker.

To size your own deployment, run `scripts/load-test.ts` on your own instance, and compare video jobs with the expected processing times on IMG.LY's [benchmarks page](https://img.ly/docs/cesdk/renderer/get-started/benchmarks-b3n4ch.md#expected-processing-times).

## When a Script or a Browser Export Is the Better Choice

If you have one batch of a few hundred files and will not run it again, you can skip the queue and the API. All you need to do is run `node src/worker.ts` on the CSV and the file check will still let you restart it after a crash, without duplicates.

If the render is one file for one user who just finished editing it, then you can render it where the user is. CE.SDK processes on the client side by default, so the editor can export the file in the user's browser.

## FAQ: Headless Rendering With CE.SDK

### How many renders per minute can one worker do?

On the ancient test laptop, one CPU-only worker rendered 10.1 two-page postcard PDFs per minute, at a median of around 4.8 s per row. Templates, formats and better hardware change those stats, so try running `scripts/load-test.ts` on your own machine and compare. To put things into perspective, Swiss Post's customers design over 1 million personalized postcards every year with CE.SDK, and [Plai](https://img.ly/case-studies/plai.md)'s users export more than 30,000 ad creatives a month on its platform.

### What happens if a worker dies mid-batch?

The way it works is that another worker takes over its job once the job's lock runs out. Files are renamed from `.part` to the final file extension only once it has completed, and workers skip rows where a file already exists. This makes it possible for the interrupted row to be rendered once and nothing else twice. A job that stalls twice is marked as failed and the row will need to be posted again for a retry.

### Can I render video and images from the same template?

The same service renders PNG, PDF and MP4, and the format is a parameter on each request. The sample uses a separate video template because a video scene has a timeline, clips and audio that a postcard doesn't have. MP4 jobs will need a GPU worker and on a worker that doesn't have one they fail instead of rendering on the CPU.

### How much memory does a worker need?

In the test runs, a postcard PDF worker peaked between 524 and 567 MiB, and a video worker rendering a 1080 × 1920 MP4 peaked at 1.6 GiB. IMG.LY's [compatibility page](https://img.ly/docs/cesdk/renderer/compatibility-139ef9.md) gives 4 GiB of system memory as the minimum for the host, with more for complex scenes and high resolutions.

### Does the template have to be built in the editor or can I create it in code?

Either will work. The engine has APIs for creating scenes and blocks in code, and the result saves to the same [`.scene` format](https://img.ly/glossary/scene-file.md). Building it in the editor helps to keep the layout decisions with designers, and they add the `{{variables}}` as well as name the image blocks; the service only fills them in.

### How do I add fonts?

The template references the fonts that a designer picked, so every font file it points at must be reachable from the worker. A scene archive packages a scene with its assets, including the fonts, which is described in IMG.LY's [scene archive docs](https://img.ly/docs/cesdk/node/open-the-editor/import-design/from-archive-dde9fa.md). The sample templates use font files that ship inside the renderer image, and you can set a font from code with [`engine.block.setFont`](https://img.ly/docs/cesdk/node/api/node/classes/blockapi.md#setfont).

## Glossary: Rendering Service Terms

**Headless.** Running the engine with no user interface, from a script or a server process. See [headless mode](https://img.ly/glossary/headless-mode.md).

**Idempotency key.** A value that identifies one unit of work, so doing it twice has the same effect as doing it once. Here it is the template, row id and format.

**Backoff.** Waiting longer before each retry of a failed job, here 5 s and then 10 s.

**Worker.** A process that takes jobs from the queue and renders them, one at a time in this service.

**Queue depth.** The number of jobs waiting, running or delayed for a retry. `GET /queue` reports it.

**Placeholder.** A part of a template meant to be replaced per row, such as an image block named `photo`. See [placeholder](https://img.ly/glossary/placeholder.md).

**Variable.** A named text value, written `{{name}}` in a template's text and set with `engine.variable.setString`. See [text variable](https://img.ly/glossary/text-variable.md).

**Scene archive.** A zip file holding a scene and the assets it uses. See [scene archive](https://img.ly/glossary/scene-archive.md).

**Cold start.** The time a new worker spends starting its engine before it can render its first row.

## Next Steps

Clone the [headless render service repository](https://github.com/imgly/blog-headless-render-service) and run `docker compose up -d --build`, then post the sample CSV. The [CE.SDK Renderer docs](https://img.ly/docs/cesdk/renderer/cesdk-renderer-overview-7f3e9a.md) cover the different container variants as well as the GPU setup, and the [Node.js quick start](https://img.ly/docs/cesdk/node/get-started/overview-e18f40.md) covers the engine details. For where this fits in a bigger pipeline, see IMG.LY's [creative automation](https://img.ly/use-cases/creative-automation.md) and [server-side video rendering](https://img.ly/use-cases/server-side-video-rendering.md) use cases. To try it with your own templates, [get started](https://img.ly/get-started.md) without a trial key; until you add a license key, the renders carry a watermark.

---

## More Resources

- **[IMG.LY Website](https://img.ly/index.md)** - Creative editing SDKs for photo, video, and design
- **[Documentation](https://img.ly/docs/cesdk/)** - CE.SDK developer documentation
- **[Build with a coding agent](https://img.ly/SKILL.md)** - A skill that adds a CE.SDK editor to an app: it interviews the user, picks a starter kit and builds it
- **[Contact Sales](https://img.ly/forms/contact-sales.md)** - Get a custom quote. A public JSON API accepts the request directly, no account or key needed. Ask your user for consent and their details first.
