Weaverse Full-Stack Developer Internship Curriculum

Complete 12-Week Training Program with Verified Tutorials and Documentation

This comprehensive curriculum provides a complete roadmap for developing full-stack developers specialized in modern headless commerce, with emphasis on backend engineering and AI-assisted development workflows ¹². Each week includes verified tutorials, hands-on projects, and practical learning resources to ensure mastery of Weaverse's complete technology stack ³.

Program Overview

Mission Statement

The Weaverse Full-Stack Developer Internship prepares developers for modern headless commerce development, focusing on backend engineering excellence while maintaining comprehensive frontend competency ⁴. Graduates will master production-grade Shopify Hydrogen storefronts using Weaverse's complete technology ecosystem ⁵.

Program Structure

Duration: 12 weeks (576 total hours)
Format: Full-time intensive training with mentorship support
Focus Distribution: 40% backend, 35% frontend, 25% integration/deployment
Assessment: Continuous evaluation with milestone projects and capstone delivery

Technology Stack Overview

Category	Technologies	Learning Hours
Build & Runtime	Vite, Node.js, TypeScript	48 hours
Backend Framework	Express.js, Prisma ORM, Zod	96 hours
Frontend	React, Preact Signals	72 hours
Styling	TailwindCSS, Radix UI, ShadcnUI, BaseUI	48 hours
Shopify Integration	Hydrogen, Oxygen, Admin/Storefront APIs	96 hours
AI Tools	Cursor AI, Claude AI, Vercel AI SDK, MCP	72 hours
Deployment	Docker, Fly.io, Cloudflare Workers	48 hours
Weaverse Platform	SDK, Theme Development, Visual Editor	96 hours

Week 1: Foundation & Environment Setup

Learning Objectives

Configure AI-powered development environment with Cursor IDE
Master TypeScript fundamentals with hands-on practice
Understand modern build tools and project scaffolding

Day 1-2: Development Environment & AI Tools

Core Tutorial: Cursor AI Mastery Follow the comprehensive Cursor AI beginner's guide to set up your AI-powered development environment ⁶. This tutorial covers installation, configuration, and understanding key features like AI chat, code generation, and agent mode ⁷.

Setup Requirements:

# Install Node.js (v18+ required)
node --version # Verify installation

# Install Cursor AI IDE
# Download from cursor.sh and complete setup

# Configure Git
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Hands-on Activities:

Install and configure Cursor AI with GitHub Copilot integration
Practice AI-assisted code generation using natural language prompts ⁸
Set up development workspace with proper terminal integration

Day 3-4: TypeScript Fundamentals

Primary Tutorial: TypeScript Handbook Work through the official TypeScript handbook focusing on essential concepts ⁵⁹. Supplement with the Total TypeScript beginner course for hands-on practice ¹⁰¹¹.

Video Tutorial: Complete TypeScript Course Follow the comprehensive TypeScript course covering modern patterns and best practices ¹. This tutorial provides practical examples for React integration and advanced typing patterns.

Key Learning Topics:

Type inference and explicit typing
Interface design and generics
Advanced typing patterns (utility types, conditional types) ⁵
TypeScript with modern JavaScript features

Practical Exercise: Build a TypeScript CLI application that demonstrates:

// Type-safe command line interface
interface CLIOptions {
  input: string;
  output?: string;
  verbose: boolean;
}

// Generic utility functions
function processData<T>(data: T[]): T[] {
  return data.filter(Boolean);
}

Day 5-6: Vite Build System & Project Structure

Tutorial: Express.js Hello World Setup Follow the Express.js getting started guide to understand modern build tooling ¹². Learn about instant server start, Hot Module Replacement (HMR), and optimized production builds.

Key Concepts:

ES modules and native browser support
Development server configuration
Plugin ecosystem and customization
Production build optimization

Project Setup:

# Create new Vite project
npm create vite@latest weaverse-training -- --template react-ts
cd weaverse-training
npm install
npm run dev

Week 1 Assessment

Project: AI-Powered TypeScript Development Environment Create a fully configured development setup with:

Cursor AI integration for code assistance
TypeScript project with proper configuration
Vite build system with hot reload
Basic CLI utility demonstrating TypeScript mastery

Week 2: Advanced TypeScript & Validation

Learning Objectives

Master advanced TypeScript patterns and best practices
Implement runtime validation with Zod schemas
Understand prompt engineering fundamentals for AI assistance

Day 1-2: Advanced TypeScript Patterns

Tutorial: Total TypeScript Interactive Course Complete the Total TypeScript beginner course for hands-on advanced pattern practice ¹⁰. This interactive tutorial covers utility types, conditional types, and template literal types ¹¹.

Advanced Concepts:

Mapped types and key remapping
Template literal types for string manipulation ⁹
Conditional types and type inference
Advanced generic constraints

Practical Examples:

// Advanced utility type creation
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

// Template literal type magic
type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<'click'>; // 'onClick'

Day 3-4: Zod Schema Validation

Tutorial: Master Schema Validation with Zod Follow the comprehensive Zod guide for TypeScript validation ¹³¹⁴. Learn schema definition, type inference, and error handling patterns ¹⁵.

Key Features:

Runtime type validation
TypeScript type inference from schemas ¹⁵
Custom validation rules and transformations
Integration with forms and APIs

Practical Implementation:

import { z } from 'zod';

// Define comprehensive schemas
const UserSchema = z.object({
  name: z.string().min(2).max(50),
  email: z.string().email(),
  age: z.number().min(18).max(120),
  preferences: z.object({
    newsletter: z.boolean(),
    theme: z.enum(['light', 'dark'])
  })
});

type User = z.infer<typeof UserSchema>;

// Runtime validation with error handling
function validateUser(data: unknown): User {
  return UserSchema.parse(data);
}

Day 5-6: Prompt Engineering with Anthropic

Tutorial: Anthropic Interactive Prompt Engineering Complete Anthropic's interactive prompt engineering tutorial to master AI assistance ¹⁶¹⁷. Learn advanced techniques for code generation, debugging, and documentation.

Core Techniques:

Clear instruction formulation
Context provision and role assignment ¹⁷
Chain-of-thought prompting for complex problems
XML structuring for precise outputs

Practical Applications:

Code review and improvement prompts ¹⁶
Documentation generation workflows
Debugging assistance patterns
Architecture design consultations

Week 2 Assessment

Project: Type-Safe Validation System Build a comprehensive validation system featuring:

Advanced TypeScript types for API contracts
Zod schemas with custom validation rules ¹³
Error handling and user feedback systems
AI-assisted code documentation

Week 3: Node.js & Express Backend Development

Learning Objectives

Build robust Express.js applications with TypeScript integration
Implement secure authentication and authorization systems
Master middleware patterns and error handling

Day 1-2: Node.js & Express Fundamentals

Video Tutorial: Complete Node.js & Express Course Follow the comprehensive 2-hour Node.js and Express tutorial ². This covers project setup, routing, middleware, and basic CRUD operations ¹².

Core Setup:

# Initialize Node.js project
npm init -y
npm install express @types/express typescript ts-node
npm install -D nodemon @types/node

# TypeScript configuration
npx tsc --init

Essential Concepts:

Express middleware architecture ¹²
Routing and controller patterns
Request/response handling
Environment configuration

Practical Implementation:

import express from 'express';
import { z } from 'zod';

const app = express();
app.use(express.json());

// Type-safe route handlers
const CreateUserSchema = z.object({
  name: z.string(),
  email: z.string().email()
});

app.post('/users', async (req, res) => {
  try {
    const userData = CreateUserSchema.parse(req.body);
    // Process user creation
    res.status(201).json({ success: true });
  } catch (error) {
    res.status(400).json({ error: 'Invalid user data' });
  }
});

Day 3-4: Authentication & Security

Security Implementation Tutorial Follow Node.js security best practices for authentication systems ². Implement JWT-based authentication with proper password hashing and validation.

Key Security Features:

Password hashing with bcrypt
JWT token generation and validation ²
Rate limiting and request sanitization
CORS configuration and security headers

Authentication System:

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';

// Secure password hashing
async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, 12);
}

// JWT token generation
function generateToken(userId: string): string {
  return jwt.sign({ userId }, process.env.JWT_SECRET!, {
    expiresIn: '24h'
  });
}

// Authentication middleware
function authenticateToken(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.split(' ')[^1];
  if (!token) return res.sendStatus(401);
  
  jwt.verify(token, process.env.JWT_SECRET!, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
}

Day 5-6: Advanced Express Patterns

Error Handling & Middleware Patterns Implement comprehensive error handling, logging, and middleware patterns for production-ready applications ².

Advanced Features:

Global error handling middleware
Request logging and monitoring
API versioning strategies
Testing with Jest and Supertest

Week 3 Assessment

Project: Secure Authentication API Build a complete authentication system with:

User registration and login endpoints
JWT-based session management
Password security and validation ²
Comprehensive error handling and logging

Week 4: Database Design with Prisma ORM

Learning Objectives

Design efficient relational database schemas
Master Prisma ORM for type-safe database operations
Implement migrations and data seeding strategies

Day 1-2: Database Design & Prisma Setup

Tutorial: Master Prisma for Database Management Follow the comprehensive Prisma tutorial covering setup, schema design, and basic operations ³¹⁸. This 60-minute video tutorial provides practical examples for PostgreSQL integration.

Installation & Setup:

# Install Prisma CLI and client
npm install prisma @prisma/client
npm install -D prisma

# Initialize Prisma
npx prisma init

# Configure PostgreSQL connection
# Update .env with DATABASE_URL

Schema Design Fundamentals:

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String
  profile   Profile?
  posts     Post[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Profile {
  id     String @id @default(cuid())
  bio    String?
  userId String @unique
  user   User   @relation(fields: [userId], references: [id])
}

model Post {
  id        String   @id @default(cuid())
  title     String
  content   String?
  published Boolean  @default(false)
  authorId  String
  author    User     @relation(fields: [authorId], references: [id])
  createdAt DateTime @default(now())
}

Day 3-4: Advanced Prisma Operations

CRUD Operations & Relationships Master complex database operations including joins, transactions, and relationship management ³¹⁸.

Advanced Query Patterns:

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

// Complex queries with relations
async function getUserWithPosts(userId: string) {
  return prisma.user.findUnique({
    where: { id: userId },
    include: {
      posts: {
        where: { published: true },
        orderBy: { createdAt: 'desc' }
      },
      profile: true
    }
  });
}

// Transactions for data consistency
async function createUserWithProfile(userData: CreateUserData) {
  return prisma.$transaction(async (tx) => {
    const user = await tx.user.create({
      data: {
        email: userData.email,
        name: userData.name
      }
    });

    const profile = await tx.profile.create({
      data: {
        userId: user.id,
        bio: userData.bio
      }
    });

    return { user, profile };
  });
}

Day 5-6: E-commerce Database Architecture

Tutorial: E-commerce Schema Design Design a comprehensive e-commerce database schema suitable for Shopify integration ¹⁸. Include products, orders, customers, and inventory management.

Week 4 Assessment

Project: E-commerce Database System Build a complete e-commerce database with:

Product catalog with variants and collections
Order management system ³
Customer profiles and authentication
Inventory tracking and management
Data seeding and migration scripts

Week 5: Shopify API Integration

Learning Objectives

Master Shopify Admin and Storefront APIs
Build custom Shopify applications with proper authentication
Implement webhook handling for real-time data synchronization

Day 1-2: Shopify API Fundamentals

Tutorial: Shopify API Documentation Study the comprehensive Shopify API reference and authentication patterns ¹⁹²⁰²¹. Learn about GraphQL queries, REST endpoints, and rate limiting strategies.

API Setup & Authentication:

// Shopify API client setup
import { shopifyApi } from '@shopify/shopify-api';

const shopify = shopifyApi({
  apiKey: process.env.SHOPIFY_API_KEY!,
  apiSecretKey: process.env.SHOPIFY_API_SECRET!,
  scopes: ['read_products', 'write_products', 'read_orders'],
  hostName: process.env.HOST!,
});

// GraphQL query example
const PRODUCTS_QUERY = `
  query getProducts($first: Int!) {
    products(first: $first) {
      edges {
        node {
          id
          title
          handle
          description
          variants(first: 10) {
            edges {
              node {
                id
                title
                price
                availableForSale
              }
            }
          }
        }
      }
    }
  }
`;

Day 3-4: Custom Shopify App Development

App Development Tutorial Build a complete Shopify app following the official development guide ²⁰. Implement OAuth authentication, app installation, and admin interface integration.

Day 5-6: Advanced Integration Patterns

Storefront API & Custom Storefronts Learn to build custom storefronts using the Storefront API with proper caching and performance optimization ²⁰²¹.

Week 5 Assessment

Project: Shopify Inventory Management App Build a complete Shopify app featuring:

Product catalog synchronization ¹⁹
Inventory tracking and updates
Order processing and fulfillment
Real-time webhook integration
Admin dashboard interface

Week 6: Backend Architecture & Testing

Learning Objectives

Implement clean architecture patterns for scalable backend systems
Master testing strategies including unit, integration, and API testing
Deploy backend applications with monitoring and error tracking

Day 1-2: Clean Architecture Implementation

Architecture Patterns Tutorial Study clean architecture principles and dependency injection patterns for Node.js applications ². Implement separation of concerns with proper layering.

Day 3-4: Comprehensive Testing Strategy

Testing Tutorial: Jest & Supertest Implement comprehensive testing strategies using Jest for unit tests and Supertest for API integration testing ².

Day 5-6: Deployment & Monitoring

Docker Containerization Tutorial Follow the Docker tutorial to containerize your Node.js application ²²²³. Learn about multi-stage builds, security best practices, and production optimization.

Week 6 Assessment

Project: Production-Ready Backend System Build a complete backend application featuring:

Clean architecture with proper separation of concerns
Comprehensive test suite (unit and integration tests) ²
Docker containerization with security best practices ²²
Deployment to Fly.io with monitoring and logging
Error tracking and performance monitoring

Week 7: React & Frontend Development

Learning Objectives

Master modern React patterns including hooks and component composition
Implement state management with Preact Signals
Build responsive user interfaces with type-safe props

Day 1-2: Modern React Fundamentals

Tutorial: React Full Course Follow the comprehensive React tutorial covering modern patterns and best practices ⁴²⁴. This includes functional components, hooks, and performance optimization techniques.

React Project Setup:

# Create React project with Vite
npm create vite@latest frontend -- --template react-ts
cd frontend
npm install

# Additional dependencies
npm install @preact/signals-react
npm install react-router-dom @types/react-router-dom

Day 3-4: State Management with Preact Signals

Tutorial: Preact Signals Guide Master state management using Preact Signals for fine-grained reactivity ²⁵²⁶. Learn about global state, computed values, and effects.

Signals Implementation:

import { signal, computed, effect } from '@preact/signals-react';

// Global state with signals
export const cartItems = signal<CartItem[]>([]);
export const user = signal<User | null>(null);

// Computed values
export const cartTotal = computed(() => {
  return cartItems.value.reduce((total, item) => {
    return total + (item.price * item.quantity);
  }, 0);
});

export const cartCount = computed(() => {
  return cartItems.value.reduce((count, item) => count + item.quantity, 0);
});

Day 5-6: Advanced React Patterns

Component Composition & Context Learn advanced patterns including compound components, render props, and context usage for complex state management ⁴²⁴.

Week 7 Assessment

Project: React E-commerce Dashboard Build a comprehensive admin dashboard featuring:

Product management with CRUD operations
Real-time data updates using Preact Signals ²⁵
Complex state management with context and custom hooks
Responsive design with proper component composition
Type-safe props and comprehensive error handling

Week 8: UI/UX with Modern Styling Systems

Learning Objectives

Master utility-first CSS with TailwindCSS
Build accessible components using Radix UI primitives
Create comprehensive design systems with ShadcnUI and BaseUI

Day 1-2: TailwindCSS Mastery

Tutorial: Complete TailwindCSS Course Follow the comprehensive TailwindCSS tutorial covering utility-first design principles ²⁷²⁸. Learn responsive design, custom configurations, and component extraction strategies.

TailwindCSS Setup & Configuration:

# Install TailwindCSS
npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

# Configure Tailwind
# tailwind.config.js
module.exports = {
  content: ['./src/**/*.{js,jsx,ts,tsx}'],
  theme: {
    extend: {
      colors: {
        primary: {
          50: '#eff6ff',
          500: '#3b82f6',
          900: '#1e3a8a',
        }
      },
      fontFamily: {
        sans: ['Inter', 'sans-serif'],
      }
    },
  },
  plugins: [],
}

Day 3-4: Radix UI Component Primitives

Tutorial: Advanced Radix UI Course Master building accessible components with Radix UI primitives ²⁹³⁰. Learn about compound components, state management, and custom styling.

Day 5-6: ShadcnUI & BaseUI Integration

Tutorial: ShadcnUI Component System Learn to integrate ShadcnUI components for rapid development ³¹³²³³. Understand the copy-paste component philosophy and customization strategies.

BaseUI Integration Tutorial Follow the BaseUI quickstart guide for building unstyled, accessible components ³⁴³⁵. Learn about composition patterns and styling flexibility.

Week 8 Assessment

Project: Complete Design System Build a comprehensive design system featuring:

TailwindCSS utility classes with custom theme configuration ²⁷
Accessible components using Radix UI primitives ²⁹
Pre-built ShadcnUI components with custom styling ³²
BaseUI integration for complex interactions ³⁵
Storybook documentation with component variants
Design tokens and consistent spacing/typography system

Week 9: AI Integration & Advanced User Interfaces

Learning Objectives

Integrate AI features using Vercel AI SDK and Claude API
Build streaming interfaces for real-time AI responses
Implement AI-powered workflow automation

Day 1-2: Vercel AI SDK Fundamentals

Tutorial: Complete Vercel AI SDK Guide Follow the comprehensive Vercel AI SDK tutorial covering setup, streaming, and structured outputs ³⁶³⁷³⁸. Learn about generateText, streamText, and tool calling patterns.

Vercel AI SDK Setup:

# Install Vercel AI SDK
npm install ai @ai-sdk/anthropic
npm install -D @types/node

# Environment configuration
# .env
ANTHROPIC_API_KEY=your_api_key_here

Basic AI Integration:

import { createAnthropic } from '@ai-sdk/anthropic';
import { generateText, streamText } from 'ai';

const anthropic = createAnthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!,
});

// Simple text generation
export async function generateProductDescription(productName: string) {
  const { text } = await generateText({
    model: anthropic('claude-3-sonnet-20240229'),
    prompt: `Write a compelling product description for: ${productName}`,
    maxTokens: 200,
  });
  
  return text;
}

Day 3-4: Claude API Integration

Claude API Integration Tutorial Master direct Claude API integration for advanced AI features ¹⁶¹⁷. Learn about image analysis, context management, and function calling.

Day 5-6: AI Workflow Automation

Advanced AI Patterns Implement sophisticated AI workflows including multi-step processes, context management, and tool calling for e-commerce automation ³⁶³⁷.

Week 9 Assessment

Project: AI-Powered E-commerce Platform Build an intelligent e-commerce platform featuring:

AI chat assistant for customer support ³⁶
Automated product description generation
Smart product recommendations using user behavior
Real-time sentiment analysis for customer feedback
Streaming AI responses for enhanced user experience
Context-aware AI workflows for business automation

Week 10: Shopify Hydrogen & Headless Commerce

Learning Objectives

Master Shopify Hydrogen framework for headless commerce
Build production-ready storefronts with server-side rendering
Deploy applications to Shopify Oxygen platform

Day 1-2: Hydrogen Framework Fundamentals

Tutorial: Shopify Hydrogen Getting Started Follow the official Shopify Hydrogen tutorial to create your first headless storefront ³⁹⁴⁰⁴¹. Learn about React Server Components, routing, and data loading patterns.

Hydrogen Project Setup:

# Create new Hydrogen project
npm create @shopify/hydrogen@latest my-storefront
cd my-storefront

# Install dependencies
npm install

# Link to Shopify store
npm run shopify app login
npm run shopify hydrogen link

Day 3-4: Advanced Hydrogen Patterns

Tutorial: Building Custom Storefronts Master advanced Hydrogen patterns including custom cart implementation, product variants, and checkout integration ³⁹⁴⁰.

Day 5-6: Deployment to Oxygen

Tutorial: Oxygen Deployment Guide Follow the comprehensive guide for deploying Hydrogen storefronts to Shopify Oxygen ³⁹⁴⁰. Learn about environment configuration, CI/CD setup, and performance optimization.

Week 10 Assessment

Project: Production Hydrogen Storefront Build a complete headless Shopify storefront featuring:

Server-side rendered product and collection pages ³⁹
Shopping cart with persistent state and checkout integration
Multi-language and multi-currency support
Advanced search and filtering capabilities
Performance optimization with React Server Components
Deployment to Shopify Oxygen with proper SEO and analytics

Week 11: Weaverse Platform Integration

Learning Objectives

Master Weaverse SDK for visual page building
Build custom theme components with schema definitions
Implement advanced Weaverse features and customizations

Day 1-2: Weaverse SDK Integration

Tutorial: Weaverse Platform Integration Follow the comprehensive Weaverse integration guide to set up visual page building ⁴²⁴³⁴⁴. Learn about component registration, schema definition, and studio integration.

Weaverse Setup & Configuration:

# Install Weaverse SDK
npm install @weaverse/hydrogen

# Create Weaverse configuration
mkdir app/weaverse
touch app/weaverse/components.ts
touch app/weaverse/schema.server.ts
touch app/weaverse/weaverse.server.ts

Day 3-4: Custom Component Development

Tutorial: Weaverse Component Schema Master component schema definition and advanced input types ⁴²⁴⁴. Build custom sections with proper validation and TypeScript integration.

Day 5-6: Advanced Weaverse Features

Tutorial: Advanced Component Patterns Implement advanced Weaverse features including component loaders, dynamic data integration, and MCP server integration ⁴²⁴³.

Week 11 Assessment

Project: Custom Weaverse Theme Build a complete custom theme featuring:

Multiple custom sections with advanced schemas ⁴²
Component loaders for dynamic data integration
Theme settings for global customization
Multi-language support and localization
Advanced input types and conditional logic
MCP integration for development assistance
Visual editor compatibility and testing

Week 12: Capstone Project & Advanced Deployment

Learning Objectives

Integrate all learned technologies into a comprehensive application
Implement advanced deployment strategies with Docker and edge computing
Demonstrate production-ready development skills

Day 1-2: Project Architecture & Planning

Capstone Project: AI-Powered Headless Commerce Platform Design and implement a complete e-commerce platform that showcases mastery of all technologies covered in the curriculum ¹²³.

Day 3-4: Full-Stack Implementation

Backend Implementation: Implement clean architecture patterns with comprehensive API development ²²².

Frontend Implementation: Build modern React interfaces with AI integration and comprehensive styling systems ⁴³⁶.

Day 5-6: Advanced Deployment & Infrastructure

Docker Configuration Tutorial Implement comprehensive containerization strategy following Docker best practices ²²²³.

Multi-Service Docker Setup:

# docker/Dockerfile.api
FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./
COPY apps/api/package*.json ./apps/api/
COPY packages/database/package*.json ./packages/database/

# Install dependencies
RUN npm ci --only=production

# Copy source code
COPY apps/api ./apps/api
COPY packages/database ./packages/database

# Build application
RUN npm run build

# Production stage
FROM node:18-alpine AS runtime

# Create non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S apiuser -u 1001

WORKDIR /app

# Copy built application
COPY --from=builder --chown=apiuser:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=apiuser:nodejs /app/apps/api/dist ./dist
COPY --from=builder --chown=apiuser:nodejs /app/packages/database ./packages/database

# Switch to non-root user
USER apiuser

EXPOSE 3001

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3001/health || exit 1

CMD ["node", "dist/server.js"]

Advanced Deployment Strategy: Deploy to Fly.io following the deployment guide ⁴⁵⁴⁶:

# deployment/deploy.sh
#!/bin/bash

set -e

# Build and test
echo "Building and testing application..."
docker-compose -f docker-compose.test.yml up --build --exit-code-from test

# Deploy to Fly.io
echo "Deploying API to Fly.io..."
cd apps/api
fly deploy --config ../../deployment/fly.api.toml

# Deploy Storefront to Oxygen
echo "Deploying storefront to Shopify Oxygen..."
cd ../storefront
npx shopify hydrogen deploy

# Deploy Workers to Cloudflare
echo "Deploying edge functions to Cloudflare Workers..."
cd ../../workers
wrangler deploy

echo "Deployment completed!"

Cloudflare Workers Edge Functions: Follow the Cloudflare Workers tutorial for edge computing deployment ⁴⁷⁴⁸⁴⁹:

// workers/ai-edge/src/index.ts
import { createAnthropic } from '@ai-sdk/anthropic';
import { generateText } from 'ai';

interface Env {
  ANTHROPIC_API_KEY: string;
  KV_STORE: KVNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST') {
      return new Response('Method not allowed', { status: 405 });
    }

    try {
      const { prompt, userId } = await request.json();
      
      // Rate limiting with KV store
      const rateLimitKey = `rate_limit:${userId}`;
      const currentCount = await env.KV_STORE.get(rateLimitKey);
      
      if (currentCount && parseInt(currentCount) >= 10) {
        return new Response('Rate limit exceeded', { status: 429 });
      }

      // Generate AI response
      const anthropic = createAnthropic({
        apiKey: env.ANTHROPIC_API_KEY,
      });

      const { text } = await generateText({
        model: anthropic('claude-3-haiku-20240307'),
        prompt,
        maxTokens: 150,
      });

      // Update rate limit
      await env.KV_STORE.put(
        rateLimitKey, 
        ((parseInt(currentCount || '0')) + 1).toString(),
        { expirationTtl: 3600 }
      );

      return new Response(JSON.stringify({ response: text }), {
        headers: { 'Content-Type': 'application/json' },
      });
    } catch (error) {
      return new Response(
        JSON.stringify({ error: 'Internal server error' }), 
        { status: 500, headers: { 'Content-Type': 'application/json' } }
      );
    }
  },
};

Week 12 Assessment

Final Capstone Presentation Present a complete production-ready e-commerce platform demonstrating:

Technical Architecture (20 points)
- Scalable backend API with proper separation of concerns ²
- Type-safe database operations with Prisma ³
- React frontend with modern state management ²⁵
AI Integration (20 points)
- Claude-powered chat assistant with streaming responses ³⁶¹⁶
- Personalized product recommendations
- AI-generated content and descriptions
E-commerce Features (20 points)
- Shopify Hydrogen storefront with custom components ³⁹
- Weaverse visual page builder integration ⁴²
- Complete shopping cart and checkout flow
Design System (15 points)
- Comprehensive component library with TailwindCSS ²⁷
- Accessible components using Radix UI primitives ²⁹
- Consistent design tokens and theming
Deployment & DevOps (15 points)
- Docker containerization with multi-stage builds ²²
- Production deployment to Fly.io and Cloudflare ⁴⁵⁴⁷
- Monitoring, logging, and error tracking
Code Quality (10 points)
- Comprehensive testing coverage ²
- TypeScript type safety throughout ⁵
- Clean code principles and documentation

Deliverables:

Live deployed application with full functionality
GitHub repository with complete source code
Technical documentation and deployment guide
15-minute presentation demonstrating key features
Performance metrics and optimization strategies

Program Conclusion

This comprehensive 12-week curriculum provides graduates with production-ready skills in modern full-stack development, specializing in headless commerce and AI-assisted workflows ¹²³. The program's emphasis on backend development, combined with cutting-edge technologies like Shopify Hydrogen, Weaverse platform integration, and AI tools, prepares developers for immediate contribution to enterprise-level e-commerce projects ³⁹³⁶⁴².

Graduates will be uniquely positioned for career opportunities in the rapidly growing headless commerce market, with skills that span from traditional web development to emerging AI-powered user experiences ⁴⁰⁴¹¹⁷. The curriculum's practical approach, with over 12 major projects and continuous assessment, ensures that learning translates directly into professional competency.

The integration of AI tools throughout the program reflects the future of software development, where human creativity combines with AI assistance to achieve unprecedented productivity and innovation ³⁶¹⁶⁶. This forward-looking approach positions Weaverse graduates at the forefront of the industry's evolution toward more intelligent, efficient, and user-centric development practices.

Essential Resources Summary

This curriculum ensures that each student has access to the most current and effective learning resources available, with verified links to official documentation and high-quality tutorials that will support their journey to becoming proficient full-stack developers specialized in modern headless commerce development.

⁂

paul-phan/Weaverse Full-Stack Developer Internship Curriculum.md

Weaverse Full-Stack Developer Internship Curriculum

Complete 12-Week Training Program with Verified Tutorials and Documentation

Program Overview

Mission Statement

Program Structure

Technology Stack Overview

Week 1: Foundation & Environment Setup

Learning Objectives

Day 1-2: Development Environment & AI Tools

Day 3-4: TypeScript Fundamentals

Day 5-6: Vite Build System & Project Structure

Week 1 Assessment

Week 2: Advanced TypeScript & Validation

Learning Objectives

Day 1-2: Advanced TypeScript Patterns

Day 3-4: Zod Schema Validation

Day 5-6: Prompt Engineering with Anthropic

Week 2 Assessment

Week 3: Node.js & Express Backend Development

Learning Objectives

Day 1-2: Node.js & Express Fundamentals

Day 3-4: Authentication & Security

Day 5-6: Advanced Express Patterns

Week 3 Assessment

Week 4: Database Design with Prisma ORM

Learning Objectives

Day 1-2: Database Design & Prisma Setup

Day 3-4: Advanced Prisma Operations

Day 5-6: E-commerce Database Architecture

Week 4 Assessment

Week 5: Shopify API Integration

Learning Objectives

Day 1-2: Shopify API Fundamentals

Day 3-4: Custom Shopify App Development

Day 5-6: Advanced Integration Patterns

Week 5 Assessment

Week 6: Backend Architecture & Testing

Learning Objectives

Day 1-2: Clean Architecture Implementation

Day 3-4: Comprehensive Testing Strategy

Day 5-6: Deployment & Monitoring

Week 6 Assessment

Week 7: React & Frontend Development

Learning Objectives

Day 1-2: Modern React Fundamentals

Day 3-4: State Management with Preact Signals

Day 5-6: Advanced React Patterns

Week 7 Assessment

Week 8: UI/UX with Modern Styling Systems

Learning Objectives

Day 1-2: TailwindCSS Mastery

Day 3-4: Radix UI Component Primitives

Day 5-6: ShadcnUI & BaseUI Integration

Week 8 Assessment

Week 9: AI Integration & Advanced User Interfaces

Learning Objectives

Day 1-2: Vercel AI SDK Fundamentals

Day 3-4: Claude API Integration

Day 5-6: AI Workflow Automation

Week 9 Assessment

Week 10: Shopify Hydrogen & Headless Commerce

Learning Objectives

Day 1-2: Hydrogen Framework Fundamentals

Day 3-4: Advanced Hydrogen Patterns

Day 5-6: Deployment to Oxygen

Week 10 Assessment

Week 11: Weaverse Platform Integration

Learning Objectives

Day 1-2: Weaverse SDK Integration

Day 3-4: Custom Component Development

Day 5-6: Advanced Weaverse Features

Week 11 Assessment

Week 12: Capstone Project & Advanced Deployment

Learning Objectives

Day 1-2: Project Architecture & Planning

Day 3-4: Full-Stack Implementation

Day 5-6: Advanced Deployment & Infrastructure

Week 12 Assessment

Program Conclusion