Software Engineering

Developer Portfolio Platform

A production-style portfolio platform built around validated content, reusable rendering, automated quality gates, and professional deployment.

A Next.js and TypeScript platform that presents engineering projects through validated structured content, generic project routing, reusable case-study components, automated testing and accessibility checks, CI/CD, and production deployment on a custom domain.

Problem

Context

A professional engineering portfolio must communicate technical depth clearly while remaining maintainable as new projects, evidence, and capabilities are added over time.

Challenge

Build a recruiter-facing portfolio that avoids bespoke project pages, validates public claims before rendering, preserves a consistent presentation model, and enforces production-style quality standards.

Objective

Create an extensible portfolio platform where validated project definitions automatically participate in routing, metadata, sitemap generation, evidence presentation, automated testing, and production deployment.

Architecture

Structured TypeScript project definitions are validated with Zod, registered through a centralized project registry, rendered through shared Next.js routes and React components, validated through automated quality gates, and deployed to Vercel.

  1. 01

    Structured project definition

  2. 02

    Zod validation

  3. 03

    Validated project registry

  4. 04

    Generic project discovery and routing

  5. 05

    Reusable case-study rendering

  6. 06

    Automated quality gates

  7. 07

    Production deployment

Structured Content Layer

Represents portfolio projects as structured TypeScript data instead of project-specific page implementations.

  • TypeScript

Validation Layer

Validates project definitions and content constraints before data reaches rendering logic.

  • Zod

Project Registry

Provides centralized validated project lookup and separates flagship projects from additional engineering work.

  • TypeScript

Application and Routing Layer

Generates reusable project routes, metadata, sitemap participation, and not-found behavior through the Next.js App Router.

  • Next.js
  • React

Presentation Layer

Renders project cards, case studies, technology summaries, navigation, and responsive portfolio sections through reusable components.

  • React
  • Tailwind CSS

Quality Layer

Enforces linting, type safety, unit testing, browser testing, accessibility checks, formatting, and production-build validation.

  • ESLint
  • TypeScript
  • Vitest
  • React Testing Library
  • Playwright
  • axe
  • Prettier

Delivery Layer

Runs automated CI validation and delivers the application to the production custom domain.

  • GitHub Actions
  • Vercel

Technology

Language

  • TypeScript 5

Framework

  • Next.js 16.3.6
  • React 19.2.8
  • Tailwind CSS 4
  • Zod 4

Testing

  • Vitest 5
  • React Testing Library
  • Playwright
  • axe-core

Devops

  • GitHub Actions
  • Vercel

Other

  • Node.js 24.x
  • ESLint 9
  • Prettier 3

Engineering Contribution

Designed a validated content architecture

Modeled portfolio projects as structured TypeScript content validated by Zod so project claims and presentation data fail early when they violate the content contract.

Built generic project routing and rendering

Implemented shared dynamic routes and reusable case-study components so registered projects receive routing, metadata, and presentation without project-specific page implementations.

Added extensible project discovery

Separated flagship systems from additional engineering work through registry-driven collections so new supporting projects can appear without changing project-specific rendering logic.

Implemented automated quality and accessibility gates

Integrated linting, type checking, unit tests, production builds, browser tests, automated accessibility analysis, formatting checks, and whitespace validation into the engineering workflow.

Established continuous integration and production delivery

Configured GitHub Actions to validate changes and deployed the portfolio to Vercel behind the dmortalla.dev custom domain.

Documented architectural decisions and release state

Maintained architecture documentation, an accepted architecture decision record, project-status tracking, and versioned production releases.

Engineering Evidence

Code

Validated Project Content Model

The repository defines a Zod-backed PortfolioProject schema covering positioning, architecture, technologies, contributions, evidence, capabilities, repository metadata, featured state, and SEO.

Architecture

Generic Static Project Routing

A shared dynamic Next.js route derives static parameters and project metadata from the project registry and renders every registered project through the reusable ProjectCaseStudy component.

Code

Registry-Driven Project Discovery

The project registry separates featured and additional projects through reusable selectors, while the homepage renders both collections generically.

Test

Automated Quality Gates

The project validates linting, TypeScript type safety, Vitest tests, production builds, Playwright E2E behavior, formatting, and whitespace integrity before release.

Test

Automated Accessibility Testing

Playwright browser tests integrate axe to detect automatically identifiable accessibility violations on portfolio pages.

Ci Cd

GitHub Actions CI Pipeline

GitHub Actions installs dependencies and runs linting, type checking, unit tests, a production build, Playwright accessibility tests, and formatting validation on pull requests and main-branch changes.

Validation

Production Custom-Domain Deployment

The portfolio is deployed through Vercel and served from the dmortalla.dev production domain.

Documentation

Architecture and Decision Documentation

The repository documents the platform architecture, its core extensibility invariant, release status, and the accepted decision to use a static-first Next.js platform architecture.

What It Proves

Production-style software engineering

Demonstrates structured application architecture, reusable components, typed content contracts, automated verification, CI, and production deployment.

Extensible platform architecture

Demonstrates a data-driven architecture in which project content participates in generic discovery, routing, metadata, and rendering without a bespoke project page.

Quality and accessibility engineering

Demonstrates automated unit, browser, accessibility, formatting, type-safety, and production-build verification as release gates.