How This Site Was Built
Why a garden, what the stack is, and how the notes are meant to grow
Abstract
Concept-tier colophon for this bilingual Astro garden. Stack choices, maturity labels borrowed from studio practice (concept / schematic / built = seedling / budding / evergreen), and why the notes link instead of posting once and going quiet.

Context
If you’re here, it’s because you want to see under the hood. Good. This note is for anyone curious about how this particular site is put together, why it behaves the way it does, and what keeps it running.
I’ve spent years weaving Personal Knowledge Management (PKM) and Tools for Thought (TfT) into my workflow, and I wanted a public place to think out loud, to share experiments and link ideas as they connect. Standard blogs aren’t built for that. They give you a reverse-chronological feed: you publish an idea, it goes down the archive, and it stays there. I’d like to keep my notes linked and alive. So when I built this site a month ago (October 2026), I combined my technical background, my design expertise, and my habit of chasing tangents, and turned this into a .
Ideas here are meant to cross-pollinate. It’s a living workspace for personal projects and fragments of whatever has my attention. As I write this, my focus is on:
- Spatial Analysis & Urban Networks: Field notes, street topology research, and Python workflows with OSMnx, building towards an interactive single-page app for urban network analysis.
- Spaced Repetition & Language Systems: A two-way Astro and Anki learning engine (AnkiConnect plus a local TypeScript sync) that tracks my progress as an advanced French learner, alongside prototypes for a custom LMS platform.
- Design Systems & Visual Databases: Headless content workflows, reusable Astro patterns, and visual reference libraries, like a filterable architectural precedent database that supports active recall and memorisation.
Notes are meant to grow. They stay live while they mature, linking sideways (siblings) and upward (parents).
Right now this note is a , or in the language of my architecture background, a Concept. It introduces the site and the reasoning behind it: what’s installed, how the notes are numbered, which tokens hold the visual system together, and where the heavy scripts live. Choreographing Astro pulls a few code patterns out of this build that are worth unpacking on their own. The deeper Schematic and Built stages of this come later, once I’ve worked out an efficient way to graduate a note from one to the next. It’ll be a messy process, and it’s meant to be. This is a working studio.
Tech Stack
Stack & Runtime
The dependency tree is deliberately plain. I started from the Astro minimal template and kept the runtime lean, so my energy could go into layout choreography, page transitions, and content structure.
No React. No Vue. No Svelte islands. No auth or API layers.
Source lives in Git. At build time, Astro compiles those components straight into static HTML, and Netlify takes it from there. TypeScript types the components and helper utilities. Frontmatter itself is policed at build time by the Zod schema below, so I don’t quietly drift from my own model every time I add a note.
Here’s the core dependency list:
- Framework (
Astro 7.3): Static site generation, component scoping, routing, and the view transition lifecycle. It ships zero JavaScript by default, unless I explicitly open a<script>tag. - Styling (
Tailwind CSS 4.3): Loaded through@tailwindcss/vitealongsidesrc/styles/global.css. It handles layout grids and utility spacing, while custom CSS variables carry the actual brand theme. - Motion (
GSAP 3.15+ScrollTrigger): The timeline engine behind page wipes, scroll-bound reveals, and the more involved SVG or DOM choreography. - Smooth Scroll (
Lenis 1.3): Normalises scroll inertia and runs on ’s ticker, so scrolling and animation stay in sync. - Build Environment (
Node >= 22.12): The local runtime that compiles everything before it ships.
Four tools plus the Node runtime, and only two of them, and , ever reach the browser. Clean markup and native browser APIs handle the rest.
Internationalisation
The site is bilingual, and built to include more. Every structural route and UI string exists in both English and French, with no external translation APIs and no client-side text swapping.
- Locales: English (
en) and French (fr). - Routing: Handled natively through Astro i18n routing, served under
/en/...and/fr/...path prefixes. - Content Parity: Parallel Markdown collections. Two gardens growing side by side, kept in sync.
- Language Switcher: Keeps you on the exact same node or page context when you flip locales, instead of dumping you back at the root index.
Content & Garden Model
A with unvalidated frontmatter decays fast into a messy pile of posts. So every Markdown file is validated at build time by Astro Content Collections and a strict Zod schema inside content.config.ts.
Miss a required field? The build fails. Mistype a status label? The build fails.
Each note is a Node inside a broader Cluster, and it carries a specific nodeId such as 1.1 or 2.2 to track its lineage. You can always trace how a small technical snippet ties back to a larger research topic. At launch, two primary clusters anchor the garden:
- Cluster 01 (Bangkok Mobility & Street Topology): Field, technical, and research notes from my 2026 Bangkok trip, wired back to an older street-network spatial analysis project from 2018.
- Cluster 02 ( Architecture & ): Design, build, and process notes on the site itself, anchored by this very note and paired with Choreographing Astro, the companion piece that unpacks its code patterns.
To track how ideas evolve, I mapped the usual states onto the architectural studio phases I’ve used for years in commercial building design:
| Status | Studio Equivalent | Garden Analogue | What It Actually Means |
|---|---|---|---|
01 // CONCEPT |
Working Table | Raw logs, stack inventories, initial spatial tests, first cuts. | |
02 // SCHEMATIC |
Coordinated Systems | Budding | Structured tokens, tested code libraries, validated diagrams. |
03 // BUILT |
Exhibition | Evergreen | Capstone essays and complete studies that synthesise the upstream notes. |
Unfinished work is part of the architecture here. That’s why a note’s launch state is fully decoupled from its maturity. In the schema, a Node is either live (published and readable now) or ghost (an unlinked stub for a note I’m planning). keep the visual knowledge graph honest: they let you see the shape of an argument before I’ve written all its parts.
Design Tokens
I treat the visual layer like an editorial spec sheet merged with a clean interface doc. High contrast. Warm paper tones. Sharp technical accents.
- Cream (
#F7F5F0): The primary ground and page plane. Softer on the eyes than pure white across a long reading session. - Ink (
#1C1F1E): Body copy, structural borders, and grid hairlines. - Brand Pink (
#E04343): Used sparingly. It’s a single red pin on a drawing board, calling out active states or metadata. - Green (
#00674F): The secondary semantic signal for statuses and tags. - Typography: Five fonts. Public Sans for body and long reading. Plus Jakarta Sans for document headings. Bodoni for gallery plates and echoes. Bricolage Grotesque for frame chrome and metadata. Azeret Mono for code only.
Every motion on the site runs on a small set of custom cubic-bezier easings. I’ll map out the curves and timing in a later note.
Client Behaviour & Complexity Ledger
A four-tool dependency list keeps node_modules light, but the complexity is still there. It just moved into layout choreography and custom client scripts.
Here’s how that shows up in the browser:
- Site Shell & Routing: Astro’s
ClientRouterinBaseLayoutruns two transition modes: a full-screen wipe for top-level navigation, and a split-pane transition for reading articles. Named transition groups hold the header, left stage, and article pane in place, so the screen never flashes white between clicks. - Scroll Stages (Home / About / CV): , ScrollTrigger, and share one ticker. Scroll inertia and timeline playback stay locked together.
- Interactive UI (Header, Footer, Maturity Accordion, Flashcards): Plain
<script>tags, scoped inside their parent Astro components. No framework runtime on top. - Accessibility Gate: When the operating system asks for
prefers-reduced-motion, the shared scroll-stage setup skips and the timelines and leaves those pages static.
| Axis | What Stays Simple | What Carries Weight |
|---|---|---|
| Framework | Astro + Tailwind 4 + + | None on purpose. |
| Site Systems | No database, auth, or external CMS | Strict Zod content schemas, dual-locale routing, View Transitions, shared CSS type tokens. |
| Scripts & Motion | Small DOM utilities (extracted to node 2.1, Choreographing Astro) | Heavy, custom page-level choreography in index.astro, the journal index, and [slug].astro. |
The server ships plain static HTML. The real work lies in the choreography: managing view transition lifecycles, coordinating the CSS maturity accordion on the article stage, and keeping scroll-triggered sequences interruptible when a user clicks a link mid-animation. Building it felt a lot closer to cutting a pitch film in Premiere Pro or sequencing keyframes in After Effects than to traditional React development. It’s about pacing, continuity, and knowing exactly which frame to cut on.
Synthesis
As a Concept note, this serves two purposes: (1) documentation and (2) a map for orientation. It explains what runs the site, how the knowledge graph is structured, and why I leave unfinished notes out in the open.
I care about how ideas connect, and I want to show the scaffolding. Notes should point at each other. Early thoughts can stay public while they sharpen. My architecture background shows up here not as a decorative metaphor for the garden but as an operational habit: you don’t jump straight to construction documents before you’ve sorted out the concept and the schematic systems.
Next Steps
Here’s what’s on the drawing board as this note grows.
Towards Schematic (02)
- Article Stage: How the split layout, page transitions, and maturity accordion fit together.
- Content Schema: A walk through the Zod model, from node IDs and clusters to .
- Motion Ledger: The , ScrollTrigger, and sequences on Home, About, and CV, including reduced-motion fallbacks.
Towards Built (03)
- Exhibition : A final essay with diagrams, bilingual checks, and live performance data.
Further Reading
Changelog
- 06 Nov 2026 - Publish (
v1.0) explaining the stack, garden model, tokens, client behaviour, complexity ledger, and maturity ladder.