Automating Portfolio Content: Setting Up GitHub Writeups Pipeline

Overview

Publishing technical writeups, CTF walkthroughs, and security research should require minimal friction. Instead of manually editing codebase components or redeploying full applications, this architecture decouples content creation from application hosting.

By creating a dedicated

writeups

repository on GitHub and linking it directly to Vercel via Deploy Hooks and GitHub Actions, pushing a new markdown file automatically triggers a site rebuild and instantly publishes new writeups.

System Architecture

┌─────────────────────────┐         ┌─────────────────────────┐         ┌─────────────────────────┐
│                         │  Push   │                         │  Post   │                         │
│  Writeups Repository    ├────────►│  GitHub Actions         ├────────►│  Vercel Deploy Hook     │
│  (crypticrhino0/writeups│         │  (.github/workflows)    │         │  (Production Rebuild)   │
└─────────────────────────┘         └─────────────────────────┘         └────────────┬────────────┘
                                                                                     │
                                                                                     ▼
                                                                        ┌─────────────────────────┐
                                                                        │                         │
                                                                        │  Live Portfolio Site    │
                                                                        │  (shashank.dev)         │
                                                                        └─────────────────────────┘

1. Frontmatter Standard Definition

Every writeup placed in the repository root must include standard YAML frontmatter to allow the portfolio parser to extract metadata for indexing, filtering, and tag classification:

---
title: "HTB Cyber Apocalypse: Advanced Authentication Bypass"
date: "2026-08-01"
category: "CTF"
tags: ["Web", "JWT", "Authentication"]
summary: "Detailed walkthrough of exploiting custom token verification flaws."
author: "crypticrhino0"
---

# Writeup Content Starts Here...

2. Configuring Automated Vercel Redeployment

To enable instant updates without exposing portfolio credentials or giving write access to the host app, Vercel Deploy Hooks are utilized.

Step A: Generating the Deploy Hook in Vercel

Navigate to the Vercel Dashboard → Select your portfolio project (
```
portfolio
```
).
Go to Settings → Git → Scroll down to Deploy Hooks.
Create a new Deploy Hook:
- Hook Name:
```
Writeups Repo Hook
```
- Target Branch:
```
main
```

Copy the generated Hook URL (

https://api.vercel.com/v1/integrations/deploy/prj_...

Step B: Storing the Secret in GitHub

Open the

writeups

repository on GitHub (

https://github.com/crypticrhino0/writeups

Navigate to Settings → Secrets and variables → Actions → Click New repository secret.
Set Name to
```
VERCEL_DEPLOY_HOOK
```
.
Paste the Vercel Hook URL into Secret Value.

3. GitHub Actions Workflow Configuration

Inside the

writeups

repository, create

.github/workflows/redeploy.yml

name: Trigger Portfolio Redeploy
on:
  push:
    branches:
      - main

jobs:
  redeploy:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Vercel Deploy Hook
        run: |
          curl -X POST "${{ secrets.VERCEL_DEPLOY_HOOK }}"

4. Privacy & File Organization

To prevent non-writeup files (like repository configuration, workflows, or templates) from cluttering the public writeups listing on the portfolio site:

System & Hidden Files: Folders starting with
```
.
```
(such as
```
.github/
```
and
```
.templates/
```
) are ignored by the portfolio content fetcher.
Repository README:
```
README.md
```
is automatically filtered out by the parsing pipeline so it remains strictly repository documentation.
Draft Writeups: Unfinished articles can be kept in
```
_drafts/
```
until ready for publication.

Results & Impact

With this pipeline active:

Creating or updating writeups requires only standard Git pushes.
Content updates go live within seconds without manually re-building the web application.
Decoupling content from core code improves maintainability and system safety.