Collection / Articles

The longer view.

More considered arguments built from the logs, notes, and experience underneath them.

November 13, 2026

Start here

A short introduction to this digital garden and a few useful places to begin reading.

I keep unfinished ideas here alongside longer articles. Some begin as a small observation. Others grow through reading, testing, and revision. The links between them help me see what connects.

That is what I mean by a digital garden. A page can change as my understanding changes, and an older note can become useful when a new idea connects to it. You can follow a subject across several pages without reading everything in date order.

My interests are leadership, technology, operations, and the work of making change useful. The early writing here focuses on building the site itself. It gives you a concrete example of how I approach a small system and explain the decisions underneath it.

A few places to begin

  1. Why I am building a digital garden explains why I want a place for developing ideas and how the different kinds of writing fit together. Start here if the format is new to you.
  2. What a note is for is a short example of the thinking I want to keep. It also explains the seedling, budding, and evergreen labels you will see on notes.
  3. How I built this site walks through the technology and publishing process. Read this if you want to see how the idea became a working website.
  4. Building this site follows one subject from a log entry to a note and an article. It shows how to use the connections rather than treating each page as a separate read.

Finding your next read

The Log holds short observations and decisions. Notes give individual ideas room to develop. Articles hold longer explanations, and Maps gather related pages into a reading path.

I will revisit these starting recommendations as the writing grows. Pick the read that interests you, then follow a link from there.

Read article →
Placeholder image for a site-building article

September 21, 2026

Building an Astro site as a small system

A practical way to build a personal site around content types, clear routes, and a publishing system that stays understandable.

A new website often begins as a visual exercise. There is a homepage to design, a color palette to choose, and a set of components that make the first screen feel finished. That work is satisfying, but it is not the part that determines whether the site will still be useful six months later.

The more important question is what kind of work the site is meant to support.

For mikes.blog, the answer is a digital garden: a place where small observations can become notes, notes can inform articles, and maps can help a reader see the relationships between them. That calls for a publishing model that stays close to the filesystem. Astro fits this implementation by turning Markdown into fast, static pages without requiring a large runtime system.

Start with the content model

The first design decision is not the homepage. It is the vocabulary of the site.

I am using four content types. A log is chronological and small. It captures a thought while it is fresh, usually in 50 to 300 words. A note is a developing idea, longer than a log but not necessarily finished. Notes carry a kind and a stage so I can distinguish a literature review from a permanent reference, or a seedling from an evergreen idea.

An article is the long-form layer. It has room for an argument, an explanation, or a synthesis, and it carries a sources array that points back to the logs and notes that fed it. That field is more than metadata. It makes the history of an idea visible and gives a reader somewhere to continue exploring.

A map is an index. It can be short or extensive, but its job is orientation. A map should answer the question, “Where should I go next?” rather than repeat the content of every page it links to.

These distinctions prevent one of the common problems with personal sites: every thought being forced into the same publishing shape. A small observation does not need a title, excerpt, hero image, and elaborate taxonomy. A considered article deserves more room. The model should make those differences easy rather than asking the writer to remember them every time.

Let the filesystem explain the project

Each collection has its own directory under src/data: log/, notes/, articles/, and maps/. The folder names are ordinary enough that a new contributor can understand them without reading a framework manual. The schemas in src/content.config.ts add the rules that the folders alone cannot express.

That setup is the site’s foundation. Content can remain portable Markdown while the site still gets typed frontmatter, build-time validation, and rendered pages. The system does not need a database to be useful. Git provides history, the filesystem provides organization, and Astro currently provides the build pipeline.

That simplicity is valuable for a personal site. I want to spend my time thinking and writing, not maintaining a publishing platform. When the site does need more capability, the content model gives me a stable place to add it. Search, related content, RSS, or a future editor can build on the collections instead of inventing a second structure beside them.

Routes should mirror the reader’s questions

The public routes follow the same vocabulary: /log, /notes, /articles, and /maps. Each collection has an index page that explains its purpose and lists its entries. Each entry has a detail page with a stable, readable URL.

This gives the reader two ways in. Someone can arrive through a specific link and read one piece without knowing anything about the site. Someone else can enter through a collection page and browse by form. The homepage provides a third path by explaining the relationship between the collections without turning the site into a product tour.

That relationship matters. A garden is not just four folders with four menus. It is a set of transitions. A log can point to a note. A note can become a source for an article. A map can gather the whole thread. Those links create context, and context is what makes a small site feel larger than its page count.

Build for revision

A personal knowledge system should expect change. The first version of a schema will not be perfect. A note may need a new kind. An article may need more than a list of source slugs. A map may become a guide with its own sections and explanation.

The answer is not to design every future feature now. It is to make today’s structure legible and easy to revise. Small schemas, clear routes, and content in version control give the project room to grow without requiring a rewrite at every turn.

This is also where the professional purpose of the site enters. Digital transformation and operational improvement are often described through large systems, but the same principle applies at a smaller scale: make the work visible, make the decisions inspectable, and create feedback loops that help the system improve.

The website is both the subject and the experiment. I am building a tool for thinking while paying attention to how the tool shapes the thinking. If the publishing process becomes cumbersome, that is useful evidence. If the links help an old idea become useful in a new context, that is evidence too.

A modest starting point

The first version does not need a complete identity, a sophisticated search engine, or a perfect taxonomy. It needs a clear reason to exist and a path for the next piece of writing.

For now, that path is simple: capture the moment in a log, develop the idea in a note, make the argument in an article, and draw the connections on a map. The structure is small enough to understand and flexible enough to grow.

That feels like the right kind of beginning for mikes.blog: not a finished publication, but a useful system already in motion.

Read article →
A glowing neon sine wave over a dark circuit-board grid, Tokyo midnight style

September 21, 2026

How I built this site

From an open-source Astro template to a working site: the stack, the content model, the edits, and the Cloudflare pipeline.

This site exists because I wanted a place for thoughts that are still becoming clear. A web log for ideas in motion, as the homepage now says. The title is deliberate: I spend a lot of my life thinking about movement, in the gym and in organizations, and an idea is only useful if it keeps moving toward a result.

This is the build log. The framework, the template, the content architecture, the edits that made it mine, and the pipeline that puts it online.

Why Astro

Astro is a static site generator. There is no server process answering requests and no database running behind the pages. You write Markdown and components, and at build time Astro compiles everything into a folder of plain HTML, CSS, and a small amount of JavaScript.

For a personal site that is the right trade. There are no accounts to manage and no dynamic data, so a running server would be overhead I pay for and then babysit. Astro lets the build pipeline act as the backend: Git holds the history, the filesystem holds the structure, and a build turns both into a fast static site.

The commands I use day to day:

npm run dev      # local dev server at localhost:4321
npm run build    # static output into dist/
npm run check    # astro check + ESLint + Prettier

Starting from an open-source template

I did not build the scaffolding by hand. I started from AstroWind, a free, open-source template (MIT license) built on Astro v7 and Tailwind CSS v4.

Templates get a bad name in some circles, as if starting from one means skipping the real work. On a site like this the real work is never the responsive grid or the SEO tags. A good template hands you that infrastructure, such as dark mode, RSS, sitemaps, image optimization, and accessibility, so the hours go to the part that is actually yours: the content and its structure.

npm create astro@latest -- --template arthelokyo/astrowind
npm install
npm run dev

AstroWind also centralizes site settings in src/config.yaml and exposes them to components as a virtual module. Changing the site name, the metadata, or the theme happens in one file instead of a trail of edits.

The content model

The first decision I made was not the homepage. It was the vocabulary of the site.

I use four content types, each with a distinct job:

  • Log — short, chronological observations.
  • Notes — developing ideas, tagged with a kind and a stage.
  • Articles — long-form arguments that cite their sources.
  • Maps — indexes that connect related ideas.

Each type has its own folder under src/data/ and a typed schema in src/content.config.ts:

const articleCollection = defineCollection({
  loader: glob({ pattern: ['*.md', '*.mdx'], base: 'src/data/articles' }),
  schema: gardenDocumentDefinition().extend({
    excerpt: z.string().optional(),
    image: z.string().optional(),
    sources: z.array(z.string()),
  }),
});

The sources field matters most to me. Every article points back to the logs and notes that fed it, so the history of an idea stays visible. That turns the site from a stack of pages into a connected system.

I wrote about the reasoning in Building an Astro site as a small system. That post is the philosophy; this one is the log of the work.

What I changed to make it mine

The template ships looking like a product demo. A thin bar at the top announced “Astro v7 is now available” with a GitHub star counter. The header carried a “Start here” button. The homepage introduced me as “an ITM MBA and leader.” None of that felt like me, so I removed or rewrote it:

  • Removed the announcement bar and the “Start here” button.
  • Rewrote the headline to “A web log for ideas in motion” and dropped the credential from the subtitle. The ideas should introduce themselves.
  • Gave the Log, Notes, Articles, and Maps cards neon icons in a Tokyo-midnight palette of cyan, pink, violet, and lime. I live in Tokyo, and neon against dark is the mood I want the site to carry.
  • Swapped the favicon from the template’s logo to the same sine-wave icon used in the header.

Most of these were single-file changes. That is the argument for a template: identity is a thin layer you paint over solid infrastructure, not something you rebuild from the ground up.

Publishing to Cloudflare

The site ships to Cloudflare Workers as static assets. The pipeline is short:

  1. Build — npm run build compiles the site into dist/.
  2. Validate — GitHub Actions runs npm run check and npm run build on every push to main. It validates and builds; it does not deploy.
  3. Deploy — Wrangler uploads dist/ to a Worker.

The Worker is declared in wrangler.jsonc:

{
  "name": "mikes-blog",
  "assets": {
    "directory": "./dist",
    "not_found_handling": "404-page",
  },
}
npm run build
npx wrangler deploy

wrangler deploy publishes the site to https://mikes-blog.chikaradev.workers.dev. A custom domain (mikes.blog) will point at it once the content is ready; the domain is parked at Porkbun for now.

Where it goes from here

The structure can hold more than it currently shows. More logs, deeper notes, and maps that connect threads across months. Building in public is the point: the site is small on purpose, so the system can grow without a rewrite.

Read article →

September 21, 2026

Why I am building a digital garden

A digital garden gives unfinished ideas a place to develop, connect, and become useful over time.

A polished article usually arrives at the end of a process. It has a beginning, a middle, and a conclusion. That shape is useful when I already understand what I want to say, but it can hide the work that made the idea possible. Most worthwhile thinking does not begin as a conclusion. It begins as a question, a tension, a half-remembered conversation, or a pattern that appears in several different places.

I am building this digital garden to make room for that earlier work.

A garden instead of a filing cabinet

A filing cabinet is good at keeping things. It is less good at helping ideas meet each other. A digital garden is a different model: content can be partial, revisable, and connected. A note does not have to pretend it is finished. A map does not have to tell the whole story. An article can point back to the smaller observations that shaped it.

That structure matches how I actually learn. I read, test, discuss, forget, remember, and revise. A useful idea changes as it meets evidence and experience. If I only publish the final version, I keep the result but lose the trail. The trail is often where the transferable learning is.

Four kinds of working material

The garden has four content types, each with a different job.

A log is immediate. It is a short chronological record of something I noticed, decided, tried, or learned. The log is deliberately small. Writing a few honest sentences is often enough to keep a thought from disappearing.

A note gives an idea more space. Notes can be fleeting or permanent, and they can be seedlings, budding ideas, or evergreen references. Those labels make the state of the thinking visible without pretending that every idea develops at the same speed.

An article is a longer argument or explanation. Articles are not disconnected essays; they are assembled from the questions and observations that came before them. That is why each article carries links back to its sources. The links show both the evidence and the evolution of the idea.

A map helps a reader navigate. It gathers related links around a topic, a question, or a practice. A map may be a simple index today and a substantial guide later. Its purpose is orientation: helping someone decide where to go next.

Why this matters to my work

My professional interests sit at the intersection of people, technology, and operations. Digital transformation is often described as a technology project, but the difficult work is usually broader. It includes priorities, decision rights, incentives, process design, communication, measurement, and the ability to learn when the first plan meets reality.

A garden gives me a place to examine those subjects without forcing every thought into a presentation or a business case. I can capture a small operational lesson, connect it to a leadership principle, and later develop it into a more rigorous article. That practice is useful for me, and it makes the thinking easier for others to inspect.

An invitation to return

This site will not always look complete. That is part of the point. Some pages will be rough because the idea is rough. Some will change because experience made the original version incomplete. A few may remain small because a small idea is all they need to be.

I want the garden to become a record of thoughtful iteration: strategy translated into action, systems improved through attention, and technology used in service of better outcomes. The first entries are modest. Over time, the connections should do more of the talking.

Read article →