DEV Community: Juan Carlos Padillo

Building a UI for a Team Task Manager (Laravel + Tailwind)

Juan Carlos Padillo — Mon, 18 May 2026 04:22:55 +0000

``I’ve been working on a project, a simple team task management system built with Laravel. After finishing the backend features like teams, invitations, and authentication, I finally shifted my focus to something I was avoiding for quite a while now: the UI. I also added a name for this project instead of just calling it a team task manager. The website name is Worklio.

Here's the home page of the website:

I’m keeping the UI as simple as possible because my main focus is learning the backend side. I also use ChatGPT to help generate some of the frontend code, and the results have been surprisingly good. Right now, I just need to break parts of the UI into reusable components to make the codebase easier to read and maintain, while also centralizing repeated logic and code.

Here's the rest of the pages:

Team Page

Show Single Team Page with Projects

What's next

I currently have both frontend and backend for teams, invitations, projects, and now I'll be working on the task part.

Note: I’m using ChatGPT as part of my learning process—to sanity-check ideas, understand Laravel patterns, and think through tradeoffs. I still write the code myself and use the project to test whether I actually understand what I’m building.

Why I’m Still Learning to Code Even With AI

Juan Carlos Padillo — Mon, 11 May 2026 01:42:07 +0000

A while ago, I caught myself wondering:

"Am I too late?"

Not because I started coding late.

But because every week there seems to be a new AI demo building apps, writing features, fixing bugs, and explaining code faster than I can even think through the problem.

When you’re still learning, that can get in your head.

You start asking yourself:

If AI can already do this, what exactly am I trying to learn?

I’ve been there.

I’m still early in my journey. I’m building projects, learning Laravel, breaking things, fixing them, and slowly getting better at understanding how software actually comes together.

Lately I’ve been working on a team task management app.

At first it felt straightforward.

A team has members. Owner can invite other members. Tasks can be created and assigned.

Simple.

Until it isn’t.

While working on the invitation feature, I started moving logic out of controllers and into service classes. Then I added form requests. Then policies.

And suddenly I realized something that felt bigger than the feature itself.

**The hard part wasn’t writing code.

The hard part was deciding what code should exist.**

That changed how I look at AI.

AI can absolutely generate code.

Sometimes it gives surprisingly solid code.

But while building that feature, AI wasn’t the one deciding things like:

Should this logic live in the controller or a service?
What happens if someone sends the same invitation twice?
Who should be allowed to invite people?
What happens when someone leaves a team?
How do I structure this so future me won’t hate present me?

Those decisions were still mine.

And honestly, that’s the part I actually want to learn.

When I first started coding, I treated code like a puzzle.

I kept adding pieces until the feature worked.

Once it worked, I usually didn’t want to touch it again, because I knew changing one thing might break three others.

Lately, I’ve been trying to move away from that.

I’ve started paying more attention to system design—not in the “big tech interview” way, but in the practical way.

I want to be more intentional.

Not just:

“How do I make this work?”

But also:

“Why should it work this way?”

That shift has made coding feel different.

And honestly, more interesting.

Because the more I learn, the more I realize coding isn’t mainly about syntax.

It’s about tradeoffs.

It’s about structure.

It’s about deciding what belongs where.

It’s about understanding the problem well enough to build something that won’t immediately collapse the moment you add a new feature.

That’s why AI doesn’t discourage me anymore.

If anything, it clarified what actually matters.

AI can help me write code faster.

It can explain concepts.

It can help me compare approaches.

It can even point out mistakes I didn’t notice.

But it still doesn’t replace judgment.

It doesn’t automatically know the tradeoffs inside my project.

It doesn’t know the shortcuts I took last week.

It doesn’t know what future me will struggle to maintain.

That part still comes from learning.

So if you’re just starting—or thinking about starting—and AI makes you wonder if coding is still worth learning, here’s my honest take:

This might actually be one of the best times to start.

Because now you can get unstuck faster.

You can ask better questions.

You can explore more ideas in less time.

But the real learning still happens when you decide:

what to build
how to structure it
which tradeoffs you accept
what code stays
and what code needs to be deleted

That part still belongs to you.

I’m still learning too.

Still writing code I later refactor.

Still realizing how much I don’t know.

Still trying to go from “it works” to “this makes sense.”

And right now, that feels like progress.

AI didn’t make me want to stop learning.

It made me realize something more important:

The value isn’t just in writing code.
The value is in understanding why that code should exist at all.

Note: I use AI while learning, not to skip the work, but to understand faster, explore alternatives, and challenge my thinking.

Building Team Invitations in Laravel

Juan Carlos Padillo — Sat, 02 May 2026 14:29:12 +0000

Today I finished the invitation flow for my team task management project.

At first, the feature looked simple: invite a user by email and let them join a team. But once I started building it, I realized there were a few real-world cases to handle.

What the invitation flow does

A team owner can invite someone using their email address.

When an invitation is sent:

the system checks if the user is already a team member
it checks if there is already a pending invitation for that same email in that team
if everything is valid, an invitation record is created with a token

When the invited user accepts:

the system verifies the logged-in user matches the invited email
the user gets attached to the team
the invitation gets deleted

What I learned

The biggest lesson was learning where code should live.

My controller worked, but it started getting crowded fast. It was handling:

validation
duplicate checks
member checks
creating invitations
attaching users to teams

That pushed me to move the business logic into service classes.

Now the controller mostly handles the request and delegates the actual work.

That small refactor made the code much easier to read.

Check out the difference in the controller after using service classes.

Here’s the code for storing an invitation that I originally wrote without using a service class:

There’s a lot going on in this method, and I even duplicated Invitation::create()—that’s on me. 😅

Here’s the same method refactored using a service class:

Now it's much cleaner and easier to read. I also created Form Request class, so input validation is handled in a separate class.

One small bug that taught me something

I got stuck for a while checking duplicate invitations.

At first I used get(), which returns a collection. Even when empty, it still caused confusing behavior.

Switching to exists() made the intent much clearer.

That was a small thing, but it helped me understand Eloquent a little better.

What’s next

The invitation system is working now, and the project is starting to feel like a real application instead of just practice.

Next, I’m focusing on the frontend, starting with a cleaner dashboard and better team/project pages.

Github repo: Team Task Manager

Note: I’m using ChatGPT as part of my learning process—to sanity-check ideas, understand Laravel patterns, and think through tradeoffs. I still write the code myself and use the project to test whether I actually understand what I’m building.

Building Teams in Laravel (Ownership & Membership)

Juan Carlos Padillo — Thu, 30 Apr 2026 05:40:25 +0000

After setting up the basic structure of my project, I implemented the team creation flow.

The idea is simple: a registered user can create a team and immediately become both the owner and a member of that team.

Key decision

I separated:

ownership → stored in teams.owner_id
membership → stored in team_user pivot table

This allows flexibility where:

a user can belong to multiple teams
roles can be managed per team

How it works

When registered user create a team:

A new team is stored with owner_id
The user is attached to team_user with role = owner

This ensures the creator is automatically part of the team.

Why this matters

Instead of treating the owner separately, I treat them as a member with elevated permissions

This keeps relationships consistent and simplifies access control later.

Next, I’ll implement the invitation system so team owners can invite other users and build actual collaboration.

Github repo: https://github.com/pads-only/team-task-manager

Building a Laravel Team Task Manager from Scratch (Planning & System Design)

Juan Carlos Padillo — Tue, 28 Apr 2026 15:41:21 +0000

Hello, I’m starting a new project to improve my backend development skills using Laravel.

The goal is to build a Team Task Management System that simulates real-world collaboration, similar to tools like Trello or Asana, but simplified and focused on learning backend architecture.

This post is the first in a series where I’ll document the entire development process, from planning to deployment.

Project Goal

The system allows:

Users and Teams
Projects inside teams
Tasks inside projects
Task assignments, comments, and attachments
Notifications for updates

Why am I Building This

I want to go beyond the CRUD basic apps and focus on real-world backend concepts like:

Eloquent relationships
Policies and authorization
REST API design
Service classes
Queues and notifications

High-level idea

A user joins a team via invitation
Teams manage multiple projects
Projects contain tasks
Tasks can be assigned, discussed, and tracked

Database planning

users
teams
team_user
invitations
projects
tasks
task_user
comments
attachments
notifications

Next step

Laravel Breeze setup
Database migrations
Team and user relationships

That's it for the planning phase. See you in my next blog post!