Write from a spec
A custom-coded action is a day. An app card is several. Someone starts from a blank file.
HubSpot RunbookWith the Blueprint
Every HubSpot blueprint
section, executed
click by click —
including the code
The HubSpot runbook turns all 20 blueprint sections plus appendices into an executable HubSpot build: twelve numbered phases, exact HubSpot navigation, paste-ready custom-coded workflows, custom-object schemas, API specs, per-phase Verify checklists, and a formal acceptance test before go-live.
Why the HubSpot runbook exists
The HubSpot build
writes itself
Twelve phases, exact screens, paste-ready custom code. The architecture is already decided. This is how anyone on the team executes it.
Precision
As appropriateExact screen
Every click is named
Each step gives the HubSpot navigation path, the values to enter, and what the screen should show when you are done — never “configure as appropriate.”
- Paths checked against the docs
- Exact values, not “as needed”
- Locked features flagged inline
Developer time
Blank filePaste-ready
Code, not a spec of it
Custom-coded actions, object schemas, API payloads and UI cards ship as finished artifacts against this client’s real property names — not a prose brief of what the code “must do.”
- HubSpot
exports.mainshape - This client’s internal names
- n8n / Make if the tier cannot run it
Sequence
Whatever’s next12 phases
The only order that works
Properties before views, pipelines before automation, everything before import — so records land in the right place and never email customers mid-migration.
- Same 12 phases the blueprint plans
- Each phase maps to named sections
- Nothing left as “do this later”
Verify
Trust the builderChecklist
Done means it was checked
Every phase ends with a Verify list before you move on, then a formal user-acceptance test with business users before anyone cuts over.
- Per-phase Verify checklists
- Formal acceptance test
- Go/No-Go before cutover
Who builds
Senior in portalAnyone
Follow it, or hand it off
A junior, a freelancer or you — same screens, same artifacts. Seniors review the result; they do not author the build from a spec.
- Click-by-click, not guesswork
- Custom work already written
- The knowledge lives in the file
Consistency
Who is freeOne bar
Same build, every client
Before delivery the runbook is checked against its blueprint — same phases, objects and workflows. Nothing dropped, nothing invented. Sold with the blueprint, not alone.
- 26-check consistency audit
- One standard across the book
- Blueprint + Runbook, one package
PrecisionNo "configure as appropriate"
Every step names the exact screen
Each build step gives the navigation path — Settings > Data Management > Objects > Deals > Pipelines — the exact values to enter, and what the screen should show when you've done it right.
- Navigation paths verified against the HubSpot documentation index
- Every phase ends with a Verify checklist before you move on
- Custom-coded workflow actions, object schemas and API payloads ship as complete, ready-to-paste artifacts
- Tier-gated features flagged inline, so nothing sends you down a locked path
Developer timePaste, test, ship
Save 80% of developer time
Whenever the blueprint specifies a custom-coded workflow action, a custom object, an API or batch payload, or a CRM UI extension, the runbook emits the actual artifact — HubSpot’s exports.main shape, schema JSON, batch payloads, React + serverless — using this client’s real property names, not a prose spec of what the code “must do.” Your developer pastes, tests and moves on. If the recommended HubSpot tier cannot run custom code, the equivalent n8n / Make / webhook logic is emitted instead, with the tier reason written next to it.
Already written
0%
Custom code, schemas, payloads and UI cards — this client’s property names, not a spec.
Paste & test
0%
Sandbox confirmation. That’s the work that remains.
Already in the runbook
Complete code, schemas, payloads and card projects — this client’s names, not placeholders.
Paste, test, ship
Paste into the sandbox, confirm the Verify checklist, and move on.
What the runbook emits Four artifacts. None of them a spec.
01
Custom-coded workflows
A specPaste-ready
Ready-to-paste Node.js or Python
Every custom-coded action ships as complete code in HubSpot’s exports.main = async (event, callback) shape — real logic against this client’s property names, not a spec and not a TODO. Shared helpers (withRetry, runtime guard, UTC-midnight dates) are defined once and reused.
- Numbered click path: Automation → Workflows → Custom code → Node.js 20.x or Python 3.x
- Secrets line with the exact name and private-app scopes the token needs
- Input-fields table: HubSpot property → code variable → why
- Output-fields table: name, type, and which downstream action consumes it
- Backoff + jitter on 429/5xx, 17.5s self-abort, pagination on
paging.next.after, batch writes ≤100, callback fallback so a failure cannot lock the workflow - Ops Hub Professional or Enterprise required — otherwise the n8n / Make / webhook equivalent is pasted instead
02
Custom objects
A whiteboardSchema JSON
Schema JSON, not a whiteboard
When Enterprise is in scope, the runbook includes the object schema ready for HubSpot’s data model UI or a POST /crm/v3/schemas call. Starter and Professional portals are never asked to create an object their tier cannot hold.
- Immutable object
name, singular/plural labels,primaryDisplayProperty - Required, searchable and secondary display properties with types and allowed values
- Association targets and custom association labels (Decision Maker, Billing Contact, Champion)
- Canonical data dictionary: label, internal name, owner, when it is enforced
- Object type ID note (
2-XXXXXXX) for v4 association calls that 400 on the internal name - Native Contracts / Subscriptions used instead wherever a custom object is not justified
03
API & private apps
Postman from a sheetCopy-ready
Endpoints, scopes and batch payloads
Migration and integration steps name the actual HubSpot CRM APIs and ship copy-ready JSON — so a developer is not reverse-engineering the blueprint into Postman from scratch.
- Private-app scopes listed per action (what the token may read and write)
- Rate-limit notes: 190 requests / 10 seconds; Search API 5/s global
- Batch create/update/read JSON, ≤100 records per request, unique-property identifier
- Field-mapping workbook: source field → HubSpot property → type → sync direction
- External ID properties (e.g. Salesforce Id) flagged unique, used to rebuild associations
- Short Node/Python migration script when the architecture needs more than a payload
04
UI extensions
A paragraphUpload
React cards + serverless functions
App cards and CRM UI extensions come as the project layout, the React component and the serverless function — enough to run hs project upload rather than design the card from a paragraph. Enterprise only; native cards are used below that gate.
- CLI path:
hs project create→ private app with the exact CRM scopes → folder layout - React
.jsxusing only@hubspot/ui-extensions— nowindow,documentor raw HTML - Data via
hubspot.fetch()only (15s / 1 MB / 20 concurrent) - Serverless function the card calls, plus
hsproject.jsonand*-card.json - Empty-data and error states so a user never sees a crash on the record page
- If the card only reads native CRM data, just the component file is emitted
The backboneSame phases the HubSpot blueprint plans — executed
Twelve HubSpot phases, in the only order that works
The sequence is deliberate: HubSpot properties before views, pipelines before automation, everything before data import — so records land in the right places and never trigger emails to your customers mid-migration. Each phase executes specific HubSpot blueprint sections; the full catalog is below.
Phases 0–3
Portal, data and revenue motion
-
00
Foundation & Security
Account and HubSpot tier setup, seat assignment, regional settings, SSO/MFA, sandbox.
How it’s built -
01
Data Structure
Objects, every custom property with its data dictionary, associations, lifecycle stages.
How it’s built -
02
Pipelines & Stage Gates
Every pipeline with stages, probabilities and required-property gates — plus quote-to-cash when commerce is in scope.
How it’s built -
03
Forms, Consent & Auth
Forms, GDPR consent, cookie banner, SPF/DKIM/DMARC — before any workflow can send.
How it’s built
Properties before views. Pipelines before automation.
Phases 4–7
Automation, integrations and reporting
-
04
Segments, Scoring & Views
Lists, the Fit/Engagement scores, and per-team saved views and record layouts.
How it’s built -
05
Workflows & Automation
Every workflow with full enrollment logic; sales sequences built separately — plus paste-ready custom code.
How it’s built -
06
Integrations
Launch integrations per the system-of-record table; deferred ones clearly separated for after go-live.
How it’s built -
07
Dashboards & Reporting
Every dashboard from the blueprint, the data-health dashboard, and sales forecasting configuration.
How it’s built
Everything exists before records land. Workflows stay off during import.
Phases 8–11
Cutover, acceptance and after
-
08
Data Migration & Import
Externally cleansed, sample-first imports in the safe order — companies → contacts → deals — with workflows off.
How it’s built -
09
User Acceptance Testing
A formal UAT plan: business cases, Given/When/Then test matrix, one tester per team, sign-off gates.
How it’s built -
10
Go-Live QA & Hypercare
The go-live checklist, configuration inventory, branding application and a quarterly audit cadence.
How it’s built -
11
Breeze AI Enablement
Settings and permissions, Breeze context, agents rolled out in stages on real conversation data.
How it’s built
QualityChecked before it reaches you
Audited like the blueprint. Used like a checklist.
26-check QA audit
Consistency with your blueprint
Before delivery the runbook is checked against its blueprint — same phases, same objects, same workflows, nothing dropped and nothing invented.
For agencies
Juniors execute senior HubSpot builds
Your delivery team follows the HubSpot runbook while your architects stay on architecture. One HubSpot quality standard across every engagement in your book.
For business owners
Build it yourself — or hand it off
Follow it screen by screen yourself, or give it to a freelancer or a staff member. The runbook is the institutional knowledge they'd otherwise have to bring.
Best together
The HubSpot runbook is not sold on its own. Blueprint + Runbook is $2,100 — the HubSpot architecture, the click-by-click HubSpot build guide, and the team onboarding kit in one package.
The full catalogEvery blueprint section, built
What each HubSpot phase actually builds
The HubSpot blueprint designs the architecture. The HubSpot runbook executes it. Below is every build phase in order — what you click in HubSpot, what developer artifacts ship, and which blueprint sections that phase turns into a finished HubSpot portal. A section-by-section map follows so nothing from the blueprint is left as “somebody should do this later.”
Portal, data and revenue motion
0
Foundation & Security
The portal is made safe and correctly licensed before anyone builds in it. Account and hub-tier setup follows the licensing plan; seats are assigned by role; currency, fiscal year and timezone are set; SSO/MFA and session timeouts go on; a sandbox is provisioned so later phases can be rehearsed. If PHI is in scope, the BAA and Sensitive Data Settings are switched on here — not discovered at go-live. If the AI plan needs Breeze Assistant during onboarding, the AI-settings toggles are pulled forward into this phase so they exist before anyone invites the rest of the team.
Executes blueprint §2 Licensing & TCO · start of §12 Permissions (teams, SSO, MFA) · §20 AI settings when Assistant is needed at onboarding
1
Data Structure
Objects and properties exist before anything that depends on them. Standard objects are mapped first; a Super Admin activates Services, Listings, Appointments, Courses or Projects if those are in the design. Custom objects — Enterprise only — are created from the appendix schema, with paste-ready JSON for POST /crm/v3/schemas so a developer is not reverse-engineering labels from a table. Every custom property is created from the canonical data dictionary (label, internal name, type, allowed values, owner, when it is enforced). Associations and custom association labels, then lifecycle stages with entry/exit criteria. Tier gates sit on the step: Leads need Sales Hub Pro/Ent; custom objects need Enterprise.
Executes blueprint §3 Data Model · §5 Lifecycle · Appendix A Custom Object Schema · Appendix B Property Naming
2
Pipelines & Stage Gates
Every pipeline from the architecture — new business, renewal, service, whatever discovery found — with ordered stages, close probabilities, required-property gates, and rules that stop silent stage-skipping or backward movement. Closed stages lock to Super Admin/Finance. If commerce is in scope, quote-to-cash is built in the same phase: products library, quotes, payments, subscriptions/contracts and deal splits, because quotes attach to the deal pipeline you just created. If commerce is out of scope, this phase never invents it.
Executes blueprint §6 Pipelines & Deal Stages · Commerce / quote-to-cash when Section 6 includes it
3
Forms, Consent & Email Authentication
The lawful-basis and consent model from the blueprint becomes working forms, subscription types, double opt-in where the market requires it, a cookie banner, and suppression lists from ICP exclusions. Sending-domain authentication (SPF, DKIM, DMARC) is completed before any workflow can send. Cookie and tracking steps match the jurisdiction named in discovery — including TTDSG and Impressum where you operate in DACH.
Executes blueprint §8 Marketing Assets & Consent · consent and residency rows from Appendix D
Automation, integrations and reporting
4
Segments, Scoring & Role-Based Views
Lists and segments first, then the dual Fit + Engagement scores with group caps and the sales View-Gate saved view that only shows records passing both thresholds. Then the adoption layer from the permissions design: per-object × per-team index-page saved views (tabs, column order, filters, default view), record-page layouts, and the custom cards that populate those layouts — so each team logs in to a purpose-built workspace, not a default HubSpot screen. Team-specific layouts are an Enterprise gate; below that, one global default is built and said out loud.
Executes blueprint §4 Lead Scoring · remainder of §12 Permissions (views, layouts, custom cards)
5
Workflows & Automation
Every workflow in the core table, with full enrolment triggers, branches, re-enrolment and the single Master Routing Workflow so lifecycle does not fork into silent loops. Competing workflows to deactivate are named. For every custom-coded action the blueprint scoped (CC-1, CC-2, …) this phase emits complete Node.js or Python — exports.main, secrets, input/output field tables, retry with jitter, the 20-second / 128 MB / 4 KB limits baked in as executable lines, not comments. If reps run outbound cadences, each Sales Sequence is built here as its own tool (personal inbox, not a workflow). Operations Hub Pro/Ent is required for HubSpot custom code; otherwise the equivalent external automation is pasted instead.
Executes blueprint §7 Automation & Workflows · Sales Sequences when Section 7 includes them · developer custom-code deliverables
6
Integrations
Only launch (Phase-1) integrations are built on the go-live path, each field mapped to a single system of record so nothing has two writers. Private-app scopes, rate-limit notes (190 requests / 10 seconds; Search API 5/s) and copy-ready JSON for the mapped endpoints ship with the steps. Deferred tools sit in a clearly separated post-go-live subsection with the reason they wait — day one is not “every system anyone mentioned in discovery.”
Executes blueprint §9 Integrations Architecture · Appendix C System-of-Record Summary
7
Dashboards & Reporting
Every executive, operational and compliance dashboard from the architecture, tied to the six-month success criteria — including ICP fit score and Green/Yellow/Red distribution where they belong. The Data Health Dashboard (completeness, validity, duplicates, fill rate, stage-skipping, integration ROI) is built here so RevOps has a pulse from day one. If the portal has quota and a deal pipeline, the native forecast tool is configured (amount mode, period, stage-to-forecast-category, per-rep goals) with the Professional/Enterprise seat gate; Starter portals get the workaround the blueprint already named.
Executes blueprint §11 Reporting & Dashboards · Sales Forecasting when Section 11 includes it
Cutover, acceptance and after
8
Data Migration & Import
Pipelines, properties and automation already exist, so imported records land in the right stages. Legacy data is scoped with MoSCoW, cleansed outside HubSpot (export & audit → deduplicate → standardize → validate → import & verify), then imported companies → contacts → deals/tickets. A 10% sample into sandbox, stakeholder validation, then the production run with workflows off so historical records cannot email customers. Field-mapping workbooks, owner-ID maps and picklist-value maps sit in the steps; Salesforce Id → a unique External ID property where that is the source. Batch update JSON (≤100 records per request) and any migration script the architecture needs are paste-ready, not described.
Executes blueprint §10 Data Migration Plan · API / batch developer deliverables
9
User Acceptance Testing
The click-by-click of the testing design: business users — reps, CSMs, marketers, the RevOps owner — not just the implementer, validate the end-to-end revenue flow before anyone cuts over. A Use Case → UAT → Record Case hierarchy, a RACI for Data Specialist / sponsor / Lead PM / Lead UAT, entry criteria, a sandbox (or workflows-off production) seeded with a 10% sample, one tester per persona. Each Record Case is Given/When/Then with test data, expected result, pass/fail and severity. Defects re-test. Exit criteria and a Go/No-Go ladder. A formal sign-off block with three outcomes (accepted / accepted with reservation / refused) and sponsor signatures that actually authorize go-live.
Executes blueprint §15 Testing & QA · uses §1 success criteria as the definition of done · testers named from §14 RACI
10
Go-Live QA & Hypercare
The cutover checklist, branding and templates applied (logos, sending-domain, quote/email/meeting skins), the four-sheet Configuration Inventory so the portal is not a black box after the partner leaves, and the seven-step quarterly audit cadence. Role-based training and enablement assets from the blueprint are handed to the named owners. 30 / 60 / 90-day milestones and the Phase-2 roadmap start their clock. Risks from the register become specific hypercare watches — a prior failed CRM rollout from discovery is not a generic “communicate more.” The Go-Live Appendix (inventory + quarterly audit) lives with this phase.
Executes blueprint §13 Timeline (cutover) · §16 Training · §17 Risk mitigations · §18 Post-launch / Out of Scope · §19 Branding · §14 owners for hypercare
11
Breeze AI Enablement & Staged Rollout
Agents learn from real logged conversations, so this phase starts once live data flows — unless Assistant settings were already pulled into Phase 0. Click path: AI settings and data-access toggles (including the model-training stance from discovery), AI permissions by role, Breeze context seeded from this engagement’s ICP, knowledge vaults where scoped, Breeze Intelligence fill-vs-overwrite policy, then the flagship agent (identity, knowledge sources, CRM permissions, handoff, routing). Test in the built-in panel (testing consumes no credits). Deploy stage 1 as reply recommendations a human approves. Credit controls, expansion gates with rollback, and named monthly usage review. Every Beta feature is labelled. If Section 20 scoped no AI, this phase still does foundational governance and a “revisit at +90 days” note — it is never silently dropped.
Executes blueprint §20 Breeze AI & Agent Enablement Plan
Ironwood Field ServicesComplete runbook · every phase
Read the full HubSpot runbook
The Ironwood Field Services runbook, unedited — every phase from Foundation through go-live, including click paths, custom code and Verify lists.
HubSpot Implementation Runbook · Ironwood Field Services
Complete document
Loading the full document…
Ironwood Field Services · every section
Same 12-phase document a live engagement produces. Contents lists every phase and step heading.
Start with a free HubSpot discovery.
Keep the ICP either way.
The AI-led HubSpot discovery interview and your Ideal Customer Profile are free — no credit card, no sales call. Pay only if you want the HubSpot blueprint, or Blueprint + Runbook together. The runbook is not sold on its own.
Free HubSpot discovery & ICP
Fixed one-time pricing
EU hosting, client-side encryption