There are about 5 million things that can go wrong when you’re building a new product or feature.

The best way to avoid at least a few of those obstacles? Watch how other startups tackle product development… then copy all the good stuff and avoid the mistakes.

One startup that learned a doozy of a lesson around product development is Beefree.

Beefree SDK is an embeddable white-label no-code visual builder for emails, landing pages, and pop-ups. They also have tools that are developer-friendly, for teams who need a little more customization in their tech stack.

Designed for SaaS businesses, there’s a high probability that you’ve used Beefree in your content creation or content management system without even realizing it.

A few months ago, the Beefree SDK team was up against a big roadmap challenge. 

They wanted to build a feature into their platform that was easy to use, highly customizable, and had a frictionless setup.

Let’s just say that the product development for this feature was complicated. And adoption would only happen if the team’s execution was flawless.

So… did it work?

Let’s find out.

Beefree’s big challenge

Beefree was facing a big challenge. Their AI writing assistant feature was a huge hit among their smaller clients, but enterprise customers needed something a little different.

For starters, these big organizations often had their own custom LLMs, which they wanted to embed into the Beefree platform.

Plus, large orgs had concerns about data privacy, and how their content might be used by tools like OpenAI.

So Beefree decided to create a “custom LLM add-on”... an element in the SDK that would allow customers to integrate their own models onto the Beefree platform.

Beefree needed something that was customizable, yet widely applicable. 

Something comprehensive, but not overly complicated. 

And – most importantly – something that was developer-friendly. 

I’m no engineer, but even I know that’s a tall order.

The 5 lessons learned

Throughout the process of building their custom LLM add-on product, Beefree SDK’s dev team learned 5 critical lessons.

Lesson #1: two-way communication is key

Beefree’s number one goal was to make this SDK developer-friendly.

To achieve that goal, specific features needed to be built in, like callbacks and content dialog interfaces.

This decision was brilliant.

It enabled developers to have full control over how their custom LLMs would be implemented into the Beefree platform, and allowed developers to control how their unique systems would respond to specific user actions.

The takeaway? Give users control over their own experience with your product. 

Lesson #2: Find balance

Customization and simplicity – normally I think of these two things as mutually exclusive. Unable to exist at the same time.

But Beefree thought differently. 

They were so tapped-in to their users’ behavior that they categorized developers into two camps:

• Those who want ready-to-use tools
• Those who want fully customizable options

Beefree knew they needed a solution that would work for both of these camps. So they built:

• Pre-built solutions that require minimal setup, like the AI Writing Assistant.
• Flexible interfaces that let developers customize their users’ experience. Like the Custom LLM AddOn.

Offering both options enabled Beefree to deliver something customizable, yet widely applicable. 

The takeaway? No two customers want exactly the same thing. Understand what’s important to each of them and deliver that through customizable solutions.

Lesson #3: Start small, then iterate

No matter what you build, your users will have feedback on it.

Rather than going all-in on product development and then revealing a fully built-out solution – which you’ll almost certainly need to change – start small.

Launch with a minimum viable product (MVP), collect feedback, and iterate.

For this SDK, Beefree could have tackled image generation, alt-text, and translations all at once.

But instead, they focused only on AI text generation. They released a basic interface, collected feedback, and expanded from there.

This approach saved development time and ensured Beefree built what developers – their users – actually wanted.

The takeaway? Start with the simplest version of your product that still adds significant value to your users. 

Lesson #4: Involve customers early

SDK teams often build in isolation. Founders fall into the same trap.

The solution: engage your customers before you even start building.

This was Beefree’s approach. Including enterprise customers into the development process helped the team:

• Identify important features that were missing
• Find the right balance between flexibility and usability
• Create seamless integration with existing enterprise workflows

The takeaway? Save time, save money, and build a more useful product by talking with customers in the planning phase.

Lesson #5: Make it easy to use

For customers to adopt a product or a new feature, the user experience has to be intuitive.

For developers, this means SDKs with near-perfect documentation. Because if developers can’t figure out how to implement it, the SDK is useless.

Here’s how Beefree handled this: they implemented an "Us First" principle. 

Before launching, Beefree SDK had someone from their team – who didn’t build the feature – try to implement it using only the documentation provided.

This allowed the team to fix roadblocks before customers saw them, and ensure the user experience was seamless.

The takeaway: Test ruthlessly. Find all the cracks and plug them. 

Epilogue

So what happened once Beefree launched their Custom LLM AddOn to their users?

The product was widely adopted and implemented. Enterprise users loved the customization options, and leaner teams were pumped on the ready-to-use tools the SDK had to offer.

Perhaps more importantly, though, was what happened to the Beefree team after this project.

The lessons they learned in building and launching something that appealed to such a wide group of customers can be applied to every single feature on their roadmap.

And frankly, I think those 5 lessons can be applied to every startup team building game-changing products, as well.