Welcome to the Workshop

Welcome. This is my engineering workshop, equal parts build log and notebook. I use it to document projects, share technical notes, and write down the decisions behind the tools I build. The goal is simple: keep things practical and specific enough that I can come back later and still understand what I did (and why).

If you are reading this, you found the logs. Good sign.

This first post is a quick overview of the stack, the content pipeline, and the monitoring setup. No grand manifesto, just the basics.

The Stack

The site runs on Astro, a static-first framework that ships minimal JavaScript by default. React islands handle a few interactive elements (for example, the HUD clock and theme toggle). Everything else is rendered as static HTML and CSS at build time.

Astro’s island architecture helps keep interactivity focused and avoids shipping unnecessary JavaScript.

For styling, I use Tailwind CSS v4 alongside a small set of design tokens implemented with CSS custom properties (the Protocol Obsidian design system).

Architecture Decisions

Here’s how the content pipeline works:

1. Blog posts live as .md files in src/content/blog/
2. Astro content collections handle schema validation
3. At build time, everything compiles to static HTML
4. Cloudflare Pages serves it from the edge

The content schema is defined with Zod:

const blog = defineCollection({
  loader: glob({ pattern: '**/*.md', base: './src/content/blog' }),
  schema: z.object({
    title: z.string(),
    description: z.string().optional(),
    pubDate: z.coerce.date(),
    updatedDate: z.coerce.date().optional(),
    tags: z.array(z.string()).optional(),
    draft: z.boolean().optional().default(false),
  }),
});

Why Not a CMS?

Keeping markdown in the repo means:

• Version control: every edit is a Git commit
• Portability: content stays as plain files
• Fast builds: no external API calls at build time

Monitoring with Sentry

I integrated @sentry/astro for frontend observability:

Sentry.init({
  dsn: import.meta.env.PUBLIC_SENTRY_DSN,
  tracesSampleRate: 0.2,
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.replayIntegration(),
  ],
});

This provides error tracking, Web Vitals (LCP, CLS, FID), and session replay on errors without running a backend service.

Design System: Protocol Obsidian

The UI is intentionally minimal and technical. A fixed HUD-style frame and a subtle grid establish structure across pages, while a single accent color is used consistently for emphasis and interactive states.

If you like details, I wrote a separate post with a deeper breakdown of the tokens and code block styling.

What’s Next

This is a workshop, not a museum. I’ll publish notes as I build and refine them when I learn something new.

Topics I plan to cover:

Go

• Building production-ready APIs in Go (project structure, graceful shutdown, and deployment)
• Concurrency patterns that are useful in real services
• Writing a CLI tool from scratch

Domain-Driven Design

• Applying DDD to service boundaries
• Bounded contexts and aggregates in practice
• Modeling complex business domains in large organizations

AI and Machine Learning

• Experimenting with local LLMs and building developer tools
• RAG pipelines, embeddings, and evaluation
• Integrating AI into developer workflows in a pragmatic way

React and Frontend

• React patterns for large codebases
• State management trade-offs (Redux and alternatives)
• Performance optimization (memoization, virtualization, and code splitting)

Large Systems

• Navigating large codebases and distributed teams
• Observability and incident response
• Migration strategies for legacy systems

Infrastructure

• Running a personal server for experiments
• Cloudflare Pages and Workers for edge deployments
• Docker and CI/CD pipelines for side projects

If there is a topic you would like to see first, feel free to send a note. I cannot promise a quick turnaround, but I do read everything.