---
title: "Real World"
description: "Real World documentation for Ring Platform"
locale: "en"
---
# Real World Apps

Complete application examples built with Ring Platform, showcasing end-to-end implementations for different industries and use cases.

## 🏥 Healthcare Network Platform

### Complete Healthcare Professional Network

// app/healthcare/page.tsx

{`'use client'

import { useState, useEffect } from 'react'
import { useSession } from 'next-auth/react'
import { ProtectedRoute } from '@/components/ProtectedRoute'
import { BrandProvider } from '@/components/BrandProvider'

interface HealthcareProfessional {
  id: string
  name: string
  specialty: string
  license: string
  hospital: string
  verified: boolean
  rating: number
  consultationFee: number
  availability: string[]
}

interface MedicalOpportunity {
  id: string
  title: string
  type: 'consultation' | 'collaboration' | 'research' | 'locum'
  specialty: string
  urgency: 'low' | 'medium' | 'high' | 'emergency'
  location: string
  compensation: string
  description: string
  requirements: string[]
  postedBy: string
  deadline: string
}

export default function HealthcareNetwork() {
  const { data: session } = useSession()
  const [professionals, setProfessionals] = useState<HealthcareProfessional[]>([])
  const [opportunities, setOpportunities] = useState<MedicalOpportunity[]>([])
  const [activeTab, setActiveTab] = useState<'directory' | 'opportunities' | 'consultations'>('directory')
  const [loading, setLoading] = useState(true)

  useEffect(() => {
    loadData()
  }, [])

  const loadData = async () => {
    try {
      const [professionalsRes, opportunitiesRes] = await Promise.all([
        fetch('/api/healthcare/professionals'),
        fetch('/api/healthcare/opportunities')
      ])

      const professionalsData = await professionalsRes.json()
      const opportunitiesData = await opportunitiesRes.json()

      setProfessionals(professionalsData.professionals || [])
      setOpportunities(opportunitiesData.opportunities || [])
    } catch (error) {
      console.error('Failed to load healthcare data:', error)
    } finally {
      setLoading(false)
    }
  }

  const getUrgencyColor = (urgency: string) => {
    const colors = {
      low: 'bg-green-100 text-green-800',
      medium: 'bg-yellow-100 text-yellow-800',
      high: 'bg-orange-100 text-orange-800',
      emergency: 'bg-red-100 text-red-800'
    }
    return colors[urgency as keyof typeof colors] || 'bg-gray-100 text-gray-800'
  }

  const requestConsultation = async (professionalId: string) => {
    try {
      const response = await fetch('/api/healthcare/consultations/request', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          professionalId,
          patientId: session?.user?.id,
          type: 'video',
          urgency: 'medium'
        })
      })

      if (response.ok) {
        alert('Consultation request sent successfully!')
      }
    } catch (error) {
      console.error('Failed to request consultation:', error)
      alert('Failed to send consultation request')
    }
  }

  if (loading) {
    return Loading healthcare network...
  }

  return (
    
      
        
          {/* Header */}
          
            
              
                
                  MedConnect
                  Healthcare Professional Network
                
                
                  
                    Welcome, Dr. {session?.user?.name}
                  
                  
                    
                      {session?.user?.name?.charAt(0)}
                    
                  
                
              
            
          

          {/* Navigation Tabs */}
          
            
              
                {[
                  { key: 'directory', label: 'Professional Directory', icon: '👨‍⚕️' },
                  { key: 'opportunities', label: 'Medical Opportunities', icon: '🏥' },
                  { key: 'consultations', label: 'Consultations', icon: '💬' }
                ].map((tab) => (
                   setActiveTab(tab.key as any)}
                    className={`py-4 px-1 border-b-2 font-medium text-sm ${
                      activeTab === tab.key
                        ? 'border-green-500 text-green-600'
                        : 'border-transparent text-gray-500 hover:text-gray-700'
                    }`}
                  >
                    {tab.icon}
                    {tab.label}
                  
                ))}
              
            
          

          {/* Content */}
          
            {activeTab === 'directory' && (
              
                Healthcare Professionals
                
                  {professionals.map((professional) => (
                    
                      
                        
                          
                            Dr. {professional.name}
                          
                          {professional.specialty}
                          {professional.hospital}
                        
                        {professional.verified && (
                          
                            Verified
                          
                        )}
                      

                      
                        
                          {[...Array(5)].map((_, i) => (
                            
                              ★
                            
                          ))}
                        
                        
                          ({professional.rating}/5)
                        
                      

                      
                        
                          Consultation Fee: ${professional.consultationFee}
                        
                        
                          License: {professional.license}
                        
                      

                       requestConsultation(professional.id)}
                        className="w-full bg-green-600 text-white py-2 px-4 rounded-md hover:bg-green-700"
                      >
                        Request Consultation
                      
                    
                  ))}
                
              
            )}

            {activeTab === 'opportunities' && (
              
                Medical Opportunities
                
                  {opportunities.map((opportunity) => (
                    
                      
                        
                          
                            {opportunity.title}
                          
                          
                            {opportunity.specialty} • {opportunity.location}
                          
                        
                        
                          
                            {opportunity.urgency.toUpperCase()}
                          
                          
                            {opportunity.type.toUpperCase()}
                          
                        
                      

                      {opportunity.description}

                      
                        Requirements:
                        
                          {opportunity.requirements.map((req, index) => (
                            {req}
                          ))}
                        
                      

                      
                        
                          Compensation: {opportunity.compensation}
                          Deadline: 
                            {new Date(opportunity.deadline).toLocaleDateString()}
                          
                        
                        
                          Apply Now
                        
                      
                    
                  ))}
                
              
            )}

            {activeTab === 'consultations' && (
              
                My Consultations
                
                  
                    
                      📅
                      No consultations scheduled
                      Request a consultation from the Professional Directory
                    
                  
                
              
            )}
          
        
      
    
  )
}`}

## 💼 Tech Startup Accelerator

### Startup Accelerator Platform

// app/accelerator/page.tsx

{`'use client'

import { useState, useEffect } from 'react'
import { useSession } from 'next-auth/react'

interface Startup {
  id: string
  name: string
  description: string
  stage: 'idea' | 'mvp' | 'growth' | 'scale'
  industry: string
  fundingRaised: number
  teamSize: number
  logo: string
  founders: string[]
  metrics: {
    revenue: number
    users: number
    growth: number
  }
}

interface Mentor {
  id: string
  name: string
  title: string
  company: string
  expertise: string[]
  rating: number
  sessionsCompleted: number
  hourlyRate: number
  avatar: string
}

interface InvestmentOpportunity {
  id: string
  startupId: string
  startupName: string
  round: 'pre-seed' | 'seed' | 'series-a' | 'series-b'
  targetAmount: number
  raisedAmount: number
  valuation: number
  minimumInvestment: number
  deadline: string
  highlights: string[]
}

export default function StartupAccelerator() {
  const { data: session } = useSession()
  const [activeTab, setActiveTab] = useState<'startups' | 'mentors' | 'investments' | 'events'>('startups')
  const [startups, setStartups] = useState<Startup[]>([])
  const [mentors, setMentors] = useState<Mentor[]>([])
  const [investments, setInvestments] = useState<InvestmentOpportunity[]>([])
  const [loading, setLoading] = useState(true)

  useEffect(() => {
    loadAcceleratorData()
  }, [])

  const loadAcceleratorData = async () => {
    try {
      const [startupsRes, mentorsRes, investmentsRes] = await Promise.all([
        fetch('/api/accelerator/startups'),
        fetch('/api/accelerator/mentors'),
        fetch('/api/accelerator/investments')
      ])

      const [startupsData, mentorsData, investmentsData] = await Promise.all([
        startupsRes.json(),
        mentorsRes.json(),
        investmentsRes.json()
      ])

      setStartups(startupsData.startups || [])
      setMentors(mentorsData.mentors || [])
      setInvestments(investmentsData.investments || [])
    } catch (error) {
      console.error('Failed to load accelerator data:', error)
    } finally {
      setLoading(false)
    }
  }

  const getStageColor = (stage: string) => {
    const colors = {
      idea: 'bg-gray-100 text-gray-800',
      mvp: 'bg-blue-100 text-blue-800',
      growth: 'bg-green-100 text-green-800',
      scale: 'bg-purple-100 text-purple-800'
    }
    return colors[stage as keyof typeof colors] || 'bg-gray-100 text-gray-800'
  }

  const formatCurrency = (amount: number) => {
    if (amount >= 1000000) {
      return `$${(amount / 1000000).toFixed(1)}M`
    } else if (amount >= 1000) {
      return `$${(amount / 1000).toFixed(0)}K`
    }
    return `$${amount}`
  }

  const bookMentorSession = async (mentorId: string) => {
    try {
      const response = await fetch('/api/accelerator/mentors/book', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          mentorId,
          startupId: session?.user?.entityId,
          duration: 60,
          type: 'strategy'
        })
      })

      if (response.ok) {
        alert('Mentor session booked successfully!')
      }
    } catch (error) {
      console.error('Failed to book mentor session:', error)
      alert('Failed to book mentor session')
    }
  }

  const expressInterest = async (investmentId: string, amount: number) => {
    try {
      const response = await fetch('/api/accelerator/investments/interest', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          investmentId,
          investorId: session?.user?.id,
          amount
        })
      })

      if (response.ok) {
        alert('Investment interest submitted successfully!')
      }
    } catch (error) {
      console.error('Failed to express investment interest:', error)
      alert('Failed to submit investment interest')
    }
  }

  if (loading) {
    return Loading accelerator platform...
  }

  return (
    
      {/* Header */}
      
        
          TechConnect Accelerator
          
            Connecting startups, mentors, and investors in the tech ecosystem
          
        
      

      {/* Navigation */}
      
        
          
            {[
              { key: 'startups', label: 'Startups', icon: '🚀' },
              { key: 'mentors', label: 'Mentors', icon: '👨‍🏫' },
              { key: 'investments', label: 'Investments', icon: '💰' },
              { key: 'events', label: 'Events', icon: '📅' }
            ].map((tab) => (
               setActiveTab(tab.key as any)}
                className={`py-4 px-1 border-b-2 font-medium text-sm ${
                  activeTab === tab.key
                    ? 'border-blue-500 text-blue-600'
                    : 'border-transparent text-gray-500 hover:text-gray-700'
                }`}
              >
                {tab.icon}
                {tab.label}
              
            ))}
          
        
      

      {/* Content */}
      
        {activeTab === 'startups' && (
          
            
              Featured Startups
              
                Submit Your Startup
              
            

            
              {startups.map((startup) => (
                
                  
                    
                      
                      
                        {startup.name}
                        {startup.industry}
                      
                    

                    {startup.description}

                    
                      
                        {startup.stage.toUpperCase()}
                      
                      
                        {startup.teamSize} team members
                      
                    

                    
                      
                        
                          {formatCurrency(startup.metrics.revenue)}
                        
                        Revenue
                      
                      
                        
                          {startup.metrics.users.toLocaleString()}
                        
                        Users
                      
                      
                        
                          +{startup.metrics.growth}%
                        
                        Growth
                      
                    

                    
                      
                        View Details
                      
                      
                        Connect
                      
                    
                  
                
              ))}
            
          
        )}

        {activeTab === 'mentors' && (
          
            Expert Mentors
            
              {mentors.map((mentor) => (
                
                  
                    
                    
                      {mentor.name}
                      {mentor.title}
                      {mentor.company}
                    
                    
                      
                        ${mentor.hourlyRate}/hr
                      
                      
                        ★
                        {mentor.rating}
                      
                    
                  

                  
                    Expertise:
                    
                      {mentor.expertise.map((skill, index) => (
                        
                          {skill}
                        
                      ))}
                    
                  

                  
                    
                      {mentor.sessionsCompleted} sessions completed
                    
                  

                   bookMentorSession(mentor.id)}
                    className="w-full bg-green-600 text-white py-2 px-4 rounded-md hover:bg-green-700"
                  >
                    Book Session
                  
                
              ))}
            
          
        )}

        {activeTab === 'investments' && (
          
            Investment Opportunities
            
              {investments.map((investment) => (
                
                  
                    
                      
                        {investment.startupName}
                      
                      
                        {investment.round.replace('-', ' ').toUpperCase()} Round
                      
                    
                    
                      
                        {formatCurrency(investment.valuation)}
                      
                      Valuation
                    
                  

                  
                    
                      
                        {formatCurrency(investment.targetAmount)}
                      
                      Target
                    
                    
                      
                        {formatCurrency(investment.raisedAmount)}
                      
                      Raised
                    
                    
                      
                        {formatCurrency(investment.minimumInvestment)}
                      
                      Min Investment
                    
                    
                      
                        {Math.round((investment.raisedAmount / investment.targetAmount) * 100)}%
                      
                      Complete
                    
                  

                  
                    
                      
                    
                  

                  
                    Investment Highlights:
                    
                      {investment.highlights.map((highlight, index) => (
                        {highlight}
                      ))}
                    
                  

                  
                    
                      Deadline: {new Date(investment.deadline).toLocaleDateString()}
                    
                     {
                        const amount = prompt(`Enter investment amount (min ${formatCurrency(investment.minimumInvestment)}):`)
                        if (amount && parseInt(amount) >= investment.minimumInvestment) {
                          expressInterest(investment.id, parseInt(amount))
                        }
                      }}
                      className="bg-purple-600 text-white py-2 px-6 rounded-md hover:bg-purple-700"
                    >
                      Express Interest
                    
                  
                
              ))}
            
          
        )}

        {activeTab === 'events' && (
          
            Upcoming Events
            
              
                
                  📅
                  No events scheduled
                  Check back soon for upcoming accelerator events
                
              
            
          
        )}
      
    
  )
}`}

## 🎓 Educational Institution Network

### University Alumni & Student Network

// app/university/page.tsx

{`'use client'

import { useState, useEffect } from 'react'
import { useSession } from 'next-auth/react'

interface AlumniProfile {
  id: string
  name: string
  graduationYear: number
  degree: string
  major: string
  currentRole: string
  company: string
  location: string
  industry: string
  mentoring: boolean
  avatar: string
  achievements: string[]
}

interface StudentOpportunity {
  id: string
  title: string
  type: 'internship' | 'job' | 'research' | 'mentorship' | 'project'
  company: string
  location: string
  duration: string
  requirements: string[]
  description: string
  applicationDeadline: string
  postedBy: string
}

export default function UniversityNetwork() {
  const { data: session } = useSession()
  const [activeTab, setActiveTab] = useState<'alumni' | 'opportunities' | 'mentorship' | 'events'>('alumni')
  const [alumni, setAlumni] = useState<AlumniProfile[]>([])
  const [opportunities, setOpportunities] = useState<StudentOpportunity[]>([])
  const [loading, setLoading] = useState(true)

  useEffect(() => {
    loadUniversityData()
  }, [])

  const loadUniversityData = async () => {
    try {
      const [alumniRes, opportunitiesRes] = await Promise.all([
        fetch('/api/university/alumni'),
        fetch('/api/university/opportunities')
      ])

      const [alumniData, opportunitiesData] = await Promise.all([
        alumniRes.json(),
        opportunitiesRes.json()
      ])

      setAlumni(alumniData.alumni || [])
      setOpportunities(opportunitiesData.opportunities || [])
    } catch (error) {
      console.error('Failed to load university data:', error)
    } finally {
      setLoading(false)
    }
  }

  const requestMentorship = async (alumniId: string) => {
    try {
      const response = await fetch('/api/university/mentorship/request', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          mentorId: alumniId,
          studentId: session?.user?.id,
          message: 'I would like to request mentorship guidance for my career development.'
        })
      })

      if (response.ok) {
        alert('Mentorship request sent successfully!')
      }
    } catch (error) {
      console.error('Failed to request mentorship:', error)
      alert('Failed to send mentorship request')
    }
  }

  const applyToOpportunity = async (opportunityId: string) => {
    try {
      const response = await fetch('/api/university/opportunities/apply', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          opportunityId,
          studentId: session?.user?.id,
          resume: 'path/to/resume.pdf' // In real app, this would be uploaded
        })
      })

      if (response.ok) {
        alert('Application submitted successfully!')
      }
    } catch (error) {
      console.error('Failed to apply to opportunity:', error)
      alert('Failed to submit application')
    }
  }

  const getOpportunityTypeColor = (type: string) => {
    const colors = {
      internship: 'bg-blue-100 text-blue-800',
      job: 'bg-green-100 text-green-800',
      research: 'bg-purple-100 text-purple-800',
      mentorship: 'bg-yellow-100 text-yellow-800',
      project: 'bg-pink-100 text-pink-800'
    }
    return colors[type as keyof typeof colors] || 'bg-gray-100 text-gray-800'
  }

  if (loading) {
    return Loading university network...
  }

  return (
    
      {/* Header */}
      
        
          University Alumni Network
          
            Connecting students, alumni, and opportunities for lifelong learning
          
        
      

      {/* Navigation */}
      
        
          
            {[
              { key: 'alumni', label: 'Alumni Directory', icon: '🎓' },
              { key: 'opportunities', label: 'Opportunities', icon: '💼' },
              { key: 'mentorship', label: 'Mentorship', icon: '👨‍🏫' },
              { key: 'events', label: 'Events', icon: '📅' }
            ].map((tab) => (
               setActiveTab(tab.key as any)}
                className={`py-4 px-1 border-b-2 font-medium text-sm ${
                  activeTab === tab.key
                    ? 'border-indigo-500 text-indigo-600'
                    : 'border-transparent text-gray-500 hover:text-gray-700'
                }`}
              >
                {tab.icon}
                {tab.label}
              
            ))}
          
        
      

      {/* Content */}
      
        {activeTab === 'alumni' && (
          
            Alumni Directory
            
              {alumni.map((alumnus) => (
                
                  
                    
                    
                      {alumnus.name}
                      {alumnus.currentRole}
                      {alumnus.company}
                    
                  

                  
                    
                      Class of {alumnus.graduationYear}
                    
                    
                      {alumnus.degree} in {alumnus.major}
                    
                    
                      {alumnus.location} • {alumnus.industry}
                    
                  

                  {alumnus.achievements.length > 0 && (
                    
                      Recent Achievements:
                      
                        {alumnus.achievements.slice(0, 2).map((achievement, index) => (
                          {achievement}
                        ))}
                      
                    
                  )}

                  
                    
                      Connect
                    
                    {alumnus.mentoring && (
                       requestMentorship(alumnus.id)}
                        className="flex-1 border border-indigo-600 text-indigo-600 py-2 px-4 rounded-md hover:bg-indigo-50 text-sm"
                      >
                        Request Mentorship
                      
                    )}
                  
                
              ))}
            
          
        )}

        {activeTab === 'opportunities' && (
          
            Student Opportunities
            
              {opportunities.map((opportunity) => (
                
                  
                    
                      {opportunity.title}
                      
                        {opportunity.company} • {opportunity.location}
                      
                    
                    
                      {opportunity.type.toUpperCase()}
                    
                  

                  {opportunity.description}

                  
                    Requirements:
                    
                      {opportunity.requirements.map((req, index) => (
                        {req}
                      ))}
                    
                  

                  
                    
                      Duration: {opportunity.duration}
                      Deadline: 
                        {new Date(opportunity.applicationDeadline).toLocaleDateString()}
                      
                    
                     applyToOpportunity(opportunity.id)}
                      className="bg-green-600 text-white py-2 px-6 rounded-md hover:bg-green-700"
                    >
                      Apply Now
                    
                  
                
              ))}
            
          
        )}

        {activeTab === 'mentorship' && (
          
            Mentorship Program
            
              
                
                  👨‍🏫
                  Find Your Mentor
                  
                    Connect with alumni who are available for mentorship in the Alumni Directory
                  
                   setActiveTab('alumni')}
                    className="bg-indigo-600 text-white px-6 py-2 rounded-md hover:bg-indigo-700"
                  >
                    Browse Alumni
                  
                
              
            
          
        )}

        {activeTab === 'events' && (
          
            Upcoming Events
            
              
                
                  📅
                  No events scheduled
                  Check back soon for upcoming alumni events
                
              
            
          
        )}
      
    
  )
}`}

---

*These real-world examples demonstrate complete, production-ready applications built with Ring Platform. Each example includes authentication, role-based access, real-time features, and industry-specific functionality.*

*Ready to build your own? Start with our [Quick Start Examples](/en/docs/examples/quick-start) or explore [API Integration](/en/docs/examples/api-integration).*