Audience Journey Frameworks and Content Sequencing

Last Updated June 8, 2026

Audience journey frameworks help communicators organize content around how audiences move from awareness to understanding, comparison, trust, decision, action, and continued engagement. They shift attention away from isolated content pieces and toward the sequence of questions, needs, barriers, and decisions that unfold over time. When used well, an audience journey framework helps teams decide what content should come first, what should follow, what evidence is needed, where internal links should guide readers, and how communication should adapt as audience understanding deepens.

Audience Journey Frameworks and Content Sequencing examines audience journeys as content frameworks, not merely as marketing funnels. It explains how journey stages, reader intent, decision needs, learning pathways, evidence requirements, content formats, internal links, and governance practices work together. The goal is not to force every audience into a rigid sequence. The goal is to design communication pathways that help people move through complexity with better orientation, stronger evidence, and clearer next steps.

This article explains what audience journey frameworks are, how they differ from personas and funnels, how they support content sequencing, and how they can be governed responsibly. It connects audience journeys to STP, persona frameworks, message houses, positioning, internal linking, article maps, metadata, repository workflows, and Catalyst Canvas-ready diagnostics. It also examines the limits of journey thinking, including false linearity, over-automation, exclusion, and the risk of treating audiences as predictable pathways rather than people with changing contexts.

Why Audience Journey Frameworks Matter

Audience journey frameworks matter because audiences rarely understand, trust, or act on complex information all at once. They move through stages. They encounter a topic, try to understand it, compare it with alternatives, evaluate credibility, look for examples, test relevance, consider action, and return later with deeper questions. Content systems that ignore this progression often produce isolated articles, pages, campaigns, or assets that may be useful individually but weak as a pathway.

A journey framework helps teams ask sequence questions. What does the audience need before this article will make sense? What question should be answered next? Where might the reader get stuck? What evidence is needed before a decision? What internal link should guide the reader forward? What content should be written because the journey has a gap?

This is especially important for complex knowledge systems. A reader entering a series on decision science, systems modeling, content frameworks, sustainability, international law, or strategic ideation may need orientation before methods, methods before case studies, case studies before governance, and governance before advanced critique. Audience journey thinking helps the editorial system organize progression.

Audience journey frameworks help content systems move from “What should we publish?” to “What does the audience need next, and how should the system help them get there?”

Back to top ↑

What Audience Journeys Are

An audience journey is a structured model of how an audience moves through a topic, decision, service, product, article series, learning pathway, or communication environment over time. It identifies stages, questions, barriers, emotions, information needs, trust requirements, content formats, and next steps. In content strategy, a journey framework connects audience need to content sequence.

An audience journey is not a literal prediction of every person’s path. Different people enter at different points, skip steps, return later, compare sources, and change goals. A journey framework is a working model that helps teams design better pathways. Like all frameworks, it simplifies reality. Its value depends on whether its assumptions are visible, evidence-informed, and revisable.

Audience journeys can apply to many contexts. A learner may move from unfamiliarity to conceptual fluency. A buyer may move from problem recognition to evaluation and purchase. A policymaker may move from issue awareness to evidence review and decision. A public stakeholder may move from concern to understanding, trust, participation, and accountability. A technical user may move from overview to documentation, code, testing, and implementation.

In a content-framework system, the journey should connect to article maps, metadata, repository outputs, and editorial governance. Each article should have a role in the journey, not merely a topic label.

Back to top ↑

Audience Journey vs Marketing Funnel

Audience journeys are often confused with funnels. A funnel usually models movement from awareness to conversion. It is useful in marketing and sales contexts, but it can be too narrow for research, education, public communication, governance, and complex knowledge systems. Many audiences are not moving toward purchase. They may be moving toward understanding, comparison, trust, participation, implementation, critique, or better judgment.

A funnel usually narrows. A journey may branch. A funnel often privileges the organization’s goal. A responsible audience journey also considers the audience’s goal. A funnel may measure conversion. A knowledge journey may measure comprehension, confidence, evidence use, responsible action, return visits, citation, reuse, or informed disagreement.

A funnel may be one kind of journey, but journey thinking is broader. For content frameworks, the most useful journey model is usually not “awareness to conversion,” but “orientation to understanding to evaluation to responsible use.”

Back to top ↑

Common Audience Journey Stages

Audience journey stages should be tailored to the communication context. A product launch, public policy explanation, research translation project, article series, and technical documentation system will not all use the same stages. Still, many journeys include recurring patterns: awareness, orientation, understanding, comparison, trust-building, decision, action, support, and return.

The stages below are useful for complex content systems because they focus on knowledge progression rather than only conversion.

These stages are not mandatory steps. They are diagnostic categories. They help editors see whether a content system supports the audience’s changing needs across time.

Back to top ↑

Content Sequencing and Knowledge Progression

Content sequencing is the practice of ordering content so that each piece prepares the audience for the next. In a content framework, sequencing helps transform a set of articles into a structured knowledge system. It answers questions such as: what should be introduced first, what requires prerequisite knowledge, where should examples appear, when should critique be introduced, and how should advanced content be linked?

Good sequencing does not always mean simple-to-complex in a strict line. Some readers need practical examples before theory. Some need definitions before cases. Some need comparison before commitment. Some enter through a problem and later seek conceptual depth. The sequence should reflect audience needs, not just the author’s preferred logic.

Sequencing also applies inside individual articles. A strong article often moves from orientation to definition, from definition to structure, from structure to examples, from examples to limits, from limits to method, and from method to related pathways. The table of contents should reveal that progression.

Back to top ↑

Reader Intent, Questions, and Barriers

Audience journey frameworks depend on reader intent. A reader may come to an article to define a term, solve a problem, compare alternatives, verify credibility, learn a method, apply a workflow, support a decision, or challenge a claim. These intents shape what content should be presented and where.

Reader barriers are equally important. A person may leave a journey because the article assumes too much knowledge, uses unfamiliar terms, lacks evidence, does not address their use case, feels too promotional, buries the next step, or fails to acknowledge uncertainty. Journey design should identify these barriers before publication.

Journey design becomes stronger when each stage is tied to intent and barrier. A stage is not just a label. It is a prediction about what the audience needs and what might prevent progress.

Back to top ↑

Evidence, Trust, and Decision Support

Audience journeys often fail at the trust stage. Content may explain a concept but not provide enough evidence for the audience to rely on it. This is especially important when the content makes claims about strategy, governance, risk, science, technology, policy, or public impact. Audiences need proof that matches the strength of the claim.

Trust can be built through references, examples, case studies, transparent limitations, code repositories, data outputs, author experience, review processes, update history, and governance records. A journey framework should identify where these trust supports are needed.

Decision support is also part of trust. A reader may trust an article more when it helps them understand tradeoffs, not only benefits. Content sequencing should therefore include comparison, limitations, and decision criteria before pushing toward action.

Back to top ↑

Internal Linking as Journey Infrastructure

Internal links are the infrastructure of audience journeys. A link is not simply a search-engine signal or navigation convenience. It is a pathway decision. It tells the reader what concept, method, example, comparison, or next step is relevant from their current location.

In a content-framework system, internal links should be designed around audience movement. A beginner article should link to foundations and next-step explanations. A method article should link to examples and limitations. A case study should link back to the framework it applies. A governance article should link to risk, ethics, and maintenance topics. A repository section should link to code that supports the article’s claims.

A journey audit should examine whether links exist, whether they are meaningful, and whether they support actual audience progression. A page with many links may still have weak journey design if those links do not answer the reader’s next question.

Back to top ↑

Relationship to Personas, STP, and Message Houses

Audience journey frameworks are closely related to persona frameworks, STP, positioning, and message houses. Personas describe audience types and their needs. STP clarifies audience segments, targets, and positioning. A message house organizes the central message, pillars, and proof. Audience journey frameworks sequence content across time so those insights become useful in practice.

Personas help identify who is moving through the journey. STP helps determine which audience journey receives priority. Positioning clarifies how the idea should be understood at different stages. The message house provides consistent claims and proof across the journey. The journey framework organizes when and where those messages should appear.

The frameworks should not be used as isolated exercises. Together, they form an audience strategy system: segment the audience, define the persona, position the idea, structure the message, and sequence the content pathway.

Back to top ↑

How Journey Frameworks Support Content Systems

Audience journey frameworks help content systems become more coherent. A content system includes article maps, individual articles, metadata, internal links, repository code, visual assets, references, governance records, and review processes. Without journey logic, these pieces may accumulate without forming a usable pathway.

A journey framework helps assign roles to content. One article may introduce a concept. Another may compare it. Another may explain method. Another may show a case. Another may examine ethical risk. Another may provide code. Another may govern drift. The journey framework clarifies how these pieces work together.

In a Catalyst Canvas-ready system, journey data can become structured. Each article can have a journey stage, prerequisite links, next-step links, evidence requirements, audience persona, content status, and review date. This makes content sequencing auditable.

Back to top ↑

Types of Audience Journeys

Different communication contexts require different journey types. A learning journey should not be designed like a buyer journey. A public accountability journey should not be designed like a product onboarding sequence. The journey type should match the audience’s purpose and the ethical context of the communication.

A single content system may support multiple journey types. The key is to avoid pretending that one pathway fits every audience. Journey design should include alternate routes, return loops, and clear entry points.

Back to top ↑

Risks and Limits of Journey Frameworks

Journey frameworks can clarify content strategy, but they can also mislead. The most common risk is false linearity. Teams may draw a journey as a neat sequence and then assume audiences behave that way. Real audiences move unpredictably. They skip, return, compare, search externally, get distracted, disagree, and bring different prior knowledge.

Another risk is over-optimization. Journey frameworks can become tools for pushing audiences toward organizational goals rather than supporting audience understanding and agency. This is especially dangerous in public communication, education, health, policy, and governance contexts.

The limits of journey frameworks do not make them useless. They make governance necessary. A journey should be treated as a hypothesis about audience needs, not a fixed map of audience behavior.

Back to top ↑

Ethics, Autonomy, and Audience Respect

Audience journey design has ethical implications because it shapes what people see, when they see it, and how they are guided. A journey can help audiences understand, but it can also manipulate, obscure alternatives, hide uncertainty, or push action before adequate evidence is provided.

Ethical journey design respects audience autonomy. It provides orientation, evidence, comparison, limits, and meaningful next steps. It avoids dark patterns, artificial urgency, false personalization, and pathways that restrict agency. It also recognizes that affected stakeholders may need different information from primary target audiences.

• Autonomy: The journey should support informed choice, not only desired conversion.
• Transparency: Evidence, limitations, sponsorship, and uncertainty should be visible where relevant.
• Accessibility: Pathways should account for different knowledge levels, devices, abilities, and contexts.
• Inclusion: Secondary and affected audiences should not disappear from journey design.
• Accountability: Journey assumptions should be reviewed, tested, and revised.
• Respect: Audiences should be treated as reasoning people, not predictable behavioral targets.

Ethical journeys are not weaker journeys. They are more credible. They help audiences move through complexity without concealing the choices, tradeoffs, and uncertainties that matter.

Back to top ↑

Journey Governance and Maintenance

Journey governance keeps audience pathways accurate, useful, and responsible over time. Content changes. Audiences change. Search behavior changes. Internal links break. Article maps expand. Repository outputs evolve. A journey that was useful when a series had ten articles may become confusing when the series has fifty.

Governance should identify journey owners, review dates, stage coverage, link health, evidence requirements, content gaps, analytics signals, and ethical risk flags. It should also identify which articles are entry points, which are transition points, which are evidence supports, and which are advanced or critical materials.

Journey governance makes content sequencing maintainable. It turns pathways into living infrastructure rather than one-time planning diagrams.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Audience journeys can be evaluated computationally as sequences of stages, links, content assets, evidence requirements, and gaps. Computation cannot determine the perfect journey, but it can help editors inspect whether a content system has missing stages, weak transitions, insufficient evidence, poor link coverage, or high governance risk.

A journey readiness score can be modeled as a function of stage clarity, content coverage, transition quality, evidence readiness, and governance readiness:

A basic readiness score can average these dimensions:

A weighted model can make editorial priorities explicit:

The weights should sum to one:

A link gap can be modeled as the difference between required journey links and available journey links:

A journey risk score can combine link gaps, evidence gaps, persona mismatch, and stale review status:

These models should support editorial judgment. They make journey assumptions visible and help teams decide which articles, links, evidence assets, and governance records need attention.

Back to top ↑

Python Workflow: Audience Journey and Content Sequence Audit

The Python workflow below evaluates journey stages by stage clarity, content coverage, transition quality, evidence readiness, governance readiness, link gap, persona mismatch, and staleness risk. The companion repository version extends this into a Catalyst Canvas-ready module with schemas, package-style Python, tests, JSON exports, Canvas cards, shared contracts, and governance queues.

# audience_journey_audit.py
# Dependency-light workflow for auditing audience journey stages and content sequencing.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass
class JourneyStage:
    stage: str
    audience_need: str
    stage_clarity: float
    content_coverage: float
    transition_quality: float
    evidence_readiness: float
    governance_readiness: float
    required_links: int
    available_links: int
    persona_fit: float
    staleness_risk: float
    owner: str
    status: str

    def readiness_score(self) -> float:
        return mean([
            self.stage_clarity,
            self.content_coverage,
            self.transition_quality,
            self.evidence_readiness,
            self.governance_readiness,
        ])

    def weighted_readiness(self) -> float:
        return (
            self.stage_clarity * 0.18
            + self.content_coverage * 0.22
            + self.transition_quality * 0.20
            + self.evidence_readiness * 0.22
            + self.governance_readiness * 0.18
        )

    def link_gap(self) -> int:
        return max(0, self.required_links - self.available_links)

    def persona_mismatch(self) -> float:
        return max(0.0, 1.0 - self.persona_fit)

    def journey_risk(self) -> float:
        normalized_link_gap = min(1.0, self.link_gap() / max(1, self.required_links))
        return max([
            normalized_link_gap,
            self.persona_mismatch(),
            self.staleness_risk,
            max(0.0, 0.70 - self.evidence_readiness),
        ])

    def review_priority(self) -> str:
        if self.status == "revise" or self.journey_risk() >= 0.70:
            return "high"
        if self.link_gap() > 0 or self.journey_risk() >= 0.45:
            return "medium"
        if self.governance_readiness < 0.65:
            return "medium"
        return "standard"


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    stages = [
        JourneyStage("Awareness", "Recognize the topic and relevance", 0.86, 0.84, 0.78, 0.72, 0.74, 2, 2, 0.82, 0.22, "editorial", "active"),
        JourneyStage("Orientation", "Understand category and context", 0.88, 0.82, 0.80, 0.78, 0.76, 3, 2, 0.84, 0.24, "editorial", "active"),
        JourneyStage("Trust-building", "Evaluate evidence and limits", 0.78, 0.70, 0.68, 0.62, 0.72, 4, 2, 0.76, 0.34, "governance", "review"),
        JourneyStage("Application", "Use the framework through workflow or code", 0.74, 0.76, 0.72, 0.80, 0.70, 3, 3, 0.78, 0.30, "technical", "active"),
        JourneyStage("Return", "Review updates and advanced pathways", 0.56, 0.48, 0.44, 0.52, 0.40, 3, 1, 0.58, 0.66, "governance", "revise"),
    ]

    rows = []

    for stage in stages:
        rows.append({
            "stage": stage.stage,
            "audience_need": stage.audience_need,
            "stage_clarity": stage.stage_clarity,
            "content_coverage": stage.content_coverage,
            "transition_quality": stage.transition_quality,
            "evidence_readiness": stage.evidence_readiness,
            "governance_readiness": stage.governance_readiness,
            "required_links": stage.required_links,
            "available_links": stage.available_links,
            "link_gap": stage.link_gap(),
            "persona_fit": stage.persona_fit,
            "persona_mismatch": round(stage.persona_mismatch(), 3),
            "staleness_risk": stage.staleness_risk,
            "journey_risk": round(stage.journey_risk(), 3),
            "readiness_score": round(stage.readiness_score(), 3),
            "weighted_readiness": round(stage.weighted_readiness(), 3),
            "owner": stage.owner,
            "status": stage.status,
            "review_priority": stage.review_priority(),
        })

    rows = sorted(rows, key=lambda row: row["weighted_readiness"], reverse=True)
    write_csv(TABLES / "audience_journey_audit.csv", rows)

    revision_queue = [
        row for row in rows
        if row["review_priority"] != "standard"
    ]

    write_csv(TABLES / "audience_journey_revision_queue.csv", revision_queue)

    print("Audience journey audit complete.")


if __name__ == "__main__":
    main()

This workflow helps teams identify which journey stages are strong, which need better links, which lack evidence, and which should enter a governance queue before the content system expands further.

Back to top ↑

R Workflow: Journey Readiness and Link Gap Diagnostics

The R workflow below creates a journey-stage dataset, calculates readiness, link gaps, persona mismatch, journey risk, and review priority, then exports summary tables and base R plots. It is intentionally portable and uses only base R.

# audience_journey_report.R
# Base R workflow for audience journey readiness and link gap diagnostics.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

journey <- data.frame(
  stage = c("Awareness", "Orientation", "Trust-building", "Application", "Return"),
  audience_need = c(
    "Recognize the topic and relevance",
    "Understand category and context",
    "Evaluate evidence and limits",
    "Use the framework through workflow or code",
    "Review updates and advanced pathways"
  ),
  stage_clarity = c(0.86, 0.88, 0.78, 0.74, 0.56),
  content_coverage = c(0.84, 0.82, 0.70, 0.76, 0.48),
  transition_quality = c(0.78, 0.80, 0.68, 0.72, 0.44),
  evidence_readiness = c(0.72, 0.78, 0.62, 0.80, 0.52),
  governance_readiness = c(0.74, 0.76, 0.72, 0.70, 0.40),
  required_links = c(2, 3, 4, 3, 3),
  available_links = c(2, 2, 2, 3, 1),
  persona_fit = c(0.82, 0.84, 0.76, 0.78, 0.58),
  staleness_risk = c(0.22, 0.24, 0.34, 0.30, 0.66),
  owner = c("editorial", "editorial", "governance", "technical", "governance"),
  status = c("active", "active", "review", "active", "revise"),
  stringsAsFactors = FALSE
)

journey$readiness_score <- rowMeans(journey[, c(
  "stage_clarity",
  "content_coverage",
  "transition_quality",
  "evidence_readiness",
  "governance_readiness"
)])

journey$weighted_readiness <- (
  journey$stage_clarity * 0.18 +
  journey$content_coverage * 0.22 +
  journey$transition_quality * 0.20 +
  journey$evidence_readiness * 0.22 +
  journey$governance_readiness * 0.18
)

journey$link_gap <- pmax(0, journey$required_links - journey$available_links)
journey$persona_mismatch <- pmax(0, 1 - journey$persona_fit)
journey$normalized_link_gap <- pmin(1, journey$link_gap / pmax(1, journey$required_links))
journey$evidence_gap <- pmax(0, 0.70 - journey$evidence_readiness)

journey$journey_risk <- apply(journey[, c(
  "normalized_link_gap",
  "persona_mismatch",
  "staleness_risk",
  "evidence_gap"
)], 1, max)

journey$review_priority <- ifelse(
  journey$status == "revise" | journey$journey_risk >= 0.70,
  "high",
  ifelse(
    journey$status == "review" |
      journey$link_gap > 0 |
      journey$journey_risk >= 0.45 |
      journey$governance_readiness < 0.65,
    "medium",
    "standard"
  )
)

journey <- journey[order(journey$weighted_readiness, decreasing = TRUE), ]

write.csv(
  journey,
  file.path(tables_dir, "audience_journey_summary.csv"),
  row.names = FALSE
)

revision_queue <- journey[journey$review_priority != "standard", ]

write.csv(
  revision_queue,
  file.path(tables_dir, "audience_journey_revision_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "audience_journey_readiness_scores.png"), width = 1200, height = 700)
barplot(
  journey$weighted_readiness,
  names.arg = journey$stage,
  las = 2,
  ylab = "Weighted readiness",
  main = "Audience Journey Readiness"
)
grid()
dev.off()

png(file.path(figures_dir, "audience_journey_link_gaps.png"), width = 1200, height = 700)
barplot(
  journey$link_gap,
  names.arg = journey$stage,
  las = 2,
  ylab = "Missing journey links",
  main = "Audience Journey Link Gaps"
)
grid()
dev.off()

print(journey[, c("stage", "weighted_readiness", "link_gap", "journey_risk", "review_priority")])

This workflow supports journey governance by identifying missing links, weak transitions, under-supported trust stages, stale pathways, and journey stages that need revision before reuse.

Back to top ↑

GitHub Repository

The companion repository for this article supports audience journey frameworks as a Catalyst Canvas-ready content-framework module. It includes journey-stage diagnostics, content-sequence scoring, link-gap analysis, persona-fit review, evidence-readiness checks, governance status, JSON schemas, package-style Python, tests, Canvas card outputs, markdown governance queues, synthetic datasets, SQL views, documentation, and multi-language scaffolds for journey analysis.

articles/audience-journey-frameworks-and-content-sequencing/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── canvas_cards.json
│   └── governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── audience_journey_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   └── test_audience_journey_canvas.py
│   └── run_audience_journey_canvas_audit.py
├── r/
│   ├── audience_journey_report.R
│   └── run_all_audience_journey_workflows.R
├── sql/
│   ├── canvas_schema.sql
│   └── canvas_queries.sql
├── docs/
├── data/
├── outputs/
│   ├── figures/
│   ├── json/
│   ├── markdown/
│   └── tables/
├── notebooks/
├── shared/
└── README.md

Back to top ↑

Back to top ↑

Back to top ↑

Why Audience Journeys Strengthen Content Frameworks

Audience journey frameworks strengthen content systems because they organize communication over time. They help teams decide what audiences need first, what they need next, what evidence supports trust, what links enable movement, and where gaps require new content. They turn article maps from lists into pathways.

For content frameworks, journey thinking is essential because complex knowledge rarely fits in one article. Readers need foundations, comparisons, examples, methods, critique, governance, and application. Audience journey frameworks help sequence these pieces so that readers can enter the system, move through it, and return when their questions change.

Used responsibly, audience journey frameworks do not force people into rigid paths. They provide structure while respecting autonomy, uncertainty, accessibility, and multiple entry points. They make content systems more useful, more navigable, more accountable, and more capable of supporting serious learning, strategic communication, and public reasoning.

Back to top ↑

Related Articles

• Persona Frameworks and Their Limits
• Positioning Frameworks for Complex Ideas
• STP: Segmentation, Targeting, and Positioning
• Message House and the Architecture of Strategic Messaging
• Internal Linking as Framework Infrastructure
• Narrative Pathways and Knowledge Architecture

Further Reading

• Kalbach, Jim. Mapping Experiences: A Complete Guide to Customer Alignment Through Journeys, Blueprints, and Diagrams. O’Reilly Media, 2020.
• Rosenfeld, Louis, Peter Morville, and Jorge Arango. Information Architecture: For the Web and Beyond. O’Reilly Media, 2015.
• Halvorson, Kristina, and Melissa Rach. Content Strategy for the Web. New Riders, 2012.
• Redish, Janice. Letting Go of the Words: Writing Web Content that Works. Morgan Kaufmann, 2012.
• Krug, Steve. Don’t Make Me Think, Revisited. New Riders, 2014.
• Norman, Don. The Design of Everyday Things. Basic Books, 2013.
• Cooper, Alan, Robert Reimann, David Cronin, and Christopher Noessel. About Face: The Essentials of Interaction Design. Wiley, 2014.
• Heath, Chip, and Dan Heath. Made to Stick: Why Some Ideas Survive and Others Die. Random House, 2007.

References

• Kalbach, Jim. Mapping Experiences: A Complete Guide to Customer Alignment Through Journeys, Blueprints, and Diagrams. O’Reilly Media, 2020.
• Rosenfeld, Louis, Peter Morville, and Jorge Arango. Information Architecture: For the Web and Beyond. O’Reilly Media, 2015.
• Halvorson, Kristina, and Melissa Rach. Content Strategy for the Web. New Riders, 2012.
• Redish, Janice. Letting Go of the Words: Writing Web Content that Works. Morgan Kaufmann, 2012.
• Krug, Steve. Don’t Make Me Think, Revisited. New Riders, 2014.
• Norman, Don. The Design of Everyday Things. Basic Books, 2013.
• Cooper, Alan, Robert Reimann, David Cronin, and Christopher Noessel. About Face: The Essentials of Interaction Design. Wiley, 2014.
• Heath, Chip, and Dan Heath. Made to Stick: Why Some Ideas Survive and Others Die. Random House, 2007.

Back to top ↑