Salesforce BA Zero to Hero Module 8 — Data Model Fundamentals for BAs
📅
•
BA zero to Hero
🗃️ Salesforce BA Zero to Hero — Module 8 of 15
Data Model Fundamentals for BAs
You do not need to become an Admin. But you do need enough genuine data model fluency to write requirements that are actually buildable, and to hold a credible technical conversation. This module draws that exact line.
Module 8 of 15 (counting Module 0 as a bonus prerequisite) · Phase 3: Salesforce-Specific BA Skills (Begins!)
🚀 Welcome to Phase 3: Salesforce-Specific BA Skills. Modules 8 through 11 build the technical fluency that separates a generically-skilled BA from a genuinely effective SALESFORCE BA — enough data model knowledge to write buildable requirements, wireframing, reading declarative tools, and translating requirements into developer-ready stories.
🎯 What You Will Master in This Module — and What You Will NOT
This module deliberately covers JUST ENOUGH of Salesforce's data model for you to write technically credible, genuinely buildable requirements, and to confidently hold a conversation with an Admin or Developer. This is NOT an Admin-depth deep dive — if you want that full depth, sfinterviewpro.com's free Salesforce Admin Zero to Hero course covers it comprehensively. Here, the focus stays squarely on what a BA genuinely needs.
✓ Objects, Records, and Fields — the BA's practical mental model
✓ Standard vs Custom Objects — when to recommend which in a requirement
✓ Field types and why your choice of field type genuinely affects what you can later require
✓ Lookup vs Master-Detail relationships — arguably the single most BA-relevant technical concept in this entire module
✓ Why relationship choice has real, visible consequences for the requirements you write
✓ Reading a simple schema diagram (ERD) well enough to participate confidently in a technical discussion
✓ Writing genuinely solid Data Requirements sections in your FRD (Module 7)
📋 In This Module
1Objects, Records & Fields — The BA's Mental Model
2Standard vs Custom Objects
3Field Types & Their Requirement Implications
4Lookup vs Master-Detail Relationships
5Why Relationship Choice Affects Your Requirements
6Reading a Simple Schema Diagram
7Writing Data Requirements in an FRD
QInterview Questions (6)
Concept 1 of 7
Objects, Records & Fields — The BA's Practical Mental Model
Salesforce is fundamentally a database. An Object is like a database table — it defines a TYPE of thing (Account, Opportunity, a custom Discount Request). A Field is a specific piece of information about that type of thing (an Account's Industry, an Opportunity's Amount). A Record is one actual instance — one specific Account, one specific Opportunity.
⚡ Why This Matters
Every single requirement you write eventually needs to reference specific objects and fields, even at a business level. A BA who confidently and correctly uses this vocabulary in stakeholder conversations and documentation is immediately more credible to the technical team building from their requirements.
OBJECT: Opportunity (defines what a "deal" looks like)
└─ FIELD: Amount (a number — the deal's dollar value)
└─ FIELD: Stage (a picklist — where the deal is in the sales process)
└─ FIELD: Close Date (a date — expected/actual close)
RECORD: one specific Opportunity
"Acme Corp - Annual License Renewal"
Amount: $45,000 | Stage: Negotiation | Close Date: March 15
🛠️ Practical: Translate a Business Need into Object/Field Language
1Business need: "We need to track which Discount Requests are pending, approved, or rejected, along with who requested them and the discount percentage."
2Identify: what is the OBJECT here? What are at least 3 specific FIELDS this object would need?
3Strong example: Object — "Discount Request" (likely a custom object, covered in Concept 2). Fields — "Status" (picklist: Pending/Approved/Rejected), "Requested By" (likely a Lookup to the User object), "Discount Percentage" (a Number or Percent field).
4Notice you have now described this business need using precise, technically credible vocabulary that an Admin can immediately recognize and start configuring from — exactly the fluency this module builds.
⚠️ Common Gotcha — Confusing the Object with a Specific Record
Saying "the Opportunity" when you mean a specific deal, versus "the Opportunity object" when you mean the general structure of ALL deals, are genuinely different statements that can confuse a technical conversation if used imprecisely. Be deliberate: "object" when discussing structure/configuration, "record" when discussing one specific instance of data.
Concept 2 of 7
Standard vs Custom Objects — When to Recommend Which
Salesforce ships with built-in Standard Objects (Account, Contact, Opportunity, Case, Lead, and many others) covering extremely common business concepts. When a business need does not fit any Standard Object, a Custom Object can be created (always ending in
__c). Knowing roughly which category a given requirement falls into helps you write more accurate, realistic requirements.⚡ Why This Matters
Recommending "let's just use a Custom Object" for something Salesforce already models well as a Standard Object adds unnecessary complexity. Conversely, trying to force a genuinely unique business concept into an ill-fitting Standard Object creates awkward, confusing data down the line. This judgment connects directly to Module 6's Gap Analysis thinking.
| Business Concept | Likely Object Type | Why |
|---|---|---|
| A company we sell to | Standard — Account | This is exactly what Account is built for |
| A specific deal/sale in progress | Standard — Opportunity | This is exactly what Opportunity is built for |
| A discount approval request (not a standard Salesforce concept) | Custom — e.g. Discount_Request__c | No Standard Object naturally represents this specific business process |
| A piece of equipment a customer owns that we service | Standard — Asset (often) or Custom, depending on complexity | Salesforce has a built-in Asset object for many service scenarios — worth checking before assuming Custom is needed |
🛠️ Practical: Classify Three Business Concepts
1Concept A: "A customer support ticket."
2Concept B: "A specific training session our company runs for customers, with a date, capacity, and list of attendees."
3Concept C: "A person at a company we might sell to in the future, before they become a customer."
4Classify each as likely Standard or Custom, and name the Standard Object if applicable. A — Standard (Case object — exactly what it is built for). B — Custom (no Standard Object naturally represents a training session; likely a custom
Training_Session__c object, possibly with a related custom object for Attendees). C — Standard (Lead object — exactly what it is built for, representing a pre-customer contact).5Notice this classification exercise is genuinely the same kind of judgment call from Module 6's Gap Analysis, just applied specifically to data structure rather than process functionality.
⚠️ Common Gotcha — Assuming You Always Know Which Standard Objects Exist
Salesforce has many Standard Objects beyond the most commonly discussed ones (Account, Contact, Opportunity, Lead, Case) — including Asset, Contract, Campaign, Order, and others depending on which Salesforce products are licensed. As a BA, it is genuinely fine to say "I'm not certain if there's a Standard Object for this — let's confirm with the Admin" rather than guessing confidently and potentially recommending an unnecessary Custom Object when a perfectly good Standard one already exists.
Concept 3 of 7
Field Types and Why They Genuinely Matter for Your Requirements
Salesforce fields come in distinct types — Text, Number, Picklist, Date, Lookup, and others. The field type you specify (or imply) in a requirement has real, practical consequences for what is later possible: reporting, validation, automation, and data quality all behave differently depending on field type.
⚡ Why This Matters
A requirement that vaguely says "capture the discount reason" leaves the field type ambiguous — and the choice between a free-text field and a Picklist has major downstream consequences for whether that data can ever be reliably reported on or automated against.
| Field Type | Best For | Requirement-Writing Implication |
|---|---|---|
| Text | Free-form, genuinely unpredictable input (names, notes) | Cannot reliably be used in automation logic or clean reporting — values are inconsistent by nature |
| Picklist | A defined, limited set of options (Status, Stage, Industry) | CAN be reliably used in Flow logic, Validation Rules, and clean reporting — values are consistent and controlled |
| Number / Currency / Percent | Quantifiable values (Amount, Discount %, Quantity) | Enables calculations, roll-ups, and numeric comparisons in automation |
| Lookup | A reference/relationship to another record (covered in Concept 4) | Enables relating records together, but is NOT itself a data-type for descriptive values |
🛠️ Practical: Specify Field Types for a Real Requirement
1Requirement: "Capture the reason a discount request was rejected, so we can later report on the most common rejection reasons."
2Should "rejection reason" be a Text field or a Picklist field, given the stated goal of later reporting on common reasons? Justify your answer using the table above.
3Picklist is clearly correct here — the stated business goal is reporting on "most common" reasons, which genuinely requires consistent, controlled values. A free-text field would produce inconsistent entries ("budget", "Budget concerns", "too expensive", "client budget issue") that cannot be cleanly aggregated into a meaningful report.
4Now write this as a proper FRD-style requirement, specifying the field type explicitly. Strong example: "FR-0XX: The system shall capture a Rejection Reason via a Picklist field with values including Budget Constraints, Insufficient Margin, Policy Violation, and Other, when a discount request is rejected."
⚠️ Common Gotcha — Defaulting to Text Fields for Everything
Text fields feel like the "safe," flexible default because they accept literally anything — but this flexibility is precisely the problem when later reporting or automation needs are at stake. Whenever a requirement implies the value needs to be consistently categorized, reported on, or used in automation logic, push toward a Picklist (or similar controlled field type) instead of defaulting to free text.
Concept 4 of 7
Lookup vs Master-Detail Relationships — The Single Most BA-Relevant Technical Concept
When one object relates to another (a Discount Request relates to an Opportunity, a Contact relates to an Account), that relationship has a TYPE. The two most common types are Lookup (a loose, independent relationship) and Master-Detail (a tight, dependent relationship). This single distinction has more practical, visible consequences for a BA's requirements than almost any other data model concept.
⚡ Why This Matters
Choosing the wrong relationship type is not a cosmetic detail — it directly determines whether deleting a parent record cascades to delete children, whether roll-up summary calculations are even possible, and whether sharing/visibility automatically inherits from parent to child. Getting this right (or flagging it for technical discussion) genuinely affects what your requirement can later deliver.
| Lookup Relationship | Master-Detail Relationship | |
|---|---|---|
| Independence | Child record can exist even if not related to any parent (the relationship field can be blank) | Child record CANNOT exist without a parent — the relationship is mandatory |
| Deleting the Parent | Child records survive; the relationship field simply becomes blank | Child records are automatically deleted too (cascade delete) |
| Roll-Up Summary Fields | Not available (cannot sum/count children on the parent) | Available — parent can show a sum, count, min/max of its children |
| Sharing/Visibility | Independent — child has its own separate sharing settings | Child automatically inherits the parent's sharing/visibility settings |
🛠️ Practical: Reason Through a Real Relationship Decision
1Scenario: "Discount Requests" relate to "Opportunities." A business stakeholder wants to see the TOTAL VALUE of all pending discount requests displayed directly on the Opportunity record, automatically.
2Based purely on the table above, which relationship type does this requirement likely need? Why?
3This needs Master-Detail — the stated requirement (automatically showing a TOTAL/SUM on the parent) is specifically what Roll-Up Summary fields provide, and Roll-Up Summaries require a Master-Detail relationship. A Lookup relationship genuinely could NOT achieve this exact requirement without additional, more complex automation.
4Now consider the consequence: if Discount Requests are Master-Detail to Opportunity, what happens if someone deletes the parent Opportunity? Per the table, all related Discount Request records would ALSO be automatically deleted. Is this acceptable for this business process, or does it need to be explicitly flagged as a risk in your requirement documentation?
5This is exactly the kind of consequence worth flagging explicitly in your FRD's Assumptions/Open Questions section (Module 7) — "Confirmed acceptable that deleting an Opportunity also deletes its associated Discount Request audit history" is a genuinely important thing for stakeholders to consciously agree to, not something that should happen silently.
⚠️ Common Gotcha — Assuming Relationship Type Is Purely a Technical Decision
Some BAs assume relationship type is "just an Admin implementation detail" with no business relevance, leaving it entirely undiscussed in requirements. This module's exercise demonstrates exactly why that assumption is wrong — cascade delete behavior and roll-up availability are GENUINE business-relevant consequences a stakeholder should knowingly agree to, not a silent technical decision made without their awareness.
Concept 5 of 7
Why Relationship Choice Affects the Requirements You Can Actually Write
Building directly on Concept 4, let us connect this technical distinction explicitly to the requirement-writing skill from Module 7. Knowing about Lookup vs Master-Detail BEFORE you write a requirement helps you write one that is actually achievable, rather than discovering a fundamental conflict during the Fit-Gap workshop (Module 6) or, worse, during Build.
⚡ Why This Matters
A requirement like "show a running total of X on the parent record" implicitly REQUIRES a Master-Detail relationship to be achievable through standard Roll-Up Summary functionality. Writing this requirement without realizing that implication risks an unpleasant surprise later when the Admin explains the relationship structure needs to change, or that the requirement needs a different technical approach entirely.
A practical pre-flight check before finalizing a data-related requirement:
"Does my requirement imply any of the following?"
□ A parent record needs to automatically show a SUM/COUNT/AVERAGE
of its children → implies Master-Detail is needed
□ A child record should be COMPLETELY IMPOSSIBLE without a parent
(mandatory relationship) → implies Master-Detail
□ A child should AUTOMATICALLY inherit the parent's sharing/visibility
settings, with no separate configuration → implies Master-Detail
□ The child record should be able to exist INDEPENDENTLY, or be
reassigned to a different parent later → implies Lookup instead
🛠️ Practical: Pre-Flight Check Your Own Requirement
1Requirement: "A Training Session should be able to exist and be scheduled even before any Attendees are registered, and an Attendee record, once created, should be reassignable to a different Training Session if the original is cancelled."
2Run this requirement through the pre-flight checklist above. Which relationship type does this point toward?
3This clearly points to Lookup — the requirement explicitly states the child (Attendee) should be reassignable to a different parent, which is a hallmark Lookup characteristic; Master-Detail relationships generally do not support reassigning a child to a different parent as easily.
4This pre-flight habit is genuinely valuable BEFORE bringing a requirement to a Fit-Gap workshop (Module 6) — arriving with an informed hypothesis about relationship type, rather than no awareness at all, makes that conversation faster and more productive.
⚠️ Common Gotcha — Treating Your Own Judgment as Final
This pre-flight check is meant to inform your requirement-writing and prepare you for a technical conversation — it is NOT a substitute for genuine technical validation with an Admin or Architect, exactly as Module 6 emphasized about Fit-Gap workshops needing real technical expertise. Use this judgment to ask better, more informed questions, not to confidently dictate the final technical decision yourself.
Concept 6 of 7
Reading a Simple Schema Diagram (ERD)
An Entity Relationship Diagram (ERD), or "schema diagram," visually shows objects (entities) and how they relate to each other. You do not need to be able to BUILD complex schema diagrams as a BA — but being able to confidently READ one, in a technical meeting or in Salesforce's own Schema Builder tool, is genuinely valuable.
⚡ Why This Matters
When an Architect or Admin shares a schema diagram during a Design discussion, a BA who can read it confidently participates as a genuine peer in that conversation, rather than passively waiting for someone to translate it into plain language.
A SIMPLE SCHEMA DIAGRAM, READ STEP BY STEP:
[Account] ───<1:many, Lookup>─── [Contact]
↑
│ <1:many, Lookup>
↓
[Opportunity] ──<1:many, Master-Detail>── [Discount_Request__c]
How to read this:
- An Account can have MANY related Contacts (1:many)
- An Account can have MANY related Opportunities (1:many)
- An Opportunity can have MANY related Discount Requests, and this
relationship is Master-Detail (tighter, dependent — recall Concept 4)
- A Discount Request CANNOT exist without an Opportunity (Master-Detail)
- A Contact CAN exist independently of any specific Account (Lookup)
🛠️ Practical: Answer Questions from a Schema Diagram
1Using the schema diagram above, answer: if an Opportunity is deleted, what happens to its related Discount Requests? Why?
2They are automatically deleted too — because the relationship is Master-Detail (recall Concept 4's cascade delete behavior).
3Answer: can a Contact exist without being linked to any Account? Why or why not, based on the diagram?
4Yes — because Account-to-Contact is shown as a Lookup relationship, which (per Concept 4) means the relationship field can be blank and the child can exist independently.
5Notice you just confidently answered two genuinely technical questions purely by reading the diagram's notation correctly — exactly the kind of fluency that makes you a credible participant in a technical Design discussion.
💡 Salesforce's Schema Builder Is a Genuinely Useful Tool for BAs Too
Salesforce includes a built-in visual tool called Schema Builder (accessible to anyone with appropriate permissions) that displays exactly this kind of diagram for a real org's actual configuration. As a BA, even occasionally opening Schema Builder to visually explore how objects in your project actually relate can build genuine, practical familiarity beyond just reading diagrams others create.
⚠️ Common Gotcha — Assuming All Diagrams Use Identical Notation
Different tools and different individuals sometimes use slightly different visual conventions for representing relationships (different arrow styles, different labels for cardinality). When looking at any unfamiliar schema diagram, it is genuinely fine to ask "can you walk me through how to read this specific diagram's notation?" rather than assuming it matches exactly what you have seen before.
Concept 7 of 7
Writing Data Requirements in an FRD
Everything in this module culminates here — applying this newfound data model fluency directly to Module 7's FRD "Data Requirements" section. A genuinely well-written Data Requirements section specifies new/changed objects, fields (with types), and relationships clearly enough for an Admin to build directly from it, with minimal need for clarifying questions.
⚡ Why This Matters
This is precisely where this entire module's value gets realized in a real deliverable — the Data Requirements section is often the single most technically precise part of an FRD, and is exactly where vague or imprecise data model thinking causes the most genuine Build-phase friction.
| Component | What to Specify |
|---|---|
| New/Changed Object | Standard or Custom; if Custom, the proposed name |
| New/Changed Field | Field name, field TYPE (Concept 3), and for Picklists, the specific values |
| Relationship | Which two objects relate, and Lookup or Master-Detail (Concept 4), with justification |
| Cascade/Roll-Up Implications | Explicitly flag any cascade delete or roll-up behavior the relationship choice introduces (Concept 4-5) |
🛠️ Practical: Write a Complete Data Requirements Section
1Using everything from this module's running discount approval example, write a complete, properly structured Data Requirements section for your FRD.
2Include: the new Custom Object, at least 3 specific fields with types, the relationship to Opportunity with type and justification, and any cascade/roll-up implications explicitly flagged.
3Strong example: "New Custom Object: Discount_Request__c. Fields: Discount_Percentage__c (Percent), Status__c (Picklist: Pending/Approved/Rejected), Rejection_Reason__c (Picklist: Budget Constraints/Insufficient Margin/Policy Violation/Other). Relationship: Discount_Request__c relates to Opportunity via Master-Detail, enabling a Roll-Up Summary on Opportunity showing total pending discount value. Note: Master-Detail means deleting an Opportunity will cascade-delete its related Discount Requests — confirmed acceptable with VP of Sales during Fit-Gap workshop."
4Notice this single section now demonstrates the FULL skill chain from this module — correct object classification (Concept 2), deliberate field type choices (Concept 3), justified relationship type (Concepts 4-5), and explicit business-relevant consequence flagged and confirmed — exactly the technical credibility this entire module was built to develop.
⚠️ Module Wrap-Up
Remember this module's opening framing: this is enough data model fluency to write genuinely credible, buildable requirements — not Admin-level mastery. When you encounter a data model question genuinely beyond this module's scope, the correct move is always confirming with a technical expert, not guessing confidently. Module 9 covers Wireframing and Prototyping — the visual technique for showing stakeholders what a proposed screen or interface will actually look like before development begins.
💬 Module 8 Interview Questions (6)
Q1A stakeholder wants a free-text field to capture "the reason a deal was lost," but also wants quarterly reporting showing the top reasons deals are lost. Why is this a contradiction, and how would you resolve it in your requirement?
This is a genuine contradiction because a free-text field allows completely unconstrained input, meaning different users will phrase conceptually identical reasons in many different ways, such as "price too high," "pricing concerns," and "client said too expensive," which a reporting tool cannot reliably group together into meaningful, accurate aggregate categories. Reliable reporting on "top reasons" fundamentally requires consistent, controlled values, which only a Picklist field type can provide. The resolution is to write the requirement specifying a Picklist field with a defined, agreed set of standard loss-reason values, rather than free text, ensuring the stated reporting goal is actually achievable, and if stakeholders are concerned about losing nuance, an optional supplementary free-text "additional details" field can be added alongside the Picklist to capture extra context without sacrificing the reportable, structured primary reason field.
"Free text allows inconsistent phrasing of conceptually identical reasons that cannot be reliably grouped for reporting, while a Picklist provides the controlled, consistent values genuine reporting requires — resolve this by specifying a Picklist for the primary reason, optionally paired with a supplementary free-text field for additional nuance."
Q2A requirement states that a parent record must automatically display a running total of a specific numeric field across all its related child records. What does this requirement imply about the relationship type between these two objects, and why?
This requirement implies the relationship between the parent and child objects must be Master-Detail rather than Lookup, because Roll-Up Summary fields, which provide exactly this kind of automatic sum, count, minimum, or maximum calculation displayed on a parent record based on its related children, are only available when the underlying relationship is Master-Detail. A Lookup relationship does not natively support Roll-Up Summary fields, meaning if this relationship were instead built as a Lookup, achieving the stated requirement would require a significantly more complex workaround, such as custom automation or code, rather than simply using standard, native Roll-Up Summary functionality. Recognizing this implication while writing the requirement allows the BA to either specify the Master-Detail relationship explicitly upfront, or to flag this as a specific point requiring technical confirmation during a Fit-Gap workshop.
"This implies a Master-Detail relationship is needed, since automatic running totals on a parent require Roll-Up Summary fields, which are only available with Master-Detail relationships — a Lookup relationship would require significantly more complex custom automation to achieve the same stated requirement."
Q3Why should the cascade-delete behavior of a Master-Detail relationship be explicitly flagged to stakeholders, rather than treated as a purely technical implementation detail the BA does not need to mention?
Cascade-delete behavior, where deleting a parent record automatically deletes all its related child records, is a genuine business-relevant consequence with real implications for data retention and potential loss of historical records, not merely an internal technical mechanism with no real-world impact stakeholders should care about. If a stakeholder later deletes a parent record without realizing this consequence, and discovers important related child records, such as an audit trail or approval history, were unexpectedly and irreversibly deleted along with it, this creates a genuinely damaging surprise that erodes trust in the BA and the overall solution, especially since this exact outcome could have been explicitly surfaced and consciously agreed to in advance. Flagging this explicitly during requirements gathering, and gaining genuine stakeholder confirmation that this behavior is acceptable for the specific business process in question, prevents this entirely avoidable category of surprise and ensures an informed decision was genuinely made rather than a technical detail being silently decided without the business's awareness.
"Cascade-delete is a genuine business-relevant consequence, not just a technical detail, since unexpectedly losing related records like audit history when a parent is deleted is a damaging surprise — explicitly flagging this and gaining genuine stakeholder confirmation ensures an informed decision was actually made rather than silently decided without business awareness."
Q4How does the level of Salesforce data model knowledge a BA needs differ from the level an Administrator needs, and why is this distinction important to maintain?
A BA needs sufficient data model fluency to write technically credible, genuinely buildable requirements and to participate confidently in technical discussions, understanding concepts like object types, field type implications for reporting and automation, and the practical consequences of relationship type choices, without needing the deep, comprehensive mastery an Administrator requires to actually configure every detail of the platform, including advanced security models, complex automation logic, and the full technical intricacies of deployment and governor limits. Maintaining this distinction matters because attempting to develop full Administrator-level expertise would represent significant time investment that ultimately distracts from the BA's core, distinctly different value, which centers on requirements, stakeholder management, and translating business need into clear specifications, while having genuinely insufficient data model knowledge would mean writing requirements that are technically naive, vague, or unknowingly infeasible, undermining the BA's core credibility and effectiveness with the technical team they work alongside.
"A BA needs enough data model fluency to write credible, buildable requirements and participate confidently in technical conversations, not full Administrator-level mastery — maintaining this distinction matters because deep Admin expertise would distract from the BA's core value, while insufficient knowledge would undermine requirement quality and technical credibility."
Q5You are uncertain whether a specific business concept should be modeled as a Standard Object or a new Custom Object. What is the appropriate way to handle this uncertainty as a BA?
The appropriate approach is to openly acknowledge the genuine uncertainty rather than confidently guessing and potentially recommending an unnecessary Custom Object when a suitable Standard Object might already exist, or conversely forcing a genuinely unique business concept into an ill-fitting Standard Object structure. Salesforce includes numerous Standard Objects beyond the most commonly discussed ones, and a BA cannot reasonably be expected to have memorized every single one along with its exact intended use case, especially across different Salesforce products and editions that may have different sets of available Standard Objects. The professional response is explicitly raising this specific uncertainty with a technical expert, such as an Admin or Architect, during Gap Analysis or Fit-Gap discussions, treating it as a genuine question requiring technical confirmation rather than presenting an unverified guess as if it were a confident, settled recommendation.
"Openly acknowledge the genuine uncertainty rather than confidently guessing, since no BA can be expected to have memorized every Standard Object across all editions — raise this specific question with a technical expert during Gap Analysis, treating it as something requiring confirmation rather than presenting an unverified guess as a settled recommendation."
Q6What is the practical value of a BA being able to read a basic schema diagram, even though they will not typically be the one creating complex schema diagrams themselves?
Being able to read a schema diagram allows a BA to participate as a genuine, informed peer in technical Design discussions where an Architect or Admin shares such a diagram, immediately understanding which objects relate to which others, the nature of those relationships, such as Lookup versus Master-Detail, and the practical implications that follow, like whether a child record can exist independently or whether deleting a parent will cascade-delete its children. Without this reading fluency, a BA would need to passively wait for someone else to translate the diagram's technical notation into plain language for every point of discussion, slowing down the conversation and limiting the BA's ability to immediately spot a potential business-relevant consequence, such as an unexpected cascade-delete implication, and raise it proactively in the moment rather than discovering it later. This reading fluency directly supports the BA's core responsibility of catching and surfacing genuine business implications hidden within technical design decisions, exactly the kind of value demonstrated throughout this module's relationship-type exercises.
"Reading fluency lets a BA participate as a genuine peer in technical Design discussions, immediately understanding relationship implications like cascade-delete risk without needing constant translation, allowing them to proactively spot and raise genuine business-relevant consequences in the moment rather than discovering them later."
📝 Module 8 Recap — Data Model Fundamentals for BAs Mastered
✅ Object (structure) → Field (one piece of data) → Record (one specific instance) — the BA's core practical vocabulary
✅ Standard Objects cover common business concepts; Custom Objects fill genuine gaps — always check Standard first
✅ Field type choice has real consequences — Picklist enables reliable reporting and automation; Text does not
✅ Lookup vs Master-Detail is the single most BA-relevant technical distinction — affects cascade delete, roll-ups, and sharing inheritance
✅ Relationship choice is a genuine business-relevant consequence to surface and confirm with stakeholders, not a silent technical detail
✅ Reading a simple schema diagram lets a BA participate as a genuine peer in technical Design discussions
✅ Apply this fluency directly to the FRD's Data Requirements section — specific objects, typed fields, justified relationships, flagged consequences
🎯 Before Moving to Module 9...
1. Take a real or imagined business need and classify it as Standard or Custom Object, with justification.
2. Specify 4 fields for that object with deliberate, justified field types, including at least one Picklist with defined values.
3. Design a relationship to another object, choose Lookup or Master-Detail, and run it through Concept 5's pre-flight checklist.
4. Write the complete Data Requirements section for your FRD, following Concept 7's full structure including any flagged cascade/roll-up implications.
Module 9 covers Wireframing and Prototyping — the visual technique for showing stakeholders what a proposed Salesforce screen or page will actually look like before development begins.
2. Specify 4 fields for that object with deliberate, justified field types, including at least one Picklist with defined values.
3. Design a relationship to another object, choose Lookup or Master-Detail, and run it through Concept 5's pre-flight checklist.
4. Write the complete Data Requirements section for your FRD, following Concept 7's full structure including any flagged cascade/roll-up implications.
Module 9 covers Wireframing and Prototyping — the visual technique for showing stakeholders what a proposed Salesforce screen or page will actually look like before development begins.
Test yourself on this topic
2,244 practice MCQs across 27 quizzes — 5 quizzes free, no signup
RK
Written by
Rajnish Kumar
Salesforce Developer · Apex, LWC, Data Cloud & AI · Building SF Interview Pro
Keep Preparing
Practice with real people
Join the free Mock Interview Community — practice with peers, get honest feedback, and walk into your real interview confident.
Join the Community ↗