How to code the data in NVivo 15

TL;DR

Create and manage codes in NVivo 15 by selecting transcript segments and assigning them tag-like code names that summarize meaning.

Briefing Cornell Notes

Briefing

Coding in NVivo 15 is treated as the practical engine behind later thematic analysis: the software turns selected text from transcripts into “codes” (tags) that summarize meaning and can be reorganized into a thematic framework. The workflow centers on creating codes quickly, reusing existing ones, and then structuring them into hierarchies so the eventual themes become manageable and traceable back to the original quotes.

Before coding starts, the process begins with setting up the Codes area—often by opening the Codes folder so new codes appear in a visible list as they’re created. NVivo also supports a visual check during coding: enabling “highlight all coding” (or the highlight option) marks coded text in yellow, making it easier to see what has already been covered while moving through a transcript. With a transcript open, coding starts by selecting a segment (a sentence or a cluster of sentences) and then creating a code name. One approach is drag-and-drop: selecting text and dropping it into the coding area, then typing the code name. Another approach is to select the text and type a new code directly in the “code to” field. A third approach uses right-click options such as “code in vivo” (creating a code using the exact wording from the selected sentence) or “code selection” (creating a code based on the selection).

As coding progresses, NVivo’s autocomplete helps avoid duplicate work. Typing part of an existing code name brings up suggestions; selecting one and pressing enter (or dragging and dropping) assigns the new selection to that existing code. Each code tracks “references,” which correspond to the number of coded extracts (quotes). To review what a code contains, users can open a code (double-click or right-click → open code) and then read the associated quotes. NVivo offers different right-hand views, including a text view that organizes quotes vertically by source, and a way to jump back to the exact transcript location for a specific coded segment by clicking the source name.

Once a list of codes grows, organization becomes the next priority. NVivo supports hierarchical grouping through parent–child relationships. Users can create empty parent codes (for example, “positives” and “negatives”) without coding any text yet, then drag and drop existing codes into those groups. This makes the coding framework easier to scan by expanding and collapsing categories. When two codes overlap, NVivo can merge them: cutting one code and merging it into another updates reference counts to reflect the consolidation. For parent categories that should include everything under them, “aggregate coding from children” pulls references from child codes so the parent shows the combined totals.

Additional housekeeping options include renaming codes (single-click then edit, or code properties), creating code folders only when moving between major coding stages, and exporting either individual codes (with their quotations) or the entire codebook structure to share with colleagues. The overall message is straightforward: code the data, organize codes into a hierarchy, merge duplicates, aggregate child coding into parent categories, and then carry that structured coding framework forward into the final thematic framework.

Cornell Notes

NVivo 15 coding turns selected transcript text into “codes,” which function as tags summarizing meaning and later feed into a thematic framework. Codes can be created three main ways: drag-and-drop into the coding area, typing a new name in the “code to” field after selecting text, or using right-click options like “code in vivo” to replicate exact wording. Reusing codes is streamlined through autocomplete suggestions; each code tracks “references” (how many coded extracts/quotes it contains). As the code list expands, NVivo supports hierarchy via parent–child relationships using empty parent codes (e.g., “positives”/“negatives”), drag-and-drop grouping, and merging overlapping codes. Parent categories can be made complete with “aggregate coding from children,” which rolls up child references into the parent.

What exactly counts as a “code” in NVivo, and why does it matter for thematic analysis later?

In NVivo, codes are essentially tags—short labels that summarize the meaning of selected transcript segments. Users select text (either a sentence or a cluster of sentences) and assign it a code name. Those coded segments become the building blocks for later thematic work: the final thematic framework is treated as a refined version of the coding structure, since NVivo doesn’t create themes as a separate step beyond coding.

How can a new code be created from a selected transcript segment?

After selecting the text, one method is drag-and-drop: drop the selection into the coding area and then type the code name (e.g., “enjoys danger”). Another method is to select the text and then type directly into the “code to” field (e.g., “extreme situations”). A third method uses right-click options such as “code in vivo” (creating a code using the exact wording of the sentence) or “code selection” (creating a code based on the selection).

How does NVivo help prevent creating duplicate codes, and how are existing codes reused?

When typing a code name, NVivo provides autocomplete suggestions. Selecting the suggested existing code and pressing enter (or dragging and dropping onto the code) assigns the new selection to that existing code. Reference counts update accordingly, reflecting the number of coded extracts/quotes tied to the code.

What’s the practical workflow for reviewing what a code contains?

Users can open a code (double-click or right-click → open code) to see its quotes grouped by reference number (e.g., reference 1, reference 2). The right-hand side view can be switched, with “text view” preferred for vertical organization by source. If context is forgotten, clicking the source name jumps back to the transcript location and highlights only the segments coded under that code.

How are codes organized into groups, and what is the parent–child relationship used for?

To make a growing code list manageable, users create empty parent codes (for example, “positives” and “negatives”) via right-click → new code, without coding any text yet. Existing codes are then moved into these groups using cut/paste (or copy/delete on NVivo Mac) or drag-and-drop. Expanding/collapsing parent categories helps users scan what kinds of coded material exist across the dataset.

What tools handle overlap and roll-up when codes become redundant or when parent categories need totals?

When two codes represent the same idea, NVivo can merge them: cut one code and merge it into the selected target code, which updates reference counts to reflect consolidation. When a parent code should include all child coding, “aggregate coding from children” rolls up references from child codes so the parent shows combined totals rather than zero references.

Review Questions

When should “highlight all coding” be enabled, and what does it visually indicate during coding?
Describe three different ways to create a code from selected transcript text in NVivo 15.
What’s the difference between grouping codes under parent categories and using “aggregate coding from children”?

Key Points

1
Create and manage codes in NVivo 15 by selecting transcript segments and assigning them tag-like code names that summarize meaning.
2
Use “highlight all coding” to track which parts of a transcript have already been coded as you work.
3
Reuse existing codes via autocomplete suggestions to keep the coding framework consistent and avoid duplicates.
4
Review coded material by opening a code to read its quotes, then jump back to the original transcript using the source name.
5
Organize large code lists using parent–child hierarchies (e.g., grouping into “positives” and “negatives”) with drag-and-drop or cut/paste.
6
Merge overlapping codes to consolidate references and reduce redundancy in the framework.
7
Use “aggregate coding from children” so parent categories reflect the combined references of all child codes.

Highlights

NVivo treats themes as the end-state of coding: there’s no separate theme-creation option beyond building and refining codes into a thematic framework.

“Code in vivo” lets a code mirror the exact wording from the transcript, while other options create codes from the selection or via typed labels.

Reference counts update automatically when assigning new text to an existing code, making it easy to track how often ideas appear.

Parent categories can start as empty groupings, then be completed using “aggregate coding from children” to roll up all child references.

Export options include individual codes (with quotations) and a full codebook structure for sharing in a Word table.

Topics

NVivo 15 Coding
Creating Codes
Code Hierarchies
Merging Codes
Aggregating Coding
Exporting Codebook

Mentioned

NVivo