LibraCore
An integrated library services platform demo built around MARC21, RDA, authority control, Discovery, ERM, and repository workflows.
LibraCore is a Django-based library information system scaffold that models real library information science concepts instead of reducing the domain to a single book table. It includes cataloging, MARC import review, authority control, holdings, circulation, acquisitions, serials, ERM, repository, analytics, audit, and guided staff workflows.
LibraCore guided tour recording
Playwright recording of OPAC, MARC cataloging, authority control, circulation, acquisitions, ERM, and governance workflows.
Media overview
Browse the project screenshots and recorded walkthroughs.
Project links and demo readiness
live
Live Demo
Open the verified live demo when available, or use the internal run guide for manual demo preparation.
github
View GitHub
Open the public repository when available, or review the source-access status captured by this case study.
video
Demo Recording
Open the demo recording when available, or use this section as the recording checklist for the project.
documentation
Read README
Open the project README when available, or use this case study as the documentation baseline.
Project overview
LibraCore is a portfolio-grade implementation of a real library information system architecture. The public demo is static because GitHub Pages cannot run Django, but the source repository includes the full local Django application, tests, seeded demo data, and Playwright capture script. The strongest part of the project is the domain model: Work/Expression/Instance/Item separation, MARC21 raw record preservation, authority control, holdings and circulation, acquisitions, serials, electronic resources, and repository metadata are modeled as separate concepts with their own workflows. The demo recording focuses on the guided assistant overlay added to the UI. It walks through OPAC discovery, MARC import review, authority control, circulation desk workflows, acquisitions, ERM, repository management, analytics, audit, and data quality checks.
My role
System Architect / Full-stack Developer
Problem
A credible library system needs bibliographic control, authority data, holdings, item status, electronic resources, discovery, governance, and interoperability. A simple CRUD book app cannot represent how libraries actually organize and manage information.
Solution
I designed and implemented a modular Django platform with Work/Instance separation, MARC21 raw record storage, cataloging review, authority linking, OPAC facets, circulation workflows, acquisitions and serials management, ERM records, repository metadata, audit logs, and a guided UI tour recorded with Playwright.
Current outcome
The project now has a tested local MVP, a static GitHub Pages demo, a public GitHub repository, screenshots, and a recorded walkthrough that can be reviewed from the portfolio.
Highlights
- Models Work, Expression, Instance, BibliographicRecord, MARC records, authority records, holdings, items, patrons, loans, acquisitions, serials, ERM, and repository objects.
- Supports MARC import batches, parsed/mapped review screens, match candidates, and authority suggestions.
- Provides OPAC discovery with facets, availability, authority browse, subject browse, electronic access links, and repository integration.
- Includes staff workbenches for circulation, patrons, fees, acquisitions, serials, ERM, repository, analytics, audit, and data quality.
Engineering challenges
- Keeping MARC21 raw data, normalized internal models, and Discovery indexes aligned without flattening the domain.
- Making complex staff workflows demonstrable in a portfolio without requiring a hosted Django backend.
- Representing library standards honestly while avoiding licensed vocabulary/toolkit overclaims.
Target users
- Portfolio reviewers and interviewers
- Technical readers who need a quick view of purpose, stack, and maturity
Technical highlights
- Detected technical signals: Python, Django, Django REST Framework, PostgreSQL, SQLite, Playwright, MARC21, RDA, OPAC, ERM
- README evidence exists and can support a fuller reviewed case study
- A public GitHub repository is linked for source traceability
Architecture
This case study is generated from the portfolio catalog pipeline using README, Git metadata, package/build configuration, and media signals. The final architecture narrative still needs source-level review. Current detected technology signals include: Python, Django, Django REST Framework, PostgreSQL, SQLite, Playwright, MARC21, RDA, OPAC, ERM.
Data flow
A public data-flow narrative is not fully reviewed yet. If the project includes data processing, AI pipelines, or backend APIs, the next pass should document input, processing, storage, and UI/output flow end to end.
Project structure
libracore/ README.md # project documentation, when available source files # implementation reviewed by local audit package/build config # detected capability signals
Setup / Run guide
Install dependencies, start the project with its documented dev/start command, then verify the core workflow from the portfolio demo script. Build support was detected from project configuration. Run the repo-specific build command before publishing new screenshots or demos.
Future improvements
- Complete the production-quality README, screenshots, and demo recording
- Add architecture diagrams, data-flow notes, and key technical decisions
- Verify build/test status and update the portfolio release report
Interview notes
- State the current maturity and demonstrable scope first
- Focus on verified stack, source structure, and completed behavior
- Do not claim unverified deployment, video, or test coverage as finished
Next steps
- Add a production backend deployment for the full Django system.
- Expand MARC Authority and Holdings import/export coverage.
- Add external lookup adapters for id.loc.gov, VIAF, ORCID, and OpenSearch-scale Discovery.