Designing a Modular CRM Stack: Core Objects, Relationships & Workflows

A step-by-step guide for early-stage teams building scalable, AI-ready CRM architecture using Attio.

Estimated reading time: 7 min
Keywords: modular CRM, CRM architecture, GTM stack, Attio, CRM data model, CRM workflows, startup CRM design

Why Modular CRM Architecture Matters

Most startups begin with duct-tape GTM systems: lead capture in Typeform, sales tracking in HubSpot, notes in Notion, and reporting in Sheets. This works until the team grows, the motion diversifies, or someone asks: “Where is the truth?”

The root problem isn’t the tools. It’s architectural debt.

To build a scalable, AI-compatible GTM engine, you need to design your CRM as a system — not a silo. This guide walks through how we do it at novlini, using Attio as the core platform.

Step 1: Define Your Core CRM Objects

Your CRM should reflect the structure of your GTM operations. These are the 4 core entities we define in every system:

• People – individual contacts, prospects, customers, users

• Companies – accounts, customers, organizations

• Deals – value-tracking entities (pipeline, renewals, expansions)

• Interactions – emails, calls, meetings, notes

Each object should be structured with custom fields, ownership logic, and lifecycle stages.

Example: In Attio, we use calculated fields like "Last Interaction Date" and tag critical roles like "Champion" or "Decision Maker."

Step 2: Map Relationships Between Objects

The value of CRM isn’t in the records — it’s in the connections:

• A Person → belongs to → a Company

• A Deal → involves → multiple People + one Company

• An Interaction → connects → People, Deals, and sometimes Companies

Use Attio’s native linking to enforce these relationships.

Why it matters:

• Enables context-aware views ("Show deals with no recent interaction")

• Powers rollups ("Avg. time to close by company size")

• Unlocks automation triggers ("Notify CS when a new Decision Maker joins")

Step 3: Model Object States and Transitions

Each object evolves over time. That evolution is stateful, and modeling it clearly allows you to trigger workflows and manage accountability.

Examples of state transitions:

• Deals: Created → Qualified → Proposal Sent → Won

• Contacts: Inbound → Contacted → Engaged → Converted

• Accounts: Prospect → Customer → Expansion → At Risk

Implementation tips:

• Map these transitions directly in Attio

• Trigger automations based on state changes:

  • Send alerts

  • Assign next owners

  • Launch onboarding or CS processes

Pro tip: In Attio, use the “Stage” field as a single source of truth for automations.

Step 4: Create Role-Based Views for Operational Clarity

You don’t want everyone working in the same spreadsheet. Modular architecture lets each team see the same system, through customized lenses.

Examples of role-specific views:

• SDRs: Leads with no interaction in the past 7 days

• AEs: Open deals by stage, forecast category, blockers

• CS: At-risk accounts, pending renewals, expansion potential

• Founders: Weekly pipeline movement, top stuck deals

Use Attio views, filters, and permissions to create these dashboards. This keeps alignment high and reporting consistent.

Step 5: Govern the System Like a Product

As your GTM motion matures, your CRM becomes harder to maintain — unless you treat it like infrastructure.

Governance checklist:

• Assign ownership to every list, workflow, and automation

• Tag fields by use case (e.g. [Ops], [AI], [CS])

• Archive deprecated tags and filters

• Review fields quarterly (what’s used? what’s broken?)

Your CRM should have versioning, naming conventions, and documentation — just like your product codebase.

Visual: Modular CRM Entity Diagram

👉 Use a clean, node-based diagram that shows:
People ↔ Companies ↔ Deals ↔ Interactions

Each arrow should reflect a relationship (e.g. "belongs to", "includes", "linked to") with labels showing directionality.

A clean visual is available above or can be rebuilt in Figma.

Summary & Next Steps

Modular CRM architecture isn’t about complexity — it’s about clarity.

With Attio as a base, you can:

• Define the GTM entities that matter

• Link them contextually

• Drive automation from state transitions

• Create aligned visibility for every role

• Keep the system clean as you grow

Great CRM systems are not bought. They’re designed.

If you’re rethinking your GTM stack — let’s talk. We help early-stage teams build CRM as infrastructure.