How Do We Work with Customers

Our approach: Customer-centric, but not Customer-blind

At Fibery, we call our approach customer-centric — not because it sounds good on a landing page, but because it’s the only way to build a product people truly use and love.

Being customer-centric means putting yourself in the customer’s shoes. We try to see the world as they do: what excites them, what frustrates them, how they work, and how Fibery fits into their daily flow. That doesn’t mean we always agree with their perspective — people are weird, teams are unique, and priorities can clash. But before we agree or disagree, we make sure we deeply understand what someone is trying to achieve and why.

Honesty and transparency

Empathy alone isn’t enough. Honesty is the other side of the coin. We treat customers with respect by being as transparent as possible - even if the message is uncomfortable:

• Why a feature doesn’t exist yet (or may never exist).
• Why a bug won’t be fixed immediately.
• What trade-offs we’re making and why.
• Where our design challenges or limitations are.

We overshare deliberately. When customers understand our thinking, they feel involved. They’re more likely to share valuable context, accept workarounds, and stay loyal — even when we say “no.” Respect brings respect. It turns the relationship from “service provider and user” into one team solving a problem together.

Balancing focus and customer needs

There’s a dangerous myth: “The customer is always right.” We don’t buy into it. Some requests come from people who simply aren’t a fit for the tool — their vision for the product contradicts ours. We still listen carefully, but we reserve the right to say no when needed.

Our goal isn’t to blindly follow every request; it’s to understand the intent behind it and balance it with our own company vision and priorities. That’s how we stay focused, deliver real value, and poorly avoid building a Frankenstein of mismatched features. (we don’t need feedback to build Frankenstein ourselves).

The role of Customer Success

Customer Success is the bridge between customers and the rest of the team. To do this well, we must understand not just the backlog, but also the values, trade-offs, and direction of the company. Their job is to translate both ways:

• Helping customers see why things are the way they are.
• Helping the team feel what customers actually experience.

This bridge-building is what makes a customer-centric approach actually work in practice.

Reactive vs Proactive: why we’re reactive-first

When people hear “reactive,” they sometimes think it means we’re passive or don’t care enough. For me, reactive is where we bring the most value.

Reactive means there’s already a place for our help. A customer has a real need, right now — not a hypothetical one. This immediacy lets us dive deep into their context, understand their workflow, and help them solve an actual problem.

Proactive work - reaching out, anticipating needs - is important too, but it only becomes powerful once trust is built. Trust is earned reactively: by being there, answering questions, and solving problems when they appear. Only then does proactive outreach feel helpful rather than intrusive.

So yes, we’re reactive-first.

Use Cases, not just Feature Requests

When someone says, “I need feature X”, we don’t just add it to a list and call it a day. We ask:

• Why do you need this?
• What’s your real expectation?
• Have you used it elsewhere? Did you like or hate it there?
• What else are you trying to solve?

Feature requests are surface-level. Real value comes from understanding the underlying use case — what people are actually trying to accomplish. Once we know the “why,” we can design something that solves the root problem, not just copy-paste a checkbox from another tool.

This approach also helps us prioritize. A loud request might not be important if it’s solving an edge case, while a quiet one could unlock value for many teams.

That’s because we may look annoying and silly especially in the beginning of our conversation journey, sorry! 🥲

Communication Channels

We can’t treat all customer voices equally — not in terms of respect, but in terms of how deep we can go and how representative they are. Here’s how we listen today:

1. Intercom Chats Our main channel. Fast, contextual, and full of real-world cases. This is where we invest most of our time — answering questions, uncovering pain points, and building trust. 2. Community A fascinating ecosystem. Our community is small but mighty — full of power users who dive into niche details, propose creative solutions, and challenge our thinking 🧞‍♀️. Fun fact: these aren’t always the customers bringing the most revenue. But they’re often our loudest champions and best advisors. Their feedback is deep, but not always representative of the broader user base — which is why our Solution Architect and CEO lead most of the conversations here. This is exactly why we don’t want to implement there classic “voting” systems. Numbers only tell you how many people are interested in a concept, not why they care. Real-life conversations, on the other hand, uncover the reasoning, provide a sanity check, and give concrete examples instead of abstract “hmm, I think that might be useful” guesses. That’s not enough for us. We want to know: When exactly did you miss this feature? How often does it happen? What was the last time it caused you pain? (shoutout to The Mom Test, which we love). We also rely on multiple layouts integrations with Braintree
2. Voice Conversations The most time-consuming, but also the most valuable. Calls let us see the people behind the tickets — their workflows, personalities, and frustrations. Because these are resource-heavy, we do fewer of them, but treat each one as gold 🤌.
3. Random Channels Reddit, G2, Capterra, Twitter X — random drive-by feedback. Sometimes it’s insightful, sometimes it’s just dopamine or cortisol. Hard to track, but we keep an ear out.
4. Email Technically still alive, but fading fast. Most customers switch to chat, where response time is better and the experience feels more human.

Data

To understand our customers and serve them better, we collect and connect data across several layers. Each layer focuses on a different part of the customer journey - from basic details to financial context and feedback loops.

1. Company & Contact details

We start with two core databases:

• Workspace – represents the company account. It’s created automatically through our API when someone signs up on the website. The workspace record is pre-filled with data we collect during signup (like country, signup date, etc.).
• Contact – represents the person behind the signup. We store their email and (when possible) enrich it automatically. We use Tuesday as a lead enrichment tool to automatically populate key LinkedIn data for contacts in the Contact database. When a new contact is created, an automation script sends a request to Tuesday, which returns a detailed JSON file containing information such as the contact’s LinkedIn profile, current role, company name, company size, website, and growth trend. This JSON is stored in a dedicated field, and additional scripts extract and map relevant fields to the Contact database. AI automation is then used to categorize roles and background. This process allows Fibery to monitor lead quality trends over time while keeping costs and complexity low, with plans to retroactively enrich historical leads as well.

Together, these two databases give us the foundation: who is using Fibery and where they come from.

We also rely on multiple layouts and tabs to keep things sane. The workspace database easily passes 50 fields per customer, and putting them all on a single screen would turn any CS manager into a scrolling zombie. Instead, we split data layouts — revenue, usage, customer success, etc. This way we see only what matters in the moment — no hunting for fields in an endless sea of information.

Here is how same customer cards look if you want to have CS overview or Usage details. Just switch between Layouts 🙂

2. Feedback

Feedback is the heartbeat of our customer understanding. We collect it from every conversation and channel we have:

• Intercom chats
• Community (Discourse)
• Emails
• (Occasionally) other places like Reddit or Capterra

All of this is funneled into our system and linked back to the relevant Workspace. This way, we can trace every piece of feedback to a specific customer and see the bigger picture over time.

These integrations are also a source of feedback and can help to generate customer’s review, aka what they asked for across the time and what was done.

3. Financial Details

Finally, we connect customer insights with financial data. Through integrations with Braintree and Chargebee, we track metrics like:

• Monthly Recurring Revenue (MRR)
• Lifetime Value (LTV)
• Payment history and status

This lets us see not just what customers are asking for, but also how their feedback relates or doesn’t to their growth and investment in Fibery.

4. Analytics

Beyond explicit feedback, we also track anonymized usage analytics to understand behavior at scale. Most of this data lives in Tableau and Redshift. Some metrics make sense on the workspace level — for example, weekly active users (WAU), number of collaborative spaces, or even their names. Others are more abstract and feature-oriented: what’s being used frequently, what’s ignored, and where users attempted adoption but dropped off. This helps us spot gaps, improve onboarding, and identify areas where the product isn’t living up to expectations.

And what we synced directly to Customer’s card for quick access in Fibery

What we do with the Data

Collecting data is just the beginning. The real value comes when we use it to help customers at the right moment. Our actions focus on four key parts of the journey:

• Helping new users become customers
• Helping new customers adopt Fibery better in the early stage
• Keeping an eye on big, existing customers to prevent issues
• Understanding why customers churn and learning from it

Most of these actions combine automations (to detect signals) with manual follow-up (to stay human and personal). Here’s what this looks like in practice:

1. Spotting promising new Users

We have an automation that flags interesting new users — people who have already invested time into Fibery but haven’t become customers yet. When this happens:

• The Customer Success (CS) manager gets notified
• We review the details manually and send a personal email offering help
• Because we don’t have huge volume yet, we can afford these personal touches

Challenge: Outreach emails have a terrible success rate these days. Many people ignore them or never even see them (hello spam filters). If you — dear reader — have better outreach ideas, we’re listening.

1.1. Segmented Case Studies

When new promising User/Company appears, we fill in their profile. And if we know the user’s segment (e.g., gamedev, digital agency), we send them an automatic email with a relevant customer story.

2. Trial prolongation check-ins

If someone requests to extend their trial, we track when their trial is about to expire and notify CS:

• We follow up via the same channel they used to request the extension
• We ask how things are going, offer help, and check if they’re ready to commit

3. New Customer alerts

When a lead purchases a subscription, we:

• Notify CS about the new customer
• Review their profile and segment manually
• Depending on the fit, either:
  • Send an automatic thank-you email with a Calendly link for an intro call
  • Send a custom email (for customers in exciting domains)
  • Or do nothing (if it’s a small PKM use case, for example)

4. Monitoring important Customers

For customers with MRR > $300, we have a silence detector:

• If there’s no communication with CS in 30 days, CS gets notified
• We check their health in Tableau (active users, engagement %)
• Even if usage looks fine, we send a personalized check-in email:
  • Recent updates relevant to them
  • Ask for feedback
  • Offer a check-in call
• Once a year, we also invite them for a year-in-review conversation

5. Handling churn

When a subscription is cancelled, CS is alerted. If it’s unexpected:

• We send either an automatic email asking for feedback
• Or a custom email tailored to the customer profile
• Or do nothing, if case was not a git from the beginning

6. Free Concierge service: Workspace Review

When usage spikes (high WAU), we send an automatic offer: a free workspace review.

• It’s a win-win: we learn more about their use case, and they get expert advice on improving their setup
• Currently free due to manageable volume, but we may turn this into a paid service as we grow

7. Celebrating the 90-Day Milestone 🎉

Ninety days into a paid subscription is a key checkpoint:

• By then, we know if the initial use cases work or need help
• CS reviews the profile and sends a personal note:
  • Congrats on 90 days
  • Offer a check-in call
  • Suggest next steps for adoption

(And yes — outreach emails here have the same trust problem as earlier. Still looking for better channels!)

These actions aren’t about bombarding customers with messages. They’re about timing and context: reaching out when it’s helpful, not random. Automations give us the signals, and humans provide the empathy.

Cross-team communication

Customer Success doesn’t operate in isolation — we’re deeply connected to other teams. Collaborations happen with Product & Dev and Growth, and occasionally with Finance. Here’s how it works:

Product & Dev Teams

The CS team is the main funnel for customer feedback:

• We collect feedback across all channels (support chats, community, reviews, calls).
• Every piece of feedback is processed and connected to the product backlog — whether it’s a feature request, bug report, or UX complaint.
• Because we understand the core use cases behind requests, we can map them to the right backlog items and Product guy as well as dev would see helpful context

When a backlog item gets delivered, we don’t just ship silently. CS can close the loop:

• Notify the exact customers who requested it (even if it’s been years!)
• Provide context: “Remember when you struggled with X? It’s fixed now.” After 3 years noone remembers but everyone pretends
• This makes updates personal and relevant, not just generic release notes - but we have them too, no worries!

Because all feedback is collected in one place and linked to the corresponding customer, we can see everything a single customer has ever requested — feature ideas, bug reports, pain points — all in one view. This gives us two big advantages:

• Context in discussions: When we talk to a customer, we instantly see their full history of requests and priorities.
• Proof of collaboration: We can show what’s been addressed (and what’s planned), which helps build trust and demonstrate progress.

Growth Team

For Growth, CS provides insights and context:

• Demo data (how many demos, who they were, patterns across segments)
• Churn reasons (why people leave, where adoption failed)
• Feedback on education and onboarding (what confused customers, where docs failed)
• Other very important opinions about everything and whatever

Growth reacts to these signals by improving:

• Website messaging (to attract better-fit leads)
• Sign-up and onboarding flows (to reduce early drop-off)
• Campaigns and demo positioning (to match real customer pains)
• Smth else their crazy minds come up with 🚀

We treat churn as a team-wide responsibility — not just CS. If customers leave, it’s because something in the product, onboarding, or expectations didn’t work.

CS is technically part of the Growth team, so we also join weekly syncs to align priorities and share patterns we’re seeing in the field.

By the way, Growth team also values feedback linking, but in their own way.

Not all feedback is about problems - sometimes people say something really nice about us in chats, community posts, or emails. We treat these as valuable signals, too:

• They are shared internally to boost team morale (a much‑needed dopamine hit).
• We save them for future use in marketing materials — case studies, testimonials, website quotes.
• When we need a quote, we don’t have to ask someone to “say something nice”; we just request their permission to share what they already said.

Finance

Finance steps in when there are payment issues:

• If a payment fails and it’s clearly technical, Finance solves it.
• If it smells like a relationship issue (confusion about pricing, misalignment on contract), CS jumps in to clarify.
• Finance always cc’s CS so nothing gets lost in translation — and we stay aware of potential churn risks.

Most importantly, the customer feels a single, connected experience - not a handoff between disconnected teams.

How AI changed everything or smth

AI has reshaped our work in Customer Success — but not in the way we assumed. It didn’t replace us yet. The most important part — empathy, real conversations, human judgment — remains irreplaceable. Here’s how it actually changed our day-to-day.

Self‑Service that actually works

Now anyone can summon an AI agent trained on our user guides. It answers extremely complicated questions with surprising accuracy. Customers love having the choice:

• AI for instant help (no waiting, no fluff)
• Human for empathy and context (one click, no hoops to jump through)

We deliberately keep this choice open. Even after launching AI support, chat volumes didn’t drop. Why? People still want a real human touch. And we’re proud to provide that. And I personally hate when other companies push me to talk to their fancy shmancy robots, that sucks so that won’t happen on my duty.

Feedback Linking got smarter

Before AI, we had to manually remember every backlog item when processing feedback — a mental load that doesn’t scale. Now AI parses the backlog and suggests relevant matches automatically.

It’s not perfect, but it’s a game‑changer: feedback processing is faster, cleaner, and lets us focus on the why behind requests, not the grunt work of finding them.

Call transcripts = less pain + more time for coffee

AI gives us instant transcripts and rough summaries. They’re not team‑ready (human editing is still crucial from my perspective although not all teammates agree here), but they speed up the process massively:

• Easy to pull direct quotes from calls (for dopamine or cortisol of the week)
• No more panic about missing details mid‑conversation
• Privacy exceptions? Sure - we still do old‑school notes when needed

Content creation

AI‑generated articles for SEO? Hate them.

But AI‑assisted content? Game‑changer. It helps turn messy real‑life conversations into clean FAQ structures and fixes grammar (hi, non‑native speaker here). Same for template creation — though ironically, templates are needed less now because AI can personalize on the fly.

Reports and Insights

AI can crunch massive datasets and spit out shiny reports. That’s cool. But we’ve learned not to outsource judgment:

• Metrics are easy — conclusions are hard
• We still rely on personal analysis to understand what matters
• The best combo? Manually created reports + CS insights = clarity without complacency

AI made us faster and lighter, but it didn’t take away the heart of CS: listening, understanding, building trust. The tools changed — the relationships didn’t.
But will see how it goes

Sum up

So, to sum it up: we collect a lot of data — company info, contacts, finances, feedback, usage analytics, even those sweet dopamine nuggets that make bad days better. We know who asked for what, when they asked for it, and whether we actually delivered (yes, we keep receipts). This connected view helps us act fast, keep things personal, and avoid awkward “wait, who are you again?” moments on calls.

If you’ve read this far, two things are true:

1. You now know more about our data model than some of our new hires. Because we don’t have new hires
2. You’re probably curious to see it in action — so go ahead, open Fibery and poke around. We promise it’s less scary than it sounds.

And if you spot a bug or have an idea? Or you see what is missing in our customer communication? Send us feedback. Worst case — you’ll end up in our dopamine folder. Best case — in the product backlog and in our hearts. Either way, we’ll be happy ❤️