If you already have email templates in Amazon SES, you can export them and bring them into SendOps in a few minutes. Once imported, your templates are version-controlled in Git and managed entirely through SendOps — you won't need to create or edit templates directly in the SES console again.


  This is a one-time export to move your existing SES templates into a Git-based workflow. After the import, all template changes happen through your GitHub repository and are synced to SES automatically by SendOps.


## Prerequisites

Before you start, make sure:

- Your **AWS account is connected** to SendOps. If you haven't done this yet, see [Connecting AWS](/aws-setup/connecting-aws).
- You have at least one email template in your SES account.
- You have a GitHub account where you can create a new repository (or use an existing one).
- Your SendOps role has the **SES Template Export** permission. Owners, Org Admins, Infra Admins, and Developers can export. All roles can view the template list. See [Team Members & Roles](/team/members-and-roles) for details.

## Overview

The import workflow has four steps:

1. **Export** your SES templates from the SendOps dashboard as a zip file
2. **Unzip** and review the exported files
3. **Push** the files to a GitHub repository
4. **Connect** the repository in SendOps

From that point on, you edit templates in Git, push changes, and SendOps validates and deploys them to SES automatically — just like any other SendOps-managed template.

## Step 1: Export your SES templates

There are two places to start the export, depending on whether you've already connected a GitHub repository.

### If no GitHub repository is connected

When you open the **Templates** page and SendOps detects templates in your SES account, you'll see a prompt showing how many templates were found, with a **Download Templates** button.



Click **Download Templates** to open the export dialog.

### If a GitHub repository is already connected

If you've already connected a repository (perhaps with different templates, or an empty one), click the **Import from SES** button in the page header.



### The export dialog

The export dialog lists all email templates currently in your SES account. Review the list to confirm which templates will be included.

Click **Export All** to start the export. SendOps fetches each template from SES, converts it to a Handlebars file, generates a `sendops.json` manifest, and packages everything into a zip archive. This may take a moment depending on how many templates you have.

When the export completes, the zip file downloads automatically.

## Step 2: Review the exported files

Unzip the downloaded file. You'll find a `sendops-templates` folder with this structure:


```
sendops-templates/
├── sendops.json
├── templates/
│   ├── welcome-email.hbs
│   ├── welcome-email.txt
│   ├── order-confirmation.hbs
│   ├── password-reset.hbs
│   └── ...
├── .gitignore
└── README.md
```


### What's in the zip

| File | Purpose |
|------|---------|
| `sendops.json` | Manifest file that maps each template to its file path. SendOps reads this to know which files to sync. See [Manifest File](/templates/manifest-file) for the full format reference. |
| `templates/*.hbs` | Your SES template bodies exported as Handlebars files. HTML templates are saved as `.hbs` files. If a template has both HTML and plain-text bodies, the text version is saved as a separate `.txt` file alongside the `.hbs`. |
| `.gitignore` | Standard ignore rules for macOS and editor temporary files. |
| `README.md` | A quick-start reference with the basic steps. |

The `sendops.json` manifest is already formatted for SendOps — no manual conversion is needed. It maps each SES template name to its exported file:

```json
{
  "templates": {
    "welcome-email": {
      "path": "templates/welcome-email.hbs"
    },
    "order-confirmation": {
      "path": "templates/order-confirmation.hbs"
    }
  }
}
```

Notice that each manifest **key is the exact SES template name** — capitals, spaces, and symbols preserved — while the file on disk uses a **sanitized, lowercased** version of that name (non-alphanumeric runs become hyphens, and if two names sanitize to the same stem the second gets a `-2`, `-3`, … suffix). The key is what SES sees; the filename is just where the content lives in your repo.


  The exported manifest is a working starting point. You can customize it later — for example, to add test data profiles or rename templates. See [Manifest File](/templates/manifest-file) for all available options.


## Step 3: Push to GitHub

Initialize a Git repository in the exported folder and push it to GitHub.


  <Step title="Initialize the repository">
    Open a terminal in the `sendops-templates` folder and run:

    ```bash
    git init
    git add .
    git commit -m "Import SES templates"
    ```
  </Step>

  <Step title="Create a GitHub repository">
    Create a new repository on GitHub (public or private — SendOps works with both). You can do this from [github.com/new](https://github.com/new) or using the GitHub CLI:

    ```bash
    gh repo create my-email-templates --private --source=. --push
    ```

    If you created the repository on the web, add it as a remote and push:

    ```bash
    git remote add origin git@github.com:your-org/my-email-templates.git
    git branch -M main
    git push -u origin main
    ```
  </Step>


## Step 4: Connect the repository in SendOps

Now connect your new GitHub repository to SendOps so it can sync and deploy your templates.


  <Step title="Open the Templates page">
    In the SendOps dashboard, navigate to **Templates**.
  </Step>

  <Step title="Connect GitHub">
    Click **Connect Repository** (or **Connect GitHub Repository** if this is your first connection). You'll be redirected to GitHub to install the SendOps GitHub App if you haven't already.
  </Step>

  <Step title="Select your repository">
    Choose the repository you just pushed to. Select the branch (typically `main`) and set the **Subfolder** field to match your folder structure — if you pushed the contents of `sendops-templates` directly, leave it empty (repository root). If you pushed the `sendops-templates` folder itself, set the Subfolder to `sendops-templates`. SendOps reads `sendops.json` from there.
  </Step>

  <Step title="Wait for the first sync">
    SendOps automatically triggers a sync after connecting. It reads your `sendops.json` manifest, validates each template, and deploys them to SES. You'll see the sync status on the Templates page.
  </Step>


For full details on the GitHub connection setup, see [Template Management](/templates/template-management#connecting-a-github-repository).

## What happens next

Once connected, SendOps takes over template management:

- **Pushes to the default branch** trigger automatic syncs — your templates are validated and deployed to SES.
- **Pull requests** that touch template files get validation checks and rendered previews directly in GitHub.
- **The Templates page** shows all your templates with their validation status, variables, and sync history.
- **Test data profiles** can be added to the manifest to preview templates with realistic data. See [Previews & Test Data](/templates/template-versioning).

From this point on, treat your GitHub repository as the source of truth for templates. Edit files in Git, open pull requests for review, and let SendOps handle validation and deployment to SES.


  After connecting, changes made directly in the SES console will be overwritten on the next sync. Always make template changes through your Git repository.


## Permissions

The SES template export requires specific permissions:

| Action | Required permission | Roles |
|--------|-------------------|-------|
| View the SES template list and export status | `templates.ses_export.view` | All roles |
| Trigger an export and download the zip | `templates.ses_export.execute` | Owner, Org Admin, Infra Admin, Developer |

If you don't have the required permission, the **Export All** button will be disabled. Contact your organization's Owner or Admin to request access.

## What's next?

- [Template Management](/templates/template-management) — learn about syncing, validation, and the full template lifecycle.
- [Pull Requests & Compare](/templates/github-integration) — review template changes through PRs and compare branches.
- [Manifest File](/templates/manifest-file) — customize template naming and add test data profiles.
- [Previews & Test Data](/templates/template-versioning) — preview templates and send test emails.