Algolia doing things that don't scale

In the world of startups, there’s a well-known piece of advice from Y Combinator co-founder Paul Graham: “Do things that don’t scale.” This counterintuitive wisdom suggests that in the early days of building a company, founders should embrace manual, labor-intensive processes that would be impossible to maintain as the business grows. The idea is to provide an exceptional experience to early customers, learn directly from them, and refine the product before investing in automation and scalability.

Few companies embody this philosophy more perfectly than Algolia, the search-as-a-service company founded by Nicolas Dessaigne and Julien Lemoine in 2012. Today, Algolia powers search for thousands of websites and applications, processing billions of queries monthly for companies like Stripe, Twitch, and Medium. But in its early days, Algolia’s approach to customer onboarding and implementation was decidedly hands-on—to the point where the founders themselves became the API they were selling.

The Genesis of Algolia

Before diving into Algolia’s unscalable beginnings, it’s worth understanding the company’s origins. Nicolas Dessaigne and Julien Lemoine had worked together previously on text mining, algorithms, and search engines. They shared a vision of creating a search solution that would deliver the Google-like experience that users had come to expect, but for any website or application.

Interestingly, Algolia didn’t begin as a search-as-a-service offering at all. Initially, the company developed a software development kit (SDK) for mobile developers to implement search functionality in their applications. This approach allowed for fast, offline search capabilities—a valuable feature in the early 2010s when mobile internet connections were less reliable.

However, the founders soon realized that their SDK approach had limitations. Mobile developers were hesitant to integrate a third-party SDK that would increase their app’s size. Additionally, the offline search capability, while technically impressive, wasn’t addressing the most pressing needs of their potential customers.

This realization led to a pivot in 2013, when Algolia transformed into a hosted search API service. The new approach allowed developers to implement powerful search functionality through API calls, without the overhead of integrating a full SDK. This pivot proved to be crucial to Algolia’s eventual success, but it also presented a significant challenge: how to convince developers to trust and integrate a new, unproven API for a critical function like search.

The Unscalable Solution: Founders as the API

When Algolia pivoted to its API-based model, the company faced the classic chicken-and-egg problem of many B2B startups: they needed customers to prove their product worked, but potential customers were hesitant to adopt an unproven solution, especially for something as critical as search functionality.

This is where Dessaigne and Lemoine made a crucial decision that exemplifies the “do things that don’t scale” philosophy. Instead of simply providing documentation and expecting developers to figure out the integration themselves, the founders took a radically hands-on approach: they personally implemented the Algolia search API for their early customers.

This meant that when a company like Product Hunt decided to try Algolia, they weren’t just getting access to an API—they were getting the founders themselves, who would work directly with the customer’s development team to implement the search functionality, ensure it was working correctly, and optimize it for the specific use case.

The process typically looked something like this:

1. Initial consultation: The founders would meet with the potential customer to understand their specific search needs, the structure of their data, and the user experience they wanted to create.
2. Custom implementation: Rather than providing generic documentation and leaving the customer to figure out the integration, Dessaigne and Lemoine would write custom code for each customer, tailored to their specific application and data structure.
3. Hands-on integration: The founders would work directly with the customer’s development team, often pair programming or reviewing code line by line to ensure the integration was done correctly.
4. Optimization and refinement: After the initial implementation, they would analyze search patterns, user behavior, and performance metrics to fine-tune the search experience for that specific customer.
5. Ongoing support: Even after the initial implementation, the founders remained highly accessible to early customers, responding to questions, addressing issues, and implementing improvements.

This approach was incredibly time-consuming and completely unscalable. The founders were effectively functioning as an extension of each customer’s development team, providing a level of service that would be impossible to maintain as the company grew. But it served several crucial purposes in Algolia’s early days.

The Benefits of the Unscalable Approach

While Algolia’s hands-on implementation strategy was unsustainable in the long term, it provided several critical advantages that helped the company establish itself in a competitive market:

1. Building Trust Through Direct Involvement

By personally implementing their API for early customers, Dessaigne and Lemoine demonstrated their commitment to customer success. This built trust in a way that marketing materials or sales pitches never could. When the founders of a company are willing to roll up their sleeves and work directly on your implementation, it sends a powerful message about their confidence in their product and their dedication to making it work for you.

For early-stage startups, especially those offering technical products, this kind of trust is invaluable. Potential customers are taking a risk by adopting a new, unproven solution, and the founders’ direct involvement helps mitigate that perceived risk.

2. Gathering Invaluable Feedback

By working directly with customers on implementations, Algolia’s founders gained insights that would have been impossible to obtain through more distant customer interactions. They could see firsthand how developers interacted with their API, what challenges they encountered, what features they needed, and how they integrated search into their overall user experience.

This feedback loop was incredibly tight—the founders could identify issues or opportunities in real-time during the implementation process, rather than waiting for customer support tickets or feature requests to come in. This allowed them to rapidly iterate on their product, improving the API, documentation, and supporting tools based on direct observation of customer needs.

3. Creating Evangelists Through Exceptional Experiences

The hands-on approach created an exceptional experience for early customers. Instead of struggling through documentation or waiting for support tickets to be answered, they had the founders themselves ensuring their implementation was successful. This level of service created strong goodwill and turned early customers into vocal advocates for Algolia.

Product Hunt, one of Algolia’s early customers, became a particularly important reference. As a platform frequented by developers and startup founders—exactly the audience Algolia needed to reach—Product Hunt’s endorsement carried significant weight. The fact that Algolia powered Product Hunt’s search functionality served as a powerful demonstration of the API’s capabilities and reliability.

4. Learning the Common Patterns

By implementing their API for multiple customers, Dessaigne and Lemoine began to identify common patterns, challenges, and needs across different use cases. This informed the development of tools, libraries, and documentation that would eventually allow customers to implement Algolia without the founders’ direct involvement.

For example, they might notice that customers consistently struggled with a particular aspect of the integration, indicating a need for better documentation or a simplified API. Or they might observe that certain types of search optimizations were commonly needed, suggesting an opportunity for a new feature or configuration option.

5. Refining the Product Based on Real-World Usage

The direct implementation work provided a reality check on Algolia’s product. It’s one thing to design an API in the abstract; it’s another to repeatedly implement it for real-world applications with all their complexities and idiosyncrasies.

This hands-on experience helped the founders refine their API design, identify edge cases they hadn’t considered, and develop a deeper understanding of how their product would be used in practice. This led to a more robust, developer-friendly product that addressed real needs rather than theoretical ones.

The Transition to Scalability

While the hands-on implementation approach was effective for Algolia’s early growth, it was clearly unsustainable as the company expanded. The founders couldn’t personally implement the API for hundreds or thousands of customers. At some point, they needed to transition to a more scalable model.

This transition involved several key elements:

1. Comprehensive Documentation and Examples

Based on their experience implementing the API for early customers, Algolia developed detailed documentation and example code that addressed the common challenges and use cases they had encountered. This made it easier for new customers to implement the API without direct assistance.

2. Client Libraries and Integration Tools

Algolia created client libraries for popular programming languages and frameworks, abstracting away some of the complexity of working directly with the API. They also developed integration tools for common platforms like WordPress, Shopify, and React, further simplifying the implementation process.

3. Building a Customer Success Team

As the company grew, Algolia built a customer success team that could provide implementation support at scale. While this team couldn’t offer the same level of hands-on involvement as the founders had, they could guide customers through the implementation process and help troubleshoot issues.

4. Creating Educational Resources

Algolia invested in creating educational resources like tutorials, webinars, and documentation that helped developers understand not just how to implement the API, but how to design effective search experiences. This empowered customers to make informed decisions about their search implementation without requiring direct guidance.

5. Developing a Partner Ecosystem

Algolia began working with development agencies and consultants, training them on best practices for implementing the Algolia API. This created a network of partners who could provide hands-on implementation services to customers, scaling the high-touch approach beyond what Algolia’s internal team could provide.

The Results: From Unscalable Beginnings to Sustainable Growth

Algolia’s strategy of having the founders personally implement the API for early customers paid off handsomely. The company gained traction with influential early adopters like Product Hunt, which helped establish credibility in the developer community. The direct customer interactions provided invaluable feedback that shaped the product, making it more developer-friendly and effective.

In 2014, Algolia was accepted into Y Combinator’s Winter batch, further validating their approach and providing resources to accelerate their growth. The company went on to raise significant venture capital, including a $110 million Series C round in 2019, and has continued to expand its product offerings and customer base.

Today, Algolia powers search for thousands of websites and applications, processing billions of queries monthly. The company has expanded beyond basic search functionality to offer recommendations, personalization, and other discovery features. While the founders are no longer personally implementing the API for each new customer, the insights gained from those early, hands-on days continue to inform the company’s product development and customer success strategies.

Lessons for Entrepreneurs

Algolia’s journey offers several valuable lessons for entrepreneurs, particularly those building technical products or platforms:

1. Embrace Unscalable Approaches in the Early Days

Algolia’s success demonstrates the value of Paul Graham’s advice to do things that don’t scale. By providing an exceptional, high-touch experience to early customers, the company was able to build trust, gather feedback, and create advocates in a way that would have been impossible with a more hands-off approach.

For technical founders in particular, there can be a temptation to focus on building scalable systems from day one. Algolia’s story reminds us that sometimes, the most effective path to eventual scale involves decidedly unscalable beginnings.

2. Use Direct Customer Interaction as a Product Development Tool

By personally implementing their API for customers, Algolia’s founders gained insights that would have been difficult to obtain through more traditional product development methods. This direct interaction served as a form of continuous user research, informing product decisions and helping the company build something that truly addressed customer needs.

Entrepreneurs should look for opportunities to work directly with early customers, not just to provide service but to learn from the interaction. This hands-on experience can be invaluable in refining your product and understanding your market.

3. Build Scalability Based on Real-World Experience

Algolia didn’t start with a fully scalable approach to customer implementation, but they used their early, hands-on experience to inform the development of tools, documentation, and processes that would eventually enable scalability. This grounded their scalability efforts in real-world needs rather than theoretical assumptions.

Rather than trying to anticipate all the ways you’ll need to scale from day one, consider starting with a high-touch approach and using that experience to inform your scalability strategy. This can lead to more effective, customer-centric solutions.

4. Recognize the Value of Technical Founders in Customer-Facing Roles

In technical startups, there can be a tendency to keep the technical founders focused exclusively on product development, bringing in separate teams for customer-facing roles. Algolia’s story highlights the value of having technical founders directly involved with customers, especially in the early days.

The insights gained from these interactions can be invaluable, and the credibility that comes from having the founders themselves work on your implementation can help build trust with early adopters.

5. Balance Short-Term Tactics with Long-Term Strategy

While Algolia embraced an unscalable approach in the short term, they always had a vision for how they would eventually scale. They used the insights gained from their hands-on implementations to build the tools, documentation, and processes that would enable scalability.

Entrepreneurs should similarly balance short-term tactics with long-term strategy. Doing things that don’t scale can be effective in the early days, but you should always be thinking about how those experiences will inform your path to scalability.

Conclusion: The Power of Personal Implementation

Algolia’s story exemplifies the power of founders doing things that don’t scale in the early days of a startup. By personally implementing their search API for early customers like Product Hunt, Nicolas Dessaigne and Julien Lemoine were able to build trust, gather invaluable feedback, create vocal advocates, and refi
(Content truncated due to size limit. Use line ranges to read in chunks)