You need one thing: a sandbox or a free Developer Edition org. Production is never a workspace - see the safety model below.

• Connect from the Connect page: you sign in on Salesforce's own login page (OAuth) - OrgTide never sees your password, and stored credentials are encrypted at rest. Pick the sandbox option to sign in through test.salesforce.com.
• Switch or add orgs from the org badge (top right). Your plan sets how many workspaces you can connect - Free 1, Pro 3, Developer 10. Downgrading never deletes an org: extras lock (🔒 in the switcher) and unlock the moment you upgrade again.
• Idle connections expire. An org untouched for about 30 days has its stored credentials destroyed automatically - just reconnect; your drafts, releases, and history are unaffected.
• A good first session: connect → run an Analyze on any Apex class → build something small → deploy it to the sandbox. The checklist on Home walks you through exactly this.

Everything in OrgTide moves through the same pipeline, and nothing skips a step:

• Describe what you need on Build (or start from a review on Analyze).
• Review the generated code as a diff. Edit any file by hand if you want. Nothing has touched your org yet.
• Save as a draft - drafts live in OrgTide, grouped by the generation that produced them.
• Deploy to your sandbox from Deploy: a check-only validation runs Apex tests, a coverage gate, and a static security scan first. The deploy itself is atomic, with a rollback snapshot taken automatically.
• Bundle into a release on Releases when the work spans multiple drafts - generate release notes and an impact report, then promote the release to another sandbox or, through typed confirmations, to production.

Quick one-off change? Build → draft → Deploy is enough. Releases and promotion earn their keep when you're shipping a body of work between orgs.

Press ⌘K (or the Search button in the top bar) anywhere in the app: jump to a page, a draft, or a release, or run actions directly - New build, Scan for drift, Export org metadata, Refresh org profile.

• Metadata only, never records. OrgTide reads code, flows, objects, and permissions - never Accounts, Contacts, or any business data.
• Nothing writes without your click. Every change is a reviewable diff first; deploys require explicit approval after validation.
• Gates on every deploy: Apex tests, a minimum-coverage gate, and a static scan for risky patterns (callouts, without sharing, dynamic SOQL, email sends) that you must acknowledge.
• Flows never activate themselves. A deployed flow always lands as a new inactive version - you activate it in Salesforce when ready.
• Production is a deploy target, never a workspace. OrgTide can't browse production; it deploys there only through the release-promotion path with typed confirmations, and reads from it only to verify identity, snapshot for rollback, and run drift scans you request.
• Undo exists. Deploys capture the prior source (see Version history on Analyze) and a rollback snapshot; the Deploy page can roll back a run.

Pick any Apex class, LWC, or Flow in your org and get an AI code review - governor limits, SOQL-in-loops, bulkification, security and sharing. Flows render as a visual diagram (toggle to raw JSON). Analyses are saved per component, and OrgTide flags them as stale if the code changes afterwards.

• Improve / fix: turn review findings into a generated fix, review the diff, save it as a draft.
• Ask about this → hands the component (source attached) to Ask for questions instead of a review.
• Version history shows prior versions OrgTide captured before each deploy - restore any one as a draft.

Browse is a read-only, filterable list of everything in your connected org - custom objects, fields (per object, standard and custom), Apex classes, triggers, LWCs, flows, and permission sets.

• Copy the list: every view has Copy list (plain text) and Copy as table (Markdown - pastes as a real table into Confluence, Notion, or GitHub). Both copy exactly what's shown, so filter first to copy just what you need. Writing docs about your org starts here.
• Objects → fields: click any object to open its full field table (API name, type, label).
• It costs no AI usage - these are direct metadata reads, so browse freely even when your allowance is spent. Metadata names only; OrgTide never reads your records.
• To bring a component into a deployable bundle, use Add from org on a release; to review code, use Analyze.

Describe a feature in plain English; OrgTide plans it and generates deployable metadata.

What it can generate

• Objects with fields and validation rules; record types (per-type picklist values, profile visibility, layout assignments); global value sets shared across picklists; custom metadata types with their config records (the values deploy with the type - unlike custom settings) and custom settings.
• Field types cover the full Setup palette, including roll-up summaries (master-detail only - with just a lookup, OrgTide builds a flow instead), rich text, auto number, time, geolocation, and compound Address fields (these need "Use custom address fields" enabled once in Setup → User Interface; the build notes explain it).
• Apex (always with a test class), triggers, LWC, and flows.
• List views ("show all open escalations") - complete with their filters: criteria on any field, "my records" scoping when you say my, and OR logic when you describe it. Also queues and public groups for routing (members are added in Setup - OrgTide never touches org users), custom labels, platform events (__e, with their Apex publishers/subscribers), and a Path with per-stage guidance (needs Path enabled once in Setup → Path Settings).

Options & context

• Quick-start chips scaffold common asks; the options that appear with the plan (profiles, tab + icon, permission set, custom app, page layouts, Dynamic Forms record pages, custom report types) apply automatically - no extra AI call.
• Adding fields to an existing object? Pick the layouts, Dynamic Forms record pages, and/or report types that should show them - record pages get the field as the last item in their first field section, like Setup, and you can move it afterward in Lightning App Builder.
• Attach reference material - a screenshot, a PDF, or an existing component's source/XML (up to 5MB) - and the plan takes it into account. Attachments are reference, not instructions: OrgTide regenerates from your prompt rather than copying files verbatim.
• Build works from your prompt, attachments, and org profile - it doesn't search the web (generated code is grounded in your org and checked by validation, not by web pages). When current information matters, start in Ask - which does search, with citations - then carry the answer over with Build this →.

After generation

• Revise refines the current plan without starting over - your previous prompt and plan carry forward.
• Edit any generated file before saving: the Edit button on each file swaps the diff for an editor.
• Ripple check finds org components that reference what you changed and can update them in the same batch.

Access changes in plain English - "give Sales Managers edit on Discount". OrgTide prefers permission sets (profile edits are generated as minimal deltas), validates every object, field, and profile name against your org before generating, and merges into existing permission sets rather than overwriting them. The result is a draft like any other - review, then deploy.

Conversational Salesforce help - formulas, validation rules, how-tos, best practices. The page always opens on a fresh chat; past chats are saved per org on the left so you can pick up a thread later. Paste or attach a screenshot (e.g. an error you can't put into words) and the answer will read it. When current information matters (recent releases, current limits, new features), Ask searches the web automatically and cites its sources under the answer - searched questions draw a little more of your allowance. When an answer maps to something deployable, a Build this → button carries it into Build; and Analyze's Ask about this → starts a chat with a component's source attached, so answers are grounded in your actual code.

AI answers can be wrong or outdated - verify anything important. When an answer misses something specific to your org, add the correct info under Saved corrections (left sidebar): every future chat reads those first. Corrections are per account and capped at 30.

One click on Home teaches the AI your org: OrgTide reads the org's metadata inventory (names and shapes only - never records) and writes a compact brief of what the org does, its naming conventions, key objects, and automation patterns. Every Ask answer and Build generation then FITS your org - reusing existing objects and value sets instead of duplicating them, matching your naming. Uses one generation; refresh after big schema changes (once per hour).

One button reviews your org's largest Apex classes plus the flow inventory into a 0-100 score with ranked findings (each run costs one generation). The header sparkline tracks the score across runs, so you can see the org improving as you fix things.

Everything you approved but haven't deployed, grouped by the generation that produced it. Preview any file, edit it in place, delete what you don't need, or send a whole group to Deploy. Drafts are per-org: switch orgs (top right) to see that org's drafts.

Download .zip on a group exports it as a standard Metadata API package (package.xml included) - deploy it anywhere outside OrgTide with the sf CLI or Workbench.

Select drafts → validate (check-only: nothing written) → review the gates → deploy (atomic: everything lands or nothing does). Deploys run in the background - you can leave the page and the result is recorded either way.

• Badges on drafts: deployed (in the org), edited since deploy (org has an older version - deploy again), rolled back, last deploy failed. No badge = never deployed.
• History lists every run with tests, coverage, and findings; rollback restores the pre-deploy snapshot (new components are deleted, changed ones restored).
• New Apex deploys with its tests; coverage below the gate (75% by default) blocks the deploy.
• A failed validation lists the exact per-component errors; Fix / revise pre-fills them into Build so the next attempt addresses what actually broke.

A release is a named bundle of drafts (plus components pulled straight from the org via Add from org - Apex, triggers, LWC, flows, permission sets, custom objects, even individual custom fields - including changes made outside OrgTide). From the release you can:

• Generate release notes + a risk score, and an impact report that scans org dependencies for blast radius.
• Deploy the bundle to this org through the normal gates.
• Promote it to another connected sandbox - OrgTide previews what differs in the target first. Promoting to production is three explicit steps: (1) a check-only validation runs the full gates against production without writing anything, (2) you type promote to production to confirm, (3) the deploy lands atomically, with a rollback snapshot taken first.
• Export a metadata package to hand off outside OrgTide, or save as a package for reuse (see Packages).

A package freezes a release's artifacts into an account-level bundle that follows you, not one org. Import it into any connected org and the artifacts arrive as drafts there - reviewed and deployed through the normal pipeline. Built for "I solved this in client A's org and want it in client B's."

The board groups your orgs into families - sandboxes with their production org as a strip beneath them - showing each org's latest deploys, releases, and incoming promotions. Production connections are deploy targets only and never appear in the org switcher.

Drift check compares your active sandbox against its production - or a sibling sandbox in the same family: components that exist in only one org, plus ones whose size or status differs - the "someone edited prod directly" signal. It appears on a family's card once its production org is connected (deploy-only target) and your active org is one of that family's sandboxes. Any item can show an exact side-by-side source diff. Scans run only when you click, read metadata only, and are free (no AI call).

Export metadata (button at the top) downloads the active org's own work - Apex, flows, objects, config - as a standard metadata zip: a point-in-time backup you own. Pure metadata read, free (no AI call), once per 15 minutes per org.

Every AI page has a model picker; set your default on Account.

• Sonnet 5 (the default) - fast and strong; the right choice for nearly everything.
• Opus 5 - the most capable, for gnarly builds and deep reviews; draws roughly twice the allowance. Included in paid plans - on Free, an Opus request runs Sonnet instead (the page tells you when that happens).
• Haiku 4.5 - fastest and lightest (about ⅓ the draw); good for quick questions and small changes.

Every AI action (analyze, build, ask, health, notes…) counts against a fair-use allowance shown as percent bars per rolling window (daily and monthly). The allowance is shared across all your connected orgs and weighted by how heavy each generation actually was - one big Opus build draws more than a quick question. When a window fills, the bar tells you when budget frees up.

On paid plans, Continue today lifts the daily pace limit for 24 hours - usage then draws from your monthly allowance instead. The button appears wherever you hit the wall: the limit notice itself, the usage banner, the Usage page, and Account. Plans (org count, Opus access, allowance size) are managed on Account.

Why didn't my flow activate after deploying?

By design - flows always deploy as a new inactive version. Activate it in Salesforce Setup once you've verified it (safety model, above).

Can OrgTide see my records?

No. OrgTide uses metadata APIs only. Record data is never queried, stored, or sent to the AI.

My org session expired - what do I do?

Reconnect from the org switcher (top right) or the Connect page. Your drafts, releases, and history are unaffected.

A deploy failed - is my org broken?

No. Deploys are atomic: on failure nothing was applied. Read the component errors in Deploy history, fix (the Fix / revise action pre-fills the failure), and deploy again.

What's the difference between a release and a package?

A release lives in one org and is for shipping a body of work (notes, impact, promotion). A package is an account-level frozen copy for reusing that work in other orgs.

How do plans and billing work?

Free includes one workspace (a sandbox or a free Developer Edition org) and the base allowance. Paid plans add more workspaces, production deploy targets, Opus access, and bigger allowances. Upgrade, switch plans, or cancel any time from Account - checkout and card details are handled by Stripe; OrgTide never sees your payment information. Downgrading never deletes anything: orgs beyond the smaller plan's limit are locked (visible in the switcher with a 🔒) and unlock instantly when you upgrade again.

Can I take my data with me - or delete it?

Yes to both. Export the active org's metadata as a zip (Environments), download any draft group or release as a standard Metadata API package, and delete your account from Account - deletion cancels any subscription and permanently removes everything OrgTide stores about you.

Something else?

Open a case on Support - replies come back right on that page (the Support link in the sidebar shows a badge when there's an answer waiting), and you can keep the conversation going until it's resolved.