---
sidebar_label: Explore your software
toc_max_heading_level: 3
doc_id: 65564b54-d521-45cc-84bd-dfdc460acbf6
description: >-
  Find an application in Knowledge, read its book and runbook, check what a
  change reaches, and see where risk concentrates across your organization.
keywords:
  - Knowledge
  - knowledge base
  - impact analysis
  - dependencies
  - book
  - runbook
  - patterns
  - search
title: Explore your software
canonical: 'https://docs.nullplatform.com/docs/knowledge/explore'
---
# Explore your software

Knowledge shows up in two places in the console. The **Knowledge Base** section gives you the whole organization: search, impact, patterns, and open questions. Each application also gets its own **Knowledge Base** view with its book, relations, and facts.

Everything you read links back to its evidence. A relation shows the call it's based on, a fact shows its source and commit, and a book chapter links to the lines of code it describes.

## The Knowledge Base section

Open **Knowledge Base** from the switcher at the top of the console, next to **Development**. The menu on the left holds every page of the section.

<GuidedTour
  alt="The Knowledge Base overview, recreated as an HTML scene with a step-by-step walkthrough"
  steps={[
    {
      title: '1. Move around the section',
      body: 'Overview, Explore, Patterns, Impact, Applications, and Open questions. Learning path shows up when your organization has it.',
      anchor: 'kb-nav',
      placement: 'right',
    },
    {
      title: '2. Search everything',
      body: 'Books, facts, relations, norms, and open questions. Type a name, an endpoint, a concept, or a full question.',
      anchor: 'kb-search',
      placement: 'bottom',
    },
    {
      title: '3. Check the state of the organization',
      body: 'How many applications are analyzed, how many findings are open, and how many questions still need a person.',
      anchor: 'kb-metrics',
      placement: 'bottom',
    },
    {
      title: '4. See where risk concentrates',
      body: 'Open findings by namespace, and the problems that repeat across many applications.',
      anchor: 'kb-risk',
      placement: 'top',
    },
    {
      title: '5. Start with what needs attention',
      body: 'The applications with the most high-severity findings. Click one to open it.',
      anchor: 'kb-attention',
      placement: 'top',
    },
  ]}
>
  <KnowledgeScene />
</GuidedTour>

### Search and ask

Use the search box on the **Overview** or on **Explore**. Results are grouped by kind, such as documents, components, facts, relations, questions, and knowledge, and you can filter by kind with the chips above the list. Select a result to read it next to the list, then jump to its application or to its impact from the reader.

When you type a question, such as "how do we send a transactional notification to a customer?", an **AI answer** may appear above the results. It reads the most relevant results and answers by citing them, so you can open each source. It never writes anything to Knowledge.

:::note
AI answers can be wrong. Check the cited sources before you act on one. If Knowledge doesn't hold the answer yet, it says so and shows you the closest results instead.
:::

With an empty search, **Explore** lets you browse two things:

- **Norms and know-how**: everything your organization wrote down, grouped by where it applies, from **Everywhere** down to **For one application**. This is also where you [add your own know-how](/docs/knowledge/contribute#add-know-how).
- **Facts by application**: the structured facts the analysis wrote about each application, readable as tables or YAML, with the source and commit of each one.

### Check what a change reaches

**Impact** answers "what breaks if this changes?". Pick a shared component, such as an internal API, a library, a vendor, a queue, or a datastore, and see everything that depends on it, grouped by namespace.

<KnowledgeScene view="impact" framed />

The panel on the right ranks the **calls that reach it**: the HTTP method and path each consumer uses, and how many components make each call. A change to the call at the top reaches the most consumers. Select a group or a dot in the map to list its components, and **See its impact** on any of them to follow the chain one more hop.

:::tip
Use **Impact** before you change a contract, rotate a shared credential, or upgrade a core system. It turns "who do we have to warn?" into a list with the operation each team uses.
:::

### Fix a problem once with patterns

**Patterns** groups the findings that repeat across applications, such as the same misconfiguration copied into a dozen services. The chart places each pattern by how far it reaches and how severe it is, and **Start here: wide and severe** is the corner to tackle first.

A pattern's page shows where it comes from, for example the same lines of code copied from one source, how it's fixed, and every application that has it. Click an application to open its [action items](/docs/action-items/) already filtered to that pattern.

### Browse the applications

**Applications** lists every analyzed application with its criticality, its open findings, its open questions, how many components use it, and how old its analyzed code is. Use the quick filters to find the ones with high-severity findings, open questions, or code older than six months.

### Learning path

When your organization has it, **Learning path** builds a reading list for you. If you're new, pick a goal, such as **Onboarding**, **Ship changes to my apps**, or **Be on call**, and the namespaces you'll work in. You can also ask for a path about any topic, such as "how approvals work". It picks the book chapters, runbooks, norms, and open questions that matter for that goal, and tracks what you've read.

If you've been around for a while, it also shows the applications you changed recently and the people who changed them with you, so you know who to ask.

## An application's knowledge

On an application's overview, the **Knowledge Base** card on the right sums up what Knowledge knows: its criticality, how old the analyzed code is, its open findings and questions, and who uses it. Click **Open**, or open **Knowledge Base** from the application sidebar, to read the full view.

<GuidedTour
  alt="An application's Knowledge Base view, recreated as an HTML scene with a step-by-step walkthrough"
  steps={[
    {
      title: '1. Know what you are reading',
      body: 'The repository and the commit the analysis read, and how long ago it was analyzed. A Not in production label means the application has no production scope, so its relations come from code that does not run in production.',
      anchor: 'app-header',
      placement: 'bottom',
      align: 'end',
    },
    {
      title: '2. See who it touches',
      body: 'Who uses it, by namespace. What it depends on, by type. Its open findings, by severity, with a link to Action items.',
      anchor: 'app-highlights',
      placement: 'bottom',
    },
    {
      title: '3. Pick a view',
      body: 'Overview holds the book and the documents. Relations, Questions, Profile, and Facets cover the rest.',
      anchor: 'app-tabs',
      placement: 'bottom',
    },
    {
      title: '4. Read the book',
      body: 'What the application is and how it works, chapter by chapter, plus documents such as the runbook and its risks. Search inside this application from here.',
      anchor: 'app-book',
      placement: 'right',
    },
    {
      title: '5. Fix what is wrong',
      body: 'Suggest a correction or add context to the chapter you are reading. It is signed with your name.',
      anchor: 'app-contribute',
      placement: 'top',
    },
  ]}
>
  <KnowledgeScene view="app" />
</GuidedTour>

The view has five tabs:

| Tab | What you'll find |
|---|---|
| **Overview** | The book, chapter by chapter, and the other documents, such as the runbook and its risks. Search or ask about this application from the box at the top |
| **Relations** | What the application calls and what calls it, as a map. Choose a lens: **Runtime** (APIs, queues, identity providers, datastores), **Deployment** (the scopes it runs on), **Build & supply chain** (base images, libraries, CI templates), or **All**. Turn groups on and off under **Depends on** and **Used by** to focus the map. Select a component to see exactly which endpoints it calls |
| **Questions** | What its analysis couldn't answer from the code. [Answer them](/docs/knowledge/contribute#answer-open-questions) from here |
| **Profile** | A summary of its facts: where it runs, what it exposes, how it's configured, the data it holds, access and secrets, and the standards it fails |
| **Facets** | Every fact recorded about it, with its [provenance](/docs/knowledge/#how-much-to-trust-each-fact) and when it was updated. Search them or filter by provenance, and open one to read it as YAML or as tables |

:::tip
In **Profile**, open **What it exposes** to see every endpoint with the permission it checks, whether it's public, and the file where it's defined.
:::

If an application has no knowledge yet, it hasn't been analyzed. Its knowledge appears after the first analysis.

### Dependencies on the application overview

Your administrator can also add a **Dependencies** card to every application's overview. It shows the application's relations as a small map and a table, and **See all relations** opens the **Relations** tab.

## Related docs

- [Contribute knowledge](/docs/knowledge/contribute): answer open questions, add know-how, and correct what's wrong
- [Connect your agents](/docs/knowledge/agents): ask the same questions from your coding agent
- [Triage and resolve action items](/docs/action-items/triage-and-resolve): work through the findings Knowledge files