Feature · GitHub PublishingRepository publishing console

Publish content to GitHub without giving everyone GitHub access.

Acrosite connects through a GitHub App, writes Markdown/MDX with frontmatter to your repository, records commit details in Publish Logs, and triggers the configured deployment trigger profile after publishing.

GitHub AppMarkdown / MDXCommit SHAPublish LogsDeployment triggers
The GitHub problem

Git is the right place for your website. Not for every content user.

A repository is built for code, branches, and commits — not as an everyday editing surface for clients, writers, and reviewers. GitHub Publishing keeps the repo central while keeping content work out of it.

Scoped

Clients should not need repository access.

Client stakeholders can review content without seeing branches, commits, repository files, or deployment settings.

Risk

Writers should not edit production files.

Content creators need a clean editing workflow, not direct access to Markdown files inside GitHub.

Friction

Developers should not publish every update manually.

Simple content updates should not become repeated commit and deployment tasks.

Kept

Git history still matters.

Published content should remain traceable through commits, file paths, and commit SHA records.

Yours

Repository structure should stay yours.

Acrosite writes content to the paths your website expects instead of forcing a new frontend architecture.

Honest

Deployment should be triggered, not overclaimed.

Acrosite records deployment trigger results without pretending to track the full provider lifecycle.

GitHub App

Scoped repository access through a GitHub App.

Acrosite uses a GitHub App connection so repository access can be scoped, managed, and revoked without sharing personal access tokens.

1
GitHub App installed
Install the Acrosite GitHub App and grant access to the repositories you select.
Installed
2
Repository selected
Choose which repository this project publishes to, scoped to the App installation.
Repo selected
3
Project connected
Branch and write access are verified, and the project is ready to publish.
Connected
Acrosite GitHub App
acmeagency · client-site
  • Repository access scoped to selected repos
  • Branch selected per project
  • Write access tested
  • Installation can be revoked
  • No personal access tokens

Access is scoped and revocable. Connection is managed through GitHub App installation settings — not shared tokens.

Repository mapping

Map Acrosite content to the folders your website already uses.

Each project can define where Posts, Pages, Custom Content Types, and media should be written in the connected repository.

Acrosite contentmaps toRepository paths
Posts
ACROSITE
Pages
ACROSITE
Case Studies
CUSTOM CONTENT TYPE
Media Assets
ACROSITE
content/posts
content/pages
content/case-studies
public/images
Your website keeps reading content from the repo. Acrosite handles the publishing workflow before files are committed.
Publishing output

From approved content item to GitHub commit.

At publish time, Acrosite turns an approved item into a committed file in your repository — then hands off to your deployment trigger profile.

Validate content
Required fields, SEO fields, media references, and publish readiness are checked.
Generate Markdown/MDX
Acrosite creates the content file with frontmatter for the connected website.
Write to repository
The file is created or updated in the configured path.
Save commit SHA
Publish Logs store the commit reference for traceability.
Trigger deployment profile
After the GitHub commit succeeds, Acrosite triggers the configured deployment trigger profile.
commit · client-sitemain
Filecontent/posts/local-seo-guide.mdx
Branchmain
content: publish local-seo-guide
SHA9f3a2c1
StatusCommitted
DeploymentDeployment triggered
Access separation

Let content teams work without giving them GitHub control.

Acrosite separates technical setup from everyday content work, so each role gets the access it needs.

Developer

Connects GitHub, selects repository and branch, configures content paths, media paths, and deployment trigger profiles.

Manager

Reviews, approves, schedules, publishes, and monitors Publish Logs.

Editor / Author

Creates and edits Posts, Pages, and Custom Content Types without repository access.

Client Reviewer

Reviews assigned content, comments, approves, or requests changes without seeing GitHub.

Role
GitHub settings
Content editing
Scheduling
Publishing
Publish Logs
Client review
Developer
Manager
Editor / Author
Client Reviewer
Traceability

See what was committed, when, and by which publish job.

Publish Logs help teams understand whether content was validated, committed to GitHub, and whether the deployment trigger was accepted.

acrosite.com/app/acmeagency/workspace/publish-logsmain
Publish job · #4821
main-site · today
Published
ContentLocal SEO Guide
StatusPublished
File pathcontent/posts/local-seo-guide.mdx
Branchmain
Commit SHA9f3a2c1
Deployment triggerAccepted
Started09:00
Completed09:01
Retrynot needed

Commit details

Store file path, branch, commit status, and commit SHA.

Safe failure states

If commit or trigger fails, the failure is logged with a safe reason.

Retry visibility

Authorized users can retry where safe, including deployment-trigger-only retries when applicable.

After commit

After the GitHub commit, trigger deployment.

After the GitHub commit succeeds, your site deploys the way the project is set up: your host builds from the commit, Acrosite calls a deploy hook and records the result, or you deploy by hand.

GitHub commit succeedsThe generated file is committed to the configured branch and the commit SHA is saved.
Deployment startsYour host builds from the commit (Git-connected), Acrosite calls the project's deploy hook, or you deploy by hand (Manual).
Trigger result recordedFor a deploy hook, the request and your host's response are recorded in Publish Logs and Deployment Logs. Whether the build finished comes from the build status your host reports to GitHub, which Owners and Admins see with each publish.
Git-connectedBuilds from commit

Your host is connected to the repository and builds from each commit Acrosite makes. No hook is needed.

VercelDeploy hook

Acrosite calls your Vercel deploy hook after the commit and records the response.

NetlifyBuild hook

Acrosite calls your Netlify build hook after the commit and records the response.

Cloudflare PagesDeploy hook

Acrosite calls your Cloudflare Pages deploy hook after the commit and records the response.

ManualSelected manually

No automatic deployment. Acrosite commits the content and you deploy from your host on your own schedule.

Other hostsVia Git-connected

Any other host that builds from your repository works through Git-connected. Otherwise, deploy it yourself with Manual.

Clear boundaries

What GitHub Publishing means in Acrosite.

A focused publishing layer with deliberate edges — here is what it does, and what it does not try to be.

GitHub Publishing is
  • GitHub App connection
  • Repository and branch selection
  • Content path mapping
  • Markdown/MDX output
  • Frontmatter generation
  • GitHub commits
  • Commit SHA records
  • Publish Logs
  • Deployment trigger handoff
GitHub Publishing is not
  • Giving clients GitHub access
  • A visual website builder
  • A replacement for your website frontend
  • A generic headless CMS database
  • Full deployment lifecycle tracking
  • GitLab or Bitbucket support in the first version
  • A promise to manage every Git workflow
Setup checklist

What you need before your first GitHub publish.

A short, technical setup — usually done once by a developer — before content teams start publishing.

1

GitHub repository

Your website source code and content output should live in a GitHub repository.

2

GitHub App access

Install the Acrosite GitHub App and allow access to the selected repository.

3

Branch

Choose the branch Acrosite should publish to.

4

Content paths

Define paths for Posts, Pages, Custom Content Types, and media.

5

Markdown/MDX format

Confirm how your website reads frontmatter and content files.

6

Deployment trigger profile

Choose Manual / No Automatic Deployment or configure a supported automatic trigger profile.

GitHub Publishing FAQ

Questions about publishing to GitHub.

Access, tokens, file format, scheduling, deployment triggers, and recovery — the specifics teams ask before connecting a repository.

Open documentation
No. Client Reviewers can review assigned content without repository, branch, deployment, billing, team, or internal project access.
No. Acrosite connects only through its GitHub App, so repository access is scoped to the repositories you select and managed in the App's installation settings on GitHub.
Acrosite publishes Markdown/MDX files with frontmatter to the configured repository paths.
Yes. Developers or authorized technical users can configure content paths for Posts, Pages, Custom Content Types, and media.
No. Scheduled content stays in Acrosite until publish time. At publish time, Acrosite validates the content and commits the generated file to GitHub.
After the commit succeeds, your host builds from it (Git-connected), Acrosite calls your Vercel, Netlify or Cloudflare Pages deploy hook and records the response, or you deploy by hand (Manual). Owners and Admins then see the build status reported to GitHub for the commit; if your host reports nothing, Acrosite says so.
Only as far as GitHub was told. Acrosite records the deployment trigger request and the response it receives, and uses “Deployment triggered” wording for that step. It then shows the build status reported to GitHub for the commit: Deployed or Build Failed only when Acrosite recognizes your hosting provider's own status, Checks Passed, Check Failed or Checks Running for other checks, and No Build Status when nothing was reported.
Publish Logs show a safe failure reason. Authorized users can fix the issue and retry where possible.
GitHub is the supported Git provider for the current version. Other Git providers can be considered later.
Start here

Keep GitHub as the source of truth — without making everyone use GitHub.

Create your workspace, connect a Git-backed project, map content paths, and test GitHub publishing with a 14-day free trial.

14-day trialGitHub AppMarkdown/MDXCommit SHAPublish Logs