Forem: Juan Carlos Padillo

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!