How mrkat303/hiveyoung-website works
This repository is a Next.js App Router project organized as a multi-section public website with one special event microsite.
At a high level, there are three architectural layers:
1. Route composition layer
2. Shared UI and behavior layer
3. Content/data and static asset layer
The app is split into two major route domains:
• app/(site): the main organizational site
• app/congreso: a dedicated congress/event experience
1) Route composition layer
Main site routes
The (site) route group contains the standard informational pages:
• home: app/(site)/page.tsx
• somos
• equipo
• historia
• advisory-board
• contacto
• unete
Each of these routes follows the same pattern:
• a page.tsx file for the route entry point
• a route-specific client component such as SomosClient.tsx, EquipoClient.tsx, etc.
• a co-located stylesheet such as Somos.css, Equipo.css, etc.
This indicates the route files are mainly thin composition shells, while the actual page behavior and rendering logic lives in the corresponding client components.
Congress microsite
app/congreso is structured more like a standalone landing page or microsite:
• app/congreso/page.tsx
• app/congreso/layout.tsx
• reusable section components in app/congreso/components
• a dedicated stylesheet bundle in app/congreso/styles
This area is more modularized by section than the main site. The congress page is assembled from section-level components such as:
• HeroCarousel
• StatsSection
• SpeakersGrid
• VenueSection
• MomentosGallery
• FAQSection
That suggests the congress route is designed as a long-form, scrollable page made of clearly separated content blocks.
Root app shell
At the top level:
• app/layout.tsx defines the global shell for the whole app
• app/globals.css contains global styles
• app/(site)/layout.tsx and app/congreso/layout.tsx provide route-group-specific wrappers where needed
There is also app/(site)/template.tsx, which implies the main site group may be using a template boundary for page transitions or per-navigation resets.
2) Shared UI and behavior layer
Shared site-wide components
The components/ directory contains reusable pieces used across multiple routes:
• Navbar/
• Footer/
• home page sections like Hero, AboutSection, CongressCarousel, JoinBanner, QuienesSomos, QueHacemos
• utility visuals such as CircleMarker, HighlightMarker
• DisableRightClick.tsx, which suggests some content protection or interaction restriction behavior
This indicates the site is not built from a monolithic page, but from reusable presentation blocks assembled per route.
UI primitives
components/ui contains lower-level controls:
• Accordion.tsx
• Button.tsx
• FormField.tsx
These are likely used to standardize interactive elements and form layout across pages such as contact or FAQ sections.
Client-side hooks
The hooks/ folder contains reusable interaction logic:
• useCarousel.ts
• useEmailForm.ts
• useScrollReveal.ts
These hooks are an important architectural boundary:
• carousel timing/state is isolated from visual components
• email/contact form state and submission behavior are isolated from UI
• scroll-triggered animation/reveal behavior is reusable across sections
That means the interactive logic is centralized, while the route components remain mostly declarative.
3) Content/data and page assembly flow
Data modules
The data/ directory contains structured content for the site:
• navigation.ts
• equipo.ts
• historia.ts
• advisory.ts
• congreso.ts
• congress-carousel.ts
• speakers.ts
• somos-values.tsx
These files appear to provide the content model for the application:
• navigation configuration
• team/member listings
• historical timeline data
• advisory board content
• congress program/speakers/carousel data
• values/content blocks for the “somos” page
The presence of these modules shows that most visible content is data-driven rather than hardcoded directly inside page components.
Example data flow
A typical route likely follows this pattern:
• page route (page.tsx)
• route-specific client component
• consumes structured data from data/*
• renders reusable UI blocks from components/*
• applies local styles from a co-located CSS file
The historia page is a good example of this pattern:
• timelineData.ts feeds the historical narrative
• FloatingNames.tsx adds a specialized visual layer
• HistoriaClient.tsx assembles the interactive page
• Historia.css handles presentation
4) Forms and validation
The contact/join flow is supported by:
• hooks/useEmailForm.ts
• utils/validation.ts
• components/ui/FormField.tsx
This suggests form handling is centralized rather than embedded in each page. The likely flow is:
• page/client component renders form fields
• validation utilities enforce input rules
• hook manages submission state and side effects
This is important because it separates presentation from form business rules.
5) Routing, SEO, and request-time concerns
SEO assets
The app includes:
• app/robots.ts
• app/sitemap.ts
• app/sitemap-images.xml/route.ts
This means the site explicitly generates crawler metadata and an image sitemap, which is relevant for discovery and indexability, especially because the site appears image-heavy.
Middleware
middleware.ts is present at the root, so there is some request-time cross-cutting logic. The exact behavior is not visible from the tree alone, but architecturally this means some routing or request policy is enforced before route rendering.
Next.js app metadata/static optimization
The README indicates the project uses:
• Next.js App Router
• next/font for font loading
• deployment-friendly static asset handling
6) Static assets and presentation system
The public/ directory contains:
• fonts
• images
• congress-specific imagery and logos
• home page imagery
• a site.webmanifest
This suggests the site is visually driven and depends heavily on local static assets rather than remote media services.
Styling is mostly CSS-based rather than a CSS-in-JS system:
• global styles in app/globals.css
• route-level and component-level CSS files
• the congress section has a dedicated style bundle under app/congreso/styles
So the visual architecture is:
• global baseline styles
• route-specific styles
• component-specific styles
• larger microsite styles for the congress experience
7) Architectural boundaries to reflect in a diagram
If you are drawing a diagram, the clearest boundaries are:
• App shell boundary: app/layout.tsx, global CSS, SEO routes, middleware
• Main site boundary: (site) route group with reusable navbar/footer and section-driven pages
• Congress microsite boundary: app/congreso with its own layout, section components, and style system
• Shared component boundary: reusable UI, navbar/footer, home sections, marker components
• Content boundary: typed/static data in data/
• Behavior boundary: hooks and validation utilities
• Asset boundary: public/ fonts, images, and manifest
8) Overall system shape
This is not a backend-heavy or service-oriented repository. It is primarily a content-rich, marketing/information website built with Next.js, where:
• routes assemble pages from reusable sections
• client components handle interaction
• data modules supply page content
• CSS files control styling at a granular level
• SEO routes and middleware provide cross-cutting platform behavior
The most important conceptual split is between the main organizational website and the congress event microsite, with shared components and content data reused where appropriate.
Main entry points: app/layout.tsx Root layout · (site)/layout.tsx Site layout · components Section blocks · Home Home sections
Components 23
App shell
Global Next.js shell, metadata, and request-time concerns.
- Root layout · Global app shell and metadata host.
app/layout.tsx - Global CSS · Base stylesheet for the entire app.
app/globals.css - Middleware · Cross-cutting request-time routing or policy logic.
middleware.ts - Robots · Crawler directives for the site.
app/robots.ts - Sitemap · Primary sitemap generation.
app/sitemap.ts - Image sitemap · Dedicated sitemap endpoint for images.
app/sitemap-images.xml/route.ts
Main site
Primary organizational website routes.
- Site layout · Wrapper for the main informational site.
app/(site)/layout.tsx - Site template · Per-navigation boundary for the main site.
app/(site)/template.tsx - Home route · Entry page for the main site.
app/(site)/page.tsx - Section pages · Thin route entries for Somos, Equipo, Historia, Advisory Board, Contacto, and Unete.
- Page clients · Route-specific client components that hold the main site rendering logic.
Congress microsite
Standalone event experience under its own layout.
- Congress layout · Dedicated wrapper for the congress microsite.
app/congreso/layout.tsx - Congress page · Long-form event landing page.
app/congreso/page.tsx - Section blocks · Hero, stats, speakers, venue, gallery, and FAQ sections.
app/congreso/components - Congress styles · Dedicated stylesheet set for the microsite.
app/congreso/styles
Shared UI
Reusable components and interaction logic.
- Navbar · Primary navigation used across the site.
components/Navbar/Navbar.tsx - Footer · Site-wide footer component.
components/Footer/Footer.tsx - Home sections · Reusable landing-page sections such as Hero, About, CongressCarousel, JoinBanner, QuienesSomos, and QueHacemos.
components/Home - UI primitives · Accordion, Button, and FormField building blocks.
components/ui - Hooks · Reusable carousel, form, and reveal behavior.
hooks - Validation · Shared input validation for contact and join flows.
utils/validation.ts
Content
Structured page data used by routes and sections.
- Content data · Navigation, team, history, advisory, congress, speakers, and values content.
data
Assets
Static visual and branding assets.
- Public assets · Fonts, images, congress media, home media, and web manifest.
public
Connections 26
- Root layout → Global CSS: loads · Applies global styling to the app shell.
- Root layout → Site layout: wraps · Provides the shell for the main site routes.
- Root layout → Congress layout: wraps · Provides the shell for the congress microsite.
- Root layout → Robots: exposes · Serves crawler metadata.
- Root layout → Sitemap: exposes · Serves site map metadata.
- Root layout → Image sitemap: exposes · Serves image sitemap metadata.
- Middleware → Root layout: precedes · Runs before route rendering.
- Site layout → Navbar: uses · Adds shared navigation to the main site.
- Site layout → Footer: uses · Adds shared footer to the main site.
- Site template → Section pages: bounds · Defines a page boundary for section routes.
- Home route → Home sections: assembles · Composes the landing page from reusable sections.
- Section pages → Page clients: delegates · Thin pages hand off to route-specific client components.
- Page clients → Content data: reads · Client pages consume structured content modules.
- Page clients → UI primitives: renders · Uses shared UI building blocks.
- Page clients → Hooks: uses · Shares carousel, reveal, and form behavior.
- Page clients → Validation: validates · Applies shared form validation rules.
- Page clients → Public assets: displays · Uses local imagery and fonts.
- Congress layout → Congress styles: loads · Applies the microsite style bundle.
- Congress page → Section blocks: assembles · Builds the congress landing page from sections.
- Congress page → Content data: reads · Pulls event content and speaker data.
- Section blocks → Hooks: uses · Section blocks may rely on shared interaction logic.
- Section blocks → Public assets: displays · Shows congress imagery and logos.
- Home sections → Content data: reads · Home blocks are driven by structured content.
- Home sections → Public assets: displays · Uses local hero and section imagery.
- UI primitives → Validation: supports · Form field components work with shared rules.
- Hooks → Validation: coordinates · Email form flow depends on validation.