Starting from zero (but not really): What it looks like to be the first CS hire
When I joined Dropzone as the first customer success (CS) hire, the hardest part wasn't building from scratch. It was not breaking what was already working.
In under a year, Dropzone's Net Promoter Score (NPS) went from 52 to 66. When I ran our first survey in Q2 FY25, that 52 score was extraordinary given we had no formal customer success function at the time. An NPS of 52 is considered in the "excellent" range for SaaS companies; the average NPS for SaaS companies is 30-45.
At the time, our people were driving customer satisfaction, not necessarily structure or process. Our Sales Engineers, Regional Sales Directors, and engineering team were doing everything they could to support customers, and it showed. Our early customers didn't just use Dropzone, they believed in it. I used to joke that I've never seen customers bleed for a product like they do here.
So the question I walked into wasn't "How do we fix a broken experience?" It was "How do we build on something that's already working, without breaking it?"
When I joined as the first post-Sales hire, support was happening everywhere: SEs jumping in to troubleshoot, AEs staying close to accounts, and engineers solving real customer problems directly. We weren't missing effort, but rather consistency and scale. There was no formal onboarding, no defined customer journey, no playbooks, and no clear post-sales account ownership. Customer success, such as it was at the time, relied on individual heroics that pulled pre-Sales team members away from their most important job: selling more Dropzone AI. My job was to make the positive experience that our customers loved repeatable and scalable.
What does "good customer success" look like at Series A?
Good customer success work always comes down to one thing: if you tell a customer you'll do something, follow through every time.
The goal is to build a level of trust where customers never wonder whether they'll hear back. Instead, they know exactly what happens as laid out through our service-level objectives (SLOs), and upheld through Pylon. It's not glamorous, but it shows up in the feedback: "There is transparency in communication." "The team eagerly worked with us, and came to meetings showing real work done."
One of my favorite quotes comes from Dave Howard, Senior Director of Cybersecurity Operations at ECS, in a case study: "From the onset, Dropzone was responsive and welcomed us into a design partnership. Working with them has been one of the best vendor experiences of my career."
With a growing customer base, I wanted to ensure that following through on this promise didn't transition to heroics for my growing CS team as well, leaving opportunities for drops. You can read more of what our customers say in their own words.
What we built: the first scalable CS layer at Dropzone
As we added structure, the goal was never to layer in process for its own sake. It was to support what was already working.
The first thing we added was a customer journey, without overengineering it. A simple, clear flow:
- POC — get the prospect to a fast, real proof of value
- Onboarding — set up integrations and reach the first "aha" moment
- Ongoing use — daily investigations and analyst trust
- Expansion — new use cases, more coverage, more agents
- Renewal — sustained value, not a renegotiation
The intentional focus is getting to first real value quickly. For us, that "aha" moment is when customers see Dropzone not just investigate, but take action through Response Actions and Remediations. That's when it clicks that this isn't just analysis. It actually changes how they operate.
The second gap we filled was legibility. Customers didn't know what existed. So we built a more product-aware layer into CS:
- Documentation that went beyond integrations — see docs.dropzone.ai
- Clearer communication on what was shipping — see a release summary
- In-product notifications for new capabilities
If customers don't know what's possible, they can't get value from it.
As we grew, I made a deliberate decision around ownership: each person on the CS team owns their accounts end-to-end. They're not just handling tickets. They know how their customers operate, where they get stuck, and what success looks like for them. We still pool tickets (Pylon was a huge unlock for managing Slack and Microsoft Teams support without losing things in the noise), but the relationship stays with one person. At this stage, that continuity matters more than efficiency.
On tooling, we stayed deliberately scrappy:
- Pylon — ticketing across Slack and Microsoft Teams
- Metabase — visibility and reporting
- AI tools — notes and internal workflows
- Salesforce (SFDC) — CRM
We're an AI company, so we use it everywhere, but always with a priority to keep personalization wherever possible.
Why our NPS moved from 52 to 66
Looking at the jump from an NPS of 52 to 66, with more than double the response rate, a few things stand out.
Even with our growing customer base, we were able to give each customer personal attention and timely assistance. As we built out a true Support function with Pylon, we also set advanced SLOs based on priority and ticket type. Because of this, customers are consistently calling out our responsiveness.
Perhaps most importantly, we're continuing to be genuinely open to feedback, and showing customers their input turned into real product changes:
- An MSSP needed visibility across customers, so we built the Fleet Dashboard.
- Blunt feedback on investigations led to an upcoming new analyst type.
- With teams needing overnight coverage, we stepped in with automation and overnight support workflows.
This is where CS and product really blur, and I think that's actually the point at this stage.
How my view of NPS changed: it's a signal, not a goal
At the beginning, NPS felt like a goal. Now it feels like a signal. A score of 52 didn't mean we were broken. And 66 doesn't mean we've figured it out, either. What matters more:
- Are customers getting value?
- Do they feel heard?
- Do they trust that something will happen when they reach out?
The higher response rate tells me something important: more customers care enough to respond. That's a better signal than the number itself.
What we'll carry forward: lessons for early-stage CS leaders
A few principles we'll keep building on:
- Early CS is much closer to product than support.
- Reliability beats sophistication.
- You don't need a full function. You need ownership.
- Customers remember what happens after they reach out.
Most importantly: you don't scale customer trust by introducing processes. You scale it by making sure the experience that worked early on becomes consistent for every customer. That means continuing to be proactive, supporting more customers, and adding structure where it actually helps without losing the thing that got us here.
Dropzone AI is the Agentic SOC — a team of AI agents that autonomously investigate alerts, hunt threats, and respond to attackers at machine scale.
