She Sharp is a comprehensive mentorship platform dedicated to bridging the gender gap in STEM fields. Founded in 2014, we've built a thriving community of over 1000+ women in technology, supported by 50+ corporate partners, and have hosted 84+ events to empower women in their STEM careers.

🚀 Revolutionary Dual-Role System: Users can seamlessly switch between mentor and mentee roles, enabling them to both guide others and learn from experienced professionals simultaneously - a unique approach that maximizes growth opportunities and creates a dynamic learning ecosystem.

	Experience our platform without installation!
	Explore the source code and contribute!

⭐ Star History

We are committed to creating an inclusive environment where women in STEM can:

• Connect with mentors and peers in the industry
• Learn through workshops, events, and educational resources
• Grow professionally through mentorship and career development programs
• Inspire the next generation of women in technology

• 🎯 1000+ Active Community Members
• 🤝 50+ Corporate Partners & Sponsors
• 📅 84+ Events Since 2014
• 👩‍🏫 18 Industry Mentors
• 📈 85% Mentorship Success Rate
• 🚀 5-6x Higher Promotion Likelihood for Mentees

• Dynamic Homepage - Hero carousel showcasing latest initiatives and achievements
• About Section - Mission, vision, team profiles, and organizational timeline
• Events Platform - Browse upcoming events, workshops, and special programs
• Mentorship Program - Connect with industry mentors, apply for mentorship
• Media Hub - Access podcasts, newsletters, photo galleries, and press coverage
• Support Options - Multiple donation channels and sponsorship opportunities

• Smart Chatbot - OpenAI GPT-powered assistant for instant help
• Contextual Responses - Organization-specific knowledge and guidance
• 24/7 Availability - Always available to answer questions
• Multilingual Support - Assists users in their preferred language

• Dual-Role Capability - Simultaneously act as both mentor and mentee
• Smart Matching - AI-powered mentor-mentee pairing based on expertise and goals
• Dynamic Role Switching - Seamlessly transition between mentor and mentee roles
• Relationship Management - Track mentorship progress with detailed analytics
• Meeting Scheduler - Integrated scheduling with automated reminders
• Progress Tracking - Monitor learning goals and professional development

• Multi-Role Activation - Users can activate mentor, mentee, or admin roles independently
• Role Verification - Mentor verification process ensures quality mentorship
• Capacity Management - Mentors set their availability and maximum mentee count
• Role Analytics - Detailed statistics for both mentoring and learning activities

• Team Management - Invite members, manage roles and permissions
• Activity Tracking - Monitor team engagement and participation
• User Management - Comprehensive user administration
• Analytics - Track impact metrics and engagement

• Modern Full-Stack Architecture - Next.js 15.4 with App Router, TypeScript, PostgreSQL
• Type-Safe Development - End-to-end TypeScript with Drizzle ORM for database operations
• Comprehensive API Layer - RESTful API with 25+ specialized endpoints
• Multi-Role Authentication - JWT-based with role-based access control (RBAC)
• Advanced Database Management - Migration versioning, automatic snapshots, rollback capabilities
• Real-time Features - Dynamic dashboards with live data synchronization
• Component Architecture - shadcn/ui with custom design system and Radix UI primitives
• AI Integration - OpenAI GPT-powered intelligent assistant
• Performance Optimization - Edge deployment with CDN and intelligent caching
• Security-First Design - No payment processing, focus on core community features

Next.js 15

React 19

TypeScript 5

PostgreSQL 16

Drizzle ORM

Tailwind CSS

Vercel

Frontend Stack:

• Framework: Next.js 15 with App Router
• Language: TypeScript for type safety
• Styling: Tailwind CSS v4 + Framer Motion
• State: React Context + Server State
• UI Components: shadcn/ui + Radix UI

Backend Stack:

• Runtime: Node.js with Next.js API Routes
• Database: PostgreSQL (Neon) with Drizzle ORM
• Database Version Control: Migration snapshots and checkpoints
• Authentication: JWT-based with bcrypt + NextAuth (OAuth)
• AI Integration: OpenAI GPT API
• Email: Resend for transactional emails (auth, mentorship, recruitment)
• Notifications: Slack Incoming Webhooks for form submission alerts

DevOps & Monitoring:

• Deployment: Vercel Edge Network
• Storage: Cloudinary (image hosting)
• Notifications: Slack (webhook-based alerts)
• Analytics: Vercel Analytics
• CI/CD: GitHub Actions

Before you begin, ensure you have the following installed:

• Node.js (v20.0.0 or higher)

  node --version

• pnpm (v8.0.0 or higher)

  npm install -g pnpm

• PostgreSQL (v14 or higher)

  • Local installation or cloud service (e.g., Neon, Vercel Postgres, Supabase)
  • Note: pg_dump utility needed for full snapshot functionality (optional)

• Git

  git --version

1. Clone the repository

   git clone https://github.com/NZ-SheSharp/she-sharp.git
   cd she-sharp

2. Install dependencies

   pnpm install

3. Set up environment variables

   cp .env.example .env.local

4. Configure environment variables (see Environment Setup)

5. Set up the database

   pnpm db:setup
   pnpm db:migrate
   pnpm db:seed
   
   # Create initial snapshot for version control
   pnpm db:snapshot "initial-setup"

6. Start the development server

   pnpm dev

7. Open your browser Navigate to http://localhost:3000

Create a .env.local file with the following variables:

# Database (Neon PostgreSQL)
DATABASE_URL="postgresql://user:[email protected]/neondb?sslmode=require"

# Authentication
AUTH_SECRET="your-auth-secret-key-min-32-chars"

# OAuth (NextAuth)
AUTH_GOOGLE_ID="your-google-oauth-client-id"
AUTH_GOOGLE_SECRET="your-google-oauth-client-secret"
AUTH_GITHUB_ID="your-github-oauth-client-id"
AUTH_GITHUB_SECRET="your-github-oauth-client-secret"


# Email Service (Resend)
RESEND_API_KEY="re_..."

# Application
BASE_URL="http://localhost:3000"
NEXT_PUBLIC_APP_URL="http://localhost:3000"

# Cloudinary Image Storage
CLOUDINARY_CLOUD_NAME="your_cloud_name"
CLOUDINARY_API_KEY="your_api_key"
CLOUDINARY_API_SECRET="your_api_secret"

# Slack Notifications (Optional)
SLACK_VOLUNTEER_WEBHOOK_URL="https://hooks.slack.com/services/..."
SLACK_CONTACT_WEBHOOK_URL="https://hooks.slack.com/services/..."

# Start development server with Turbopack
pnpm dev

# Build for production
pnpm build

# Start production server
pnpm start

# Database operations
pnpm db:setup         # Initial setup
pnpm db:generate      # Generate migrations
pnpm db:migrate       # Apply migrations
pnpm db:migrate:safe  # Apply migrations with automatic backup
pnpm db:seed          # Seed sample data
pnpm db:studio        # Open Drizzle Studio

# Database version control
pnpm db:status        # Check migration status
pnpm db:history       # View migration history
pnpm db:snapshot      # Create database snapshot
pnpm db:version       # Access all version control commands

# Linting and formatting
pnpm lint             # Run ESLint
pnpm format           # Format with Prettier

# Type checking
pnpm type-check       # Run TypeScript compiler

1. Create a new file in app/(site)/your-page/page.tsx
2. Implement the page component:

   export default function YourPage() {
     return (
       <div className="container mx-auto py-8">
         <h1>Your Page Title</h1>
         {/* Page content */}
       </div>
     );
   }

1. Create a new file in app/api/your-endpoint/route.ts
2. Implement the route handler:

   import { NextResponse } from 'next/server';
   
   export async function GET(request: Request) {
     // Your logic here
     return NextResponse.json({ data: 'response' });
   }

1. Define the schema in lib/db/schema.ts:

   export const yourTable = pgTable('your_table', {
     id: serial('id').primaryKey(),
     name: text('name').notNull(),
     createdAt: timestamp('created_at').defaultNow()
   });

2. Generate and apply migrations:

   pnpm db:generate
   pnpm db:migrate

The project includes a comprehensive database version control system built on top of Drizzle ORM:

1. Before making schema changes, create a snapshot:

   pnpm db:snapshot "before-feature-xyz"

2. Check migration status before deployment:

   pnpm db:status

3. Apply migrations safely with automatic backup:

   pnpm db:migrate:safe

4. Create checkpoints for stable versions:

   pnpm db:version checkpoint "v1.0-stable"

5. View available snapshots for rollback:

   pnpm db:version list-snapshots

For detailed documentation, see:

• Database Version Control Guide
• Migration Quick Start

She Sharp introduces a groundbreaking approach to mentorship where users can seamlessly operate in multiple roles simultaneously. This innovative system recognizes that learning and teaching often go hand-in-hand, especially in the dynamic STEM field.

// Users can activate multiple roles independently
const userRoles = {
  mentor: true,    // Guide junior professionals
  mentee: true,    // Learn from senior experts
  admin: false     // Platform administration (by invitation)
}

• Mentors can learn advanced skills while teaching fundamentals
• Mentees can mentor others in areas where they excel
• Continuous Growth through both teaching and learning experiences
• Network Expansion across different experience levels
• Skill Diversification by engaging with various expertise areas

1. Discovery Phase: Browse mentor profiles with detailed expertise and availability
2. Application Process: Mentees apply with specific learning goals and challenges
3. Matching & Approval: Mentors review and approve/reject applications based on fit
4. Active Mentorship: Regular meetings with goal tracking and progress monitoring
5. Relationship Management: Pause, resume, or complete relationships as needed

• Meeting Types: Intro sessions, regular check-ins, milestone reviews, final evaluations
• Smart Scheduling: Integrated calendar with automated reminders
• Progress Tracking: Action items, goals, and feedback collection
• Quality Assurance: Rating system and continuous improvement feedback

• Personal Stats: Meeting hours, mentorship count, goal achievement rates
• Relationship Insights: Satisfaction scores, progress metrics, outcome tracking
• Platform Metrics: Success rates, engagement levels, community growth

• Multi-Format Events: Online, in-person, and hybrid options
• Event Categories: Workshops, networking, training, social gatherings, THRIVE programs
• Smart Registration: Capacity management with waitlist functionality
• Member Benefits: Tiered access based on membership level
• Engagement Tracking: Attendance, feedback, and certificate issuance

• Content Categories: Documents, videos, links, templates, guides
• Access Control: Role-based and membership-tier permissions
• Usage Analytics: Download tracking and engagement metrics
• Quality Curation: Community ratings and admin moderation

• Basic mentor browsing and application
• Access to public resources
• Free event participation
• Community networking

• Priority mentor matching
• Exclusive events and workshops
• Advanced resources and templates
• Extended meeting durations
• Detailed analytics and insights

graph TB
    subgraph "Frontend Layer"
        A[Next.js App Router] --> B[React Components]
        B --> C[shadcn/ui Components]
        C --> D[API Client]
    end
    
    subgraph "Backend Layer"
        E[API Routes] --> F[Business Logic]
        F --> G[Drizzle ORM]
        G --> H[PostgreSQL]
    end
    
    subgraph "External Services"
        I[JWT Auth]
        J[Stripe API]
        K[OpenAI GPT]
        L[Cloudinary]
        P[Slack Webhooks]
    end
    
    D --> E
    F --> I
    F --> J
    F --> K
    F --> L
    F --> P
    
    subgraph "Infrastructure"
        M[Vercel Edge Network]
        N[CDN]
        O[Database Pool]
    end
    
    M --> A
    N --> A
    O --> H

sequenceDiagram
    participant U as User
    participant F as Frontend
    participant A as API Routes
    participant D as Database
    participant S as Stripe
    participant G as OpenAI
    
    U->>F: User Action
    F->>A: API Request
    A->>A: JWT Validation
    alt Payment Flow
        A->>S: Process Payment
        S->>A: Payment Confirmation
    else AI Chat
        A->>G: Send Message
        G->>A: AI Response
    else Data Operation
        A->>D: Query/Mutation
        D->>A: Result
    end
    A->>F: JSON Response
    F->>U: Update UI

graph LR
    subgraph "Pages"
        P1[Home]
        P2[About]
        P3[Events]
        P4[Mentorship]
        P5[Dashboard]
    end
    
    subgraph "Components"
        C1[Layout]
        C2[Sections]
        C3[UI Library]
        C4[Chatbot]
    end
    
    subgraph "Services"
        S1[Auth Service]
        S2[Payment Service]
        S3[Database Service]
        S4[AI Service]
    end
    
    P1 --> C1
    P2 --> C2
    P3 --> C3
    P4 --> C4
    P5 --> S1
    C4 --> S4
    P5 --> S2

Key Metrics:

• ⚡ 95+ Lighthouse Score across all categories
• 🚀 < 1s Time to First Byte (TTFB)
• 💨 < 100ms API response times
• 📊 99.9% uptime reliability
• 🔄 Real-time data synchronization

Performance Optimizations:

• 🎯 Smart Caching: Next.js ISR and dynamic caching
• 📦 Code Splitting: Automatic route-based splitting
• 🖼️ Image Optimization: Next.js Image with WebP/AVIF
• 🔄 Database Optimization: Connection pooling and indexed queries
• 🌐 Edge Deployment: Global CDN distribution

she-sharp/
├── app/                          # Next.js App Router
│   ├── (dashboard)/             # Protected dashboard routes
│   │   ├── dashboard/          # Main dashboard
│   │   ├── team/              # Team management
│   │   └── settings/          # User settings
│   ├── (login)/                # Authentication pages
│   │   ├── sign-in/          # Sign in page
│   │   └── sign-up/          # Sign up page
│   ├── (site)/                 # Public website
│   │   ├── about/            # About pages
│   │   ├── events/           # Events listing
│   │   ├── mentorship/       # Mentorship program
│   │   ├── media/            # Media hub
│   │   └── support/          # Support/donation
│   ├── api/                    # API routes
│   │   ├── auth/             # Authentication endpoints
│   │   ├── chat/             # AI chatbot endpoint
│   │   ├── stripe/           # Payment endpoints
│   │   └── user/             # User management
│   └── layout.tsx              # Root layout
├── components/                  # React components
│   ├── chatbot/                # AI chatbot UI
│   ├── layout/                 # Layout components
│   ├── sections/               # Page sections
│   └── ui/                     # shadcn/ui components
├── lib/                        # Core utilities
│   ├── auth/                   # Authentication logic
│   ├── db/                     # Database configuration
│   │   ├── schema.ts         # Database schema
│   │   ├── queries.ts        # Database queries
│   │   ├── drizzle.ts        # Drizzle client
│   │   ├── migrations/       # Database migrations
│   │   ├── snapshots/        # Database snapshots
│   │   ├── migration-manager.ts # Version control
│   │   └── snapshot-manager.ts  # Snapshot management
│   ├── data/                   # Static data
│   └── payments/               # Stripe integration
├── scripts/                    # Utility scripts
│   ├── db-version.ts          # Version control CLI
│   ├── db-snapshot.ts         # Snapshot creation
│   └── migrate-with-backup.ts # Safe migration
├── public/                     # Static assets
│   ├── images/                # Image files
│   └── logos/                 # Logo assets
├── styles/                     # Global styles
│   └── globals.css            # Tailwind imports
├── docs/                       # Documentation
├── data/                       # Static content data
└── middleware.ts              # Next.js middleware

Create a new user account

{
  "email": "[email protected]",
  "password": "securePassword123"
}

Authenticate user

{
  "email": "[email protected]",
  "password": "securePassword123"
}

Sign out current user

Get user's active roles and role details

{
  "activeRoles": ["mentor", "mentee"],
  "roles": [
    {
      "type": "mentor",
      "isActive": true,
      "activatedAt": "2024-01-01T00:00:00Z",
      "verifiedAt": "2024-01-02T00:00:00Z"
    }
  ]
}

Activate a new role for the user

{
  "roleType": "mentor"
}

Deactivate a role

{
  "roleType": "mentee"
}

Manage mentor profile with expertise, availability, and verification status

{
  "expertiseAreas": ["Software Engineering", "Data Science"],
  "yearsExperience": 5,
  "company": "Tech Corp",
  "jobTitle": "Senior Engineer",
  "bio": "Passionate about helping others grow",
  "maxMentees": 3,
  "isAcceptingMentees": true
}

Manage mentee profile with learning goals and preferences

{
  "learningGoals": ["Career advancement", "Technical skills"],
  "careerStage": "mid-level",
  "preferredExpertiseAreas": ["Machine Learning", "Leadership"],
  "currentChallenge": "Transitioning to management role"
}

Browse available mentors with filtering options

Get detailed mentor information

Apply for mentorship relationship

{
  "mentorId": 123,
  "message": "I would love to learn from your experience",
  "goals": "Improve technical leadership skills"
}

Approve or reject mentorship application (mentors only)

{
  "relationshipId": 456,
  "action": "approve",
  "feedback": "Looking forward to working together"
}

Get user's mentorship relationships (as mentor or mentee)

Get user's meetings with filtering options

Schedule a new meeting

{
  "relationshipId": 789,
  "scheduledAt": "2024-12-01T10:00:00Z",
  "meetingType": "regular",
  "agenda": "Discuss career progression"
}

Get or update meeting details, add notes and feedback

Browse upcoming events with filtering

Get detailed event information

Register for an event

Get user's event registrations

Browse learning resources with access control

Download resource (with permission checks)

Get comprehensive dashboard data including role-specific metrics

{
  "user": {
    "roles": ["mentor", "mentee"],
    "emailVerified": true
  },
  "stats": {
    "totalMeetings": 15,
    "completedMeetings": 12,
    "totalMeetingHours": 18.5
  },
  "mentor": {
    "currentMentees": 2,
    "maxMentees": 3,
    "isAcceptingMentees": true
  },
  "mentee": {
    "activeMentors": 1
  }
}

Send message to AI assistant

{
  "messages": [
    {
      "role": "user",
      "content": "How do I become a better mentor?"
    }
  ]
}

Get platform analytics (admin only)

Manage admin permissions (admin only)

The database architecture supports a sophisticated mentorship platform with flexible role management and comprehensive tracking capabilities.

erDiagram
    USERS ||--o{ USER_ROLES : "has"
    USERS ||--o{ MENTOR_PROFILES : "can have"
    USERS ||--o{ MENTEE_PROFILES : "can have"
    USERS ||--o{ USER_MEMBERSHIPS : "has"
    USERS ||--o{ ADMIN_PERMISSIONS : "may have"
    USERS ||--o{ USER_MENTORSHIP_STATS : "has"
    
    MENTOR_PROFILES ||--o{ MENTORSHIP_RELATIONSHIPS : "mentors"
    MENTEE_PROFILES ||--o{ MENTORSHIP_RELATIONSHIPS : "learns from"
    MENTORSHIP_RELATIONSHIPS ||--o{ MEETINGS : "includes"
    
    USERS ||--o{ EVENT_REGISTRATIONS : "registers for"
    EVENTS ||--o{ EVENT_REGISTRATIONS : "has"
    USERS ||--o{ RESOURCES : "uploads"
    USERS ||--o{ RESOURCE_ACCESS_LOGS : "accesses"
    
    USERS {
        int id PK
        string email UK
        string name
        string password_hash
        datetime created_at
        datetime email_verified_at
        datetime last_login_at
    }
    
    USER_ROLES {
        int id PK
        int user_id FK
        enum role_type "mentor|mentee|admin"
        boolean is_active
        datetime activated_at
        datetime verified_at
        int activation_step
    }
    
    MENTOR_PROFILES {
        int id PK
        int user_id FK
        json expertise_areas
        int years_experience
        string company
        string job_title
        text bio
        int max_mentees
        int current_mentees_count
        boolean is_accepting_mentees
        datetime verified_at
    }
    
    MENTEE_PROFILES {
        int id PK
        int user_id FK
        json learning_goals
        string career_stage
        json preferred_expertise_areas
        string preferred_meeting_frequency
        text current_challenge
    }
    
    MENTORSHIP_RELATIONSHIPS {
        int id PK
        int mentor_user_id FK
        int mentee_user_id FK
        enum status "pending|active|paused|completed|rejected"
        datetime started_at
        datetime ended_at
        text relationship_goals
        text mentor_notes
        text mentee_notes
    }
    
    MEETINGS {
        int id PK
        int relationship_id FK
        datetime scheduled_at
        int duration_minutes
        enum meeting_type "intro|regular|milestone|final"
        enum status "scheduled|completed|cancelled|no_show"
        json topics_discussed
        json action_items
        text mentor_notes
        text mentee_feedback
        int rating
    }
    
    EVENTS {
        int id PK
        string title
        text description
        enum event_type "workshop|networking|training|social|thrive"
        datetime start_time
        datetime end_time
        enum location_type "online|in_person|hybrid"
        int capacity
        boolean is_members_only
        enum required_membership_tier
    }
    
    USER_MEMBERSHIPS {
        int id PK
        int user_id FK
        enum tier "free|basic|premium"
        datetime expires_at
        json features_access
        datetime last_payment_at
        datetime next_billing_date
    }

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100),
  email VARCHAR(255) UNIQUE NOT NULL,
  password_hash TEXT,
  created_at TIMESTAMP DEFAULT NOW(),
  email_verified_at TIMESTAMP,
  last_login_at TIMESTAMP,
  login_attempts INTEGER DEFAULT 0,
  locked_until TIMESTAMP
);

CREATE TABLE user_roles (
  id SERIAL PRIMARY KEY,
  user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
  role_type user_role_type NOT NULL, -- 'mentor', 'mentee', 'admin'
  is_active BOOLEAN DEFAULT TRUE,
  activated_at TIMESTAMP DEFAULT NOW(),
  verified_at TIMESTAMP,
  activation_step INTEGER DEFAULT 0,
  UNIQUE(user_id, role_type)
);

CREATE TABLE mentor_profiles (
  id SERIAL PRIMARY KEY,
  user_id INTEGER UNIQUE REFERENCES users(id) ON DELETE CASCADE,
  expertise_areas JSONB, -- Array of expertise areas
  years_experience INTEGER,
  company VARCHAR(200),
  job_title VARCHAR(200),
  bio TEXT,
  max_mentees INTEGER DEFAULT 3,
  current_mentees_count INTEGER DEFAULT 0,
  is_accepting_mentees BOOLEAN DEFAULT TRUE,
  verified_at TIMESTAMP,
  verified_by INTEGER REFERENCES users(id)
);

CREATE TABLE mentee_profiles (
  id SERIAL PRIMARY KEY,
  user_id INTEGER UNIQUE REFERENCES users(id) ON DELETE CASCADE,
  learning_goals JSONB, -- Array of learning objectives
  career_stage VARCHAR(100),
  preferred_expertise_areas JSONB,
  preferred_meeting_frequency VARCHAR(50),
  current_challenge TEXT,
  profile_completed_at TIMESTAMP
);

CREATE TABLE mentorship_relationships (
  id SERIAL PRIMARY KEY,
  mentor_user_id INTEGER REFERENCES users(id),
  mentee_user_id INTEGER REFERENCES users(id),
  status relationship_status DEFAULT 'pending', -- 'pending', 'active', 'paused', 'completed', 'rejected'
  started_at TIMESTAMP,
  ended_at TIMESTAMP,
  paused_at TIMESTAMP,
  meeting_frequency VARCHAR(50),
  next_meeting_date TIMESTAMP,
  relationship_goals TEXT,
  mentor_notes TEXT,
  mentee_notes TEXT,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE meetings (
  id SERIAL PRIMARY KEY,
  relationship_id INTEGER REFERENCES mentorship_relationships(id),
  scheduled_at TIMESTAMP NOT NULL,
  duration_minutes INTEGER DEFAULT 60,
  meeting_type meeting_type DEFAULT 'regular', -- 'intro', 'regular', 'milestone', 'final'
  status meeting_status DEFAULT 'scheduled', -- 'scheduled', 'completed', 'cancelled', 'no_show'
  topics_discussed JSONB, -- Array of discussion topics
  goals_set JSONB, -- Array of goals established
  action_items JSONB, -- Array of action items with deadlines
  mentor_notes TEXT,
  mentee_feedback TEXT,
  rating INTEGER,
  actual_start_time TIMESTAMP,
  actual_end_time TIMESTAMP
);

CREATE TABLE events (
  id SERIAL PRIMARY KEY,
  title VARCHAR(200) NOT NULL,
  description TEXT,
  event_type event_type NOT NULL, -- 'workshop', 'networking', 'training', 'social', 'thrive'
  start_time TIMESTAMP NOT NULL,
  end_time TIMESTAMP NOT NULL,
  location_type location_type NOT NULL, -- 'online', 'in_person', 'hybrid'
  capacity INTEGER,
  current_registrations INTEGER DEFAULT 0,
  is_members_only BOOLEAN DEFAULT FALSE,
  required_membership_tier membership_tier,
  created_by INTEGER REFERENCES users(id)
);

CREATE TABLE user_memberships (
  id SERIAL PRIMARY KEY,
  user_id INTEGER UNIQUE REFERENCES users(id) ON DELETE CASCADE,
  tier membership_tier DEFAULT 'free', -- 'free', 'basic', 'premium'
  expires_at TIMESTAMP,
  features_access JSONB, -- Dynamic feature permissions
  last_payment_at TIMESTAMP,
  next_billing_date TIMESTAMP,
  cancelled_at TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

graph TB
    subgraph "Local Development"
        L1[pnpm dev]
        L2[localhost:3000]
    end
    
    subgraph "Cloud Deployment"
        C1[Vercel]
        C2[Railway]
        C3[Render]
        C4[Netlify]
    end
    
    subgraph "Container Deployment"
        D1[Docker]
        D2[Docker Compose]
        D3[Kubernetes]
    end
    
    L1 --> L2
    C1 --> |Recommended| Production
    D1 --> D2
    D2 --> D3

1. Fork and import repository

   • Fork this repository to your GitHub account
   • Import to Vercel: vercel.com/new

2. Configure environment variables

   • Add all variables from .env.local to Vercel dashboard
   • Set up production database URL

3. Deploy

   • Vercel automatically builds and deploys on push to main

1. Build the application

   pnpm build

2. Set production environment variables

   export NODE_ENV=production
   export DATABASE_URL="your-production-db-url"
   # Add other production variables

3. Run database migrations

   # Create pre-deployment snapshot
   pnpm db:snapshot "pre-deployment-$(date +%Y%m%d)"
   
   # Run migrations safely
   pnpm db:migrate:safe

4. Start the production server

   pnpm start

FROM node:20-alpine AS builder
WORKDIR /app
COPY package.json pnpm-lock.yaml ./
RUN npm install -g pnpm && pnpm install
COPY . .
RUN pnpm build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV production
COPY --from=builder /app/.next ./.next
COPY --from=builder /app/public ./public
COPY --from=builder /app/package.json ./
RUN npm install -g pnpm && pnpm install --prod
EXPOSE 3000
CMD ["pnpm", "start"]

We welcome contributions from the community! Here's how you can help improve this project:

flowchart TD
    A[Create Issue] --> B[Fork Repository]
    B --> C[Create Feature Branch]
    C --> D[Develop Feature]
    D --> E[Write Tests]
    E --> F[Update Documentation]
    F --> G[Run Linting]
    G --> H{All Checks Pass?}
    H -->|No| D
    H -->|Yes| I[Create Pull Request]
    I --> J[Code Review]
    J --> K{Review Approved?}
    K -->|No| D
    K -->|Yes| L[Merge to Main]
    L --> M[Deploy to Production]

1. Fork the repository

   git clone https://github.com/NZ-SheSharp/she-sharp.git

2. Create a feature branch

   git checkout -b feature/amazing-feature

3. Make your changes

   • Follow the existing code style
   • Write meaningful commit messages
   • Add tests for new features

4. Commit your changes

   git commit -m "feat: add amazing feature"

5. Push to your branch

   git push origin feature/amazing-feature

6. Open a Pull Request

   • Provide a clear description of changes
   • Link any related issues
   • Ensure all tests pass

We follow the Conventional Commits specification:

• feat: New feature
• fix: Bug fix
• docs: Documentation changes
• style: Code style changes
• refactor: Code refactoring
• test: Test additions or changes
• chore: Maintenance tasks

• TypeScript: Use strict mode and proper typing
• React: Functional components with hooks
• Formatting: Prettier with default settings
• Linting: ESLint with Next.js configuration

This project is licensed under the MIT License - see the LICENSE file for details.

Chan Meng

Chan Meng

LinkedIn • GitHub Email • Portfolio

Chan Meng

Lesley Gao

• Website: https://she-sharp-zeta.vercel.app/
• Repository: https://github.com/NZ-SheSharp/she-sharp
• Email: [email protected]
• LinkedIn: She Sharp LinkedIn
• Twitter: @SheSharpOrg

• Developer: Chan Meng
• Email: [email protected]
• LinkedIn: chanmeng666
• Portfolio: chanmeng.org

For support, please:

1. Check the Documentation
2. Search existing issues
3. Create a new issue

• Our Mentors: 18 dedicated professionals sharing their expertise
• Corporate Partners: 50+ organizations supporting our mission
• Community Members: 1000+ women driving change in STEM
• Volunteers: Countless hours contributed to our cause

• Next.js - The React framework
• Vercel - Deployment platform
• shadcn/ui - Beautiful components
• Stripe - Payment infrastructure
• Google AI - AI capabilities

This project was inspired by the need to create equal opportunities for women in STEM fields and build a supportive community for professional growth.

# Check Node.js version
node --version

# Use Node Version Manager (nvm)
nvm install 20
nvm use 20

# Clear pnpm cache
pnpm store prune

# Delete node_modules and reinstall
rm -rf node_modules pnpm-lock.yaml
pnpm install

# Find process using port 3000
lsof -i :3000

# Kill the process
kill -9 <PID>

# Or use a different port
pnpm dev --port 3001

# Check migration status first
pnpm db:status

# Create backup before troubleshooting
pnpm db:snapshot "before-fix"

# Reset database (if needed) - Note: db:reset command not available
# Instead, manually drop and recreate database, then:
pnpm db:setup
pnpm db:migrate

# Regenerate migrations
pnpm db:generate
pnpm db:migrate

# View migration history
pnpm db:history

# List available snapshots
pnpm db:version list-snapshots

# Generate rollback SQL
pnpm db:version rollback-sql <migration-tag>

# Check for TypeScript errors
pnpm type-check

# Check for linting errors
pnpm lint

# Clear Next.js cache
rm -rf .next
pnpm build