With a team that has ranged from 10 to 15 developers over the years, qubIT manages a platform with more than 4,000 UI screens, thousands of domain entities, and a shared codebase used by Portugal's largest universities. Built with Vaadin under a Java-first approach, the team uses compile-time safety, massive automation, and custom tooling to scale complexity without scaling the team.
qubIT develops and maintains Fenix, an Academic Management platform used by some of Portugal's largest universities. What makes their story remarkable is not the size of the platform. It's the size of the team behind it.
Originally developed as an open-source project at Instituto Superior Técnico (IST) for internal use, it was later adopted by a group of alumni who bootstrapped a company and completely rebuilt it around a product-oriented vision.
With a current development team of 15 engineers, qubIT builds and manages:
- ~4,000 UI screens
- ~3,000 domain entities
- 120+ internal modules
- 450+ external libraries
- a single shared codebase for multiple universities (serving in total ~80,000 students)
By investing heavily in automation, abstractions, code generation, and type-safe development, the team has been able to scale the software without scaling the organization.
Our goal was never just to build software. It was to build better ways of building software.
– Hugo Querido, CEO, qubIT
Company profile
Company: Quorum Born IT (aka. qubIT)
Location: Portugal
Industry: Higher Education
Founded: 2010 kick-off, bootstrapped since 2008
Team size: 15 developers
Product: Fenix Academic Management platform
Vaadin customer since: 2012
Vaadin version(s) used: Vaadin 8, Vaadin 23
Customers: University of Lisbon, ISCTE-IUL, Catholic University of Portugal
The challenge: Managing enterprise-scale complexity with a small team
Fenix supports the full academic lifecycle, from admissions and enrollment to graduation and alumni management. Over time, as qubIT rebuilt it to support any institution requirements, the platform grew to thousands of screens, thousands of business entities, and hundreds of modules.
Most software platforms of this size require large engineering organizations.
For qubIT, the challenge wasn't simply building new features. It was maintaining control of complexity while continuing to move quickly with a small team. They also wanted customers to be able to implement and maintain institution-specific functionalities in their own modules.
As the platform expanded, the company needed an approach that would allow developers to:
- Maintain a single shared codebase
- Reduce repetitive development work
- Refactor safely at a massive scale
- Shift business logic from source code to metamodel-based configuration
- Keep long-term costs under control, both for ongoing maintenance and for roadmap evolution
- Enable customers to independently build extensions and applications on top of the platform
The solution: Build tools to make developers more productive
From the beginning, qubIT focused on creating reusable abstractions rather than solving problems one project at a time.
"We always tried to build something that could be used many times, not just once," says Querido.
That mindset evolved into Omnis, qubIT's internal development platform, initially built around an Application Lifecycle Management (ALM) philosophy and later expanded to incorporate modern DevOps practices and toolchains.
The platform includes:
- Code generation
- Deployment automation
- Workflow tooling
- Development management tools
- Reusable UI components
- Internal support and monitoring systems
- Internal issue management, customer service tools, and self-help documentation
The goal is simple: automate repetitive work so developers can focus on solving complex business problems.
"Sounds cliché, but to save time on simple parts so you can spend it on the hard ones."
qubIT also acknowledges external merits that have shaped its path. Part of its technological architecture is based on a 2006 PhD thesis from IST that introduced a Software Transactional Memory framework, enabling access to the persistence layer through a natural and highly productive programming model.
Why Vaadin
A Java-first approach to large-scale development
As Fenix grew, qubIT needed a development model that would allow them to make large-scale changes without losing confidence in the codebase, also enabling the consolidation of multiple UI technologies present in the legacy codebase they've inherited and started with.
After prior experiences with component-based UI development, although not in Fenix and not in Java, the team decided on a 100% compile-time safety approach. They ultimately choose Vaadin after validating it through a controlled production pilot.
Instead of managing separate frontend and backend technology stacks, developers work in Java while benefiting from end-to-end type safety. According to Querido, that became one of the company's greatest advantages.
According to qubIT estimations, its full-stack Java development model delivers 3 to 4 times higher developer productivity when compared with JavaScript-based approaches, while also helping make large-scale systems easier to maintain. And having UI interfaces based on reusable components, by-design allows for a look and feel that is coherent throughout the entire software produced.
Building a platform others can extend
qubIT applies the same productivity principles to its customers. Universities can develop their own modules and extensions using the same tools that qubIT uses internally. Today, customer organizations collectively have more developers building on the platform than qubIT itself.
Rather than relying on consulting-heavy customization projects, qubIT focuses on giving customers the tools to solve problems independently.
"We don't want people dependent on us, we want to give them autonomy. The technology is ours but the business is theirs. So, they are the ones that should model it and manage it."
Enterprise-scale software without enterprise-scale teams
Today, qubIT supports three of Portugal's leading universities: the University of Lisbon, ISCTE-IUL, and the Catholic University of Portugal, all while maintaining a compact engineering organization.
Key outcomes
- A single shared codebase across multiple universities
- Large-scale refactoring supported by compile-time safety
- Customer teams actively developing their own extensions
- Higher developer productivity through automation and abstraction
- Parallel support for Vaadin 8 and Vaadin 23, enabling independent phased modernization for each customer
- More than 15 years of continuous platform evolution, both on Fenix and Omnis
All this is based around a software architecture that combines several best practices, so each of them is used for what is best suited for.
"We were building low-code and no-code tools before those terms were coined, just because it made sense for us to combine it all under our technologies. Depending on the problem we wanted to solve, we have always built the tools we envisioned from scratch."
Looking ahead
For qubIT, Vaadin is more than a UI framework. It is a foundation for a development philosophy centered on productivity, maintainability, and long-term ownership.
"Vaadin is deeply embedded in our history, even if our customers' minds aren't aware of how important it is to the success of Fenix, both ours in building it and theirs in using it."
By combining Java-first development, compile-time safety, and a strong investment in internal tooling, the company has shown how a small team can successfully manage software at a scale that would typically require a much larger organization.
"Necessity is the mother of invention, but if a small company like ours can compete at this scale, imagine what larger organizations can achieve with this same philosophy and using all the technologies Vaadin provides."
Manage enterprise-scale complexity with a small team
Learn how Vaadin helps Java teams reduce complexity, improve productivity, and confidently evolve large applications over time.