The Best Knowledge Base
After a lot of context switching between five different knowledge bases and interviews with startups using each one, we think that Slab is the best knowledge base for most teams.
After extensive testing, we've realized that there are two distinct product philosophies for knowledge bases, which we'll roughly call replication and integration. Replication-based products like Notion try to get you to replicate as much third-party functionality as possible within their products, while integration-based products like Slab try to defer to a third-party tool whenever possible. We're quite confident in saying that we think the integration-based approach is superior, but we'll talk about the distinctions at play in more detail later in this guide.
For teams that are keen on open-sourcevia a BSL license that converts to Apache in 2023 and self-hosting, or have somewhat unique privacy requirements, try Outline. While you can self-host, their managed product, only $10 for ten users, was also excellent. While it lacks some of the UI polish of Slab, Notion, or Slite, it effectively organizes a company wiki, provides a quality writing tool, and has the integrations needed to create useful documents and help the team keep them updated. Outline was also the only tool that offered full access to its API in its most affordable tiers, which can suit more technical teams that want to invest time into automation and extensibility, or for those worried about data portability.
Two product philosophies
As previously mentioned, there are two distinct product philosophies for knowledge bases.
After extensive testing, we've realized that there are two distinct product philosophies for knowledge bases, which we'll roughly call replication and integration. Replication-based products like Notion try to get you to replicate as much third-party functionality as possible within their products, while integration-based products like Slab try to defer to a third-party tool whenever possible.
We think the integration approach is the better approach because it is best-suited to ensure a single-source of knowledge within your company. This is a result of the following reasons:
- By nature, it minimizes knowledge duplication across products. For example, if you're using a project management tool, you can embed an issue within a page in your knowledge base. If something changes, you'll only have to change the information in the original tool for its embed to update. With a replication-based knowledge base, you'll have to transcribe the issue manually, and if something changes, then you'll have to update every replicated instance manually as well. If this sounds like unnecessary work that might demotivate people to use the knowledge baseYou get half of the benefit just by getting a team to use it and create potential information mismatches, then you'd be correct. And, importantly, it becomes hard to figure out whether canonical information is in the knowledge base or the original tool.
- Replication-based tools are inherently general-purpose and unopinionated to support all of the workflows that users might build. That lack of structure becomes an issue once your team grows to an appreciable size. One software engineer we talked with explained it quite eloquently (when talking about Notion, a quintessential replication-based tool):
It's beautiful and amazing for personal use and I actually like using it to prototype application ideas, but getting an entire team on board to use it "the right way" is unbelievably annoying. Do project plans go in Notion? What about in-progress pages? Should there be a canonical table of customers? Notion provides no opinion on these questions, but your team will happily fill that void many times over.
Why use a knowledge base
Anyone who's written a technical specification or a sales playbook knows just how hard it is to write in a way that de-silos information and serves as a useful recurring reference. Typical startup happenings, such as upcoming product launches or week-to-week changes in spec, can quickly hobble any startups' ability to get tribal knowledge out of their team members' heads. Unfortunately, it only gets worse as a team grows.
Enter the knowledge base, a dedicated tool intended to keep stakeholders across a company — leadership, engineers, product managers, designers, and customer success teams alike — engaged with getting the knowledge in their heads written down such that it can start benefitting the rest of the company.
Being able to unify company knowledge across different tools and resources, and thereby having a single source of truth for knowledge within a company, is much of the value of a knowledge base. E.g. having Airtable or Google sheets data in a page to show the breakdown of different support use cases, or an embedded Google map that shows how your routing algorithm works, or even a Youtube video that explains how to package a product for physical delivery correctly, can take a workflow from incomprehensible to manageable.
Another point that's particularly relevant at the time of writing: we've found knowledge-bases help build team cohesion, especially with a growing trend towards remote. As interactions and decisions for remote teamsWhich most of us are likely part of at this current point in time occur in a more fragmented and asynchronous manner, clear documentation of decisions and information is essential to ensuring that your team is on the same page and that any potential blockers are minimized. And, as remote work starts becoming more common, clear online written communication will only increase in value.
A note on scope
We don't focus on building a wiki with Google Drive, other shared directory providers like Dropbox Paper, or git-tracked text files. Teams we spoke to who didn't want to manage one more admin panel or pay the cost of a dedicated company wiki often went this route. These are valid strategies for managing company knowledge, but we think it's worth adopting a dedicated company knowledge base for even the leanest of startups.
Our recommendation: Slab
We think Slab is the best knowledge base because it is the product that is best suited to become a single source of knowledge within your company.
Slab is the only knowledge base that fully embraces the integration-based approach, which we think is the best product philosophy, and offers embeds and integrations wherever possible. It actively tries to help you avoid replicating information that might live elsewhere, so you don't end up with multiple variations of the same information that all need to be updated.
Plus, it's a great product. It helps teams document and maintain complex sets of tasks and processes in an understandable and user-friendly way that led founders we spoke to gush about it. Slab marshals a complete set of features and integrations, including the best writing UI we tested, simple administration tools, and a good interface for rich text commands and embeds. First and foremost, it focuses on being a reference rather than a more all-encompassing product management and productivity tool, which was key to its effectiveness. The absence of pre-built templates within the application and typed data tables, deferred instead to an Airtable embed, is an illustrative example of the tool's philosophy of joining resources rather than re-creating them.
For all this praise, though, Slab isn't perfect. It lacks API access for its non-enterprise plans, which can be critical for customers concerned about portability or specific documentation-bound workflows. Also, the choices that make it feel fast make it possible to lose input data in an internet outage or network failure (more on how this affects all the tools in the tips section below).
Nonetheless, Slab is the most focused wiki-writing tool we reviewed, and one that encourages users to weave together company resources in a way that was well-received by both founders and our review team. Its customer service and support also received top-notch marks with no complaints from founders and a praise for the fast turnaround time for the addition of product embeds/integrations on request.
The Remaining Competition
The OSS recommendation: Outline
Outline is our preferred knowledge base for teams that feel strongly about using OSSNote that it isn't fully-fledged FOSS since Outline is licensed under the recently developed BSL. or need access to an API. It can also be the best option for teams that might not have access to Slab or Slite's startup deals More on this in the tips section below.. At $10/mo for ten team members and $79/mo for 100 it's almost 10x cheaper than the other alternatives in this article sans startup deals. Integrations for Slack and Zapier, as well as high-quality embeds are present, with a focus on the unification of reference materials within your Outline docs. It also has the option to self-host, if that's your cup of teaAlso, critically, at least for this reviewer, it also has a dark-mode color scheme..
There are trade-offs, of course. The UI is less sleek than many of its competitors, e.g. the oft-mentioned command bar is a bit harder to parse, and the typography doesn't feel quite as neat. It lacks pre-fab templates, and the team management/admin panels/permissions UI requires a bit more attention than those laid out by other providers. But, despite these complaints, the essentials are all in there, and we expect it will only get better. As a developer-focused open-source tool, we see good promise for plugin development and reuse as Outline and its community continues to grow.
Slite is a hybrid product that toes the line between an integration-based and replication-based product philosophy, although our understanding is that it's slowly progressing more towards the latter.
Slite's editor is almost as snappy as Slab's, and its rich-text invocation UI was our favorite design with its horizontal layout and greyscale icons. Although fewer than Slab's, its embeds and integrations aim to reduce breaks in context while users are writing, e.g. creating new cards in Trello from a Slite post, for instance. The presence of workflow templates and typed data tables suggest that Slite, much like Notion, has ambitions that extend into the realm of product and light data management.
We prefer the way that Slite approaches this ambition to how Notion handles the same challenge. By encouraging the creation of resources in third party tools through Slite, and then embedding those newly created resources in documents, the tool has a "never leave the command line" level of usability. Plus, the substantial baseline of integrations is a decent guard against knowledge duplication. That said, despite the integrations, we think that Slite is still starting to approach a don't-leave-the-doc philosophy, akin to NotionWe see this with Confluence, where there is limited integration and embed support for content hosted outside the Atlassian universe.
In general, Slite inhabits a middle ground between Slab and Notion. It has a pretty powerful general-purpose editor, but not as powerful as Notion's; it has a decent number of integrations, but not as extensive as Slab.
Notion was the most used tool by the founders we spoke with. It's mature, has a great editor, and the teams that most appreciated it committed to using it for, well, mostly everything (e.g. CRM, project management, data storage, etc.). As previously mentioned, we don't think this is the ideal approach, but it has the potential to pay off if you can get good team buy-in and maintain discipline around its use.
First off, we want to say that we fully understand people's love for Notion. At Satchel, we love it for personal use, but we also understand that what makes it a much-loved product for personal use makes it less good for teams.
When you're using Notion personally, you can keep all of your schemas and workflows in your head. On top of that, you're probably not using third-party SaaS tools in your day-to-day personal (i.e. non-work) life. However, these two become issues in a team environment. Because there's no "right" schema, your team will be spending brain cycles figuring that out and staying on top of changese.g. "Are we tracking issues in a kanban board or a table? What about for our customer list?". And because in a startup you'll likely be using third-party tools (e.g. mail-merge and scheduled emails via a CRM), you'll need to figure out where information should liee.g. "Do we track engineering issues in Notion as well as Github? What information do we record in Notion, and what do we record in Github?".
To be clear, this isn't to say that teams can't figure out a way around these issues. We just think that these issues result from Notion's fundamental design choices and are avoidable by using a different product for a knowledge base.
Once API access becomes available This is a promised feature for the Personal Pro tier on their pricing page and has been on their roadmap since at least early 2019., some of these concerns might be eased, but until then, we'd generally recommend sticking with a different product.
Confluence is great if you live in Atlassian world. It integrates seamlessly with all of the tools from that productivity suite and brings the most cohesive design amongst all the tools we tested. Plus, the markdown functionality is some of the best we've seen in providing easy-to-use upfront formatting.
Still, the absence of many of the integrations and rich embeds present in other tools, a high price tag, and UI slowdowns in navigation outside of the editor context make Confluence hard to recommend for non-Atlassian customers.
We found that many of the founders we spoke to commonly hooked their knowledge bases up to a communication platform, typically Slack. This particular integration is the most advertised for the knowledge bases we tested, and that makes sense — it's usually quite helpful to know when there's an improvement on long-standing information. For teams that don't use Slack, email can, of course, also cover these bases so long as your team remembers to check the folders where all the automated notifications get filtered into.
If you often work with intermittent internet, or on-the-go where network failures are more common, then make sure to check how your editor handles these disruptions. Notion, Slab, and Slite all took a fair amount of time to notify the author that the document was offline and that the text might not be saved if that particular browser tab was closed. Notion was particularly bad in this regard — not only did the notification take some time to show up, but it was also quite subtle as a same-color text box that cropped up in the top editing bar. Some users reported this experience was better in the Desktop app, but that data loss was still an issue. Outline gave the fastest in-your-face notification of potential data loss.
Teams should also note that many of the listed knowledge bases offer excellent startup deals through incubators. We've heard Slite, for example, provides a 90%-off lifetime discount for the first ten team members via several accelerators, a deal that could push it ahead of Slab when being considered by companies that don't plan to expand headcount by a significant amount. Slab and Notion also offer substantial startup discounts, but their plans seem more geared towards bringing you in for a period of timeOne year of discounts for Slab and $1,000 in credits for Notion before charging full price.