# Github

GitHub automations automatically create issues in your repositories when recordings or captures are added to a folder. Convert customer bug reports, feature requests, and support tickets into actionable GitHub issues with video evidence and console logs.

<figure><img src="https://3820804400-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FfW6XSzJSKsNyZnOkSJPt%2Fuploads%2FkGx9eh2k7dOrbc61OaMW%2FCleanShot%202026-02-09%20at%2015.23.36%402x.png?alt=media&#x26;token=7fb3ffd2-04ca-4d1f-ae93-40bf94dbab54" alt=""><figcaption></figcaption></figure>

***

### When to Use GitHub Automations

GitHub automations are ideal for:

* **Bug Report Tracking** — Convert customer-reported bugs into GitHub issues with video evidence
* **Feature Request Management** — Automatically create enhancement issues from customer feedback
* **Support Escalations** — Create high-priority issues when critical problems are reported
* **Cross-Team Collaboration** — Link customer recordings directly to development work
* **Engineering Visibility** — Ensure engineers see customer context immediately
* **Issue Triage Workflow** — Route issues to specific repositories and projects automatically

{% hint style="info" %}
**GitHub vs. Email/Webhook**

Use GitHub when:

* Your engineering team uses GitHub for issue tracking
* You want automatic issue creation with full context
* You need to organize issues by repository
* You want to assign issues to team members
* You need bi-directional sync with status updates

Use Email when:

* Recipients don't use GitHub
* You just need notifications
* You want simpler setup without OAuth

Use Webhooks when:

* You need integration with a different tool
* You want custom payload formatting
* You're building custom automation
  {% endhint %}

***

### Prerequisites

Before setting up GitHub automations:

1. **GitHub Account** — With repository write access
2. **Repository Access** — Admin or write access to target repositories
3. **Screendesk Plan** — Pro or Enterprise plan to enable automations
4. **Folder** — Created in Screendesk to trigger the automation

***

### Setup

#### Connect GitHub to Screendesk (First-time only)

Navigate to your integrations:

1. Click your avatar in the top right corner
2. Select **Account Settings**
3. Go to **Integrations & Automations → Integrations**
4. Find **GitHub** in the list
5. Click **Connect GitHub**

You'll be redirected to GitHub to authorize access. You'll see a dialog showing the permissions Screendesk requires:

* Create and read issues
* Read repository metadata
* Read organization members (for assignees)

Click **Install & Authorize** to proceed.

{% hint style="warning" %}
**GitHub App Installation**

You'll need to select installation scope:

* **All repositories** — Screendesk can access all current and future repos
* **Select repositories** — Choose specific repos you want to allow

You can change this anytime in GitHub settings.
{% endhint %}

#### Review GitHub connection status

After authorization completes, you'll return to **Account Settings → Integrations**.

You should see:

* ✅ **GitHub Connected** with your account name
* List of accessible repositories
* **Disconnect** button (if you need to remove the integration)

{% hint style="success" %}
**Connection Verified**

If you see your username and repositories list, GitHub is successfully connected. You can now create automations in any folder.
{% endhint %}

#### Open folder automations

Create an automation in any folder:

1. Navigate to the folder you want to automate
2. Click **Settings** (gear icon) in the top right
3. Select the **Automations** tab
4. Click **+ Add Automation**
5. Select **GitHub** from the integration list

#### Select target repository

Configure where issues will be created:

**Repository (required):**

* Select the GitHub repository where issues will be created
* Only repositories with write access appear in the dropdown
* Can't find your repo? Verify GitHub App installation includes it
* Click **Refresh** to reload the repository list

**Note:** Each automation targets one repository. Create multiple automations for multiple repositories.

{% hint style="info" %}
**Repository Selection**

If you don't see expected repositories:

1. Ensure GitHub App installation includes them
2. Verify you have write access to the repo
3. Click **Refresh** in the GitHub integration settings
4. Re-save your automation
   {% endhint %}

#### Configure issue title

Customize how issue titles appear in GitHub:

**Default title template:**

```
{{item.title}}
```

**Example outputs:**

```
Checkout page crashes on iOS
User can't reset password
Feature request: Dark mode toggle
```

**Other title examples:**

For bug reports:

```
🐛 {{item.title}}
```

For feature requests:

```
💡 Feature: {{item.title}}
```

Including customer context:

```
[{{creator.email}}] {{item.title}}
```

For folder-specific routing:

```
[{{folder.name}}] {{item.title}}
```

{% hint style="warning" %}
**Title Length**

Keep titles under 100 characters for clarity. GitHub will display full titles but very long titles may be truncated in lists.
{% endhint %}

View all available template variables →

#### Configure issue description

Create a rich issue description with recording context:

**Default description template:**

```markdown
## Recording from Screendesk

**Title:** {{item.title}}
**From:** {{creator.name}} ({{creator.email}})
**Folder:** {{folder.name}}

**View recording:** {{item.url}}

---

This issue was automatically created from a recording uploaded to Screendesk.
```

**Example: Detailed bug report description**

```markdown
## Bug Report

A customer submitted a recording that describes this issue.

**Reported by:** {{creator.email}} ({{creator.name}})
**Folder:** {{folder.name}}

### Description
{{item.title}}

### Watch Recording
[View on Screendesk]({{item.url}})

---

### Recording Details
| Property | Value |
|----------|-------|
| Duration | {{item.duration}} seconds |
| Browser | {{item.browser}} |
| OS | {{item.os}} |
| Resolution | {{item.resolution}} |
| Location | {{item.country}} |
| Recorded | {{item.created_at}} |

### Technical Information

**Console Errors:**
\`\`\`
{{item.console_errors}}
\`\`\`

**Network Errors:**
\`\`\`
{{item.network_errors}}
\`\`\`

---

This issue was automatically created from a customer recording on Screendesk.
```

**Example: Feature request description**

```markdown
## Feature Request

A customer requested the following feature.

**Suggested by:** {{creator.email}} ({{creator.name}})

### Feature Description
{{item.title}}

### Customer Recording
[View request on Screendesk]({{item.url}})

**Recording Duration:** {{item.duration}} seconds

---

This feature request was automatically created from a customer recording.
```

**GitHub Markdown Support**

GitHub descriptions support GitHub-Flavored Markdown:

* **Bold** — `**text**`
* *Italic* — `*text*`
* Code blocks — ` ``` `
* Links — `[text](url)`
* Headers — `## Heading`
* Lists — `* item`
* Task lists — `- [ ] item`
* Collapsible sections — `<details>`

Use markdown to format important information effectively. {% endhint %}

View all available variables → {% endstep %}

{% step %}

#### Apply labels automatically

Organize issues with GitHub labels:

**To add labels:**

1. Click **+ Add Label**
2. Select from your repository's available labels
3. Add multiple labels as needed

**Suggested labels:**

* `from-screendesk` — Track all automated issues
* `customer-reported` — Mark customer submissions
* `needs-triage` — Flag for manual review
* `bug` or `enhancement` — Categorize issue type
* `critical` — For urgent folders
* `customer-feedback` — Specific to feature requests

**Example configurations:**

For bug reports folder:

```

from-screendesk, customer-reported, bug, needs-triage
```

For feature requests folder:

```
from-screendesk, enhancement, customer-feedback
```

For critical issues folder:

```
from-screendesk, critical, urgent
```

{% hint style="warning" %} **Label Availability**

Only labels that exist in your repository appear in the dropdown. If you don't see a label you want:

1. Create it in GitHub first
2. Return to Screendesk
3. Click **Refresh** in the GitHub integration settings
4. The new label will appear in the dropdown {% endhint %} {% endstep %}

{% step %}

#### Assign team members (optional)

Auto-assign issues to team members:

**Assignee dropdown:**

* Select specific team members
* Multiple assignees supported
* Or leave unassigned for manual assignment
* Only active repository members appear in the list

**Recommended approach:**

* Leave unassigned for most automations
* Use assignee for on-call or urgent issues
* Let team leads manually assign based on expertise

**Example uses:**

* Assign critical bugs to on-call engineer
* Assign feature requests to product manager
* Leave general issues unassigned for triage

{% hint style="info" %} **Multiple Assignees**

GitHub supports multiple assignees per issue. Add team members to distribute work:

* Bug triage: Add QA and backend leads
* Feature requests: Add product and design
* Critical issues: Add on-call engineer and team lead {% endhint %} {% endstep %}

{% step %}

#### Test the automation

Before activating, create a test issue:

1. Click **Create Test Issue** button
2. Check your GitHub repository for the new issue
3. Verify all fields populated correctly:
   * [ ] Title matches template
   * [ ] Description includes all variables
   * [ ] Repository is correct
   * [ ] Labels are applied
   * [ ] Assignees are set (if configured)
   * [ ] Recording link works
   * [ ] Markdown renders properly

**If something looks wrong:**

1. Click **Back**
2. Update the settings
3. Click **Create Test Issue** again

**Delete test issues in GitHub:** After verifying, you can delete test issues directly in GitHub (they won't affect the automation).

{% hint style="success" %} **Ready to Activate**

Once testing passes, proceed to save. {% endhint %} {% endstep %}

{% step %}

#### Save and activate

Finalize the automation:

1. Click **Save Automation**
2. The automation is **enabled by default**
3. You'll see it listed in the folder's **Automations** tab

**Status indicators:**

* ✅ Green toggle — Automation is active
* ⚫ Gray toggle — Automation is disabled

You can disable/enable the automation anytime without deleting it.

From now on, every recording or capture added to this folder will automatically create an issue in GitHub.

{% hint style="info" %} **Automation Activity**

View execution history:

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by folder or automation type
3. See success/failure details for each execution {% endhint %} {% endstep %} {% endstepper %}

***

### Template Variables

Use these variables in title and description templates:

#### Item Information

| Variable              | Description                | Example                  |
| --------------------- | -------------------------- | ------------------------ |
| `{{item.title}}`      | Recording or capture title | "Checkout crashes"       |
| `{{item.url}}`        | Link to recording/capture  | Full HTTPS URL           |
| `{{item.type}}`       | Item type                  | "recording" or "capture" |
| `{{item.duration}}`   | Length in seconds          | "45"                     |
| `{{item.created_at}}` | Submission timestamp       | "Feb 6, 2026 at 2:30 PM" |

#### Creator Information

| Variable            | Description          | Example                |
| ------------------- | -------------------- | ---------------------- |
| `{{creator.name}}`  | Person who submitted | "Alice Johnson"        |
| `{{creator.email}}` | Creator's email      | "<alice@customer.com>" |

#### Recording-Specific (if applicable)

| Variable                       | Description          | Example               |
| ------------------------------ | -------------------- | --------------------- |
| `{{recording.title}}`          | Recording title      | "Checkout page error" |
| `{{recording.url}}`            | Recording link       | Full HTTPS URL        |
| `{{recording.browser}}`        | Browser info         | "Chrome 121.0.6167"   |
| `{{recording.os}}`             | Operating system     | "macOS 14.3"          |
| `{{recording.resolution}}`     | Screen resolution    | "2560x1440"           |
| `{{recording.country}}`        | Geographic location  | "United States"       |
| `{{recording.console_errors}}` | JavaScript errors    | Formatted list        |
| `{{recording.network_errors}}` | Failed HTTP requests | Formatted list        |

#### Capture-Specific (if applicable)

| Variable            | Description   | Example                     |
| ------------------- | ------------- | --------------------------- |
| `{{capture.title}}` | Capture title | "Bug description"           |
| `{{capture.url}}`   | Capture link  | Full HTTPS URL              |
| `{{capture.type}}`  | Capture type  | Screenshot or document type |

#### Folder & Account

| Variable           | Description    | Example       |
| ------------------ | -------------- | ------------- |
| `{{folder.name}}`  | Folder name    | "Bug Reports" |
| `{{account.name}}` | Workspace name | "Acme Corp"   |

View complete variable reference →

***

### Example Configurations

#### Example 1: Bug Report Automation

**Folder:** Bug Reports **Target:** Report customer bugs to engineering team

**Configuration:**

| Setting    | Value                                         |
| ---------- | --------------------------------------------- |
| Repository | `acme/frontend`                               |
| Labels     | `from-screendesk`, `bug`, `customer-reported` |
| Assignees  | Unassigned (for triage)                       |

**Title Template:**

```

🐛 {{item.title}}
```

**Description Template:**

```markdown
## Customer Bug Report

A customer submitted a recording describing this issue.

**Reported by:** {{creator.email}} ({{creator.name}})
**Folder:** {{folder.name}}

### Description
{{item.title}}

### Watch Recording
[View on Screendesk]({{item.url}})

---

### System Information
| Property | Value |
|----------|-------|
| Browser | {{recording.browser}} |
| Operating System | {{recording.os}} |
| Resolution | {{recording.resolution}} |
| Location | {{recording.country}} |
| Duration | {{recording.duration}} seconds |
| Submitted | {{recording.created_at}} |

### Technical Details

**Console Errors:**
\`\`\`
{{recording.console_errors}}
\`\`\`

**Network Errors:**
\`\`\`
{{recording.network_errors}}
\`\`\`

---

This issue was automatically created from a customer recording on Screendesk.
```

**Result:** Issues created with full bug context, ready for engineer triage and investigation.

***

#### Example 2: Feature Request Automation

**Folder:** Feature Requests **Target:** Track customer feature suggestions for product team

**Configuration:**

| Setting    | Value                                                 |
| ---------- | ----------------------------------------------------- |
| Repository | `acme/product-feedback`                               |
| Labels     | `from-screendesk`, `enhancement`, `customer-feedback` |
| Assignees  | (Unassigned)                                          |

**Title Template:**

```
💡 Feature Request: {{item.title}}
```

**Description Template:**

```markdown
## Customer Feature Request

A customer has requested the following feature.

**Suggested by:** {{creator.name}} ({{creator.email}})
**Folder:** {{folder.name}}

### Feature Description
{{item.title}}

### Customer Recording
[View feature request on Screendesk]({{item.url}})

**Recording Duration:** {{recording.duration}} seconds

---

This feature request was automatically created from a customer recording.
```

**Result:** Feature requests flow directly to product team for evaluation and roadmap planning.

***

#### Example 3: Critical Issue Automation (High Priority)

**Folder:** Critical Issues **Target:** Escalate urgent problems to on-call engineer immediately

**Configuration:**

| Setting    | Value                                                         |
| ---------- | ------------------------------------------------------------- |
| Repository | `acme/frontend`                                               |
| Labels     | `from-screendesk`, `critical`, `urgent`, `customer-impacting` |
| Assignees  | On-Call Engineer                                              |

**Title Template:**

```
🚨 CRITICAL: {{item.title}}
```

**Description Template:**

```markdown
## CRITICAL ISSUE ALERT

A critical production issue has been reported.

**Reported by:** {{creator.email}} ({{creator.name}})

### Issue Details
{{item.title}}

### Watch Recording
[View Screendesk Recording]({{item.url}})

---

**IMMEDIATE ACTION REQUIRED**

This issue requires investigation as soon as possible.

**Timeline:**
* Submitted: {{recording.created_at}}
* Severity: CRITICAL

**Environment:**
* Browser: {{recording.browser}}
* OS: {{recording.os}}
* Location: {{recording.country}}

---

[Assigned to: On-Call Engineer]
```

**Result:** Critical issues immediately become high-visibility tickets assigned to on-call engineers.

***

#### Example 4: Support Escalation Automation

**Folder:** Escalations **Target:** Create tickets when support team escalates customer issues

**Configuration:**

| Setting    | Value                                                   |
| ---------- | ------------------------------------------------------- |
| Repository | `acme/support-issues`                                   |
| Labels     | `from-screendesk`, `support-escalation`, `needs-triage` |
| Assignees  | Support Lead                                            |

**Title Template:**

```
[ESCALATED] {{item.title}} - {{creator.email}}
```

**Description Template:**

```markdown
## Support Escalation

The support team has escalated this issue from a customer.

**Customer:** {{creator.name}} ({{creator.email}})
**Escalated at:** {{item.created_at}}

### Customer Issue
{{item.title}}

### Supporting Evidence
[View Recording]({{item.url}})

**Duration:** {{recording.duration}} seconds
**Browser:** {{recording.browser}}
**OS:** {{recording.os}}

---

This customer has been waiting for resolution. Please prioritize.
```

**Result:** Support escalations create visible tickets that go directly to support leads.

***

### Managing the Integration

#### View Integration Status

Check GitHub connection status:

1. Go to **Account Settings**
2. Select **Integrations & Automations**
3. Find **GitHub** in the integrations list
4. See connection status and account information

**Displayed information:**

* Connection status (Connected/Disconnected)
* Account name
* Number of accessible repositories
* Last sync status

#### Configure Repository Access

Modify which repositories Screendesk can access:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Configure GitHub App**
4. Add or remove repositories from installation
5. Return to Screendesk

#### Disconnect GitHub

Remove the GitHub integration:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Disconnect**
4. Confirm disconnection

**What happens:**

* All GitHub automations are **disabled** (not deleted)
* Existing issues in GitHub **remain unchanged**
* Sync stops immediately
* Automations can be re-enabled by reconnecting

#### Refresh Repositories

If GitHub resources aren't loading:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Refresh**
4. Repositories update immediately

**When to refresh:**

* New repositories created in GitHub
* Repository access changed
* Permissions modified

***

### Troubleshooting

#### Issues Not Creating

**Symptom:** Automations enabled but no issues appear in GitHub

**Solutions:**

{% stepper %} {% step %}

#### Verify GitHub is connected

1. Go to **Account Settings → Integrations & Automations**
2. Check GitHub status shows "Connected"
3. If disconnected, click **Connect GitHub** to re-authorize {% endstep %}

{% step %}

#### Check repository permissions

1. Verify you have write access to the selected repository
2. Check that the GitHub App installation includes the repository
3. Try selecting a different repository to test {% endstep %}

{% step %}

#### Verify automation is enabled

1. Open folder **Settings → Automations**
2. Find the GitHub automation
3. Toggle should be **green** (on)
4. If disabled, click to enable {% endstep %}

{% step %}

#### Check execution logs

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by the folder or automation
3. Look for error messages explaining why issue creation failed
4. Recent failures show detailed error information {% endstep %}

{% step %}

#### Test with a test issue

1. Open the automation
2. Click **Create Test Issue**
3. If test fails, error message explains why
4. Fix the issue and test again

{% hint style="info" %} Test issues show specific error messages that help diagnose problems. {% endhint %} {% endstep %} {% endstepper %}

#### Missing or Incorrect Fields

**Symptom:** GitHub issue created but fields are empty or wrong

**Solutions:**

{% stepper %} {% step %}

#### Verify template syntax

Check title and description templates:

* Variables must be enclosed in double braces: `{{variable}}`
* Variable names must be spelled exactly
* No extra spaces or special characters

**Correct:** `{{item.title}}` **Incorrect:** `{{ item.title }}` or `{{item.Title}}` {% endstep %}

{% step %}

#### Check data availability

Some variables only exist for certain item types:

* `{{recording.*}}` — Only for recordings
* `{{capture.*}}` — Only for captures
* `{{creator.*}}` — Available for all items

If a recording doesn't have console errors, `{{recording.console_errors}}` will be empty. {% endstep %}

{% step %}

#### Test with sample data

Create a test recording/capture with the data you're referencing:

1. Add test item to folder
2. Create test issue
3. View the result
4. Adjust templates based on what's missing {% endstep %} {% endstepper %}

#### Wrong Repository

**Symptom:** Issue created in wrong repository

**Solutions:**

1. Open the automation settings
2. Verify **Repository** dropdown shows correct repo
3. Click **Save** to update
4. Create a test issue to verify

**Note:** Changes only affect new issues, not previously created ones.

#### Labels Not Applied

**Symptom:** Issue created but labels are missing

**Solutions:**

{% stepper %} {% step %}

#### Verify labels exist in GitHub

1. Open GitHub repository
2. Go to **Issues → Labels**
3. Check that your configured labels exist
4. Labels must be created in GitHub before using in Screendesk {% endstep %}

{% step %}

#### Refresh label list in Screendesk

1. Go to **Account Settings → Integrations & Automations**
2. Find GitHub
3. Click **Refresh**
4. Wait for labels to update
5. Edit automation and verify labels appear {% endstep %}

{% step %}

#### Re-add labels to automation

1. Open the automation settings
2. Remove old labels
3. Click **+ Add Label** to re-select
4. Choose labels from the refreshed list
5. Save and test {% endstep %} {% endstepper %}

#### Assignee Not Applied

**Symptom:** Issue not assigned to selected team member

**Solutions:**

1. Verify the selected person has **write access** to the repository
2. Person must be a collaborator on the repo
3. Go to GitHub repository settings → Manage access
4. Check if the person is listed
5. If not, add them as a collaborator
6. Select a different assignee in automation and test again

#### Rate Limiting

**Symptom:** "API rate limit exceeded" error

**Solutions:**

1. **Wait before retrying** — GitHub enforces rate limits; wait a few minutes
2. **Space out automations** — Don't trigger many automations simultaneously
3. **Check rate limit status** — View your GitHub API rate limit at github.com/settings/tokens
4. **Contact GitHub support** — If limits are too restrictive for your use case

#### Markdown Rendering Issues

**Symptom:** Description formatting looks wrong in GitHub

**Solutions:**

1. Test your Markdown template in a GitHub issue directly
2. Verify GitHub-Flavored Markdown syntax is correct
3. Common issues:
   * Missing line breaks between sections
   * Incorrect code block syntax (use triple backticks)
   * Unescaped special characters
4. Test with a test issue to verify before activating

#### OAuth Authorization Failed

**Symptom:** "GitHub authorization failed" error during connection

**Solutions:**

1. **Verify GitHub account** — Ensure you're logged into the correct account
2. **Check OAuth permissions** — Screendesk requires write access to issues
3. **Try again** — Click **Connect GitHub** to retry
4. **Clear browser cache** — OAuth may fail due to cached credentials

If issues persist, contact Screendesk support.

***

### Best Practices

#### Use Consistent Naming

Keep naming conventions consistent:

{% columns %} {% column %} **❌ Inconsistent:**

```

bug: checkout error
BUG - login failing
Customer says: password reset broken
[SEV-1] database timeout
```

{% endcolumn %}

{% column %} **✅ Consistent:**

```

🐛 Checkout page error
🐛 Login failing
🐛 Password reset broken
🐛 Database timeout
```

{% endcolumn %} {% endcolumns %}

Consistent naming makes issues easier to scan and search in GitHub.

***

#### Use Meaningful Labels

Create labels for quick filtering:

**Organizational labels:**

* `from-screendesk` — Track all automated issues
* `customer-reported` — Issues from customers
* `internal-report` — Issues from your team

**Type labels:**

* `bug`, `enhancement`, `documentation`
* `performance`, `security`, `ui`, `backend`

**Status labels:**

* `needs-triage`, `blocked`, `duplicate`
* `critical`, `high-priority`, `low-priority`

Apply 2-4 labels per issue for effective organization.

***

#### Include Recording Links Prominently

Make accessing customer evidence easy:

{% columns %} {% column %} **❌ Buried:**

```

This is a bug report.
See details below.
...lots of text...
Link: {{item.url}}
```

{% endcolumn %}

{% column %} **✅ Prominent:**

```

[View Recording]({{item.url}})

**Description:**
{{item.title}}
```

{% endcolumn %} {% endcolumns %}

Put the recording link near the top where developers will see it first.

***

#### Add Environment Context

Include technical details for debugging:

```markdown
**System Information**
| Property | Value |
|----------|-------|
| Browser | {{recording.browser}} |
| OS | {{recording.os}} |
| Resolution | {{recording.resolution}} |
| Location | {{recording.country}} |
```

This helps developers reproduce issues and understand scope.

***

#### Test Before Large Deployment

Before creating many automations:

1. Create one automation
2. Add a test recording
3. Verify in GitHub
4. Check title, description, labels, assignees
5. Adjust templates as needed
6. Then create additional automations

Testing first saves time fixing issues later.

***

#### Create Repository-Specific Automations

Organize automations by repository:

For bug reports:

* Create separate automations for `frontend`, `backend`, `mobile`
* Target appropriate teams automatically
* Makes triage more efficient

For feature requests:

* Route to `product-feedback` repository
* Assign to product manager

For support:

* Route to `support-issues` repository
* Assign to support team lead

***

#### Monitor Automation Success Rate

Regularly check execution logs:

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by GitHub automations
3. Look for patterns in failures
4. Address common issues

**Target success rate:** 99%+

***

#### Document Your Setup

Keep notes on your automations:

* Why each automation exists
* What folder triggers it
* What repository it targets
* Who manages it
* When to update templates

This helps new team members understand the system.