From Vibe Coding to Spec-Driven Development: Part 2 - The Spec-Kit Workflow

# TODO(PROJECT_NAME) Constitution

## Core Principles

### TODO(PRINCIPLE_1_NAME)
TODO(PRINCIPLE_1_DESCRIPTION): Define first core principle...

### TODO(PRINCIPLE_2_NAME)
TODO(PRINCIPLE_2_DESCRIPTION): Define second core principle...

## Governance

TODO(GOVERNANCE_RULES): Define how this constitution is amended...

# Team Task Manager Constitution

## Project Purpose

Build a collaborative task management system for small teams (5-20 people) to organize work, assign tasks, and track progress in real-time.

## Core Principles

### I. Simplicity First
Start with the minimum viable feature set. Complexity must be justified against simpler alternatives. The constitution's Complexity Tracking mechanism MUST be used to document any deviation from this principle.

**Rationale**: Small teams need tools they can understand and maintain. Over-engineering leads to technical debt and slower iteration.

### II. User Experience Over Features
A polished core beats a bloated mess. Every feature must demonstrably improve the user experience. Feature requests that compromise UX quality are rejected.

**Rationale**: Users value reliable, intuitive tools over feature-rich but confusing interfaces.

### III. Security By Design
Authentication and authorization at every layer. Security is non-negotiable and cannot be retrofitted.

**Rationale**: Task management involves sensitive business information. A single breach destroys trust.

### IV. Performance Matters
Sub-second response times for all interactions. Performance targets are requirements, not aspirations.

**Rationale**: Slow tools disrupt workflow. Performance directly impacts user adoption and satisfaction.

### V. Mobile-Friendly
Responsive design, not separate mobile apps. The web interface must work seamlessly on all device sizes.

**Rationale**: Team members work from various devices. Maintaining separate mobile apps increases complexity and violates Principle I.

## Technical Constraints

### Must Use
- **Backend**: .NET 9 with C#
- **Frontend**: Blazor Server (keep it simple, no separate SPA)
- **Database**: SQL Server or PostgreSQL
- **Authentication**: ASP.NET Core Identity
- **Deployment**: Containerized (Docker)

### Must Avoid
- No complex microservices (keep it monolithic for now)
- No separate frontend frameworks (React, Angular, Vue, etc.)
- No over-engineered authentication flows (stick to ASP.NET Core Identity)

**Rationale**: These constraints enforce Principle I (Simplicity First) by limiting architectural complexity and preventing technology sprawl.

## Quality Standards

### Code Quality
- C# nullable reference types MUST be enabled project-wide
- Roslyn analyzers MUST be enabled (minimum: StyleCop.Analyzers)
- EditorConfig MUST be configured for consistent formatting
- All public methods MUST be documented with XML comments

### Testing
- Unit tests for business logic (80%+ coverage REQUIRED)
- Integration tests for all API endpoints
- End-to-end tests for critical user flows (defined as: create team, create task, assign task, complete task)

**Enforcement**: Pull requests failing coverage or missing critical path tests will be rejected.

### Performance
- Page load time < 2 seconds (measured at p95)
- API response time < 500ms (measured at p95)
- Database queries MUST be optimized (execution plans reviewed during code review)

**Enforcement**: Features that regress performance targets will be rolled back.

### Security
- OWASP Top 10 MUST be addressed for all user-facing features
- Dependencies MUST be scanned weekly (automated via CI/CD)
- SQL injection prevention: parameterized queries ONLY (raw SQL prohibited)
- XSS protection: all user input MUST be sanitized

**Enforcement**: Security violations block deployment.

## Non-Goals (What We're NOT Building)

Explicitly out of scope to prevent feature creep:

- ❌ Project management (Gantt charts, resource allocation, burndown charts)
- ❌ Time tracking or invoicing
- ❌ Complex workflows or automation (no custom workflow engines)
- ❌ Native mobile apps (web-first per Principle V)
- ❌ Real-time video/chat (out of scope for task management)

**Rationale**: These features violate Principle I (Simplicity First) and expand scope beyond small team task management. Feature requests in these categories should be politely declined.

## Success Criteria

### MVP (Version 1.0)
- Users can create teams
- Users can create, assign, and complete tasks
- Users can see team activity in real-time
- Application is secure (authentication required, OWASP Top 10 addressed)
- Application is fast (performance targets met)

### Future Enhancements (Post-MVP)
Considered only after MVP is stable and validated with users:
- Task comments and attachments
- Task dependencies and blocking relationships
- Email notifications
- Calendar integration (read-only)

## Governance

### Amendment Process
1. Amendments proposed via pull request to this file
2. Proposed changes must include:
   - Rationale for the change
   - Impact assessment on existing features/plans
   - Migration plan if breaking change
3. Approval requires: project maintainer sign-off
4. Constitution takes precedence over all other documents

### Versioning Policy
Semantic versioning (MAJOR.MINOR.PATCH):
- **MAJOR**: Backward incompatible changes (principle removal, constraint changes that invalidate existing code)
- **MINOR**: New principle or section added, material expansion of guidance
- **PATCH**: Clarifications, wording improvements, non-semantic refinements

### Compliance Review
- All feature specifications MUST reference this constitution
- All implementation plans MUST include "Constitution Check" section
- Code reviews MUST verify adherence to quality standards and technical constraints
- Violations MUST be documented in plan.md Complexity Tracking section

### Review Cadence
Constitution reviewed quarterly or when significant architectural decisions arise.

**Version**: 1.0.0 | **Ratified**: 2026-01-12 | **Last Amended**: 2026-01-12

# Team Task Manager Specification

## Overview

A collaborative task management application for small teams to organize work, 
assign tasks, and track progress.

---

## User Stories

### Authentication

**As a new user**, I want to:
- Sign up with my email or Google account
- Receive a confirmation email
- Log in securely
- Reset my password if forgotten

**Acceptance Criteria:**
- Sign-up takes < 30 seconds
- Email confirmation sent within 1 minute
- Password reset link expires in 24 hours
- Failed login attempts rate-limited after 5 attempts

---

### Team Management

**As a team admin**, I want to:
- Create a new team with a unique name
- Invite members via email
- Remove members from the team
- Transfer ownership to another member

**Acceptance Criteria:**
- Team names must be unique
- Email invitations expire in 7 days
- Removed members lose access immediately
- Ownership transfer requires confirmation

---

### Task Management

**As a team member**, I want to:
- Create tasks with title, description, and due date
- Assign tasks to myself or team members
- Mark tasks as complete
- Edit or delete tasks I created
- Filter tasks by assignee or status

**Acceptance Criteria:**
- Task creation takes < 5 seconds
- Tasks appear in real-time for all team members
- Completed tasks marked with timestamp
- Only task creator or assignee can edit/delete
- Filters apply instantly (no page reload)

---



## User Interface Requirements

### Dashboard View
- Navigation bar with logo, user menu
- Tab navigation: My Tasks, Team Tasks, Completed
- Filter dropdown: All, Assigned to me, Created by me
- Task cards showing: title, description preview, assignee, due date
- Checkbox to mark tasks complete
- "New Task" button

### Task Detail View
- Back navigation to dashboard
- Task title (editable)
- Creator and creation date
- Assignee dropdown (team members)
- Due date picker
- Status dropdown (Open, In Progress, Completed)
- Description text area
- Delete and Save buttons

### Responsive Behavior
- **Desktop (> 1024px)**: Side-by-side task list and detail
- **Tablet (768-1024px)**: Stacked layout with full-width cards
- **Mobile (< 768px)**: Single-column, touch-optimized buttons

---

## Data Requirements

### Users
- Unique identifier (UUID)
- Email (unique, validated)
- Display name
- Avatar URL (optional)
- Created timestamp
- Last login timestamp

### Teams
- Unique identifier (UUID)
- Team name (unique)
- Owner (user reference)
- Created timestamp
- Member count

### Team Memberships
- Team reference
- User reference
- Role (admin, member)
- Joined timestamp

### Tasks
- Unique identifier (UUID)
- Title (required, max 200 chars)
- Description (optional, max 5000 chars)
- Status (open, in_progress, completed)
- Created by (user reference)
- Assigned to (user reference, optional)
- Team reference
- Due date (optional)
- Created timestamp
- Updated timestamp
- Completed timestamp (nullable)

---

## Edge Cases & Error Handling

### Authentication
- **Scenario**: User tries to access app without logging in
- **Expected**: Redirect to login page, preserve intended destination

- **Scenario**: Session expires while user is working
- **Expected**: Show modal "Session expired, please log in again"

### Task Management
- **Scenario**: Two users edit the same task simultaneously
- **Expected**: Last write wins, show conflict notification

- **Scenario**: User tries to delete a task they didn't create
- **Expected**: Show error "Only task creator can delete"

### Real-time updates
- **Scenario**: Network connection drops
- **Expected**: Show "Offline" indicator, queue updates, sync when reconnected

- **Scenario**: User has 1000+ completed tasks
- **Expected**: Paginate results, load 50 at a time

### Team Management
- **Scenario**: Last admin leaves the team
- **Expected**: Promote oldest member to admin automatically

- **Scenario**: User invited to team they're already in
- **Expected**: Show message "You're already a member"

---

## Performance Requirements

### Page Load
- Initial load: < 2 seconds (3G connection)
- Subsequent navigation: < 500ms

### API Response Times (95th percentile)
- GET requests: < 200ms
- POST/PUT requests: < 500ms
- Real-time updates: < 2 seconds

### Concurrent Users
- Support 100 concurrent users per team
- Support 1000 teams total (MVP target)

---

## Security Requirements

### Authentication
- Passwords hashed with bcrypt (cost factor 12)
- OAuth tokens stored securely (httpOnly cookies)
- MFA support (optional for MVP)

### Authorization
- Role-based access control (RBAC)
- Users can only access teams they belong to
- Task operations checked against user permissions

### Data Protection
- All API requests over HTTPS
- SQL injection prevention (parameterized queries)
- XSS prevention (sanitize user input)
- CSRF tokens on all state-changing requests

### Auditing
- Log all authentication attempts
- Log all task CRUD operations
- Log all team membership changes

---

## Success Metrics

### User Engagement
- Daily active users per team: > 60%
- Tasks created per user per week: > 5
- Task completion rate: > 70%

### System Health
- Uptime: > 99.5%
- Error rate: < 0.1% of requests
- Response time (p95): < 500ms

### User Satisfaction
- NPS score: > 40
- Support tickets per user: < 0.05/month

# Specification Quality Checklist: Team Task Manager

## Content Quality
✅ Written for non-technical stakeholders
✅ Focused on user value and business needs  
✅ No implementation details (languages, frameworks, APIs)

## Requirement Completeness
✅ No NEEDS CLARIFICATION markers remain
✅ Success criteria are technology-agnostic
✅ All acceptance scenarios are defined
✅ Use cases are identified

## Feature Readiness
✅ All functional requirements have clear acceptance criteria
✅ User scenarios cover primary flows
✅ Feature meets measurable outcomes
✅ No implementation details leak into specification

## Edge Cases
✅ Nine edge case scenarios documented covering:
   - Concurrent editing conflicts
   - Network issues and offline scenarios
   - Data volume and pagination
   - Team management edge cases
   - Authorization failures

## Validation Summary
Status: ✅ PASSED - All quality criteria met

This specification is ready for /speckit.plan

# Technical Plan: Team Task Manager

## Technology Stack

### Backend
- **Framework**: .NET 9
- **Language**: C# 13
- **Authentication**: ASP.NET Core Identity
- **Database ORM**: Entity Framework Core 9
- **Validation**: FluentValidation
- **Testing**: xUnit + Moq

### Frontend
- **Framework**: Blazor Server
- **UI Components**: Bootstrap 5 or MudBlazor

### Database
- **Primary**: SQL Server 2022 or PostgreSQL 16+
- **Schema Migrations**: EF Core Migrations
- **Connection Pooling**: Built-in connection pooling

### Infrastructure
- **Containerization**: Docker + Docker Compose
- **Web Server**: Kestrel (built-in)
- **Environment Config**: appsettings.json + User Secrets

---

## Architecture Overview

The application follows a traditional three-tier architecture:

**Presentation Layer**
- Blazor Server (server-side rendering)
- Standard HTTP requests

**Application Layer**
- .NET 9 Web Application
- ASP.NET Core Identity for authentication
- API Controllers for REST endpoints

**Data Layer**
- Entity Framework Core 9
- SQL Server or PostgreSQL database

---

## Database Schema

See `data-model.md` for complete Entity Framework model.

### Key Entities
- `User` - User accounts (ASP.NET Identity)
- `Team` - Team workspaces
- `TeamMember` - Many-to-many relationship
- `Task` - Task data

### Indexes
- `User.Email` (unique)
- `Team.Name` (unique)
- `Task.TeamId` (for filtering)
- `Task.AssignedToId` (for user task views)
- `Task.Status` (for status filters)

---

## API Design

### RESTful Endpoints

#### Authentication
- Built-in ASP.NET Core Identity pages
- `/Account/Register` - Create new user
- `/Account/Login` - Login existing user
- `/Account/Logout` - Logout user

#### Teams
- `GET /api/teams` - List user's teams
- `POST /api/teams` - Create new team
- `GET /api/teams/{id}` - Get team details
- `PUT /api/teams/{id}` - Update team
- `DELETE /api/teams/{id}` - Delete team
- `POST /api/teams/{id}/invite` - Invite member
- `DELETE /api/teams/{id}/members/{userId}` - Remove member

#### Tasks
- `GET /api/teams/{teamId}/tasks` - List team tasks
- `POST /api/teams/{teamId}/tasks` - Create task
- `GET /api/tasks/{id}` - Get task details
- `PUT /api/tasks/{id}` - Update task
- `DELETE /api/tasks/{id}` - Delete task

---

## Security Implementation

### Authentication Flow
1. User submits credentials
2. ASP.NET Core Identity validates
3. Authentication cookie created
4. Authorization policies check on each request

### Authorization Policy
```csharp
// Verify user belongs to team
public class TeamMemberRequirement : IAuthorizationRequirement
{
    public string TeamIdClaimType { get; set; } = "TeamId";
}

public class TeamMemberHandler : AuthorizationHandler<TeamMemberRequirement>
{
    private readonly AppDbContext _context;

    public TeamMemberHandler(AppDbContext context)
    {
        _context = context;
    }

    protected override async Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        TeamMemberRequirement requirement)
    {
        var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
        var teamId = context.User.FindFirstValue(requirement.TeamIdClaimType);

        if (userId == null || teamId == null)
        {
            return;
        }

        var isMember = await _context.TeamMembers
            .AnyAsync(tm => tm.UserId == userId && tm.TeamId == teamId);

        if (isMember)
        {
            context.Succeed(requirement);
        }
    }
}

# Tasks: Team Task Manager

**Organization**: Tasks are grouped by user story to enable independent 
implementation and testing of each story.

## Format: `- [ ] [ID] [P?] [Story?] Description`

- **[P]**: Can run in parallel (different files, no dependencies)
- **[Story]**: Which user story this task belongs to (e.g., US1, US2)

---

## Phase 1: Setup (Shared Infrastructure)

**Purpose**: Project initialization and basic structure

- [ ] T001 Create .NET 9 solution with TeamTaskManager project and test project
- [ ] T002 Configure project settings: enable nullable reference types
- [ ] T003 [P] Add NuGet packages: EF Core, Npgsql, Identity
- [ ] T004 [P] Create EditorConfig with StyleCop.Analyzers configuration
- [ ] T005 [P] Create docker-compose.yml with PostgreSQL service
- [ ] T006 [P] Create Dockerfile with multi-stage build
- [ ] T007 Create directory structure: Components, Models, Data, Services, Auth
- [ ] T008 Create appsettings.json with connection string placeholders
- [ ] T009 Create .gitignore excluding appsettings.Development.json

---

## Phase 2: Foundational (Blocking Prerequisites)

**Purpose**: Core infrastructure that MUST be complete before ANY user story

⚠️ **CRITICAL**: No user story work can begin until this phase is complete

- [ ] T010 Create User entity model with all properties from data-model.md
- [ ] T011 Create Team entity model with all properties
- [ ] T012 [P] Create Task entity with Status enum and RowVersion for concurrency
- [ ] T013 [P] Create TeamMembership entity with Role enum
- [ ] T014 [P] Create TeamInvitation entity with Status enum
- [ ] T015 [P] Create AuditLog entity model
- [ ] T016 Create ApplicationDbContext extending IdentityDbContext<User>
- [ ] T017 Configure entity relationships using Fluent API per data-model.md
- [ ] T018 Create indexes: Task(TeamId,Status), TeamMembership(TeamId,UserId)
- [ ] T019 Create initial EF Core migration: dotnet ef migrations add InitialCreate
- [ ] T020 Configure ASP.NET Core Identity with password requirements
- [ ] T021 Configure authentication: AddIdentity, cookie settings (24hr expiration)
- [ ] T022 Create custom AuthenticationStateProvider for Blazor
- [ ] T023 [P] Create IRepository<T> interface
- [ ] T024 [P] Create Repository<T> implementation with async methods
- [ ] T025 Configure error handling middleware
- [ ] T026 Configure structured logging using ILogger<T>
- [ ] T027 Configure rate limiting middleware per API specification
- [ ] T028 Create MainLayout.razor with navigation and auth state
- [ ] T029 Create NavMenu.razor with conditional rendering
- [ ] T030 Configure SignalR hub with connection timeout and group support

**Checkpoint**: Foundation ready - user story implementation can now begin in parallel

---

## Phase 3: User Story 2 - User Authentication (Priority: P1) 🎯 MVP Foundation

**Goal**: Enable secure user sign-up, login, and password recovery

**Independent Test**: Sign up with email, log in, reset password, verify rate limiting

**Why First**: Authentication is foundational - required before collaborative features

### Implementation for User Story 2

- [ ] T031 [P] [US2] Create Register.razor page with email/password form
- [ ] T032 [P] [US2] Create Login.razor page with email/password form
- [ ] T033 [P] [US2] Create ForgotPassword.razor page with email input
- [ ] T034 [P] [US2] Create ResetPassword.razor page with token validation
- [ ] T035 [US2] Create AuthService with RegisterAsync, LoginAsync, LogoutAsync
- [ ] T036 [US2] Implement email confirmation using ASP.NET Core Identity tokens
- [ ] T037 [US2] Implement password reset with 24-hour token expiration
- [ ] T038 [US2] Implement rate limiting: 5 attempts, 15-minute lockout
- [ ] T039 [US2] Add session expiration: 24-hour absolute expiration
- [ ] T040 [US2] Create AuditService with LogAsync method
- [ ] T041 [US2] Add audit logging for authentication events
- [ ] T042 [US2] Create IEmailService interface
- [ ] T043 [US2] Create SendGridEmailService implementation
- [ ] T044 [US2] Add email templates for confirmation and password reset
- [ ] T045 [US2] Wire up Register page to AuthService with validation
- [ ] T046 [US2] Wire up Login page with error handling
- [ ] T047 [US2] Wire up ForgotPassword and ResetPassword pages
- [ ] T048 [US2] Add redirect to preserved destination after login
- [ ] T049 [US2] Create API endpoints: POST /api/auth/register, /login, /logout

**Checkpoint**: Users can sign up, log in, reset passwords securely

---

## Phase 4: User Story 1 - Task Management Core (Priority: P1) 🎯 MVP

**Goal**: Enable task creation, assignment, editing, and completion

**Independent Test**: Create task, edit description, mark complete, verify timestamp

**Why Second**: Core value proposition - delivers immediate task tracking

### Implementation for User Story 1

- [ ] T050 [P] [US1] Create TaskCard.razor component
- [ ] T051 [P] [US1] Create TaskDetailModal.razor for editing
- [ ] T052 [P] [US1] Create NewTaskModal.razor for creating tasks
- [ ] T053 [US1] Create Tasks.razor page with task list view
- [ ] T054 [US1] Create TaskService with CRUD methods
- [ ] T055 [US1] Implement CreateTaskAsync with validation
- [ ] T056 [US1] Implement UpdateTaskAsync with optimistic concurrency using RowVersion
- [ ] T057 [US1] Implement CompleteTaskAsync setting CompletedAt timestamp
- [ ] T058 [US1] Implement DeleteTaskAsync with creator-only authorization
- [ ] T059 [US1] Add authorization: only creator/assignee can edit
- [ ] T060 [US1] Implement real-time task broadcast using SignalR (< 2 seconds)
- [ ] T061 [US1] Add audit logging for task operations
- [ ] T062 [US1] Wire up Tasks.razor to TaskService with data loading
- [ ] T063 [US1] Wire up NewTaskModal with form validation
- [ ] T064 [US1] Wire up TaskDetailModal with concurrency conflict handling
- [ ] T065 [US1] Add checkbox for marking complete
- [ ] T066 [US1] Implement SignalR hub subscription for real-time updates
- [ ] T067 [US1] Add "New Task" button opening NewTaskModal
- [ ] T068 [US1] Handle concurrent edit conflict: show notification with conflicting user
- [ ] T069 [US1] Create API endpoints: GET/POST /api/teams/{teamId}/tasks, etc.

**Checkpoint**: Users can create, assign, edit, complete tasks with real-time updates

---

## Phase 5: User Story 3 - Team Collaboration (Priority: P2)

**Goal**: Enable team creation, member invitations, and membership management

**Why Third**: Enables collaboration; builds on tasks and auth

- [ ] T070-T094 [US3] Team management implementation (25 tasks)
  - Create Teams.razor, TeamSettings.razor, invitation flows
  - Implement TeamService and MembershipService
  - Email invitations with 7-day expiration
  - Auto-promote oldest member when last admin leaves
  - Handle edge cases: duplicate invitations, expired tokens

**Checkpoint**: Users can create teams, invite members, manage membership

---

## Phase 6: User Story 4 - Task Filtering (Priority: P2)

**Goal**: Enable filtering by assignee, status, and creator

- [ ] T095-T106 [US4] Filtering implementation (12 tasks)
  - Create TaskFilters.razor component
  - Implement instant filtering without page reload
  - Add pagination for completed tasks (50 per page)
  - Optimize queries using database indexes

**Checkpoint**: Users can filter tasks instantly by multiple criteria

---

## Phase 7: User Story 5 - Responsive Interface (Priority: P3)

**Goal**: Ensure mobile, tablet, and desktop layouts work seamlessly

- [ ] T107-T117 [US5] Responsive UI implementation (11 tasks)
  - Mobile-first CSS with 768px and 1024px breakpoints
  - Touch-optimized buttons (44px minimum)
  - Hamburger menu for mobile navigation
  - Test across device sizes

**Checkpoint**: Application works on all device sizes

---

## Phase 8: Polish & Cross-Cutting Concerns

**Purpose**: Final quality, security hardening, performance optimization

- [ ] T118-T137 Polish tasks (20 tasks)
  - Health check endpoint
  - CORS, HTTPS, anti-forgery tokens
  - Input sanitization for XSS prevention
  - Database query optimization
  - Caching with IMemoryCache
  - Performance testing: < 2s page load, < 500ms API
  - OWASP Top 10 security review

---

## Task count summary

- **Phase 1 (Setup)**: 9 tasks
- **Phase 2 (Foundational)**: 21 tasks ← Critical path
- **Phase 3 (US2 - Auth)**: 19 tasks ← P1 (MVP Foundation)
- **Phase 4 (US1 - Tasks)**: 20 tasks ← P1 (MVP Core)
- **Phase 5 (US3 - Teams)**: 25 tasks ← P2
- **Phase 6 (US4 - Filtering)**: 12 tasks ← P2
- **Phase 7 (US5 - Responsive)**: 11 tasks ← P3
- **Phase 8 (Polish)**: 20 tasks ← Cross-cutting

**Total**: 137 tasks

**MVP Scope (Phases 1-5)**: 94 tasks (~69% of total)

---

## Dependencies and execution order

### Task Comments

**As a team member**, I want to:
- Add comments to tasks
- See all comments with timestamps
- Edit or delete my own comments

**Acceptance Criteria:**
- Comments appear in real-time
- Comments support basic Markdown
- Comments preserved when task completed

#### Comments
- `GET /api/tasks/:id/comments` - List task comments
- `POST /api/tasks/:id/comments` - Add comment
- `PUT /api/comments/:id` - Edit comment
- `DELETE /api/comments/:id` - Delete comment

## Phase 11: Task Comments
- [ ] 11.1 Add Comment model to Prisma schema
- [ ] 11.2 Run migration
- [ ] 11.3 Create comments API endpoints
- [ ] 11.4 Add comments UI component
- [ ] 11.5 Implement real-time comment updates

**Dependencies**: 9.1-9.5
**Acceptance**: Users can add, edit, delete comments

Build a task manager with teams

## User Story: Team Creation

As a user, I want to create a new team by:
1. Clicking "New Team" button
2. Entering team name (3-50 chars, alphanumeric)
3. Seeing confirmation "Team created"

**Acceptance Criteria:**
- Team name must be unique
- Creator becomes admin automatically
- Team appears in sidebar immediately
- Error shown if name taken: "Team name already exists"

Must use microservices with event sourcing

Start with monolithic architecture
Consider microservices only if:
- Team exceeds 10 developers
- System exceeds 10k users
- Performance becomes bottleneck

## Technical Constraints
- React >= 18.2 (use new hooks API)
- Express >= 4.18 (async/await support)