Publishing to your CMS

Viewfield publishes to one place: your own website, through the CMS it already runs on. A reviewed piece is saved there as a draft first, and goes live only by a separate press that a person makes. Nothing else publishes. An X post, a LinkedIn post or a newsletter leaves the editor as text you paste or export; Viewfield holds no keys to a social network and posts nothing in your name.

Which CMSs

Works with Webflow; Payload tested against Viewfield's own live Payload 3.90.2; HubSpot CMS opening now; more on request.

Payload is the studio's first CMS: Viewfield's own blog runs on it, it is the one the welcome offers, and its draft and publish path is open to every workspace. Webflow's draft and publish path was proven on a real Webflow account and is open to every workspace too. Every other CMS below connects and reads your pages for AI visibility, and opens for drafts once it has been tested the same way; until then the connection says "Sending drafts to (the CMS) is not open for your workspace yet", and a piece or a page change is ready to copy into the CMS by hand.

CMS	How it connects	Where a draft lands	Publishing
Payload	An integration user's API key	A draft version in your posts collection	A separate press publishes that one document
Webflow	Sign in with Webflow, or a site token	A draft item in your blog collection	That one item, never the whole site
WordPress	Approve Viewfield on your own admin screen, an application password, or WordPress.com. Not listed on viewfield.ai yet: it connects where the operator lists it	A WordPress draft, or an autosave revision of a live post	That one post or page
HubSpot CMS	Sign in with HubSpot, or a private app token	HubSpot's own draft of the post	That one draft pushed live
GitHub	The Viewfield GitHub App, or a fine-grained token	A branch and a draft pull request	Your team merges; Viewfield follows the deployment
Contentful, Sanity, Framer, Directus, BaseHub	A token	An unpublished entry, a draft document, a draft item, a content version, an uncommitted change	One entry or document, or the CMS's own press

See Payload and Other CMSs for each one's setup.

Which pieces go to your website

A blog post, a custom kind and any piece written for an AI visibility question go to your CMS. An X post or thread, a LinkedIn post and a newsletter do not: their Publish button opens a tray to copy the text (Copy as text, Open X or Open LinkedIn, and for a newsletter Copy subject, Copy preview line and Copy body), export it, and Mark as published with the address where it went. Marking it only records the address; the piece stays editable.

From the editor to your site

1. Connect the CMS under Settings › Connections (a manager's). The credential is checked against the CMS, the site must serve one of your own hosts, and then it is stored encrypted and never shown again.
2. Add a destination: where in the CMS posts go (a collection, a content type, a blog, a repository folder), with the mapping of the piece's title, slug, body, excerpt, SEO fields and image onto the target's fields, and the public URL rule (the address a post will have, such as https://acme.com/blog/{slug}). When the CMS has exactly one blog and says its own public address, the destination is set up for you on connect; otherwise, and always for Payload and GitHub, you choose the collection under the connection, where Viewfield suggests the mapping. Each destination shows where it stands: Setup incomplete, Drafts not open yet, Ready for drafts, or Ready to publish (the mapping is complete, it has a public URL rule on your own hosts, and the CMS can publish from Viewfield).
3. Publish in the editor's header (⌘ Enter) opens the Publish tray: choose the destination, check the post details (Suggest summary and SEO fills the excerpt and SEO fields), and optionally Preview exactly what will be sent. Preview sends nothing.
4. Save as draft in your CMS: a manager's press. It lands as the CMS's own draft; nothing goes live.
5. Publish on your site: a manager's second, separate press, offered once the draft is saved and the piece has not changed since.
6. Visible on website once your public page serves the piece. From that moment the piece itself reads Published.

When a piece reads Published

A piece reads Published only once its page on your site is seen live: Viewfield reads the public address and finds the piece's title or its opening words there. That is true whichever road it took (the Publish press, a pull request your team merged, or I published it in your CMS for a CMS where Viewfield cannot publish), and only the version that went live is marked.

Published is final. The editor shows "Published on" your site and the day, and the piece is read-only. Edit reopens it as a Draft; the live page keeps the published version while you work, and the post reads Editing the live post. Send the update the same way (Save the update as a draft in your CMS, then publish it), and once the page shows it, the piece reads Published again.

Live pages are read again every day. A page that answers "not found" (404 or 410) on two reads an hour apart is taken off: the post shows that the address no longer shows the piece, and the piece goes back to Final (unless another of its posts is still live). An error, a timeout or a slow page never counts as gone. Check (your site) again reads the page now, and any member can press it.

Status

A post (one piece in one destination) shows one status at a time:

Status	Meaning
Saving draft, Publishing	A press is on its way to the CMS
Draft saved	The CMS holds it as its own draft; nothing is live. If you edit the piece afterwards, the post says so: save the update first, then publish
Website update pending	Published in the CMS; Viewfield is waiting for your site to rebuild or revalidate and reads the page again, for up to 48 hours
Visible on website	The public page was seen serving it; the piece reads Published, and the day it was first seen is the day its impact is measured from
Published in CMS	Published, but the page has not been seen: the 48 hours passed, the destination has no public address on your hosts, or the page was taken down. It is live on my site confirms it by hand
Outcome unknown	The write timed out, or the CMS answered with an error that does not say whether it applied. Viewfield checks with the CMS before anything is sent again, and offers no second save meanwhile
Needs review	Viewfield could not prove where the last send landed. Check the CMS, then I checked: it is not there to send again
Failed before write	Refused before anything reached the CMS; the reason says why
Reconnect required	The CMS stopped accepting the credential; reconnect it under Settings › Connections

A piece can be more than one post in the same destination (up to five) when you tick Create a separate post instead of updating the one this piece already has there.

The rules every write follows

• Only your own hosts. A site is connected only when it serves one of your hosts: your website and the hosts you own in AI visibility settings. A CMS that serves your site through a proxy (a Webflow site behind Cloudflare) connects too: Viewfield reads your public page to prove it serves that CMS site. The hosts are checked at connect and again at every write.
• Draft first. The first write is always the CMS's own reviewable form.
• A person decides. A draft is saved only when a manager presses the button, and every write is recorded with their name. Ask Viewfield and agents over MCP can prepare a preview and read where a piece stands; they cannot save or publish.
• Never over a newer edit. Before an update, Viewfield reads the item in the CMS again and compares it with what Viewfield itself last wrote there (the draft it saved, or the version it published). If anyone edited the item in the CMS since, the preview says so and a plain save is refused; the only way to write over their edit from Viewfield is a separate press, Replace their edit, which is recorded with the save. Where a CMS offers a version check (Contentful, Sanity), Viewfield uses it at the write too; elsewhere it compares just before the write and never calls that atomic.
• One write at a time per item, behind a lock, so two managers pressing Save at once make one draft.
• Nothing deleted. Viewfield never deletes a post, a page or an image in your CMS.
• Images first. Where the CMS takes images from Viewfield (Payload and Webflow today), they are uploaded to its media collection before the post, once, and reused. Where it does not yet, a piece with images says so, and you add them in the CMS.

Operator switches can pause every write, every live publish, or one CMS's operations; the button then says so and your work is kept.

Disconnecting a CMS

Disconnect on a connection is a manager's, and it asks first. The question names what goes and what stays, with the numbers, before anything happens:

• The sign-in is deleted from Viewfield at once. Where the CMS lets an app give its access back, Viewfield does: a Webflow or HubSpot connection made through their sign-in is revoked there too, and a WordPress application password Viewfield created is deleted from your site where WordPress allows it (if it is still listed under your profile's application passwords, remove it there). A token or key you pasted keeps working in your CMS until you delete it there, and the Viewfield GitHub app stays installed on your account until you uninstall it in GitHub settings.
• The pages listed for the connection are cleared, and read again when you reconnect.
• The destinations are kept, unless you tick Also delete its destinations. A kept setup is listed under its CMS ("acme.com was disconnected 2d ago. 2 destinations kept"). Connect the same site again and the destinations come back as they were, the default one included, and every post already sent is still linked, so the next send updates its own post instead of creating a second one. Delete setup on that line deletes it for good.
• Nothing on your site changes. Posts already sent stay in your CMS, and their history stays in Viewfield.

If the connection was the site AEO Pages tracks, AEO Pages goes back to tracking your website.

If your CMS stops accepting Viewfield's access (you revoke it there, uninstall the app, or the sign-in expires for good), Viewfield deletes the stored credential the moment it finds out and the connection asks to be reconnected; its destinations stay.

When Viewfield last read your CMS

Each connection says when its pages were last read ("Pages last read 3h ago", the exact time on hover) beside Refresh pages, each destination says when its fields were last checked ("Checked 1d ago") beside Check, and AEO Pages names when it last read the pages of a connected CMS. Viewfield reads a connection's pages again when they are more than a day old, and when you press Refresh pages.

Roles

Any member opens the tray, previews, reads where a piece stands and presses Check again. Saving a draft, publishing, I published it in your CMS, It is live on my site and I checked: it is not there need the manager role; a contributor sees "A manager saves it to" your CMS. Connecting and disconnecting a CMS and adding destinations are a manager's too.

Over MCP and in chat

list_site_destinations, get_site_post_form (the fields a destination asks for), prepare_site_publication (the preview), get_site_publication (where a piece stands) and get_site_coverage (what your site serves on a question, and where a new piece belongs). No tool saves or publishes. See MCP overview.