If your library’s website feels like navigating a labyrinth designed by someone who’s never actually tried to find a book, or your physical space makes patrons look like they’re searching for buried treasure without a map, you’re not alone. The good news? Designing libraries that people genuinely enjoy using isn’t some mystical art reserved for tech giants with bottomless budgets. It’s about understanding that libraries aren’t just repositories of books—they’re experiences. And experiences can be designed, tested, and continuously improved. Let me take you on a journey through the practical world of library UX design, where we’ll discover that the secret to making people love your library isn’t grand architectural gestures. It’s often the small, thoughtful details that matter most.

Why Library UX Actually Matters (And It’s Not What You Think)

Here’s the thing about libraries: they’re caught in a uniquely awkward position. Students expect them to work like Google. Faculty members want comprehensive research capabilities. Librarians need efficient systems. Casual visitors want a peaceful space to study. And somehow, you’re supposed to make everyone happy. This isn’t just about aesthetics or convenience—it’s about respect. When you design with genuine user experience in mind, you’re essentially saying to your patrons: “Your time matters. Your goals matter. Your frustration matters.” And that message, delivered consistently across every touchpoint, builds loyalty and actually increases library usage. The beauty of this approach? It works. Libraries that have invested in understanding their users through proper UX methodologies report that most of the improvements don’t require massive budget injections. They’re smaller, incremental changes that compound into a dramatically better experience.

The Foundation: Understanding Your Users Before You Design

This is where most library redesign projects go sideways. Someone decides the website needs refreshing, hires a designer, and boom—six months later you’ve got something shiny that nobody uses the way you intended. The antidote to this disaster is brutally simple: talk to your actual users before you design anything.

Research Method #1: Persona Development Through User Interviews

Start by conducting structured interviews with different user segments. This isn’t casual coffee chat—it’s purposeful conversation designed to uncover mental models, pain points, and actual workflows. Here’s what you’re looking for: Interview Structure:

  • Time constraints (how long do users typically have?)
  • Goals (what are they actually trying to accomplish?)
  • Environment (where are they using your library services?)
  • Existing workflows (what tools do they currently use?)
  • Frustration points (where does the current system fail them?) After conducting 8-12 interviews across diverse user groups, you’ll start seeing patterns. Group these patterns into personas. Don’t make them up; ground them in actual user data. Example persona framework:
Persona: "Occasional Oliver"
- Uses library systems rarely (1-2 times per semester)
- Mobile-first user
- Limited patience for complex workflows
- Needs: Simple, step-by-step guidance
- Pain points: Doesn't remember how to use the system

Why this matters: When your UX team knows “Occasional Oliver” exists, designers naturally prioritize simplicity and clear navigation. When they’re designing for a generic “user,” everything becomes a compromise that satisfies nobody.

Research Method #2: Cognitive Mapping for Creative Insights

Here’s where things get fun. Instead of traditional surveys, try cognitive mapping—basically, asking users to draw instead of write. This seemingly playful approach unlocks unconscious preferences and creative ideas that formal questionnaires miss entirely. Here’s how to facilitate a cognitive mapping session: Step-by-step:

  1. Recruit 5-8 users from your target segment
  2. Provide large paper, markers, and minimal structure
  3. Ask open-ended prompts: “Draw how you currently search for research materials” or “Sketch what an ideal library experience looks like to you”
  4. Don’t correct or judge—let them work freely for 15-20 minutes
  5. Conduct brief interviews after: “Tell me about your drawing. What does this represent?”
  6. Look for recurring symbols, workflows, and emotional cues across drawings The reason this works? It bypasses people’s tendency to give “correct” answers. Users sketch what they actually think, not what they think you want to hear.

The Dual-Channel Problem: Bridging Physical and Digital

Here’s something that trips up most library redesign projects: they treat the website and physical space as separate kingdoms. A patron’s journey doesn’t work that way. Someone might discover your library through your website, navigate using your online catalog, arrive at the building, become hopelessly lost looking for the book, give up, and never return. Then they leave a one-star review about how “the library is confusing.” But here’s the insight: the problem wasn’t either channel individually—it was the failure to connect them.

Designing the Digital-to-Physical Handoff

Your library website should be the first waypoint in the user’s journey. This means your catalog system should do more than provide a call number. It should tell users:

  • Which floor the book is on
  • Where on that floor (section, aisle)
  • Whether the book is currently available
  • A floor map showing the location
  • Alternative shelving locations if the primary is full This single piece of context prevents one of the most frustrating library experiences: holding a call number and wandering the stacks like you’re in the Upside Down.

Physical Wayfinding and Signage Design

Once users arrive, they need to navigate confidently. This is where traditional library signage often fails spectacularly. Signs are outdated, inconsistent, or assume knowledge users don’t have. To approach this systematically: Conduct a sign audit:

  1. Walk your library with fresh eyes (or better, with an actual user unfamiliar with your space)
  2. Document every sign: what it says, where it is, its condition
  3. Test whether the sign actually helps people find what they’re looking for
  4. Identify gaps: places where confused users congregate but no signage exists
  5. Check consistency: do different floors use the same terminology and visual language? The goal isn’t more signs—it’s strategic signs that actually guide behavior. Signs should:
  • Use consistent terminology with your online catalog
  • Include visual elements, not just text
  • Be accessible (contrast, font size, reading level)
  • Reflect current policy and reality
  • Present clear hierarchies (main categories first, subcategories second)

The Digital Layer: Designing Websites That Don’t Make Users Want to Scream

Let’s talk about library websites. Many of them are… not great. They’re organized around librarian logic, not user logic. They’re densely packed with information structured by how the library operates internally, not how users actually think.

Information Architecture: Topic-Based Beats Audience-Based

Here’s a specific, actionable insight from real-world library redesigns: organize your primary navigation around topics, not audiences. Wrong approach (audience-based):

  • For Faculty
  • For Students
  • For Community Members
  • For Researchers Right approach (topic-based):
  • Find Books & Articles
  • Databases by Subject
  • Research Guides
  • Citation Help
  • Library Hours & Locations Why? A chemistry student doesn’t think “I’m a student, let me click the student section.” They think “I need to find peer-reviewed articles on polymer synthesis.” They’re task-focused, not role-focused.

Search: Your Most Important Feature (Seriously)

Here’s a hard truth: users expect your library’s search to work like Google. That’s not reasonable, but it’s reality. Your collections are vastly more complex than Google’s index, but users still expect fast, intuitive search. Search functionality checklist:

  • Obvious search box (large, prominent, top of page)
  • Helpful results display (show what IS available, what ISN’T available, why)
  • Smart filtering options (by date, format, subject without overwhelming the user)
  • Auto-complete or suggested searches (reduce errors and show what you can find)
  • Transparent about limitations (if something isn’t in your collection, admit it)
  • Refine search capabilities (users should be able to narrow results easily) One concrete example: Ex Libris discovered that users loved their bookmark feature, but almost nobody used it because the icon wasn’t recognizable. After changing the icon based on usability testing feedback, usage jumped dramatically. That’s the level of detail that matters.

Content Strategy: Less Is Actually More

Your website shouldn’t be a digital encyclopedia of library information. It should answer the specific questions users have when they visit. Content pruning exercise:

  1. List every section and page on your website
  2. For each, ask: “Does this help users accomplish a specific task?”
  3. If the answer is “it provides information about the library” rather than “it helps users do something,” consider removing it or moving it to a secondary location
  4. Rewrite remaining content in plain language, avoiding “library-ese” Example: instead of “Interdisciplinary Research Consultation Services,” write “We help researchers find materials across multiple subjects.”

The Bento Box Approach: Unified Search Across Systems

Most libraries maintain multiple disconnected systems—the catalog, various databases, digital collections, subject guides, etc. Users have to search each separately, which is terrible UX. Some forward-thinking libraries are implementing “bento box” search: a single search box where users input their query and receive results from multiple systems simultaneously. It’s a more complex engineering problem, but from a user perspective, it’s dramatically simpler.

The Testing Phase: Turning Theory Into Reality

Here’s where the rubber meets the road. You’ve researched, designed, and built something new. Now what? Test it with actual humans before you launch it to everyone.

Prototype Testing: The Quiet Revolution

Before testing with users, create prototypes. These don’t need to be fully functional—they just need to represent the key user flows and design decisions. Prototyping approaches, from simple to complex:

  • Paper prototypes: Sketches or printouts arranged to show a workflow
  • Interactive wireframes: Tools like Figma or Adobe XD that simulate navigation
  • High-fidelity mockups: Detailed visual designs with realistic UI elements
  • Functional prototypes: Actually working code (usually helpful for digital interfaces)

Usability Testing: The Scientific Method of UX

Now conduct usability testing with representative users. This is the moment where you learn whether your design actually works. Running a usability session:

  1. Recruit 5-8 users (more isn’t better—you’ll see patterns by test 5)
  2. Assign realistic tasks: “Find a peer-reviewed article on climate change” (not “click around and tell me what you think”)
  3. Observe without leading: Watch what they do without explaining how it works
  4. Encourage thinking aloud: Ask “What do you expect to happen next?” and “What do you understand from this screen?”
  5. Remain neutral: Never defend your design choices—you’re testing the interface, not the users
  6. Document everything: Note where they succeed easily and where they struggle Critical insight: You’re not testing users; you’re testing your interface. If someone can’t find something, the interface failed, not the user. This mindset shift is essential.

Building a Testing Workflow

Here’s a practical flow diagram for moving from research through testing to implementation:

graph TD A[User Research Interviews] --> B[Develop Personas] B --> C[Identify Key Pain Points] C --> D[Design Solutions] D --> E{Create Prototypes} E -->|Paper/Wireframe| F[Initial Feedback] E -->|High-Fidelity| G[Usability Testing] F --> H{Issues Found?} G --> H H -->|Yes| D H -->|No| I[User Focus Groups] I --> J{Implementation Ready?} J -->|No| D J -->|Yes| K[Soft Launch] K --> L[Monitor Usage] L --> M{Performance OK?} M -->|No| D M -->|Yes| N[Full Launch & Monitor]

The key principle: this isn’t a linear process. You’ll loop back to design multiple times based on what you learn. That’s not failure—that’s the process working.

Beyond Testing: The Continuous Improvement Mindset

Here’s where most library projects derail: they launch and then forget about it. They move on to the next crisis, and the new system slowly accumulates the same problems the old one had. Real UX in libraries is continuous. Not in an overwhelming, everything-changes-every-month way. But in a systematic way where you’re regularly checking:

Monthly Check-ins: Usage Metrics

  • Are users finding things where you expect them to find them?
  • Which features are actually used? Which are ignored?
  • Where are users getting lost or abandoning tasks?
  • What are users searching for that you’re not serving well?

Quarterly User Sessions: Feedback Loops

Conduct quick feedback sessions (20-30 minutes) with a small group of users every quarter. Not massive redesigns—just conversations about what’s working and what isn’t. Template for quarterly check-in:

  • “Since we redesigned the website/space, what’s been better?”
  • “What’s been more frustrating?”
  • “If you could change one thing, what would it be?”
  • “How does this compare to how you used the library before?”

Annual Deep Dive: Comprehensive Review

Once a year, do a more substantial UX project. Pick a specific area—search functionality, mobile experience, physical signage, whatever data suggests needs attention. Run full research, testing, and implementation. This keeps the library evolving without requiring constant upheaval.

The Budget Reality: Why Good UX Doesn’t Require Unlimited Funds

One of the best-kept secrets in library UX: most improvements are cheap to implement. Not free, but cheap. Cognitive mapping sessions require paper and markers. Usability testing requires a quiet space and participant incentives ($20-30 per person). User interviews require skilled facilitation and time. None of these break budgets. The expensive parts are typically:

  • Staff training in UX methods
  • Technology (website redesigns, discovery systems)
  • Signage printing and installation
  • Prototype development tools But here’s the thing: if you do the research and testing properly, your limited budget goes toward implementing changes that actually matter, not guesses that might help.

Implementation: Where Design Meets Reality

Let’s talk about actually putting this into practice. Because great research that never ships is just expensive navel-gazing.

Stakeholder Alignment

Before implementing changes, get buy-in from the people who run the library. Show them the research. Show them the testing data. Explain why “because users wanted it” is better than “because I have a vision.” Here’s a rough flow for getting consensus:

  1. Present research findings (anonymized user quotes are powerful)
  2. Show testing results (video clips of users struggling are more convincing than written reports)
  3. Propose specific changes (not vague improvements, but concrete actions)
  4. Estimate effort and impact (which changes give the biggest benefit for reasonable effort?)
  5. Propose a timeline (phased rollout reduces risk)

Phased Implementation

Don’t change everything at once. Even if all your changes are good, massive simultaneous changes create confusion and backlash. Example implementation schedule:

  • Phase 1 (Month 1): Update website search and results display
  • Phase 2 (Month 2): Implement new signage in high-traffic areas
  • Phase 3 (Month 3): Reorganize physical book sections per user feedback
  • Phase 4 (Month 4): Add catalog integration with floor maps Between phases, gather feedback. Some things will work better than expected; others will need adjustment. The phased approach gives you information to improve subsequent phases.

Training and Communication

When you change things, people get confused. Plan for this. Communication plan:

  • Email campaign (3 emails before launch, 1 during, 1 week after)
  • Website banner (temporary, obvious)
  • Printed guides (for major changes)
  • Staff training (they’ll answer most questions)
  • FAQ page (monitor support tickets and add real questions)

Building a Culture of User-Centered Design

Here’s the ultimate goal: making UX methodology part of your library’s DNA, not a one-off project. This requires a few things:

Designate or Hire a UX Champion

Someone needs to be responsible for making this happen consistently. This person doesn’t need to be a full-time role initially, but they need space and support. They should understand both the methodology and the library world.

Create Simple Documentation

Don’t over-systematize, but do document:

  • How to run a usability test (template)
  • How to conduct user interviews (guide)
  • Where to store research findings (shared drive)
  • Timeline for annual UX projects (calendar)

Celebrate Small Wins

When an improvement based on user research lands and people love it, tell the story. Show the research that prompted it. Help your colleagues understand that this process works.

The Uncomfortable Truth: You Can’t Design for Everyone

Here’s something to make peace with: you’ll make tradeoffs. A feature that works for academic researchers might not work for casual browsers. Mobile-first design might require rethinking your desktop experience. The goal isn’t to eliminate all friction for everyone. The goal is to serve your core users exceptionally well while reasonably accommodating edge cases. When you see conflicting user needs, your research data should guide you. “Which group is larger? Which need is more critical? Which tradeoff is users most willing to tolerate?” These are design decisions, not failings.

Getting Started This Week

You don’t need permission or budget to start. Pick one small area and research it properly. Start here:

  1. Choose a problem: Something users complain about or where you suspect issues (e.g., “People have trouble finding databases”)
  2. Schedule 5 user interviews (30 minutes each, with someone from your target user group)
  3. Ask one simple question: “Tell me about the last time you [searched for a database/looked for a book/used the library website]. What was hard about it?”
  4. Listen. Really listen.
  5. Look for patterns across the interviews
  6. Propose one small change based on what you heard
  7. Test it with 3-4 users
  8. Implement it
  9. Measure whether it worked That’s a complete UX cycle. It’s not fancy, but it works.

Wrapping Up: The Joy Is in the Details

The best-designed libraries aren’t the ones with the most impressive architecture or the biggest budget. They’re the ones where someone cared enough to watch how users actually behave, asked them what frustrated them, listened to the answers, and made small, thoughtful changes based on that feedback. It’s not glamorous work. It requires patience, humility, and a willingness to be wrong. But when a patron walks into your library, finds what they’re looking for in half the time it used to take, and leaves feeling like the space was designed with them in mind? That’s when you know you’re building something worth building. The joy to use isn’t an accident. It’s the result of systematic, empathetic design. And it’s absolutely within reach.