Devcorp Website

A modern, responsive portfolio website built with Next.js 15, TypeScript, and Tailwind CSS. Features centralized content management, custom design system, and production-ready deployment. Showcases our development projects with interactive UI and comprehensive blog system.

MMMahadev Mohan
PSMParamraj Singh Machre
15 min read
“The best way to predict the future is to create it.” - Alan Kay

The Devcorp Website is our flagship project—a modern, production-ready portfolio website that showcases our development journey, technical expertise, and innovative projects. Built from the ground up with Next.js 15, TypeScript, and Tailwind CSS, this website demonstrates enterprise-level software engineering practices and serves as a living example of our capabilities.

Live and Production-Ready

Visit devcorpwebsite.vercel.app to explore the live site and experience all the features we'll discuss in this article.

Project Genesis

Every great project starts with a problem to solve. For Devcorp, we needed a platform that could showcase our work while demonstrating technical excellence.

Showcase Our Work

Present projects in a professional manner that highlights technical depth and innovation

Share Our Journey

Document our development process, challenges, and learnings through detailed blog entries

Demonstrate Skills

Use the website itself as a technical showcase of modern web development

Easy Maintenance

Create a system where adding new projects automatically updates all pages

Architecture & Tech Stack

We chose cutting-edge technologies that balance performance, developer experience, and maintainability. Each decision was made with scalability and future growth in mind.

🛠️Complete Technology Stack

Next.js 15TypeScriptReact 19Tailwind CSSFramer MotionGray MatterZodVercel

Core Framework: Next.js 15

Next.js 15 provides the foundation for our modern web application with cutting-edge features:

React 19 Server Components

Default to server rendering for optimal performance

Static Site Generation

Pre-render pages at build time for instant loading

App Router

File-based routing with enhanced developer experience

Image Optimization

Automatic WebP conversion and lazy loading

Type Safety: TypeScript + Zod

End-to-end type safety from content files to rendered components:

// Zod schema defines structure and validation
export const projectSchema = z.object({
  title: z.string(),
  slug: z.string(),
  status: z.enum(["planned", "building", "shipped"]),
  techStack: z.array(z.string()).default([]),
  author: z.string().optional(),
  readTime: z.number().optional(),
  // ... 15+ more fields
});

// TypeScript types auto-generated
type Project = z.infer<typeof projectSchema>;
  • Build-time validation: Catches content errors before deployment
  • IDE autocomplete: Full IntelliSense support for content fields
  • Refactoring safety: Schema changes propagate through entire codebase

Styling: Custom Design System

A carefully crafted five-color palette provides the foundation for all visual design:

Black

#000000

Davy Gray

#4a4a4a

Silver

#b3b3b3

Seasalt

#f8f7f5

Alabaster

#f5f2e9

// CSS variables for consistent theming
:root {
  --black: #000000;
  --davy-gray: #4a4a4a;
  --silver: #b3b3b3;
  --seasalt: #f8f7f5;
  --alabaster: #f5f2e9;
}

Content Management System

The centerpiece of the Devcorp website is its centralized content management system. This system eliminates hardcoded data and makes the entire site update automatically when new projects are added.

How the System Works

  1. 1
    Create Project File: Add one MDX file in content/projects/[slug]/index.mdx
  2. 2
    Parse & Validate: Gray Matter extracts frontmatter, Zod validates schema
  3. 3
    Generate Data: Functions aggregate all projects with type safety
  4. 4
    Auto-Update Pages: Home, Projects, and Blog pages all show the new project
  5. 5
    Build & Deploy: Vercel automatically rebuilds and deploys changes

Content Schema Fields

Basic Info

  • • title, slug, summary
  • • status, progress, tags
  • • techStack, role, duration

Links & Assets

  • • demoUrl, repoUrl
  • • thumbnail, author
  • • publishedAt, updatedAt

Project Details

  • • challenges (array)
  • • keyFeatures (array)
  • • highlights (array)

Blog Specific

  • • blogTitle, blogExcerpt
  • • readTime, lessonsLearned
  • • nextSteps

15+ Content Fields

Our content schema supports over 15 different fields, giving you complete control over how projects are presented while maintaining type safety and validation throughout the entire system.

Major Technical Challenges

Building a production-ready website from scratch presented some fascinating architectural and design challenges. Here are the big problems we tackled:

Challenge: Designing a Scalable Content Architecture

How do you build a content management system that's powerful enough for complex projects but simple enough that adding a new project is just creating one file?

// The goal: One file controls everything
content/projects/new-project/index.mdx
  ├── Homepage project card
  ├── Projects page entry
  ├── Blog page preview
  ├── Detailed blog post
  └── All metadata & relationships

// The challenge: 15+ fields, type safety, validation
export const projectSchema = z.object({
  title: z.string(),
  status: z.enum(["planned", "building", "shipped"]),
  techStack: z.array(z.string()).default([]),
  challenges: z.array(z.string()).default([]),
  keyFeatures: z.array(z.string()).default([]),
  highlights: z.array(z.string()).optional(),
  lessonsLearned: z.array(z.string()).optional(),
  // ... and 8 more fields
});

Solution: Built a Zod-powered schema system that validates content at build time while generating TypeScript types automatically

Challenge: Creating a Custom Design System from Scratch

We needed a design system that felt unique and professional while being maintainable. The challenge was balancing creativity with consistency across 5+ different page layouts.

// Design constraints:
- 5 distinct page types (Home, About, Projects, Blog, Contact)
- Each needs unique layout but consistent branding
- Mobile-first responsive design
- Dark hero sections + light content sections
- Custom color palette that works in all contexts

// Our approach:
:root {
  --black: #000000;      // Headers, CTAs
  --davy-gray: #4a4a4a;  // Secondary text
  --silver: #b3b3b3;     // Muted elements
  --seasalt: #f8f7f5;    // Primary backgrounds
  --alabaster: #f5f2e9;  // Secondary backgrounds
}

Solution: Created a five-color palette with CSS variables, ensuring every page feels cohesive while maintaining visual hierarchy

Challenge: Optimizing for Performance Without Compromising Features

We wanted rich animations, large images, and interactive features while maintaining lightning-fast load times. The challenge was finding the right balance.

// Performance goals:
- < 3s initial page load
- Smooth 60fps animations
- Optimized images with lazy loading
- Minimal JavaScript bundle

// Our strategy:
1. Server Components by default (smaller JS bundles)
2. Client components only for interactivity
3. Next.js Image optimization (WebP + lazy loading)
4. Framer Motion with GPU acceleration
5. Static site generation for instant loads

// Result: 95+ Lighthouse scores across all metrics

Solution: Server-first architecture with selective client-side enhancements, achieving 95+ Lighthouse scores

Challenge: Building Intelligent User Experience Patterns

How do you create navigation that feels intuitive and smart? Users expect the back button to work like a browser, but single-page apps with anchor links break this expectation.

// The UX problem:
User journey: Home → Projects → Project Detail → Click TOC → Click Back
Expected: Goes back to Projects page
Actual: Goes to previous TOC section (confusing!)

// Our intelligent solution:
const SmartBackButton = () => {
  const referrer = document.referrer;
  const basePath = referrer.split('#')[0]; // Strip anchor links

  // Smart routing based on actual previous page
  if (basePath === "/") return "Back to Home";
  if (basePath === "/projects") return "Back to Projects";
  if (basePath === "/blog") return "Back to Blog";

  // Smooth scrolling without history pollution
  const handleTOCClick = () => {
    element.scrollIntoView({ behavior: 'smooth' });
    // No href="#" = no history entry
  };
};

Solution: Built a SmartBackButton that tracks actual navigation patterns and table of contents that scrolls without polluting browser history

Challenge: Future-Proofing the Architecture

How do you build a website that can grow from 5 projects to 50 projects, from 2 authors to 10 authors, without major refactoring?

// Scalability considerations:
- Dynamic sorting by status priority (shipped > building > planned)
- Flexible author system (single or multiple authors)
- Extensible content schema with optional fields
- Modular component architecture
- Type-safe refactoring (change schema = auto-update everywhere)

// Example: Adding a new project status
enum Status { shipped, building, planned, archived } // Just add here
// → All sorting, filtering, and UI updates automatically

// Example: Adding new content fields
blogExcerpt: z.string().optional(), // Just add to schema
// → TypeScript types generated, validation added, UI ready

Solution: Built extensible schemas with optional fields, dynamic sorting algorithms, and type-safe architecture that grows with requirements

Feature Showcase

Let's explore the key features that make the Devcorp website stand out.

Status Badge System

Color-coded badges appear across all project displays

ShippedBuildingPlanned

Responsive Design

Mobile-first approach ensures perfect display on all devices from phones to desktops

Smooth Animations

Framer Motion powers entrance animations, hover effects, and page transitions

Table of Contents

Sticky sidebar navigation with smooth scrolling for long-form content

SEO Optimization

Proper meta tags, structured data, and server-side rendering for search engines

Accessibility

Semantic HTML, ARIA labels, keyboard navigation, and screen reader support

Lessons Learned & Takeaways

Building the Devcorp website taught us invaluable lessons about modern web development, content architecture, and user experience design.

Content Management is Key

Centralized content management eliminates hardcoded data and makes updates seamless across all pages. The investment in building a robust content system pays dividends in maintenance and scalability.

Design Systems Provide Consistency

Custom design systems with CSS variables provide consistency and easier maintenance. Our five-color palette ensures brand coherence without limiting creative expression.

Type Safety Catches Bugs Early

Zod schemas at the content layer catch errors at build time, not runtime. TypeScript integration provides excellent IDE support and refactoring safety.

User Experience is in the Details

Small details matter: intelligent back buttons, smooth scrolling, hover effects, and thoughtful navigation create a polished experience that users notice and appreciate.

Server Components as Default

Server components should be the default—use client components only when you need interactivity. This approach reduces JavaScript bundle size and improves performance significantly.

Future Enhancements

The Devcorp website is a living project that continues to evolve. Here's what's planned for future releases.

Phase 1: Dark Mode

  • • System preference detection
  • • Manual toggle with persistence
  • • Smooth theme transitions

Phase 2: Advanced Filtering

  • • Filter projects by tech stack
  • • Search across all content
  • • Tag-based navigation

Phase 3: Analytics

  • • User engagement tracking
  • • Popular projects insights
  • • Performance monitoring

Phase 4: Interactive Demos

  • • Embedded code playgrounds
  • • Live project previews
  • • Interactive tutorials

Final Thoughts

The Devcorp website is more than just a portfolio—it's a demonstration of what happens when you combine modern technologies with thoughtful engineering. From the centralized content management system to the intelligent navigation patterns, every feature was built with intention and care.

This project showcases our ability to build production-ready applications that are not only functional but also maintainable, scalable, and delightful to use. It represents our commitment to code quality, user experience, and continuous improvement.

Explore the live site at devcorpwebsite.vercel.app and see these features in action!

💡

Open Source & Collaboration

We believe in learning by doing and sharing our knowledge. The Devcorp website is open source and available for others to learn from. We welcome feedback, suggestions, and contributions from the developer community.