Agylo

TL;DR

agylo was my final degree project for Web Application Development (CIPFP Ausias March). It is a task and project management app with kanban boards, designed for multiple users to collaborate, assign tasks, share files, and view recent team activity.

The point of the project was not “building a Trello clone.” It was learning to build a real full-stack application with end-to-end type safety, authentication, a relational database, and continuous deployment, all from scratch.

The context: final degree project

When I had to choose my final project, I wanted something that would force me to touch every layer of a modern web application: reactive frontend, typed API backend, database, authentication, and deployment.

I was not interested in building a basic CRUD just to pass and forget. I wanted a project that would serve as a real technical reference after graduating.

A project manager with kanban fit perfectly: complex frontend state, non-trivial database relations, multi-user collaboration, and the need for a smooth UX.

Demo of the kanban board

Why T3 Stack

After evaluating options, I chose T3 Stack (Next.js + tRPC + Prisma + TailwindCSS + NextAuth.js). The reasons were practical:

• End-to-end type safety with tRPC: the contract between frontend and backend is validated at compile time. That eliminates an entire class of bugs that in conventional REST you only discover at runtime.
• Prisma as ORM: declarative schema, clear migrations, and real query autocompletion.
• NextAuth.js: authentication with external providers (GitHub, Google) without reinventing the wheel.
• Next.js: SSR/SSG where needed, integrated API routes, and direct Vercel deployment.

The bet was that stack productivity would outweigh the learning curve. And it did.

What the app does

Main features

• Create projects and kanban boards.
• Create, assign, and move tasks between columns (drag & drop).
• Collaboration: invite members, view recent team activity.
• Share files within projects.
• Authentication with OAuth providers (GitHub, Google).
• Responsive interface with TailwindCSS.

Global view of all tasks assigned to the user

What it does not do (and why)

• No real-time notifications (WebSockets). The operational complexity did not justify the scope of a final degree project.
• No user roles (admin/editor/viewer). Just member or not.
• No advanced search or complex task filters.
• No automated tests. This is the most obvious technical debt and the one that bothers me most in retrospect.

Architecture and technical decisions

tRPC as communication layer

The most differentiating decision. Instead of defining REST endpoints and then manually typing responses on the client, tRPC generates the contract automatically from the server.

This means that if I change a procedure’s return type on the backend, the frontend breaks at compile time, not in production. For a solo project, that was an enormous speed multiplier.

Prisma + PlanetScale

PlanetScale gave me serverless MySQL with schema branching (similar to git branches for the database). That let me iterate fast on the data model without fear of breaking the production database.

The Prisma schema covered the main relations: users, projects, boards, columns, tasks, and memberships.

Kanban drag & drop

Implementing drag & drop that felt natural was not trivial. I had to handle:

• Reordering within the same column.
• Moving between columns with position updates.
• Optimistic persistence: updating the UI before server confirmation so the experience did not feel slow.

Races between local state and server response were the most fragile point of the entire application.

Vercel deployment

Deployment was straightforward: push to main, Vercel builds and deploys. No infra to maintain, no Docker, no manual CI/CD.

For a final degree project, that simplicity was a huge advantage. It let me focus on the product, not on operations.

Where it was hardest

Kanban state

Keeping task order synchronized between what the user sees and what the database stores was the hardest challenge. Reordering operations generate multiple updates that need to be atomic, and if the server fails midway, the UI becomes inconsistent.

Relational data model

Designing relations between projects, boards, columns, tasks, and users so that queries were efficient but the schema did not become rigid was a constant exercise in trade-offs.

Main dashboard

Building the main dashboard with all the project information was another point that took significant effort. Fitting all the relevant data into a single view (assigned tasks, recent activity, members, project statistics) required multiple coordinated queries and a layout that didn’t feel cluttered. Getting the load to be fast and the information properly prioritized took several iterations.

Main dashboard view

T3 Stack learning curve

Learning Next.js, tRPC, Prisma, and NextAuth.js simultaneously was intense. Each piece on its own was manageable, but integrating them all with coherent typing required understanding how types flow from the Prisma schema to the React component.

Current limits

What I take from the project

1. End-to-end type safety changes the rules. Working with tRPC showed me that most frontend/backend integration bugs are avoidable if the contract is validated at compile time.
2. An ambitious final project teaches more than three simple ones. Touching authentication, complex state, relational databases, and deployment in one project forced me to understand how the pieces connect.
3. Drag & drop is harder than it looks. The visual part is the easiest. State persistence and optimistic reconciliation are the real challenge.
4. Technical debt shows up fast. Not writing tests from the start cost me time debugging regressions I could have caught automatically.

Personal closing

agylo was the project that took me from “I know a bit of React” to “I understand how a real modern web application works.” Touching every layer, fighting with state, designing a data model, and deploying something functional gave me a technical foundation I still use today.

If I had to redo it, I would change two things: tests from day one and WebSockets for real-time collaboration. But as a first serious full-stack project, it more than fulfilled its purpose.