Salesforce Data 360 Consultant

A good design starts with the question the customer wants answered. You run discovery, rank use cases by value and effort, take stock of the data sources behind them, and set the measures that will show success.

• Discovery questions that expose real use cases
• Ranking use cases by value and effort
• Taking an inventory of data sources
• Judging data quality before ingestion
• Defining success measures

You build A discovery summary that ranks use cases and lists the data each one needs.

Setup choices are hard to reverse once data flows. You provision the product, assign permissions to the people who build and use it, and divide data into spaces so each brand or region sees only its own.

• Provisioning and first-time setup
• Permission sets and what each grants to a role
• Org-wide settings that affect everything else
• Data spaces for brands, regions and teams
• Planning who owns what

You build A setup plan with roles, permissions and data spaces for a multi-brand company.

Changes to a live data platform carry risk. You apply governance to the configuration, package work to move it between environments, plan updates, and troubleshoot problems when something stops flowing.

• Governance for configuration changes
• Packaging work into data kits
• Moving configuration between environments
• Planning updates and rollback
• Troubleshooting a stalled stream or mapping
• Documenting what exists

You build A change-management plan, with a packaged configuration moved between two environments.

Data has to arrive before it can be used. You connect Salesforce, marketing, storage and web sources, choose batch or streaming for each, and decide what to ingest rather than ingesting everything.

• Connectors for common sources
• Data streams and their refresh modes
• Batch compared with streaming ingestion
• Capturing web and mobile engagement
• Choosing what not to ingest
• Monitoring an ingestion

You build An ingestion plan for four sources, with refresh mode and purpose for each.

Not all data needs to move. You decide when to query data in place with zero-copy integrations, and when to reshape it with batch or streaming transforms so that it matches the model the platform expects.

• Zero Copy: query in place, not copy
• Trade-offs of federation against ingestion
• Batch transforms
• Streaming transforms
• Cleaning and standardizing values
• Choosing between a transform and a source change

You build A transform that cleans a raw feed, plus a written case for one zero-copy source.

Everything downstream depends on the model. You map ingested objects to the standard data model, extend it when it falls short, and design relationships so that profiles, orders and engagement connect correctly.

• Lake objects and model objects
• Mapping source fields to the model
• Standard model subject areas
• Custom model objects and when to add them
• Relationships between objects
• Checking a mapping with sample data

You build A mapped data model for a retail customer, with relationships tested on sample data.

One person appears under many records. You write match and reconciliation rules that join them into a unified profile, judge how strict to be, and diagnose a profile that merged too much or too little.

• How identity resolution works
• Writing match rules
• Reconciliation rules for conflicting values
• Choosing how strict matching should be
• Reading unified profile results
• Fixing over-merged and under-merged profiles

You build An identity resolution ruleset, tuned against sample customer records.

Unified data becomes valuable when it is measured. You create calculated and streaming insights, enrich profiles with derived values, report on the results, and use predictive models to score outcomes.

• Calculated insights
• Streaming insights for fast signals
• Enriching records with related data
• Reporting on unified data
• Predictive models and how they are used
• Sharing data and results with other systems

You build A set of calculated insights and a report that shows lifetime value by segment.

A segment is a decision about who to reach. You build segments from unified data, set how often they refresh, and send them to the channels where they will be used, with an eye on cost and consent.

• Building a segment from rules
• Refresh and publish schedules
• Activation targets and what each receives
• Activating to marketing and advertising channels
• Respecting consent in segments
• Checking segment size and accuracy

You build A segment and an activation to one channel, with a consent filter.

The platform pays back when other teams act on it. You trace use cases through marketing journeys, sales prompts, service context and Agentforce, and show how unified data grounds each one.

• Personalizing marketing with unified profiles
• Giving sellers and agents customer context
• Triggering actions from data changes
• Grounding Agentforce with unified data
• Measuring what each use case returns

You build Four worked use cases, one for each team, tracing data from source to action.

Take a customer from question to design. You position the product, scope the use cases, design ingestion, model, identity and activation, estimate consumption, and present the plan with its risks and open questions.

• Framing the customer’s goals
• Designing the end-to-end flow
• Estimating consumption and effort
• Naming risks and open questions
• Presenting the proposal

You build A complete solution proposal with architecture, plan, and consumption estimate.