Tutorials › Biostatistics › Table, Listing, and Figure (TLF) Development Basics

Clinical Trial Reporting & Statistical Programming

Table, Listing, and Figure (TLF) Development Basics

A practical guide to developing clinical-trial Tables, Listings, and Figures, from statistical shells and analysis populations through programming, formatting, quality control, traceability, and final production of submission-ready outputs.

Intermediate 18 min read

What You'll Learn

  • What Tables, Listings, and Figures are designed to communicate in a clinical study
  • How TLF shells translate the SAP into concrete statistical outputs
  • How analysis populations, treatment groups, visits, and endpoints determine TLF structure
  • How descriptive statistics, inferential statistics, and denominators are represented
  • How TLF programming, formatting, QC, and traceability fit together
  • How to identify common TLF development errors before database lock and submission

Introduction

Clinical trials generate large amounts of statistical information. The final clinical study report, regulatory submission, and internal study reviews must transform that information into outputs that investigators, statisticians, clinicians, regulators, and other reviewers can interpret efficiently.

The primary mechanism for presenting these results is the Table, Listing, and Figure, commonly abbreviated as TLF.

A TLF is more than a formatted statistical result. A well-designed output communicates the study population, treatment groups, analysis method, endpoint definition, time point, and resulting evidence in a standardized and reproducible form.

Key idea: TLF development is the process of translating the statistical analysis plan into reproducible clinical-trial outputs. The goal is not simply to make a table look correct, but to ensure that the output represents the correct population, endpoint, analysis, and data.

What Are Tables, Listings, and Figures?

The three major TLF categories serve different purposes.

Output Primary Purpose
Table Summarizes data using structured rows and columns
Listing Presents subject-level or record-level information in detail
Figure Communicates patterns, trends, distributions, or relationships visually

Tables

Tables are generally used when the reader needs a concise summary of a population, endpoint, treatment comparison, or safety event.

Examples include:

  • Demographic and baseline characteristics
  • Disposition of subjects
  • Primary efficacy results
  • Secondary efficacy results
  • Adverse event summaries
  • Laboratory shift tables
  • Vital-sign summaries
  • Exposure summaries

Listings

Listings provide more granular information than tables. They commonly display individual subjects or individual records.

For example, a serious adverse-event listing might contain:

  • Subject identifier
  • Treatment group
  • Adverse-event term
  • Start and stop dates
  • Severity
  • Relationship to treatment
  • Seriousness
  • Outcome

Listings are particularly useful for reviewing individual patient profiles, important safety events, protocol deviations, deaths, and other events where aggregate summaries may not be sufficient.

Figures

Figures allow investigators and reviewers to recognize patterns that may be difficult to see in a numerical table.

Common examples include:

  • Kaplan–Meier survival curves
  • Mean profiles over time
  • Boxplots
  • Forest plots
  • Waterfall plots
  • Scatterplots
  • Subject-level laboratory profiles
Important: A figure should not simply reproduce a table in graphical form. The choice of graphical display should reflect the scientific question being communicated.

The TLF Development Lifecycle

TLFs are usually developed through a sequence of planning, programming, review, validation, and production steps.

1
Define the reporting requirement: determine what clinical question the output must answer.
2
Develop the shell: define the intended structure, populations, variables, statistics, and footnotes.
3
Program the analysis: derive the required analysis variables and calculate the statistical results.
4
Format the output: apply titles, headers, footnotes, decimal rules, pagination, and presentation standards.
5
Perform QC: independently verify the programming logic, results, population, and presentation.
6
Finalize: produce the controlled final output for the intended clinical or regulatory use.

TLF Shells

A TLF shell is a specification for what the final output is expected to contain before the actual study results are populated.

The shell serves as a bridge between the SAP and the statistical programming.

For example, an efficacy table shell might specify:

Component Example
Population Full Analysis Set
Endpoint Change from baseline in disease score
Time point Week 24
Treatment columns Placebo, Treatment A
Statistics N, mean, SD, median, minimum, maximum
Inferential analysis Adjusted treatment difference and confidence interval
Footnotes Analysis method, missing-data handling, abbreviations
Why shells matter: The shell establishes what should be produced before programmers begin calculating results. This reduces ambiguity and makes it easier for the statistician, programmer, and reviewer to agree on the intended analysis.

From the SAP to the TLF

The SAP defines the statistical methods. The TLF shell translates those methods into specific outputs.

Consider a SAP statement such as:

$$ \text{Change from baseline} = \text{Post-baseline value} - \text{Baseline value} $$

The corresponding TLF might need to display:

  • Number of subjects analyzed
  • Baseline value
  • Week 24 value
  • Change from baseline
  • Treatment-group summaries
  • Between-group comparison
  • Confidence interval
  • P-value

Thus, the TLF is not an independent statistical exercise. It is the operational implementation of the analysis defined in the SAP.

Analysis Populations

One of the most important decisions in TLF development is determining which subjects belong in each output.

Common analysis populations include:

Population Typical Use
Safety Set Safety summaries and adverse-event analyses
Intent-to-Treat / ITT Primary or supportive efficacy analyses, depending on protocol
Full Analysis Set Efficacy analyses based on the prespecified estimand and population
Per-Protocol Set Supportive efficacy analyses in subjects sufficiently compliant with the protocol
Pharmacokinetic Set PK concentration and parameter analyses

The exact definitions are study-specific and should be taken from the protocol, SAP, or relevant population specifications.

Common programming error: A TLF can contain perfectly calculated statistics and still be wrong if the programmer uses the wrong analysis population.

Treatment Groups and Denominators

Treatment columns are another fundamental component of TLF development.

Suppose a study contains:

  • Placebo
  • Low-dose treatment
  • High-dose treatment
  • Total

The TLF must clearly identify which subjects contribute to each column.

For a proportion:

$$ \text{Percentage} = \frac{\text{Number of subjects with event}} {\text{Number of subjects in denominator}} \times100 $$

The denominator is therefore critical.

For example, if 8 of 50 subjects experience an event:

$$ \frac{8}{50}\times100=16\% $$

But if only 40 subjects have post-baseline assessments and the analysis specifies that the denominator is the number evaluable at that time point, the appropriate denominator may instead be 40.

TLF rule: Never assume that the denominator is simply the number randomized. The denominator should be determined from the analysis specification and the endpoint definition.

Descriptive Statistics

Many clinical-trial TLFs summarize continuous variables using a standard set of descriptive statistics.

Statistic Meaning
N Number of nonmissing observations
Mean Arithmetic average
SD Standard deviation
Median 50th percentile
Q1 25th percentile
Q3 75th percentile
Minimum Smallest observed value
Maximum Largest observed value

The mean is calculated as:

$$ \bar{x} = \frac{1}{n} \sum_{i=1}^{n}x_i $$

The sample standard deviation is:

$$ s = \sqrt{ \frac{1}{n-1} \sum_{i=1}^{n}(x_i-\bar{x})^2 } $$

A TLF specification should make clear which statistics are required and how they should be displayed.

Categorical Summaries

Categorical variables are commonly displayed as counts and percentages.

For example:

Adverse Event Placebo (N=50) Treatment A (N=50)
Headache 8 (16.0%) 11 (22.0%)
Nausea 5 (10.0%) 7 (14.0%)
Fatigue 4 (8.0%) 9 (18.0%)

The displayed percentage is generally based on the appropriate denominator specified for the analysis.

Programmers must also consider whether subjects can contribute to more than one category. This is especially important for adverse-event tables.

Important: In many adverse-event summaries, a subject may experience multiple different events but should be counted only once within a particular event category. The counting rule must follow the SAP and table specification.

Inferential Statistics in TLFs

Many TLFs contain both descriptive and inferential statistics.

For example, a treatment comparison might include:

  • Adjusted treatment difference
  • Standard error
  • 95% confidence interval
  • P-value

A confidence interval for a treatment difference can be represented generally as:

$$ \widehat{\Delta} \pm c\times SE(\widehat{\Delta}) $$

where \(\widehat{\Delta}\) is the estimated treatment difference, \(SE(\widehat{\Delta})\) is its standard error, and \(c\) is the appropriate critical value for the specified confidence level and analysis.

The precise method may instead involve a model such as ANCOVA, MMRM, logistic regression, Cox regression, or another prespecified method.

Key principle: The statistical method displayed in the TLF must correspond to the method specified in the SAP. A programmer should not substitute a different analysis simply because it is easier to code.

Visit Structure

Longitudinal clinical-trial outputs frequently organize results by visit.

Visit Placebo Treatment A
Baseline 50 50
Week 4 47 48
Week 12 45 46
Week 24 42 44

The programmer must determine how visits are derived and which records represent the analysis value for each subject at each visit.

This becomes particularly important when there are:

  • Unscheduled visits
  • Repeated measurements
  • Windowed visits
  • Early termination visits
  • Post-baseline assessments
  • Multiple records on the same date

Missing Data

Missing data can substantially affect TLF results.

For example, suppose 100 subjects are randomized but only 82 have a Week 24 assessment.

A table may therefore show:

$$ N=82 $$

rather than:

$$ N=100 $$

The appropriate approach depends on the endpoint and analysis method.

Possible approaches include:

  • Observed-case analysis
  • Mixed-effects models
  • Multiple imputation
  • Nonresponder imputation
  • Last observation carried forward
  • Worst-case or tipping-point analyses

The TLF should communicate the analysis actually performed rather than implicitly suggesting that missing observations were analyzed as though they were observed.

Table Titles and Numbering

Clinical-trial outputs are normally assigned unique identifiers.

For example:

Identifier Example Description
Table 14.1.1 Demographic and Baseline Characteristics
Table 14.2.1 Primary Efficacy Analysis
Table 14.3.1 Overall Summary of Treatment-Emergent Adverse Events
Figure 14.2.1 Kaplan–Meier Estimate of Time to Event
Listing 16.2.1 Subjects with Serious Adverse Events

The numbering convention is study-specific. The important requirement is that every output can be uniquely identified, tracked, reviewed, and reproduced.

Footnotes and Abbreviations

Footnotes provide information that is necessary to correctly interpret an output.

A well-designed table may contain footnotes describing:

  • The analysis population
  • The statistical method
  • Missing-data handling
  • Multiplicity adjustments
  • Rounding conventions
  • Definitions of abbreviations
  • Special counting rules
  • Confidence-interval methodology

For example:

Example: Values are mean (SD) unless otherwise specified. N represents the number of subjects with nonmissing data. Percentages are based on the number of subjects in the specified analysis population.

Footnotes should explain information that cannot be understood reliably from the table itself.

Programming a TLF

Once the shell has been approved, the programmer converts the specification into executable statistical programming.

A typical workflow is:

1
Read the specification: identify the population, endpoint, treatment groups, visits, statistics, and display rules.
2
Identify the source data: determine which SDTM, ADaM, or derived analysis datasets contain the required information.
3
Construct the analysis dataset: derive analysis flags, baseline values, changes, treatment variables, and other required analysis parameters.
4
Calculate statistics: generate counts, percentages, descriptive statistics, model estimates, confidence intervals, and p-values as required.
5
Apply formatting: construct the final table, listing, or figure according to the approved shell.

Example: Building a Simple Efficacy Table

Suppose a study compares placebo with Treatment A and evaluates change from baseline in a continuous endpoint at Week 24.

The shell might require:

Statistic Placebo Treatment A
N 42 44
Baseline Mean (SD) 72.4 (10.1) 71.8 (9.7)
Week 24 Mean (SD) 68.1 (11.2) 62.5 (10.4)
Change from Baseline Mean (SD) -4.3 (7.9) -9.3 (8.1)
Adjusted Treatment Difference -5.0
95% CI (-8.1, -1.9)
P-value 0.002

The output communicates several distinct pieces of information:

  • How many subjects contributed data
  • Whether the treatment groups were comparable at baseline
  • The observed Week 24 values
  • The within-subject change
  • The model-based treatment comparison
  • The uncertainty around the treatment comparison
  • The statistical evidence against the null hypothesis

Figures and Graphical TLFs

Figures require many of the same decisions as tables, but also require explicit choices about graphical encoding.

For example, a longitudinal mean-profile figure may contain:

  • Time on the x-axis
  • Change from baseline on the y-axis
  • One line for each treatment group
  • Error bars representing the specified uncertainty measure
  • A legend identifying treatment groups
  • A population and endpoint definition

A simple treatment profile might be represented conceptually as:

$$ \text{Mean Change}_{t} = \frac{1}{n_t} \sum_{i=1}^{n_t} \Delta_{it} $$

where \(t\) denotes the visit and \(n_t\) is the number of subjects contributing to the analysis at that visit.

Figure design principle: Every visual element should have a purpose. Avoid unnecessary decoration, misleading scales, unexplained symbols, or graphical choices that make treatment differences appear larger or smaller than they actually are.

Listings and Subject-Level Traceability

Listings are especially important when reviewers need to trace an aggregate result back to individual subjects.

For example, if a table summarizes serious adverse events, a corresponding listing might contain the individual records contributing to that summary.

Subject Treatment Event Serious? Outcome
001-001 Placebo Pneumonia Yes Recovered
001-014 Treatment A Appendicitis Yes Recovered
001-027 Treatment A Heart failure Yes Fatal

This relationship between aggregate outputs and subject-level records is an important component of clinical-trial data traceability.

Traceability

A high-quality TLF should be traceable through the analysis pipeline.

Conceptually, the chain is:

A
Source data: observations collected during the clinical trial.
B
SDTM: standardized tabulation datasets representing collected clinical-trial data.
C
ADaM: analysis-ready datasets containing derived variables and analysis structures.
D
Statistical programming: programs calculate the specified summaries or models.
E
TLF: the resulting statistical output is formatted for review or submission.

The further a programmer moves away from the source data, the more important it becomes to understand the derivations that produced the displayed result.

Quality Control of TLFs

TLF QC should address both the statistical result and the presentation.

A QC process may include:

QC Area Question
Population Are the correct subjects included?
Treatment Are subjects assigned to the correct treatment group?
Endpoint Is the correct parameter or endpoint being analyzed?
Visit Are the correct records selected?
Derivation Are baseline and derived variables correct?
Statistics Are the calculations correct?
Denominators Are counts and percentages based on the correct denominator?
Formatting Are decimals, labels, footnotes, and pagination correct?
Traceability Can important results be traced back to the analysis data?

Independent Programming QC

For important clinical-trial outputs, an independent programmer may reproduce the results using a separate programming approach.

The objective is not necessarily to recreate every line of the production program. Instead, the QC programmer should independently verify the critical logic and resulting values.

For example, if a table reports:

$$ \text{Treatment A mean change}=-9.3 $$

the QC process should be able to independently confirm the value from the appropriate analysis dataset.

QC can therefore be viewed as:

$$ \text{Production Result} \quad\stackrel{?}{=}\quad \text{Independent QC Result} $$

Agreement does not prove that the underlying analysis specification is correct, but it provides important evidence that the programmed implementation is reproducible.

Common TLF Development Errors

Many TLF errors are not caused by complicated statistical mathematics. They result from seemingly small inconsistencies between the protocol, SAP, ADaM datasets, programs, and output specifications.

Error Potential Consequence
Wrong analysis population Incorrect study conclusion
Incorrect treatment assignment Results attributed to the wrong group
Wrong baseline definition Incorrect change-from-baseline results
Incorrect visit selection Wrong longitudinal results
Incorrect denominator Incorrect percentages
Duplicate subject counting Inflated event counts
Incorrect rounding Discrepancies between displayed and source values
Outdated shell Output no longer reflects the approved analysis
Missing footnote Ambiguous interpretation

Common Programming Pitfall: Duplicate Records

Suppose a subject has multiple records for the same analysis visit.

If the intended analysis requires one observation per subject per visit, the programmer must establish the correct selection rule.

For example:

$$ \text{One Subject} \rightarrow \text{One Analysis Record per Visit} $$

Failure to enforce the intended structure can result in:

  • Incorrect sample sizes
  • Incorrect means
  • Incorrect standard deviations
  • Incorrect percentages
  • Incorrect model inputs
Practical check: Before calculating statistics, verify the expected observation structure. Ask how many records each subject should contribute to the analysis.

Rounding and Display Rules

The stored analysis value and the displayed TLF value are not necessarily the same number of decimal places.

For example, the underlying value might be:

$$ -9.347826 $$

while the TLF displays:

$$ -9.35 $$

The rounding rule should be prespecified or standardized rather than selected arbitrarily during output production.

Different variables may require different display precision.

Variable Possible Display
Age Years, typically 1 decimal or integer depending on specification
Laboratory measurement Parameter-specific precision
Percentage 1 decimal place
P-value Study-specific convention
Confidence interval Usually consistent with the estimate's precision

Statistical vs. Presentation Errors

It is useful to distinguish between two broad classes of TLF errors.

Type Example
Statistical error Wrong model, wrong population, incorrect calculation
Data-selection error Wrong visit or duplicate record selected
Display error Incorrect decimal places or rounding
Labeling error Incorrect treatment or endpoint label
Formatting error Broken pagination or misplaced footnote

A table can therefore be numerically correct but still unacceptable if its labels or presentation are misleading.

TLF Review Checklist

Before approving a TLF, reviewers should systematically check the output.

  1. Confirm the output number and title.
  2. Confirm the analysis population.
  3. Confirm treatment groups and treatment labels.
  4. Confirm the endpoint and parameter.
  5. Confirm the analysis visit or time point.
  6. Confirm the number of subjects.
  7. Check denominators for percentages.
  8. Verify key descriptive statistics.
  9. Verify inferential statistics and confidence intervals.
  10. Confirm footnotes and abbreviations.
  11. Check decimal precision and rounding.
  12. Review pagination and page breaks.
  13. Confirm that no text or columns are truncated.
  14. Confirm consistency with related outputs.
  15. Verify that the final version corresponds to the approved specification.

Consistency Across TLFs

TLFs should not be developed in isolation.

For example, if the demographic table reports 250 subjects in the Safety Set, a safety adverse-event table should generally reconcile to the same population definition unless the SAP specifies otherwise.

Similarly, treatment labels should be consistent across:

  • Disposition tables
  • Demographic tables
  • Efficacy tables
  • Safety tables
  • Listings
  • Figures
Cross-output QC: One of the most powerful TLF checks is to compare related outputs. Discrepancies between outputs can reveal population, treatment, derivation, or programming errors that are difficult to detect within a single table.

Production TLFs vs. Mock TLFs

TLF development often occurs at multiple stages of a clinical study.

Early in the study, programmers may generate mock or preliminary outputs using simulated or blinded data structures.

Later, production TLFs are generated from finalized analysis datasets.

Stage Purpose
Mock TLF Test structure, programming logic, formatting, and shell interpretation
Dry-run TLF Test production processes before database lock
Production TLF Generate final study results from finalized analysis data
Submission TLF Prepare controlled outputs for regulatory submission

TLF Development and Database Lock

Database lock is a major milestone because production TLFs generally depend on the finalized clinical-trial data and analysis datasets.

Before database lock, teams often perform dry runs to identify:

  • Programming errors
  • Unexpected data structures
  • Missing derivations
  • Formatting problems
  • Population discrepancies
  • Output reconciliation issues

The goal is to minimize the number of unexpected problems discovered after final data become available.

Putting It All Together

The complete TLF development process can be viewed as a chain:

1
Protocol: defines the scientific objectives, endpoints, populations, and study design.
2
SAP: defines the statistical methods and analysis rules.
3
TLF shells: translate the SAP into specific output requirements.
4
ADaM datasets: provide analysis-ready data and derived variables.
5
Programming: calculates the statistical results.
6
TLF production: formats the statistical results into tables, listings, and figures.
7
QC: independently verifies the calculations, data selection, and presentation.
8
Finalization: produces the controlled outputs used for reporting and submission.

Worked Example: From SAP Requirement to TLF

Suppose the SAP specifies:

Primary endpoint: Change from baseline in a continuous disease-severity score at Week 24.

Population: Full Analysis Set.

Analysis: An analysis of covariance adjusting for baseline score.

Effect measure: Adjusted treatment difference with a two-sided 95% confidence interval.

The TLF development process might proceed as follows.

Step 1: Identify the analysis dataset

The programmer identifies the ADaM dataset containing the analysis parameter, baseline value, post-baseline values, treatment assignment, population flag, and visit information.

Step 2: Apply the population

Only subjects satisfying the prespecified Full Analysis Set criterion are included.

Step 3: Select Week 24

The programmer identifies the appropriate Week 24 analysis record for each subject according to the study's visit and data-selection rules.

Step 4: Calculate change from baseline

$$ CHG_i = AVAL_i-BL_i $$

where \(AVAL_i\) is the Week 24 analysis value and \(BL_i\) is the baseline value for subject \(i\).

Step 5: Fit the prespecified model

The model may conceptually be represented as:

$$ CHG_i = \beta_0 + \beta_1 TRT_i + \beta_2 BL_i + \epsilon_i $$

where \(TRT_i\) represents treatment assignment and \(BL_i\) represents baseline disease score.

Step 6: Extract the treatment comparison

The programmer extracts the adjusted treatment difference, confidence interval, and p-value specified by the SAP.

Step 7: Populate the TLF

The results are inserted into the approved table structure.

Step 8: QC the output

The QC programmer independently confirms the population, selected records, descriptive statistics, model results, and final presentation.

What Makes a Good TLF?

A high-quality TLF should satisfy several principles simultaneously.

Principle Meaning
Correct The statistics and displayed values are accurate.
Relevant The output answers the intended clinical question.
Traceable The results can be connected to analysis data and specifications.
Consistent Terminology, populations, treatment labels, and formatting agree across outputs.
Readable The reader can understand the result without unnecessary complexity.
Reproducible The output can be regenerated from controlled data and programs.
Reviewable The structure facilitates statistical and clinical QC.

Key Takeaways

TLF development is one of the central activities connecting clinical-trial data, statistical analysis, and clinical reporting.

The most important concepts are:

  • Tables summarize clinical-trial information in structured form.
  • Listings provide detailed subject-level or record-level information.
  • Figures communicate patterns and relationships visually.
  • TLF shells translate SAP requirements into concrete output specifications.
  • Analysis populations determine which subjects contribute to an output.
  • Denominators must be explicitly understood when calculating percentages.
  • Visit and record-selection rules are critical for longitudinal analyses.
  • Statistical methods must match the approved SAP.
  • Formatting is part of the output specification, not an afterthought.
  • QC should verify both statistical correctness and presentation.
  • Traceability connects the final TLF back through programming and analysis datasets.
Bottom line: A TLF is the visible endpoint of an entire statistical data pipeline. A professional TLF is not merely a table containing numbers—it is a controlled, reproducible representation of a prespecified clinical-trial analysis.

References

International Council for Harmonisation (ICH). E3: Structure and Content of Clinical Study Reports.

International Council for Harmonisation (ICH). E9: Statistical Principles for Clinical Trials.

U.S. Food and Drug Administration. Study Data Technical Conformance Guide.

CDISC. Analysis Data Model (ADaM).