If your sales pipeline feels more like a black hole than a clear path to closing deals, you’re not alone. B2B sales is messy, and all the fancy dashboards in the world won’t fix bad deal stages. This guide is for sales managers, ops folks, and anybody who wants to set up deal stages in Einstein CoPilot that actually help you forecast, coach reps, and close more business—without drowning in busywork. No fluff, just practical steps and real talk about what matters.
Why Deal Stages Matter (and Where Most Go Wrong)
Deal stages are supposed to tell you where a deal stands and what needs to happen to move it forward. Simple, right? In reality, most pipelines are either way too generic ("Prospecting", "Proposal", "Closed") or so over-engineered nobody follows them. Both are a waste.
What works: - Clear, actionable stages tied to real events or behaviors. - Fewer stages, not more—nobody wants a 12-step sales saga. - Stages that everyone understands the same way.
What doesn't: - Vague stages like “In Progress” (what does that even mean?). - Stages based on how you feel, not what actually happened. - Letting the pipeline get messy because “we’ll fix it later.”
If you get this part right, the rest of your CRM setup actually does what it’s supposed to: help you sell.
Step 1: Map Out Your Actual Sales Process
Before you touch Einstein CoPilot, sketch out what really happens in your sales cycle. Grab a whiteboard, Google Doc, or napkin—doesn’t matter. The point is to be honest about your sales process (not what the playbook says, but what your reps actually do).
Questions to ask: - What’s the first thing that happens when a deal comes in? - What’s the “aha” moment that tells you a deal is real? - What steps always happen before you win or lose? - Where do deals typically get stuck or fall apart?
Example for a SaaS B2B sale: 1. Discovery call booked 2. Needs analysis/demo completed 3. Proposal sent 4. Decision maker engaged 5. Contract negotiation 6. Closed won/lost
Don’t get hung up on perfection. You can (and should) tweak these later.
Step 2: Translate Your Process into Deal Stages
Now, turn those real-world steps into deal stages in Einstein CoPilot. Here’s where you need to be ruthless about clarity.
Tips: - Each stage should reflect something observable (e.g., “Demo Completed,” not “Interest Shown”). - Fewer than 8 stages is usually plenty. - Avoid overlapping meanings (don’t have both “Negotiation” and “Final Negotiation”).
How to phrase stages:
Make them past-tense or definitive, so there’s no confusion. For instance:
- “Discovery Call Completed”
- “Proposal Sent”
- “Contract Signed”
What to ignore:
Fancy “qualification” frameworks that add extra steps just to sound smart. Unless your team uses them, skip them.
Step 3: Set Up Deal Stages in Einstein CoPilot
Once you’ve got your stages mapped, it’s time to build them in Einstein CoPilot. The interface is straightforward, but here’s how to avoid common headaches:
- Admin access: Make sure you (or whoever’s setting this up) has the right permissions.
- Navigate to Pipeline Settings: In Einstein CoPilot, go to your CRM’s pipeline or opportunity settings.
- Create/Edit Stages:
- Add your stages in the order they happen.
- Give each stage a clear name.
- (Optional) Set probability percentages, but don’t obsess—these are a rough guide, not gospel.
- Deactivate old/useless stages: If your pipeline is full of junk stages from past experiments, turn them off. Less clutter = less confusion.
- Save and preview: Make sure everything looks right and matches your process.
Pro tip:
Write a one-line description for each stage (e.g., “Proposal Sent = Customer has received a formal proposal via email”). This helps new reps and keeps everyone honest.
Step 4: Align Your Team—And Actually Use the Stages
Even the best stage setup falls apart if no one uses it right. Here’s how to keep your pipeline from turning into a junk drawer:
- Train your reps: Walk through each stage and what “counts” as moving a deal forward.
- Make it part of your 1:1s: Review deals by their stage. If something doesn’t fit, call it out.
- Spot check: Every couple weeks, pick a few deals at random. Ask, “Does this really belong in that stage?” If not, fix it.
- Update your process: If everyone’s skipping a stage or making their own rules, your process is broken—not your team. Change it.
What to watch out for: - Reps skipping stages to pad their pipeline. - Deals stuck in one stage for months (that’s a sign your definitions aren’t clear, or the deal is dead).
Step 5: Use Automation—But Don’t Overdo It
Einstein CoPilot offers automation and AI-driven suggestions for moving deals through the pipeline. These are handy…up to a point.
Use automation for: - Reminders to update stages after key events (like after a demo). - Nudges when a deal’s been stuck too long. - Simple workflows (e.g., auto-assigning tasks when a stage is reached).
Don’t use automation for: - Automatically advancing stages without rep input. (AI is great, but it can’t read minds—or email threads—perfectly.) - Overcomplicating your process with a dozen triggers nobody understands.
Reality check:
AI can flag things you might miss, but it won’t fix a broken process. Use it to save time, not to avoid real conversations.
Step 6: Clean Up and Iterate—Regularly
Your deal stages aren’t “set it and forget it.” Every few months, review how your stages are working.
What to look for: - Are deals bunching up at a certain stage? - Is your team misinterpreting a stage? - Are your close rates off because your probabilities are outdated?
How to fix: - Meet with your team, ask what’s working, and cut what isn’t. - Update stage definitions or add/remove stages based on real feedback. - Keep it simple—if you can remove a step, do it.
Don’t:
Cling to stages just because “that’s how we’ve always done it.” The best pipelines evolve.
What to Avoid (Common Pitfalls)
- Too many stages: If your pipeline feels like a maze, you’ll lose deals and frustrate your team.
- Vague names: “Negotiation” could mean anything. Be specific.
- Ignoring feedback: If reps are confused, your pipeline isn’t working.
- Letting old deals rot: Regularly close out dead deals—don’t let them clog up your data.
- Over-automating: Automation is for grunt work, not judgment calls.
Keep It Simple—And Change What Doesn’t Work
The best sales pipelines are clear, honest, and easy to use. Don’t overthink your deal stages—start with what’s real, roll it out, and adjust as you learn. If something feels off, fix it. The goal isn’t perfection, it’s a sales process that helps your team close more business (and keeps your sanity intact).
If you ever feel like your pipeline is running you in circles, take a step back and simplify. You’ll thank yourself later.