Contents

1. Introduction

1.1 What is NAVAL-QDA?

NAVAL-QDA is a desktop application for qualitative data analysis (QDA). It lets a researcher import interview transcripts, documents, and media; code that material against a hierarchical tree of nodes (codes); classify sources by case and attribute; write analytic memos; run text and coding queries; visualize patterns; and generate reports — all inside a single local Electron + React application, without any data leaving the researcher's machine unless an optional AI feature is switched on.

The project is currently in an early, pre-release stage (version 0.4.13 at the time of writing). Interfaces, database schemas, and menu wording may change between releases, so this guide should be read alongside the current in-app labels rather than as an unchanging reference.

1.2 Who this guide is for

This guide is written for students, academic researchers, UX researchers, and market researchers who need to code qualitative material — interviews, focus groups, open-ended survey responses, field notes — and who want a local-first, low-cost alternative to commercial CAQDAS (computer-assisted qualitative data analysis software) packages. No programming knowledge is required to use the application itself; the worked examples in Section 5 assume only that you can open the app and follow along step by step.

1.3 Key features at a glance

• Project Explorer: browse, switch, and create projects from a dedicated sidebar section.
• Sources: import .txt, .docx, and .pdf documents, plus audio/video files for transcription.
• Coding: build a hierarchical node (code) tree; apply codes to text selections; rename, merge, or move nodes; track percent of a source that has been coded.
• Cases & attributes: classify sources by case (e.g., participant) and attribute (e.g., age group, site), viewable in a classification sheet and framework matrix.
• Memos: attach analytic memos to sources, cases, or nodes.
• Queries: text search, word frequency, coding queries, matrix coding queries, and coding comparison (with agreement-level interpretation).
• Interactive dashboard: resizable, filterable bar, pie, treemap, and word cloud charts.
• Similarity clustering: compare sources by word usage or by coding pattern, with a similarity matrix and dendrogram.
• Reports: coding reports (all coded excerpts under a node, including its children) and project summaries.
• Optional AI assist: source summarization and child-code suggestions, backed by Gemini or Mistral; the app works fully offline without a key.
• Local-first storage: project data lives in a local SQLite database; nothing is transmitted anywhere unless the optional AI provider is enabled.

2. Installation and Getting Started

2.1 What NAVAL-QDA is built on

NAVAL-QDA is an Electron desktop application (Electron 43) with a React 19 + TypeScript front end (built with Vite) and a Node.js back end using better-sqlite3 (falling back to Node's built-in node:sqlite where necessary). Packaged installers are produced with electron-builder for Windows (NSIS), macOS (DMG), and Linux (AppImage/deb).

2.2 Obtaining and running the application

Step 1. Download or clone the project from the source repository: github.com/navalsingh9/naval-qda.

Step 2. Install dependencies and launch the development build with the project's own npm scripts, or install a packaged release for your platform if one has been built for you. Because the project is source-available (see Section 6 on licensing), redistributing modified copies is not permitted — only official releases published by the maintainer are authorized NAVAL-QDA distributions.

Step 3. On first launch, the app initializes a local SQLite database under the operating system's standard per-user application data directory. You do not need to configure a database connection yourself.

Step 4. (Optional) If you want AI-assisted source summaries and child-code suggestions, open the AI section in the sidebar and paste a Gemini API key into the settings panel, then save. You can alternatively set a GEMINI_API_KEY environment variable before launching the app, which the in-app panel will pick up automatically. Without a key configured either way, the app falls back to local placeholder summaries/suggestions so the rest of the application remains fully usable offline.

2.3 Interface overview

The application window is organized around a left-hand Workspace sidebar and a main panel that changes depending on which area you are working in. Project Explorer is the first item in the sidebar — it is where you browse, switch, and create projects, rather than a sub-panel reachable only through whichever project happens to be active.

• Project Explorer — browse every project, switch which one is active, or create a new one.
• Sources panel — import and browse documents and media for the active project.
• Node tree sidebar — the hierarchical list of codes for the project, with controls to create, rename, delete, move, and merge nodes; this lives inside the Coding workspace rather than as its own sidebar section.
• Coding workspace ("Code text to nodes") — a split view showing a source's text alongside the node tree, used to select passages and apply codes.
• Classification sheet — a spreadsheet-style view of cases and their attribute values.
• Query workspace ("Search, frequencies, and matrix views") — text search, word frequency, coding query, matrix coding query, and coding comparison panels.
• Visualizations — the interactive dashboard: word cloud, hierarchy treemap, bar and pie charts.
• Similarity — source clustering by word usage or coding pattern, its own sidebar section.
• Reports — coding report and project summary generation.

Figure 1. The Sources panel (NAVAL-QDA v0.4.13) with an active project — the Workspace sidebar on the left (Project Explorer now its own section), and the Sources / Cases & classification sheet / Framework matrix tabs on the right, sources shown in a compact table with each one's current case link.

3. Core Concepts

3.1 Project

A project is the top-level container for one study: its sources, node tree, cases, memos, and query results all belong to a single project.

3.2 Source

A source is an imported document (.txt, .docx, .pdf) or media file (audio/video, once transcribed). Each source has a title and a body of text that can be searched, coded, and linked to a case.

3.3 Node (code)

A node is a code in NAVAL-QDA's vocabulary — a label you apply to a stretch of text to mark that it represents a theme, concept, or category of interest. Nodes are organized hierarchically (a tree), so a broad theme such as "Barriers to adoption" can contain child nodes such as "Cost" or "Lack of training." Nodes can be created, moved to a new parent, or merged into another node.

3.4 Case and attribute

A case typically represents a unit of analysis such as a participant, site, or organization. Attributes are variables you attach to cases (for example, "Role" or "Experience level"), and each attribute can be given a value type such as text. Linking a source to a case lets you later filter or cross-tabulate coding by that case's attributes.

3.5 Memo

A memo is a free-text analytic note that can be linked to a source, a case, or a node, letting you record interpretations, decisions, or emerging ideas as you work.

3.6 Coder

Where more than one person codes the same material, each coder is tracked separately so that their coding can later be compared for agreement (see Section 5, Example 5).

4. Feature Reference

4.1 Sources

Import .txt, .docx, or .pdf files as text sources, or import audio/video for transcription. On import, NAVAL-QDA extracts and normalizes the text and builds a paragraph index so that later operations (search, coding, queries) can work against consistent character offsets. Apostrophes and quotation marks in .docx files are decoded to plain text rather than left as literal '/" markup.

4.2 Coding

Select a passage of text in the Coding workspace and apply a node to it. Applied codes ("codings") are stored as start/end character offsets against the source, so overlapping and non-contiguous coding is supported. The node tree lets you create child nodes, rename a node in place, delete a node (with a confirmation step, and an explicit prompt if it has children you may want to delete along with it), move a node to a new parent, and merge one node into another (which reassigns all of that node's codings). A percent-coded figure shows how much of a given source has at least one code applied.

4.3 Cases, attributes, and the classification sheet

Create cases to represent your units of analysis, define attributes with a value type, and set attribute values per case. Linking a source to a case makes that source's coding available for case-based filtering and cross-tabulation. The classification sheet shows every case with its attribute values in one spreadsheet-style table.

4.4 Memos

Create and edit memos linked to a source, a case, or a node, and list all memos attached to a given item. Memos are a good place to record why a coding decision was made, or to draft interpretive notes as themes emerge.

4.5 Queries

• Text search — plain-text or regular-expression search across some or all sources in a project, case-sensitive or not, returning each match with surrounding context.
• Word frequency — the most frequent words across selected sources, with a configurable minimum word length and stopword removal for common English function words.
• Coding query — every coded excerpt for one or more chosen nodes, optionally filtered to sources whose linked case has a particular attribute value.
• Matrix coding query — a nodes-by-cases matrix showing how many times each node was applied within each case, useful for comparing subgroups at a glance.
• Coding comparison — for a chosen source, node, and two coders, a paragraph-level contingency table (both coded, only coder A, only coder B, neither) that supports inter-coder reliability checks.

4.6 Interactive dashboard and similarity clustering

Visualizations were rebuilt around a real charting library — each chart card can be dragged to resize, and clicking a bar, pie slice, or treemap cell filters the other charts on the dashboard against it.

• Bar and pie charts — references per node, and distinct sources coded per node, each switchable to a table view.
• Word cloud — frequency-weighted word lists rendered as a word cloud.
• Hierarchy treemap — a nested view of the node tree sized by how much each node has been used, with non-overlapping leaf labels.
• Similarity clustering (its own sidebar section, not part of the dashboard) — groups sources either by word usage or by coding pattern, showing a similarity matrix and a dendrogram. An expandable "How is this number calculated?" section explains the underlying Jaccard-distance formula.

4.7 Reports

• Coding report — every coded excerpt under a chosen node and its child nodes, across all sources, in one list.
• Project summary — a project-level overview: number of sources, the full node tree with usage counts, the list of coders, and the classification sheet.

4.8 AI assist (optional)

Two optional AI-assisted actions are available: summarizing a source, and suggesting candidate child codes for a node based on a source's content. Both can be backed by Gemini or Mistral — pick a provider and add your API key from the AI section of the sidebar (Section 2.2, Step 4), or set the corresponding environment variable before launching. With no key configured, the app substitutes local placeholder output so the rest of the application remains usable without ever contacting an external service. AI suggestions are never applied automatically — review each one, then accept or reject it manually.

Formatting note: AI providers sometimes return markdown-style emphasis (e.g., **like this**) in their prose. The app strips these formatting marks before displaying a summary or suggestion, so what you see in the review panel is plain text.

4.9 Data storage and privacy

All project data — sources, nodes, codings, cases, attributes, memos, and query results — is stored in a local SQLite database under the operating system's per-user application data directory. No project content is transmitted anywhere unless you explicitly enable the AI provider, and even then only the specific content being summarized or analyzed for a suggestion is sent.

5. Five End-to-End Worked Examples

The five examples below share one running scenario so that the outputs of an earlier example become the inputs to a later one, the way a real analysis would unfold. Substitute your own project, sources, and node names when you follow along in the application; the screens, fields, and calculations described are accurate to how NAVAL-QDA's Sources, Coding, Cases, Query, and Report features are implemented.

Example 1 — Importing Sources and Building a Node Tree for Thematic Coding

Goal — Get transcripts into a project, build a first-pass node tree, and apply codes to text — then check how much of each transcript has been coded so far.

Step 1. Create a new project named "Remote Work Adoption Study" from the Workspace sidebar.

Step 2. Open the Sources panel and import the six transcripts (P1.docx … P6.docx). NAVAL-QDA extracts the text of each .docx file and builds a paragraph index automatically.

Step 3. Open the Node tree sidebar (inside the Coding workspace) and create two parent nodes: "Barriers to adoption" and "Enablers of adoption." Under "Barriers to adoption," create child nodes "Cost of equipment" and "Lack of training." Under "Enablers of adoption," create child nodes "Manager flexibility" and "Team trust."

Step 4. Open P1 in the Coding workspace. Read the transcript and, for each passage that illustrates one of the four child nodes, select the text and apply the matching node — for example, select the sentence "My manager just told us to figure out our own hours" and apply it to "Manager flexibility."

Step 5. Repeat coding for the remaining five transcripts. As you go, use the percent-coded indicator for each source to see how much of the transcript has at least one code applied, which is a quick way to spot passages you may have skipped.

Step 6. Partway through, decide that "Lack of training" is better understood as two separate ideas. Create a new child node "Lack of onboarding materials" under "Barriers to adoption," then move some existing codings there, or merge nodes later in Example 5 once you see how they were actually used.

Illustrative outcome

Example 2 — Cases, Attributes, and the Classification Sheet

Goal — Turn each participant into a case with attributes, link each source to its case, and review the result in the classification sheet.

Step 1. In the Cases area, create six cases: P1 through P6, one per participant.

Step 2. Create two attributes: "Role" (text: "Manager" or "Individual contributor") and "Team size" (text: "Small (<10)" or "Large (10+)").

Step 3. Set each case's attribute values based on your recruitment notes, for example P1 → Role: Manager, Team size: Large (10+).

Step 4. Link each transcript source to its matching case (P1.docx → case P1, and so on) so that later queries can filter or cross-tabulate by case attributes.

Step 5. Open the classification sheet to review all six cases and their attribute values in one table before moving on to querying.

Illustrative classification sheet

Example 3 — Text Search and Word Frequency for Exploratory Analysis

Goal — Use the Query workspace's text search and word frequency tools to sanity-check your emerging node tree against the raw language of the transcripts.

Step 1. Open the Query workspace and select all six sources as the search scope.

Step 2. Run a text search for the term "trust" (case-insensitive). Review each hit with its surrounding context to judge whether it reflects the "Team trust" node or something else, such as "trust the process."

Step 3. Run a word frequency query across the same six sources with a minimum word length of 4 and stopwords removed, requesting the top 10 terms.

Step 4. Compare the frequency list against your node tree from Example 1: frequent terms with no matching node are candidates for a new code; nodes with no corresponding frequent term may be too narrowly worded.

Illustrative text search result (excerpt)

Illustrative word frequency result (top terms)

Example 4 — Coding Query and Matrix Coding Query to Compare Subgroups

Goal — Retrieve every coded excerpt for a node with a coding query, then cross-tabulate node usage against case attributes with a matrix coding query.

Step 1. Run a coding query for the "Manager flexibility" node with no case filter, to review every excerpt coded to it across all six transcripts in one list.

Step 2. Re-run the same coding query filtered to cases where Role = "Individual contributor," to see only the flexibility excerpts that came from non-managers.

Step 3. Open the matrix coding query, set rows to nodes and columns to cases, and run it to get a full nodes-by-cases count matrix in one view.

Step 4. Read the matrix by row (which cases discuss a given theme most) and by column (which themes dominate a given participant's interview) to spot patterns worth writing up as a memo.

Illustrative matrix coding query (counts)

Example 5 — Inter-Coder Reliability and Reporting

Goal — Use the coding comparison query to build a paragraph-level agreement table for two coders on one node, interpret the resulting agreement level, and then generate a coding report and project summary to close out the analysis.

Step 1. Have both coders (Coder A and Coder B) code P3's transcript against the "Team trust" node independently, without seeing each other's work.

Step 2. Open the coding comparison panel, choose source P3, node "Team trust," and the two coders, then run the comparison. NAVAL-QDA splits the transcript into paragraphs and, for each one, records whether Coder A coded it, Coder B coded it, both did, or neither did.

Step 3. Review the resulting contingency table.

Step 4. Compute observed and chance agreement from the table above to get Cohen's kappa: observed agreement = (9 + 27) / 41 ≈ 0.878. Expected chance agreement, from the row and column marginals, works out to ≈ 0.583, giving kappa ≈ (0.878 − 0.583) / (1 − 0.583) ≈ 0.71.

Step 5. Classify that value using the same agreement bands NAVAL-QDA applies internally (adapted from Landis and Koch's scale): ≤0.00 Poor, 0.01–0.20 Slight, 0.21–0.40 Fair, 0.41–0.60 Moderate, 0.61–0.80 Substantial, 0.81–1.00 Almost perfect. A kappa of 0.71 falls in the "Substantial" band, indicating the two coders are applying "Team trust" consistently enough to treat their combined coding as reliable for this node.

Step 6. Once satisfied with reliability, generate a coding report for "Team trust" to list every coded excerpt under that node across all six transcripts, and a project summary to capture the final source count, full node tree with usage counts, coder list, and classification sheet as a record of the completed analysis.

6. How NAVAL-QDA Differs from NVivo

NVivo is a long-established, commercial QDA package now developed by Lumivero (formerly QSR International, which merged with Palisade and Addinsoft in October 2022 to form Lumivero). It is a mature, feature-rich product used widely across academia and industry. NAVAL-QDA is a much younger, source-available desktop tool with a narrower feature set. The comparison below is meant to help you choose the right tool for a given project, not to claim parity between a pre-release application and an established commercial product.

6.1 Practical takeaway

• Choose NAVAL-QDA when you want a free, local-first, source-available tool for a small-to-medium qualitative project, are comfortable with an early-stage feature set, and do not need multi-user cloud collaboration.
• Choose NVivo when you need a mature, vendor-supported package with a broader query and visualization toolkit, formal statistical reliability reporting, team collaboration, or support for a wider range of import formats and languages.

7. Citing NAVAL-QDA in Your Work (APA 7th Edition)

If you use NAVAL-QDA to support a thesis, dissertation, journal article, or report, cite it as software in your reference list, and note the version you used in your methods section so your analysis can be reproduced.

7.1 Reference list entry

NAVAL-QDA. (2026). Naval-QDA (Version 0.1.2) [Computer software]. GitHub. https://github.com/navalsingh9/naval-qda

APA 7 treats software as a "work with no individual author" when the developer is credited as an organization or project name rather than a named person, which is the case here (the repository lists "NAVAL-QDA" as the package author). Adjust the year to the year of the release you actually used, and update the version number to match.

7.2 In-text citation

• Parenthetical: (NAVAL-QDA, 2026)
• Narrative: NAVAL-QDA (2026) was used to code and query the interview transcripts.

7.3 Methods-section wording (example)

"Interview transcripts were imported, coded, and queried using NAVAL-QDA (Version 0.1.2; NAVAL-QDA, 2026), an open, local-first qualitative data analysis application. Coding was carried out by two researchers, and inter-coder agreement was assessed using NAVAL-QDA's coding comparison query (see Section 5, Example 5, of the NAVAL-QDA User Guide)."

Bibliography

Braun, V., & Clarke, V. (2006). Using thematic analysis in psychology. Qualitative Research in Psychology, 3(2), 77–101. https://doi.org/10.1191/1478088706qp063oa

Cohen, J. (1960). A coefficient of agreement for nominal scales. Educational and Psychological Measurement, 20(1), 37–46. https://doi.org/10.1177/001316446002000104

Landis, J. R., & Koch, G. G. (1977). The measurement of observer agreement for categorical data. Biometrics, 33(1), 159–174. https://doi.org/10.2307/2529310

Lumivero. (2026). NVivo (Version 15) [Computer software]. https://lumivero.com/products/nvivo/

NAVAL-QDA. (2026). Naval-QDA (Version 0.1.2) [Computer software]. GitHub. https://github.com/navalsingh9/naval-qda

NAVAL-QDA. (2026). SECURITY.md [Data storage and security policy]. GitHub. https://github.com/navalsingh9/naval-qda/blob/main/SECURITY.md