Building OpenQDA: Free Open-Source Qualitative Data Analysis

Project Type: Research Software / Open Source
Role: Backend Developer
Technologies: PHP, Laravel, Vue.js, MySQL, Laravel Reverb, Python microservices
Repository: github.com/openqda/openqda
Live Platform: openqda.org

Why This Project Matters

Commercial qualitative data analysis (CAQDAS) tools like NVivo and ATLAS.ti cost hundreds of euros per license—often per year. For students writing their thesis or small research teams at underfunded institutions, this creates a real barrier to conducting proper qualitative research.

OpenQDA exists to change that. It's a free, open-source alternative that gives students and universities access to professional-grade qualitative data analysis without the financial burden. As the backend developer on this project over the past two years, I built the server-side infrastructure that makes this possible.

My Role

I was the only backend developer on the project, responsible for all PHP/Laravel architecture, API design, database optimization, microservices, and server infrastructure. The project is a collaboration at ZeMKI (University of Bremen), where I worked alongside frontend developers and researchers to build a platform that meets real academic needs.

Technical Implementation

Authentication and Team Collaboration

The platform uses Laravel Jetstream with Teams for authentication and project access. Users can invite collaborators to projects via email, and currently all team members have admin-level access within their projects. This keeps the permission model simple while enabling the collaborative workflows researchers need.

Real-Time Presence with Laravel Reverb

Researchers often work on the same project simultaneously. Using Laravel Reverb and Echo, I implemented real-time presence awareness—users can see avatars of other team members in the navigation, showing who else is currently active in the project. This creates a sense of shared workspace without the complexity of operational transforms or conflict resolution.

RTF Document Conversion Microservice

Researchers often have documents in RTF format from word processors. Rather than forcing users to manually convert files, I built a microservice architecture for seamless document conversion:

A separate Python-based micro VM running unoconv handles RTF-to-HTML conversion
When users upload RTF files to OpenQDA, the document is automatically sent to the microservice
The converted HTML appears in the portal, ready for qualitative coding
The process is transparent to users—they upload RTF, they see their document

This separation of concerns keeps the main Laravel application focused on its core responsibilities while offloading CPU-intensive document processing.

Working with REFI-QDA Standard

One of the more interesting challenges was adhering to the REFI-QDA database schema—an interchange standard that allows researchers to move their projects between different QDA tools. The challenge wasn't just implementing the spec, but understanding how their schema design should inform our own architecture. This required careful study of the standard to ensure our data model could export compliant files while still being optimized for a web application's access patterns.

Performance Optimization: Lazy Loading Strategy

As projects grew larger, page load times became a problem. Using Laravel Debugbar to analyze query counts, I discovered we were loading far too much data upfront—codebooks, audit logs, team information—all fetched on every page load whether the user needed it or not.

The solution was a lazy loading strategy: only fetch data when the user actually needs it. If someone opens a project and goes straight to coding documents, why load the audit history? If they never click the "Collaboration" tab, why fetch team data?

I moved data loading from the initial page render to on-demand API calls triggered by user actions. This also meant adding proper pagination and search with debounce to keep the UI responsive when users do request that data. Database indexes on frequently filtered columns completed the optimization.

The principle is simple: respect the user's time by not making them wait for data they haven't asked for.

Testing

The backend includes PHPUnit tests for critical functionality, including codebook access permissions and API endpoints. GitHub Actions runs the test suite on every push.

What I Learned

Standards-based design pays off. Implementing REFI-QDA compatibility forced me to think carefully about data modeling. The result is a system that not only exports properly but is internally well-structured.

Measure before optimizing. Laravel Debugbar was invaluable. Without seeing the actual query counts, I would have been guessing at performance problems instead of fixing them systematically.

Microservices where they make sense. Document conversion is a perfect microservice use case—it's stateless, CPU-intensive, and benefits from isolation. Not everything needs to be a microservice, but this clearly did.

Impact

OpenQDA is actively used by researchers and available to anyone at openqda.org. The project has 44 GitHub stars, published releases with DOI citations via Zenodo, and is licensed under AGPL-3.0 to ensure it remains free and open.

Most importantly, it's helping students and researchers who couldn't afford commercial alternatives. That's the part I'm most proud of.

This project was developed at ZeMKI, Centre for Media, Communication and Information Research, University of Bremen.